From b02e494fcce444408ce99c00c49b3b0d19e01537 Mon Sep 17 00:00:00 2001 From: Denys Kuzmenko Date: Mon, 9 Feb 2026 14:56:05 +0200 Subject: [PATCH 1/4] HIVE-29450: Iceberg: Multi-table, multi-statement txn support --- .../org/apache/iceberg/HiveTransaction.java | 54 + .../iceberg/hive/HiveTableOperations.java | 8 + .../iceberg/hive/HiveTxnCoordinator.java | 201 + .../iceberg/hive/StagingTableOperations.java | 72 + .../mr/hive/HiveIcebergOutputCommitter.java | 65 +- .../mr/hive/HiveIcebergStorageHandler.java | 27 +- .../iceberg/mr/hive/IcebergAcidUtil.java | 29 + .../iceberg/mr/hive/IcebergTableUtil.java | 10 +- .../hive/TestHiveIcebergOutputCommitter.java | 8 +- .../HiveIcebergStorageHandlerStub.java | 2 +- .../positive/iceberg_multi_table_txn.q | 35 + .../positive/iceberg_multi_table_txn.q.out | 141 + .../hadoop/hive/ql/DriverTxnHandler.java | 19 +- .../hive/ql/lockmgr/AcidTxnCoordinator.java | 88 + .../hadoop/hive/ql/lockmgr/DbTxnManager.java | 113 +- .../hive/ql/lockmgr/HiveTxnManager.java | 18 + .../ReExecuteOnWriteConflictPlugin.java | 35 +- .../hive/metastore/IMetaStoreClient.java | 8 + .../client/MetaStoreClientWrapper.java | 5 + .../client/ThriftHiveMetaStoreClient.java | 5 + .../thrift/gen-cpp/ThriftHiveMetastore.cpp | 3935 +++++++++-------- .../gen/thrift/gen-cpp/ThriftHiveMetastore.h | 125 + .../ThriftHiveMetastore_server.skeleton.cpp | 5 + .../thrift/gen-cpp/hive_metastore_types.cpp | 1557 ++++--- .../gen/thrift/gen-cpp/hive_metastore_types.h | 82 + .../api/DeleteColumnStatisticsRequest.java | 64 +- .../hive/metastore/api/GetFieldsResponse.java | 36 +- .../metastore/api/GetOpenTxnsRequest.java | 36 +- .../api/GetPartitionNamesPsRequest.java | 32 +- .../api/GetPartitionNamesPsResponse.java | 32 +- .../metastore/api/GetPartitionRequest.java | 32 +- .../api/GetPartitionsFilterSpec.java | 32 +- .../api/GetPartitionsPsWithAuthRequest.java | 96 +- .../api/GetPartitionsPsWithAuthResponse.java | 36 +- .../metastore/api/GetPartitionsRequest.java | 64 +- .../metastore/api/GetPartitionsResponse.java | 36 +- .../hive/metastore/api/GetSchemaResponse.java | 36 +- .../metastore/api/PartitionsResponse.java | 36 +- .../api/ReplayedTxnsForPolicyResult.java | 44 +- .../metastore/api/ReplicationMetricList.java | 36 +- .../hive/metastore/api/TableParamsUpdate.java | 942 ++++ .../metastore/api/ThriftHiveMetastore.java | 3897 +++++++++------- .../hive_metastore/ThriftHiveMetastore-remote | 7 + .../hive_metastore/ThriftHiveMetastore.py | 1242 +++--- .../thrift/gen-py/hive_metastore/ttypes.py | 382 +- .../gen/thrift/gen-rb/hive_metastore_types.rb | 31 + .../thrift/gen-rb/thrift_hive_metastore.rb | 58 + .../apache/hadoop/hive/TxnCoordinator.java | 42 + .../src/main/thrift/hive_metastore.thrift | 12 + .../hadoop/hive/metastore/DirectSqlBase.java | 75 + .../hive/metastore/DirectSqlUpdateParams.java | 168 + .../hive/metastore/DirectSqlUpdatePart.java | 164 +- .../hadoop/hive/metastore/HMSHandler.java | 5 + .../hive/metastore/MetaStoreDirectSql.java | 57 + .../hadoop/hive/metastore/ObjectStore.java | 38 +- .../hadoop/hive/metastore/RawStore.java | 8 + .../hive/metastore/cache/CachedStore.java | 4 + 57 files changed, 9292 insertions(+), 5135 deletions(-) create mode 100644 iceberg/iceberg-catalog/src/main/java/org/apache/iceberg/HiveTransaction.java create mode 100644 iceberg/iceberg-catalog/src/main/java/org/apache/iceberg/hive/HiveTxnCoordinator.java create mode 100644 iceberg/iceberg-catalog/src/main/java/org/apache/iceberg/hive/StagingTableOperations.java create mode 100644 iceberg/iceberg-handler/src/test/queries/positive/iceberg_multi_table_txn.q create mode 100644 iceberg/iceberg-handler/src/test/results/positive/iceberg_multi_table_txn.q.out create mode 100644 ql/src/java/org/apache/hadoop/hive/ql/lockmgr/AcidTxnCoordinator.java create mode 100644 standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/TableParamsUpdate.java create mode 100644 standalone-metastore/metastore-common/src/main/java/org/apache/hadoop/hive/TxnCoordinator.java create mode 100644 standalone-metastore/metastore-server/src/main/java/org/apache/hadoop/hive/metastore/DirectSqlBase.java create mode 100644 standalone-metastore/metastore-server/src/main/java/org/apache/hadoop/hive/metastore/DirectSqlUpdateParams.java diff --git a/iceberg/iceberg-catalog/src/main/java/org/apache/iceberg/HiveTransaction.java b/iceberg/iceberg-catalog/src/main/java/org/apache/iceberg/HiveTransaction.java new file mode 100644 index 000000000000..21a918d35ce9 --- /dev/null +++ b/iceberg/iceberg-catalog/src/main/java/org/apache/iceberg/HiveTransaction.java @@ -0,0 +1,54 @@ +/* + * 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.iceberg; + +import org.apache.iceberg.hive.HiveTableOperations; +import org.apache.iceberg.hive.StagingTableOperations; + +/** + * Transaction implementation that stages metadata changes for atomic batch HMS updates across + * multiple tables. + * + *

Extends BaseTransaction to leverage Iceberg's retry and conflict resolution logic while + * capturing metadata locations instead of publishing directly to HMS. + */ +public class HiveTransaction extends BaseTransaction { + + private final HiveTableOperations hiveOps; + private final StagingTableOperations stagingOps; + + public HiveTransaction(Table table, HiveTableOperations ops) { + this(table, ops, ops.toStagingOps()); + } + + private HiveTransaction(Table table, HiveTableOperations ops, StagingTableOperations stagingOps) { + super(table.name(), stagingOps, TransactionType.SIMPLE, ops.current()); + this.hiveOps = ops; + this.stagingOps = stagingOps; + } + + public HiveTableOperations ops() { + return hiveOps; + } + + public StagingTableOperations stagingOps() { + return stagingOps; + } +} diff --git a/iceberg/iceberg-catalog/src/main/java/org/apache/iceberg/hive/HiveTableOperations.java b/iceberg/iceberg-catalog/src/main/java/org/apache/iceberg/hive/HiveTableOperations.java index a0f0e779d9b7..e2cb3d7a72ec 100644 --- a/iceberg/iceberg-catalog/src/main/java/org/apache/iceberg/hive/HiveTableOperations.java +++ b/iceberg/iceberg-catalog/src/main/java/org/apache/iceberg/hive/HiveTableOperations.java @@ -93,6 +93,14 @@ protected HiveTableOperations( conf.getLong(HIVE_TABLE_PROPERTY_MAX_SIZE, HIVE_TABLE_PROPERTY_MAX_SIZE_DEFAULT); } + /** + * Create a staging operations instance that skips HMS updates and locking. + * Used by HiveTransaction to defer HMS updates to coordinator for atomic batch commits. + */ + public StagingTableOperations toStagingOps() { + return new StagingTableOperations(conf, metaClients, fileIO, catalogName, database, tableName); + } + @Override protected String tableName() { return fullName; diff --git a/iceberg/iceberg-catalog/src/main/java/org/apache/iceberg/hive/HiveTxnCoordinator.java b/iceberg/iceberg-catalog/src/main/java/org/apache/iceberg/hive/HiveTxnCoordinator.java new file mode 100644 index 000000000000..360043c899d1 --- /dev/null +++ b/iceberg/iceberg-catalog/src/main/java/org/apache/iceberg/hive/HiveTxnCoordinator.java @@ -0,0 +1,201 @@ +/* + * 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.iceberg.hive; + +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.stream.Collectors; +import org.apache.hadoop.conf.Configuration; +import org.apache.hadoop.hive.TxnCoordinator; +import org.apache.hadoop.hive.metastore.IMetaStoreClient; +import org.apache.hadoop.hive.metastore.api.Table; +import org.apache.hadoop.hive.metastore.api.TableParamsUpdate; +import org.apache.iceberg.BaseMetastoreOperations; +import org.apache.iceberg.BaseTable; +import org.apache.iceberg.HiveTransaction; +import org.apache.iceberg.TableMetadata; +import org.apache.iceberg.Transaction; +import org.apache.iceberg.relocated.com.google.common.collect.Lists; +import org.apache.iceberg.relocated.com.google.common.collect.Maps; +import org.apache.thrift.TException; + +/** + * Transaction coordinator that aggregates Iceberg table commits and performs atomic HMS updates + * across multiple tables using {@code updateTableParams}. + */ +public final class HiveTxnCoordinator implements TxnCoordinator { + + private final Configuration conf; + private final IMetaStoreClient msClient; + + private final Map stagedCommits = Maps.newConcurrentMap(); + + public HiveTxnCoordinator(Configuration conf, IMetaStoreClient msClient) { + this.conf = conf; + this.msClient = msClient; + } + + @Override + public boolean hasPendingWork() { + return !stagedCommits.isEmpty(); + } + + public Transaction getOrCreateTransaction(org.apache.iceberg.Table table) { + Transaction txn = getTransaction(table); + if (txn != null) { + return txn; + } + if (!(table instanceof BaseTable baseTable && + baseTable.operations() instanceof HiveTableOperations ops)) { + return table.newTransaction(); + } + return stagedCommits.computeIfAbsent( + table.name(), ignored -> new HiveTransaction(table, ops)); + } + + public Transaction getTransaction(org.apache.iceberg.Table table) { + return stagedCommits.get(table.name()); + } + + @Override + public synchronized void commit() throws TException { + if (stagedCommits.isEmpty()) { + return; + } + + // Sort commits by table name for deterministic ordering + List> updates = Lists.newArrayList(stagedCommits.entrySet()); + updates.sort(Map.Entry.comparingByKey()); + + attemptCommit(updates); + } + + @Override + public synchronized void rollback() { + clearState(); + } + + private void clearState() { + stagedCommits.clear(); + } + + private TableParamsUpdate buildTableParamsUpdate( + TableMetadata base, TableMetadata newMetadata, HiveTableOperations ops, String newMetadataLocation) { + Set removedProps = + base.properties().keySet().stream() + .filter(k -> !newMetadata.properties().containsKey(k)) + .collect(Collectors.toSet()); + + Table tbl = new Table(); + tbl.setParameters(Maps.newHashMap()); + + long maxPropSize = conf.getLong( + HiveOperationsBase.HIVE_TABLE_PROPERTY_MAX_SIZE, + HiveOperationsBase.HIVE_TABLE_PROPERTY_MAX_SIZE_DEFAULT); + + HMSTablePropertyHelper.updateHmsTableForIcebergTable( + newMetadataLocation, + tbl, + newMetadata, + removedProps, + true, + maxPropSize, + base.metadataFileLocation()); + + TableParamsUpdate newParams = new TableParamsUpdate(); + newParams.setDb_name(ops.database()); + newParams.setTable_name(ops.table()); + newParams.setParams(tbl.getParameters()); + + newParams.setExpected_param_key(HiveTableOperations.METADATA_LOCATION_PROP); + if (base.metadataFileLocation() != null) { + newParams.setExpected_param_value(base.metadataFileLocation()); + } + return newParams; + } + + private void attemptCommit(List> updates) throws TException { + List payload = Lists.newArrayList(); + List txns = Lists.newArrayList(); + List locks = Lists.newArrayList(); + + try { + for (Map.Entry entry : updates) { + HiveTransaction hiveTxn = entry.getValue(); + + // Stage the transaction and track it for potential reset on retry + hiveTxn.commitTransaction(); + txns.add(hiveTxn); + + TableMetadata base = hiveTxn.startMetadata(); + TableMetadata newMetadata = hiveTxn.currentMetadata(); + HiveTableOperations ops = hiveTxn.ops(); + + String newMetadataFileLocation = hiveTxn.stagingOps().metadataLocation(); + + // Acquire lock - if this fails, txn is already in list for cleanup + HiveLock lock = ops.lockObject(base); + lock.lock(); + locks.add(lock); + + // Build and add the HMS update payload + TableParamsUpdate paramsUpdate = buildTableParamsUpdate(base, newMetadata, ops, newMetadataFileLocation); + payload.add(paramsUpdate); + } + + // Ensure all locks are active + locks.forEach(HiveLock::ensureActive); + + msClient.updateTableParams(payload); + + // Success - release locks and clear state + releaseLocks(locks); + clearState(); + + } catch (Exception e) { + cleanupFailedCommit(txns, locks); + throw e; + } + } + + private void cleanupFailedCommit(List txns, List locks) { + cleanupMetadata(txns); + releaseLocks(locks); + clearState(); + } + + private void cleanupMetadata(List txns) { + txns.forEach(txn -> { + String metadataLocation = txn.stagingOps().metadataLocation(); + if (metadataLocation != null) { + HiveOperationsBase.cleanupMetadata( + txn.ops().io(), + BaseMetastoreOperations.CommitStatus.FAILURE.name(), + metadataLocation); + } + }); + } + + private void releaseLocks(List locks) { + locks.forEach(HiveLock::unlock); + } + +} diff --git a/iceberg/iceberg-catalog/src/main/java/org/apache/iceberg/hive/StagingTableOperations.java b/iceberg/iceberg-catalog/src/main/java/org/apache/iceberg/hive/StagingTableOperations.java new file mode 100644 index 000000000000..beee3df417a1 --- /dev/null +++ b/iceberg/iceberg-catalog/src/main/java/org/apache/iceberg/hive/StagingTableOperations.java @@ -0,0 +1,72 @@ +/* + * 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.iceberg.hive; + +import org.apache.hadoop.conf.Configuration; +import org.apache.hadoop.hive.metastore.IMetaStoreClient; +import org.apache.hadoop.hive.metastore.api.Table; +import org.apache.iceberg.ClientPool; +import org.apache.iceberg.TableMetadata; +import org.apache.iceberg.io.FileIO; +import org.apache.thrift.TException; + +/** + * TableOperations that skips HMS updates and locking during staging. + * Extends HiveTableOperations and overrides: + * 1. lockObject() to return NoLock (coordinator handles locking) + * 2. persistTable() to be no-op (coordinator handles HMS batch update) + * 3. Captures the staged metadata location for cleanup + */ +public class StagingTableOperations extends HiveTableOperations { + + private String newMetadataLocation; + + public StagingTableOperations( + Configuration conf, + ClientPool metaClients, + FileIO fileIO, + String catalogName, + String database, + String table) { + super(conf, metaClients, fileIO, catalogName, database, table); + } + + @Override + protected String writeNewMetadataIfRequired(boolean newTable, TableMetadata metadata) { + String location = super.writeNewMetadataIfRequired(newTable, metadata); + this.newMetadataLocation = location; + return location; + } + + @Override + HiveLock lockObject(TableMetadata metadata) { + // No lock needed during staging - coordinator will acquire locks before HMS batch update + return new NoLock(); + } + + @Override + public void persistTable(Table hmsTable, boolean updateHiveTable, String metadataLocation) { + // No-op - skip HMS update, metadata files already written by doCommit() + } + + public String metadataLocation() { + return newMetadataLocation; + } +} diff --git a/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/HiveIcebergOutputCommitter.java b/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/HiveIcebergOutputCommitter.java index 348fdea28ba6..549bdc1b4152 100644 --- a/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/HiveIcebergOutputCommitter.java +++ b/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/HiveIcebergOutputCommitter.java @@ -41,6 +41,7 @@ import org.apache.hadoop.fs.FileStatus; import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.fs.Path; +import org.apache.hadoop.hive.conf.HiveConf; import org.apache.hadoop.hive.conf.HiveConf.ConfVars; import org.apache.hadoop.hive.ql.Context.Operation; import org.apache.hadoop.hive.ql.Context.RewritePolicy; @@ -59,6 +60,7 @@ import org.apache.hadoop.mapred.TaskAttemptID; import org.apache.hadoop.mapreduce.TaskType; import org.apache.iceberg.AppendFiles; +import org.apache.iceberg.BaseTransaction; import org.apache.iceberg.ContentFile; import org.apache.iceberg.DataFile; import org.apache.iceberg.DeleteFile; @@ -70,6 +72,7 @@ import org.apache.iceberg.Snapshot; import org.apache.iceberg.SnapshotUpdate; import org.apache.iceberg.Table; +import org.apache.iceberg.Transaction; import org.apache.iceberg.exceptions.NotFoundException; import org.apache.iceberg.expressions.Expression; import org.apache.iceberg.expressions.Expressions; @@ -106,6 +109,15 @@ public class HiveIcebergOutputCommitter extends OutputCommitter { private static final String CONFLICT_DETECTION_FILTER = "Conflict detection Filter Expression: {}"; private ExecutorService workerPool; + private final Configuration conf; + + public HiveIcebergOutputCommitter() { + this(new HiveConf()); + } + + public HiveIcebergOutputCommitter(Configuration conf) { + this.conf = conf; + } @Override public void setupJob(JobContext jobContext) { @@ -435,22 +447,22 @@ private void commitTable(FileIO io, ExecutorService executor, OutputTable output Expression filterExpr = null; for (JobContext jobContext : jobContexts) { - JobConf conf = jobContext.getJobConf(); + JobConf jobConf = jobContext.getJobConf(); - table = Optional.ofNullable(table).orElseGet(() -> Catalogs.loadTable(conf, catalogProperties)); - branchName = conf.get(InputFormatConfig.OUTPUT_TABLE_SNAPSHOT_REF); + table = Optional.ofNullable(table).orElseGet(() -> Catalogs.loadTable(jobConf, catalogProperties)); + branchName = jobConf.get(InputFormatConfig.OUTPUT_TABLE_SNAPSHOT_REF); snapshotId = getSnapshotId(outputTable.table, branchName); if (filterExpr == null) { - filterExpr = SessionStateUtil.getConflictDetectionFilter(conf, catalogProperties.get(Catalogs.NAME)) - .map(expr -> HiveIcebergInputFormat.getFilterExpr(conf, expr)) + filterExpr = SessionStateUtil.getConflictDetectionFilter(jobConf, catalogProperties.get(Catalogs.NAME)) + .map(expr -> HiveIcebergInputFormat.getFilterExpr(jobConf, expr)) .orElse(null); } LOG.info("Committing job has started for table: {}, using location: {}", - table, HiveTableUtil.jobLocation(outputTable.table.location(), conf, jobContext.getJobID())); + table, HiveTableUtil.jobLocation(outputTable.table.location(), jobConf, jobContext.getJobID())); - int numTasks = SessionStateUtil.getCommitInfo(conf, name) + int numTasks = SessionStateUtil.getCommitInfo(jobConf, name) .map(info -> info.get(jobContext.getJobID().toString())) .map(SessionStateUtil.CommitInfo::getTaskNum).orElseGet(() -> { // Fallback logic, if number of tasks are not available in the config @@ -458,7 +470,7 @@ private void commitTable(FileIO io, ExecutorService executor, OutputTable output // If this is a map only task, then every mapper will generate a result file. LOG.info("Number of tasks not available in session state for jobID: {}, table: {}. " + "Falling back to jobConf numReduceTasks/numMapTasks", jobContext.getJobID(), name); - return conf.getNumReduceTasks() > 0 ? conf.getNumReduceTasks() : conf.getNumMapTasks(); + return jobConf.getNumReduceTasks() > 0 ? jobConf.getNumReduceTasks() : jobConf.getNumMapTasks(); }); FilesForCommit writeResults = collectResults( @@ -531,8 +543,10 @@ private Long getSnapshotId(Table table, String branchName) { private void commitWrite(Table table, String branchName, Long snapshotId, long startTime, FilesForCommit results, Operation operation, Expression filterExpr) { + Transaction txn = IcebergAcidUtil.getOrCreateTransaction(table, conf); + if (!results.replacedDataFiles().isEmpty()) { - OverwriteFiles write = table.newOverwrite(); + OverwriteFiles write = txn.newOverwrite(); results.replacedDataFiles().forEach(write::deleteFile); results.dataFiles().forEach(write::addFile); @@ -548,20 +562,20 @@ private void commitWrite(Table table, String branchName, Long snapshotId, long s } write.validateNoConflictingData(); write.validateNoConflictingDeletes(); - commit(write); + commit(txn, write); return; } if (results.deleteFiles().isEmpty() && Operation.MERGE != operation) { - AppendFiles write = table.newAppend(); + AppendFiles write = txn.newAppend(); results.dataFiles().forEach(write::appendFile); if (StringUtils.isNotEmpty(branchName)) { write.toBranch(HiveUtils.getTableSnapshotRef(branchName)); } - commit(write); + commit(txn, write); } else { - RowDelta write = table.newRowDelta(); + RowDelta write = txn.newRowDelta(); results.dataFiles().forEach(write::addRows); results.deleteFiles().forEach(write::addDeletes); results.rewrittenDeleteFiles().forEach(write::removeDeletes); @@ -582,7 +596,7 @@ private void commitWrite(Table table, String branchName, Long snapshotId, long s } write.validateDataFilesExist(results.referencedDataFiles()); write.validateNoConflictingDataFiles(); - commit(write); + commit(txn, write); } LOG.info("Write commit took {} ms for table: {} with {} data and {} delete file(s)", @@ -594,12 +608,16 @@ private void commitWrite(Table table, String branchName, Long snapshotId, long s * Calls the commit on the prepared SnapshotUpdate and supplies the ExecutorService if any. * @param update the SnapshotUpdate of any kind (e.g. AppendFiles, DeleteFiles, etc.) */ - private void commit(SnapshotUpdate update) { + private void commit(Transaction txn, SnapshotUpdate update) { if (workerPool != null) { update.scanManifestsWith(workerPool); } update.commit(); + if (txn.getClass() == BaseTransaction.class) { + txn.commitTransaction(); + } } + /** * Creates and commits an Iceberg compaction change with the provided data files. * Either full table or a selected partition contents is replaced with compacted files. @@ -617,7 +635,9 @@ private void commitCompaction(Table table, Long snapshotId, long startTime, File List existingDeleteFiles = fileSizeThreshold == -1 ? IcebergCompactionUtil.getDeleteFiles(table, snapshotId, partitionPath) : Collections.emptyList(); - RewriteFiles rewriteFiles = table.newRewrite(); + Transaction txn = IcebergAcidUtil.getOrCreateTransaction(table, conf); + + RewriteFiles rewriteFiles = txn.newRewrite(); existingDataFiles.forEach(rewriteFiles::deleteFile); existingDeleteFiles.forEach(rewriteFiles::deleteFile); results.dataFiles().forEach(rewriteFiles::addFile); @@ -625,7 +645,7 @@ private void commitCompaction(Table table, Long snapshotId, long startTime, File if (snapshotId != null) { rewriteFiles.validateFromSnapshot(snapshotId); } - rewriteFiles.commit(); + commit(txn, rewriteFiles); LOG.info("Compaction commit took {} ms for table: {} partition: {} with {} file(s)", System.currentTimeMillis() - startTime, table, StringUtils.defaultString(partitionPath, "N/A"), results.dataFiles().size()); @@ -646,8 +666,11 @@ private void commitCompaction(Table table, Long snapshotId, long startTime, File private void commitOverwrite(Table table, String branchName, Long snapshotId, long startTime, FilesForCommit results) { Preconditions.checkArgument(results.deleteFiles().isEmpty(), "Can not handle deletes with overwrite"); + + Transaction txn = IcebergAcidUtil.getOrCreateTransaction(table, conf); + if (!results.dataFiles().isEmpty()) { - ReplacePartitions overwrite = table.newReplacePartitions(); + ReplacePartitions overwrite = txn.newReplacePartitions(); results.dataFiles().forEach(overwrite::addFile); if (StringUtils.isNotEmpty(branchName)) { @@ -658,17 +681,17 @@ private void commitOverwrite(Table table, String branchName, Long snapshotId, lo } overwrite.validateNoConflictingDeletes(); overwrite.validateNoConflictingData(); - commit(overwrite); + commit(txn, overwrite); LOG.info("Overwrite commit took {} ms for table: {} with {} file(s)", System.currentTimeMillis() - startTime, table, results.dataFiles().size()); } else if (table.spec().isUnpartitioned()) { - DeleteFiles deleteFiles = table.newDelete(); + DeleteFiles deleteFiles = txn.newDelete(); deleteFiles.deleteFromRowFilter(Expressions.alwaysTrue()); if (StringUtils.isNotEmpty(branchName)) { deleteFiles.toBranch(HiveUtils.getTableSnapshotRef(branchName)); } - commit(deleteFiles); + commit(txn, deleteFiles); LOG.info("Cleared table contents as part of empty overwrite for unpartitioned table. " + "Commit took {} ms for table: {}", System.currentTimeMillis() - startTime, table); } diff --git a/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/HiveIcebergStorageHandler.java b/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/HiveIcebergStorageHandler.java index 7bf2aef49a7c..c6be28c60240 100644 --- a/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/HiveIcebergStorageHandler.java +++ b/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/HiveIcebergStorageHandler.java @@ -133,6 +133,7 @@ import org.apache.hadoop.mapred.OutputFormat; import org.apache.iceberg.BaseMetastoreTableOperations; import org.apache.iceberg.BaseTable; +import org.apache.iceberg.BaseTransaction; import org.apache.iceberg.CatalogUtil; import org.apache.iceberg.DataFile; import org.apache.iceberg.DataOperations; @@ -346,7 +347,7 @@ public void configureJobConf(TableDesc tableDesc, JobConf jobConf) { HiveCustomStorageHandlerUtils.WRITE_OPERATION_CONFIG_PREFIX + tableName))); } boolean isMergeTaskEnabled = Boolean.parseBoolean(tableDesc.getProperty( - HiveCustomStorageHandlerUtils.MERGE_TASK_ENABLED + tableName)); + HiveCustomStorageHandlerUtils.MERGE_TASK_ENABLED + tableName)); if (isMergeTaskEnabled) { HiveCustomStorageHandlerUtils.setMergeTaskEnabled(jobConf, tableName, true); } @@ -555,9 +556,13 @@ public Map computeBasicStatistics(Partish partish) { throw new UncheckedIOException(e); } - table.updatePartitionStatistics() + Transaction txn = IcebergAcidUtil.getOrCreateTransaction(table, conf); + txn.table().updatePartitionStatistics() .setPartitionStatistics(statsFile) .commit(); + if (txn.getClass() == BaseTransaction.class) { + txn.commitTransaction(); + } } } return getBasicStatistics(partish); @@ -574,7 +579,7 @@ private static Map getPartishSummary(Partish partish, Table tabl recordSchema, table.io().newInputFile(statsFile.path()))) { PartitionStats partitionStats = Iterables.tryFind(recordIterator, stats -> { PartitionSpec spec = table.specs().get(stats.specId()); - PartitionData data = IcebergTableUtil.toPartitionData(stats.partition(), partitionType, + PartitionData data = IcebergTableUtil.toPartitionData(stats.partition(), partitionType, spec.partitionType()); return spec.partitionToPath(data).equals(partish.getPartition().getName()); }).orNull(); @@ -678,9 +683,14 @@ private boolean writeColStats(List colStats, Table tbl) { } return false; } - tbl.updateStatistics() + + Transaction txn = IcebergAcidUtil.getOrCreateTransaction(tbl, conf); + txn.table().updateStatistics() .setStatistics(statisticsFile) .commit(); + if (txn.getClass() == BaseTransaction.class) { + txn.commitTransaction(); + } return true; } catch (Exception e) { @@ -850,8 +860,7 @@ public LockType getLockType(WriteEntity writeEntity) { } return switch (writeEntity.getWriteType()) { case INSERT_OVERWRITE -> LockType.EXCL_WRITE; - case UPDATE, DELETE -> sharedWrite ? - LockType.SHARED_WRITE : LockType.EXCL_WRITE; + case UPDATE, DELETE -> sharedWrite ? LockType.SHARED_WRITE : LockType.EXCL_WRITE; default -> LockType.SHARED_WRITE; }; } @@ -898,7 +907,7 @@ private List getSortTransformSpec(Table table) { @Override public DynamicPartitionCtx createDPContext( - HiveConf hiveConf, org.apache.hadoop.hive.ql.metadata.Table hmsTable, Operation writeOperation) + HiveConf hiveConf, org.apache.hadoop.hive.ql.metadata.Table hmsTable, Operation writeOperation) throws SemanticException { // delete records are already clustered by partition spec id and the hash of the partition struct // there is no need to do any additional sorting based on partition columns @@ -999,7 +1008,7 @@ private void addZOrderCustomExpr(Map props, DynamicPartitionCtx } } - private void addCustomSortExpr(Table table, org.apache.hadoop.hive.ql.metadata.Table hmsTable, + private void addCustomSortExpr(Table table, org.apache.hadoop.hive.ql.metadata.Table hmsTable, Operation writeOperation, DynamicPartitionCtx dpCtx, List transformSpecs) { List fields = table.schema().columns(); @@ -1094,7 +1103,7 @@ public void storageHandlerCommit(Properties commitProperties, Operation operatio @Override public HiveIcebergOutputCommitter getOutputCommitter() { - return new HiveIcebergOutputCommitter(); + return new HiveIcebergOutputCommitter(conf); } @Override diff --git a/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/IcebergAcidUtil.java b/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/IcebergAcidUtil.java index b2feed784e39..6f7db342c5ba 100644 --- a/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/IcebergAcidUtil.java +++ b/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/IcebergAcidUtil.java @@ -23,12 +23,15 @@ import java.util.List; import java.util.Map; import java.util.Objects; +import java.util.Optional; import org.apache.commons.lang3.ObjectUtils; import org.apache.commons.lang3.StringUtils; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hive.ql.io.PositionDeleteInfo; import org.apache.hadoop.hive.ql.io.RowLineageInfo; +import org.apache.hadoop.hive.ql.lockmgr.HiveTxnManager; import org.apache.hadoop.hive.ql.metadata.VirtualColumn; +import org.apache.hadoop.hive.ql.session.SessionState; import org.apache.iceberg.ContentFile; import org.apache.iceberg.MetadataColumns; import org.apache.iceberg.PartitionKey; @@ -36,9 +39,11 @@ import org.apache.iceberg.Schema; import org.apache.iceberg.StructLike; import org.apache.iceberg.Table; +import org.apache.iceberg.Transaction; import org.apache.iceberg.data.GenericRecord; import org.apache.iceberg.data.Record; import org.apache.iceberg.deletes.PositionDelete; +import org.apache.iceberg.hive.HiveTxnCoordinator; import org.apache.iceberg.io.CloseableIterator; import org.apache.iceberg.mr.mapreduce.RowLineageReader; import org.apache.iceberg.relocated.com.google.common.collect.Lists; @@ -218,6 +223,30 @@ public static void copyFields(GenericRecord source, int start, int len, GenericR } } + public static Transaction getOrCreateTransaction(Table table, Configuration conf) { + HiveTxnManager txnManager = Optional.ofNullable(SessionState.get()) + .map(SessionState::getTxnMgr).orElse(null); + if (txnManager == null) { + return table.newTransaction(); + } + HiveTxnCoordinator txnCoordinator = txnManager.getOrSetTxnCoordinator( + HiveTxnCoordinator.class, msClient -> new HiveTxnCoordinator(conf, msClient)); + return txnCoordinator != null ? + txnCoordinator.getOrCreateTransaction(table) : table.newTransaction(); + } + + public static Transaction getTransaction(Table table) { + HiveTxnManager txnManager = Optional.ofNullable(SessionState.get()) + .map(SessionState::getTxnMgr).orElse(null); + if (txnManager == null) { + return null; + } + HiveTxnCoordinator txnCoordinator = txnManager.getOrSetTxnCoordinator( + HiveTxnCoordinator.class, null); + return txnCoordinator != null ? + txnCoordinator.getTransaction(table) : null; + } + public static class VirtualColumnAwareIterator implements CloseableIterator { private final CloseableIterator currentIterator; diff --git a/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/IcebergTableUtil.java b/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/IcebergTableUtil.java index ceb848c30952..9157a875d5a4 100644 --- a/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/IcebergTableUtil.java +++ b/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/IcebergTableUtil.java @@ -86,6 +86,7 @@ import org.apache.iceberg.StructLike; import org.apache.iceberg.Table; import org.apache.iceberg.TableProperties; +import org.apache.iceberg.Transaction; import org.apache.iceberg.UpdatePartitionSpec; import org.apache.iceberg.catalog.TableIdentifier; import org.apache.iceberg.expressions.Expression; @@ -185,8 +186,13 @@ static Table getTable(Configuration configuration, Properties properties, boolea if (skipCache) { return tableLoadFunc.apply(null); } else { - return SessionStateUtil.getResource(configuration, tableIdentifier).filter(o -> o instanceof Table) - .map(o -> (Table) o).orElseGet(() -> { + return SessionStateUtil.getResource(configuration, tableIdentifier) + .filter(Table.class::isInstance) // cleaner than instanceof lambda + .map(Table.class::cast) + .map(tbl -> Optional.ofNullable(IcebergAcidUtil.getTransaction(tbl)) + .map(Transaction::table) + .orElse(tbl)) + .orElseGet(() -> { LOG.debug("Iceberg table {} is not found in QueryState. Loading table from configured catalog", tableIdentifier); return tableLoadFunc.apply(null); diff --git a/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/TestHiveIcebergOutputCommitter.java b/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/TestHiveIcebergOutputCommitter.java index 99aab0613432..e60c21a0e69f 100644 --- a/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/TestHiveIcebergOutputCommitter.java +++ b/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/TestHiveIcebergOutputCommitter.java @@ -298,8 +298,10 @@ private List writeRecords(String name, int taskNum, int attemptNum, bool return expected; } - private List writeRecords(String name, int taskNum, int attemptNum, boolean commitTasks, boolean abortTasks, - JobConf conf) throws IOException { - return writeRecords(name, taskNum, attemptNum, commitTasks, abortTasks, conf, new HiveIcebergOutputCommitter()); + private List writeRecords( + String name, int taskNum, int attemptNum, boolean commitTasks, boolean abortTasks, JobConf conf) + throws IOException { + return writeRecords(name, taskNum, attemptNum, commitTasks, abortTasks, conf, + new HiveIcebergOutputCommitter(conf)); } } diff --git a/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/test/concurrent/HiveIcebergStorageHandlerStub.java b/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/test/concurrent/HiveIcebergStorageHandlerStub.java index a9bd1af75118..dd9ea4a6112e 100644 --- a/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/test/concurrent/HiveIcebergStorageHandlerStub.java +++ b/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/test/concurrent/HiveIcebergStorageHandlerStub.java @@ -51,7 +51,7 @@ public class HiveIcebergStorageHandlerStub extends HiveIcebergStorageHandler { @Override public HiveIcebergOutputCommitter getOutputCommitter() { - return new HiveIcebergOutputCommitter() { + return new HiveIcebergOutputCommitter(conf) { @Override public void commitJobs(List originalContextList, Context.Operation operation) throws IOException { int queryIndex = ThreadContext.getQueryIndex(); diff --git a/iceberg/iceberg-handler/src/test/queries/positive/iceberg_multi_table_txn.q b/iceberg/iceberg-handler/src/test/queries/positive/iceberg_multi_table_txn.q new file mode 100644 index 000000000000..3af717c1fe37 --- /dev/null +++ b/iceberg/iceberg-handler/src/test/queries/positive/iceberg_multi_table_txn.q @@ -0,0 +1,35 @@ +-- SORT_QUERY_RESULTS + +set hive.support.concurrency=true; +set hive.txn.manager=org.apache.hadoop.hive.ql.lockmgr.DbTxnManager; + +drop table if exists iceberg_txn_t1; +drop table if exists iceberg_txn_t2; + +create external table iceberg_txn_t1(a int) stored by iceberg +tblproperties ('format-version'='2'); + +create external table iceberg_txn_t2(a int) stored by iceberg +tblproperties ('format-version'='2'); + +from ( + select 1 as a union all select 2 +) s +insert into iceberg_txn_t1 + select a +insert into iceberg_txn_t2 + select a + 10; + +select * from iceberg_txn_t1 order by a; +select * from iceberg_txn_t2 order by a; + +start transaction; +insert into iceberg_txn_t1 values (3); +update iceberg_txn_t2 set a = a + 1; +commit; + +select * from iceberg_txn_t1 order by a; +select * from iceberg_txn_t2 order by a; + +drop table if exists iceberg_txn_t1; +drop table if exists iceberg_txn_t2; diff --git a/iceberg/iceberg-handler/src/test/results/positive/iceberg_multi_table_txn.q.out b/iceberg/iceberg-handler/src/test/results/positive/iceberg_multi_table_txn.q.out new file mode 100644 index 000000000000..d0f9475dd9bf --- /dev/null +++ b/iceberg/iceberg-handler/src/test/results/positive/iceberg_multi_table_txn.q.out @@ -0,0 +1,141 @@ +PREHOOK: query: drop table if exists iceberg_txn_t1 +PREHOOK: type: DROPTABLE +PREHOOK: Output: database:default +POSTHOOK: query: drop table if exists iceberg_txn_t1 +POSTHOOK: type: DROPTABLE +POSTHOOK: Output: database:default +PREHOOK: query: drop table if exists iceberg_txn_t2 +PREHOOK: type: DROPTABLE +PREHOOK: Output: database:default +POSTHOOK: query: drop table if exists iceberg_txn_t2 +POSTHOOK: type: DROPTABLE +POSTHOOK: Output: database:default +PREHOOK: query: create external table iceberg_txn_t1(a int) stored by iceberg +tblproperties ('format-version'='2') +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:default +PREHOOK: Output: default@iceberg_txn_t1 +POSTHOOK: query: create external table iceberg_txn_t1(a int) stored by iceberg +tblproperties ('format-version'='2') +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:default +POSTHOOK: Output: default@iceberg_txn_t1 +PREHOOK: query: create external table iceberg_txn_t2(a int) stored by iceberg +tblproperties ('format-version'='2') +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:default +PREHOOK: Output: default@iceberg_txn_t2 +POSTHOOK: query: create external table iceberg_txn_t2(a int) stored by iceberg +tblproperties ('format-version'='2') +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:default +POSTHOOK: Output: default@iceberg_txn_t2 +PREHOOK: query: from ( + select 1 as a union all select 2 +) s +insert into iceberg_txn_t1 + select a +insert into iceberg_txn_t2 + select a + 10 +PREHOOK: type: QUERY +PREHOOK: Input: _dummy_database@_dummy_table +PREHOOK: Output: default@iceberg_txn_t1 +PREHOOK: Output: default@iceberg_txn_t2 +POSTHOOK: query: from ( + select 1 as a union all select 2 +) s +insert into iceberg_txn_t1 + select a +insert into iceberg_txn_t2 + select a + 10 +POSTHOOK: type: QUERY +POSTHOOK: Input: _dummy_database@_dummy_table +POSTHOOK: Output: default@iceberg_txn_t1 +POSTHOOK: Output: default@iceberg_txn_t2 +PREHOOK: query: select * from iceberg_txn_t1 order by a +PREHOOK: type: QUERY +PREHOOK: Input: default@iceberg_txn_t1 +PREHOOK: Output: hdfs://### HDFS PATH ### +POSTHOOK: query: select * from iceberg_txn_t1 order by a +POSTHOOK: type: QUERY +POSTHOOK: Input: default@iceberg_txn_t1 +POSTHOOK: Output: hdfs://### HDFS PATH ### +1 +2 +PREHOOK: query: select * from iceberg_txn_t2 order by a +PREHOOK: type: QUERY +PREHOOK: Input: default@iceberg_txn_t2 +PREHOOK: Output: hdfs://### HDFS PATH ### +POSTHOOK: query: select * from iceberg_txn_t2 order by a +POSTHOOK: type: QUERY +POSTHOOK: Input: default@iceberg_txn_t2 +POSTHOOK: Output: hdfs://### HDFS PATH ### +11 +12 +PREHOOK: query: start transaction +PREHOOK: type: START TRANSACTION +POSTHOOK: query: start transaction +POSTHOOK: type: START TRANSACTION +PREHOOK: query: insert into iceberg_txn_t1 values (3) +PREHOOK: type: QUERY +PREHOOK: Input: _dummy_database@_dummy_table +PREHOOK: Output: default@iceberg_txn_t1 +POSTHOOK: query: insert into iceberg_txn_t1 values (3) +POSTHOOK: type: QUERY +POSTHOOK: Input: _dummy_database@_dummy_table +POSTHOOK: Output: default@iceberg_txn_t1 +PREHOOK: query: update iceberg_txn_t2 set a = a + 1 +PREHOOK: type: QUERY +PREHOOK: Input: default@iceberg_txn_t2 +PREHOOK: Output: default@iceberg_txn_t2 +PREHOOK: Output: default@iceberg_txn_t2 +POSTHOOK: query: update iceberg_txn_t2 set a = a + 1 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@iceberg_txn_t2 +POSTHOOK: Output: default@iceberg_txn_t2 +POSTHOOK: Output: default@iceberg_txn_t2 +PREHOOK: query: commit +PREHOOK: type: COMMIT +POSTHOOK: query: commit +POSTHOOK: type: COMMIT +PREHOOK: query: select * from iceberg_txn_t1 order by a +PREHOOK: type: QUERY +PREHOOK: Input: default@iceberg_txn_t1 +PREHOOK: Output: hdfs://### HDFS PATH ### +POSTHOOK: query: select * from iceberg_txn_t1 order by a +POSTHOOK: type: QUERY +POSTHOOK: Input: default@iceberg_txn_t1 +POSTHOOK: Output: hdfs://### HDFS PATH ### +1 +2 +3 +PREHOOK: query: select * from iceberg_txn_t2 order by a +PREHOOK: type: QUERY +PREHOOK: Input: default@iceberg_txn_t2 +PREHOOK: Output: hdfs://### HDFS PATH ### +POSTHOOK: query: select * from iceberg_txn_t2 order by a +POSTHOOK: type: QUERY +POSTHOOK: Input: default@iceberg_txn_t2 +POSTHOOK: Output: hdfs://### HDFS PATH ### +12 +13 +PREHOOK: query: drop table if exists iceberg_txn_t1 +PREHOOK: type: DROPTABLE +PREHOOK: Input: default@iceberg_txn_t1 +PREHOOK: Output: database:default +PREHOOK: Output: default@iceberg_txn_t1 +POSTHOOK: query: drop table if exists iceberg_txn_t1 +POSTHOOK: type: DROPTABLE +POSTHOOK: Input: default@iceberg_txn_t1 +POSTHOOK: Output: database:default +POSTHOOK: Output: default@iceberg_txn_t1 +PREHOOK: query: drop table if exists iceberg_txn_t2 +PREHOOK: type: DROPTABLE +PREHOOK: Input: default@iceberg_txn_t2 +PREHOOK: Output: database:default +PREHOOK: Output: default@iceberg_txn_t2 +POSTHOOK: query: drop table if exists iceberg_txn_t2 +POSTHOOK: type: DROPTABLE +POSTHOOK: Input: default@iceberg_txn_t2 +POSTHOOK: Output: database:default +POSTHOOK: Output: default@iceberg_txn_t2 diff --git a/ql/src/java/org/apache/hadoop/hive/ql/DriverTxnHandler.java b/ql/src/java/org/apache/hadoop/hive/ql/DriverTxnHandler.java index 307b4395d7f5..544cb2cf3db5 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/DriverTxnHandler.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/DriverTxnHandler.java @@ -27,6 +27,7 @@ import java.util.List; import java.util.Map; import java.util.Queue; +import java.util.Optional; import java.util.Set; import java.util.stream.Collectors; @@ -83,6 +84,8 @@ class DriverTxnHandler { private static final LogHelper CONSOLE = new LogHelper(LOG); private static final int SHUTDOWN_HOOK_PRIORITY = 0; + private static final Set COMMIT_OR_ROLLBACK = Set.of(HiveOperation.COMMIT, HiveOperation.ROLLBACK); + private final DriverContext driverContext; private final DriverState driverState; @@ -567,11 +570,19 @@ void release() { void destroy(String queryIdFromDriver) { // We need cleanup transactions, even if we did not acquired locks yet // However TxnManager is bound to session, so wee need to check if it is already handling a new query + + HiveTxnManager txnManager = Optional.ofNullable(driverContext) + .map(DriverContext::getTxnManager) + .orElse(null); + + HiveOperation op = Optional.ofNullable(driverContext) + .map(DriverContext::getQueryState).map(QueryState::getHiveOperation) + .orElse(null); + boolean isTxnOpen = - driverContext != null && - driverContext.getTxnManager() != null && - driverContext.getTxnManager().isTxnOpen() && - org.apache.commons.lang3.StringUtils.equals(queryIdFromDriver, driverContext.getTxnManager().getQueryid()); + txnManager != null && txnManager.isTxnOpen() && + (txnManager.isImplicitTransactionOpen(context) || COMMIT_OR_ROLLBACK.contains(op)) && + org.apache.commons.lang3.StringUtils.equals(queryIdFromDriver, txnManager.getQueryid()); release(!hiveLocks.isEmpty() || isTxnOpen); } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/lockmgr/AcidTxnCoordinator.java b/ql/src/java/org/apache/hadoop/hive/ql/lockmgr/AcidTxnCoordinator.java new file mode 100644 index 000000000000..dba1a7ac10be --- /dev/null +++ b/ql/src/java/org/apache/hadoop/hive/ql/lockmgr/AcidTxnCoordinator.java @@ -0,0 +1,88 @@ +/* + * 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.lockmgr; + +import org.apache.hadoop.hive.common.JavaUtils; +import org.apache.hadoop.hive.TxnCoordinator; +import org.apache.hadoop.hive.conf.HiveConf; +import org.apache.hadoop.hive.metastore.IMetaStoreClient; +import org.apache.hadoop.hive.metastore.api.AbortTxnRequest; +import org.apache.hadoop.hive.metastore.api.CommitTxnRequest; +import org.apache.hadoop.hive.metastore.api.NoSuchTxnException; +import org.apache.hadoop.hive.metastore.api.TxnAbortedException; +import org.apache.hadoop.hive.metastore.api.TxnType; +import org.apache.hadoop.hive.metastore.txn.TxnErrorMsg; +import org.apache.hadoop.hive.ql.ErrorMsg; +import org.apache.thrift.TException; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * Hive ACID transaction coordinator. + */ +public class AcidTxnCoordinator implements TxnCoordinator { + + static final private Logger LOG = LoggerFactory.getLogger(AcidTxnCoordinator.class); + + private final HiveConf conf; + private final IMetaStoreClient msClient; + private final String replPolicy; + private final long txnId; + + public AcidTxnCoordinator( + HiveConf conf, IMetaStoreClient msClient, String replPolicy, long txnId) { + this.conf = conf; + this.msClient = msClient; + this.replPolicy = replPolicy; + this.txnId = txnId; + } + + @Override + public void commit() throws TException { + LOG.debug("Committing txn {}", JavaUtils.txnIdToString(txnId)); + CommitTxnRequest commitTxnRequest = new CommitTxnRequest(txnId); + commitTxnRequest.setExclWriteEnabled(conf.getBoolVar(HiveConf.ConfVars.TXN_WRITE_X_LOCK)); + if (replPolicy != null) { + commitTxnRequest.setReplPolicy(replPolicy); + commitTxnRequest.setTxn_type(TxnType.DEFAULT); + } + msClient.commitTxn(commitTxnRequest); + } + + @Override + public void rollback() throws TException { + LOG.debug("Rolling back {}", JavaUtils.txnIdToString(txnId)); + if (replPolicy != null) { + msClient.replRollbackTxn(txnId, replPolicy, TxnType.DEFAULT); + } else { + AbortTxnRequest abortTxnRequest = new AbortTxnRequest(txnId); + abortTxnRequest.setErrorCode(TxnErrorMsg.ABORT_ROLLBACK.getErrorCode()); + msClient.rollbackTxn(abortTxnRequest); + } + } + + private boolean isTxnOpen() { + return txnId > 0; + } + + @Override + public boolean hasPendingWork() { + return isTxnOpen(); + } +} 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 04d498815f06..4316af69ac6c 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 @@ -22,6 +22,7 @@ import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hive.common.JavaUtils; +import org.apache.hadoop.hive.TxnCoordinator; import org.apache.hadoop.hive.common.ValidTxnList; import org.apache.hadoop.hive.common.ValidTxnWriteIdList; import org.apache.hadoop.hive.conf.Constants; @@ -29,7 +30,8 @@ import org.apache.hadoop.hive.metastore.IMetaStoreClient; import org.apache.hadoop.hive.metastore.LockComponentBuilder; import org.apache.hadoop.hive.metastore.LockRequestBuilder; -import org.apache.hadoop.hive.metastore.api.AbortTxnRequest; +import org.apache.hadoop.hive.metastore.api.DataOperationType; +import org.apache.hadoop.hive.metastore.api.GetOpenTxnsResponse; import org.apache.hadoop.hive.metastore.api.LockComponent; import org.apache.hadoop.hive.metastore.api.LockRequest; import org.apache.hadoop.hive.metastore.api.LockResponse; @@ -40,11 +42,8 @@ import org.apache.hadoop.hive.metastore.api.TxnAbortedException; import org.apache.hadoop.hive.metastore.api.TxnToWriteId; import org.apache.hadoop.hive.metastore.api.CommitTxnRequest; -import org.apache.hadoop.hive.metastore.api.DataOperationType; -import org.apache.hadoop.hive.metastore.api.GetOpenTxnsResponse; import org.apache.hadoop.hive.metastore.api.TxnType; import org.apache.hadoop.hive.metastore.txn.TxnCommonUtils; -import org.apache.hadoop.hive.metastore.txn.TxnErrorMsg; import org.apache.hadoop.hive.ql.Context; import org.apache.hadoop.hive.ql.ErrorMsg; import org.apache.hadoop.hive.ql.QueryPlan; @@ -178,6 +177,8 @@ public final class DbTxnManager extends HiveTxnManagerImpl { private static final int SHUTDOWN_HOOK_PRIORITY = 0; //Contains database under replication name for hive replication transactions (dump and load operation) private String replPolicy; + + private TxnCoordinator txnCoordinator; /** * We do this on every call to make sure TM uses same MS connection as is used by the caller (Driver, @@ -261,6 +262,7 @@ long openTxn(Context ctx, String user, TxnType txnType, long delay) throws LockE } else { txnId = getMS().openTxn(user, txnType); } + txnCoordinator = null; stmtId = 0; numStatements = 0; tableWriteIds.clear(); @@ -512,12 +514,15 @@ public void releaseLocks(List hiveLocks) { } private void clearLocksAndHB() { - lockMgr.clearLocalLockRecords(); - stopHeartbeat(); + if (lockMgr != null) { + stopHeartbeat(); + lockMgr.clearLocalLockRecords(); + } } private void resetTxnInfo() { txnId = 0; + txnCoordinator = null; stmtId = -1; numStatements = 0; tableWriteIds.clear(); @@ -526,6 +531,31 @@ private void resetTxnInfo() { replPolicy = null; } + public T getOrSetTxnCoordinator( + Class clazz, Function creator) { + if (txnCoordinator == null && creator != null) { + try { + txnCoordinator = creator.apply(getMS()); + numStatements = 1; + } catch (LockException e) { + throw new RuntimeException(e); + } + } + return clazz.cast(txnCoordinator); + } + + private TxnCoordinator getTxnCoordinator() throws LockException { + if (txnCoordinator == null) { + txnCoordinator = getDefaultCoordinator(); + } + return txnCoordinator; + } + + private TxnCoordinator getDefaultCoordinator() throws LockException { + return new AcidTxnCoordinator( + (HiveConf) getConf(), getMS(), replPolicy, txnId); + } + @Override public void replCommitTxn(CommitTxnRequest rqst) throws LockException { try { @@ -563,14 +593,8 @@ public void commitTxn() throws LockException { try { // do all new clear in clearLocksAndHB method to make sure that same code is there for replCommitTxn flow. clearLocksAndHB(); - LOG.debug("Committing txn " + JavaUtils.txnIdToString(txnId)); - CommitTxnRequest commitTxnRequest = new CommitTxnRequest(txnId); - commitTxnRequest.setExclWriteEnabled(conf.getBoolVar(HiveConf.ConfVars.TXN_WRITE_X_LOCK)); - if (replPolicy != null) { - commitTxnRequest.setReplPolicy(replPolicy); - commitTxnRequest.setTxn_type(TxnType.DEFAULT); - } - getMS().commitTxn(commitTxnRequest); + getTxnCoordinator().commit(); + } catch (NoSuchTxnException e) { LOG.error("Metastore could not find " + JavaUtils.txnIdToString(txnId)); throw new LockException(e, ErrorMsg.TXN_NO_SUCH_TRANSACTION, JavaUtils.txnIdToString(txnId)); @@ -579,13 +603,34 @@ public void commitTxn() throws LockException { LOG.error(le.getMessage()); throw le; } catch (TException e) { - throw new LockException(ErrorMsg.METASTORE_COMMUNICATION_FAILED.getMsg(), - e); + throw new LockException(ErrorMsg.METASTORE_COMMUNICATION_FAILED.getMsg(), e); } finally { // do all new reset in resetTxnInfo method to make sure that same code is there for replCommitTxn flow. resetTxnInfo(); } } + + @Override + public void rollbackTxn() throws LockException { + if (!isTxnOpen()) { + throw new RuntimeException("Attempt to rollback before opening a transaction"); + } + try { + clearLocksAndHB(); + getTxnCoordinator().rollback(); + + } catch (NoSuchTxnException e) { + LOG.error("Metastore could not find " + JavaUtils.txnIdToString(txnId)); + throw new LockException(e, ErrorMsg.TXN_NO_SUCH_TRANSACTION, JavaUtils.txnIdToString(txnId)); + } catch(TxnAbortedException e) { + throw new LockException(e, ErrorMsg.TXN_ABORTED, JavaUtils.txnIdToString(txnId)); + } catch (TException e) { + throw new LockException(ErrorMsg.METASTORE_COMMUNICATION_FAILED.getMsg(), e); + } finally { + resetTxnInfo(); + } + } + @Override public void replRollbackTxn(String replPolicy, long srcTxnId) throws LockException { try { @@ -611,36 +656,6 @@ public Map getReplayedTxnsForPolicy(String replPolicy) throws Lo } } - @Override - public void rollbackTxn() throws LockException { - if (!isTxnOpen()) { - throw new RuntimeException("Attempt to rollback before opening a transaction"); - } - try { - clearLocksAndHB(); - LOG.debug("Rolling back " + JavaUtils.txnIdToString(txnId)); - - if (replPolicy != null) { - getMS().replRollbackTxn(txnId, replPolicy, TxnType.DEFAULT); - } else { - AbortTxnRequest abortTxnRequest = new AbortTxnRequest(txnId); - abortTxnRequest.setErrorCode(TxnErrorMsg.ABORT_ROLLBACK.getErrorCode()); - getMS().rollbackTxn(abortTxnRequest); - } - } catch (NoSuchTxnException e) { - LOG.error("Metastore could not find " + JavaUtils.txnIdToString(txnId)); - throw new LockException(e, ErrorMsg.TXN_NO_SUCH_TRANSACTION, JavaUtils.txnIdToString(txnId)); - - } catch(TxnAbortedException e) { - throw new LockException(e, ErrorMsg.TXN_ABORTED, JavaUtils.txnIdToString(txnId)); - - } catch (TException e) { - throw new LockException(ErrorMsg.METASTORE_COMMUNICATION_FAILED.getMsg(), e); - } finally { - resetTxnInfo(); - } - } - @Override public void replTableWriteIdState(String validWriteIdList, String dbName, String tableName, List partNames) throws LockException { @@ -961,17 +976,21 @@ public static class HeartbeaterThread extends Thread { @Override public boolean isTxnOpen() { - return txnId > 0; + return txnId > 0 || + txnCoordinator != null && txnCoordinator.hasPendingWork(); } + @Override public long getCurrentTxnId() { return txnId; } + @Override public int getStmtIdAndIncrement() { assert isTxnOpen(); return stmtId++; } + @Override public int getCurrentStmtId() { assert isTxnOpen(); 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 aec7a809d279..90778091c68c 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 @@ -17,8 +17,10 @@ */ package org.apache.hadoop.hive.ql.lockmgr; +import org.apache.hadoop.hive.TxnCoordinator; import org.apache.hadoop.hive.common.ValidTxnList; import org.apache.hadoop.hive.common.ValidTxnWriteIdList; +import org.apache.hadoop.hive.metastore.IMetaStoreClient; import org.apache.hadoop.hive.metastore.api.CommitTxnRequest; import org.apache.hadoop.hive.metastore.api.GetOpenTxnsResponse; import org.apache.hadoop.hive.metastore.api.LockResponse; @@ -36,6 +38,7 @@ import java.util.List; import java.util.Map; +import java.util.function.Function; /** * An interface that allows Hive to manage transactions. All classes @@ -102,6 +105,21 @@ public interface HiveTxnManager { void replTableWriteIdState(String validWriteIdList, String dbName, String tableName, List partNames) throws LockException; + /** + * Returns the transaction coordinator managed by this transaction manager. + *

+ * This method must be used instead of directly instantiating a transaction + * coordinator, as the transaction manager is responsible for selecting and + * managing the coordinator’s lifecycle. + * @param clazz the transaction coordinator class to get or set + * @param creator a function that creates a new coordinator instance if one is not already set + * @return the instance of the transaction coordinator + */ + default T getOrSetTxnCoordinator( + Class clazz, Function creator) { + return null; + } + /** * 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/reexec/ReExecuteOnWriteConflictPlugin.java b/ql/src/java/org/apache/hadoop/hive/ql/reexec/ReExecuteOnWriteConflictPlugin.java index 4b4a3044ada0..932e3375498e 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/reexec/ReExecuteOnWriteConflictPlugin.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/reexec/ReExecuteOnWriteConflictPlugin.java @@ -26,31 +26,40 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import java.util.Set; + public class ReExecuteOnWriteConflictPlugin implements IReExecutionPlugin { private static final Logger LOG = LoggerFactory.getLogger(ReExecuteOnWriteConflictPlugin.class); private static boolean retryPossible; - private static final String validationException = "org.apache.iceberg.exceptions.ValidationException"; + private static final Set RETRYABLE_EXCEPTION_CLASS_NAMES = Set.of( + "org.apache.iceberg.exceptions.ValidationException", + "org.apache.iceberg.exceptions.CommitFailedException" + ); private static final class LocalHook implements ExecuteWithHookContext { @Override - public void run(HookContext hookContext) throws Exception { - if (hookContext.getHookType() == HookContext.HookType.ON_FAILURE_HOOK) { - Throwable exception = hookContext.getException(); - - if (exception != null && exception.getMessage() != null) { - Throwable cause = Throwables.getRootCause(exception); + public void run(HookContext hookContext) { + if (hookContext.getHookType() != HookContext.HookType.ON_FAILURE_HOOK) { + return; + } + Throwable exception = hookContext.getException(); + if (exception == null) { + return; + } + Throwable rootCause = Throwables.getRootCause(exception); - if (cause.getClass().getName().equals(validationException)) { - retryPossible = true; - LOG.info("Retrying query due to write conflict."); - } - LOG.info("Got exception message: {} retryPossible: {}", exception.getMessage(), retryPossible); - } + if (isRetryable(rootCause)) { + LOG.info("Write conflict detected ({}), retrying query.", rootCause.getClass().getName()); + retryPossible = true; } } } + private static boolean isRetryable(Throwable t) { + return RETRYABLE_EXCEPTION_CLASS_NAMES.contains(t.getClass().getName()); + } + @Override public void initialize(Driver driver) { driver.getHookRunner().addOnFailureHook(new ReExecuteOnWriteConflictPlugin.LocalHook()); diff --git a/standalone-metastore/metastore-client/src/main/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java b/standalone-metastore/metastore-client/src/main/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java index f13c7de29b12..99c257e64e34 100644 --- a/standalone-metastore/metastore-client/src/main/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java +++ b/standalone-metastore/metastore-client/src/main/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java @@ -1938,6 +1938,14 @@ default void alter_table(String catName, String databaseName, String tblName, Ta * @throws MetaException something went wrong, usually in the RDBMS * @throws TException general thrift error */ + + /** + * Multi-table table-parameter update. + */ + default void updateTableParams(List updates) throws TException { + throw new UnsupportedOperationException("MetaStore client does not support updating table params"); + } + void createDatabase(Database db) throws InvalidObjectException, AlreadyExistsException, MetaException, TException; diff --git a/standalone-metastore/metastore-client/src/main/java/org/apache/hadoop/hive/metastore/client/MetaStoreClientWrapper.java b/standalone-metastore/metastore-client/src/main/java/org/apache/hadoop/hive/metastore/client/MetaStoreClientWrapper.java index 4d63e4f88124..aac5fadeeef2 100644 --- a/standalone-metastore/metastore-client/src/main/java/org/apache/hadoop/hive/metastore/client/MetaStoreClientWrapper.java +++ b/standalone-metastore/metastore-client/src/main/java/org/apache/hadoop/hive/metastore/client/MetaStoreClientWrapper.java @@ -856,6 +856,11 @@ public void abortTxns(AbortTxnsRequest abortTxnsRequest) throws TException { delegate.abortTxns(abortTxnsRequest); } + @Override + public void updateTableParams(List updates) throws TException { + delegate.updateTableParams(updates); + } + @Override public long allocateTableWriteId(long txnId, String dbName, String tableName, boolean reallocate) throws TException { diff --git a/standalone-metastore/metastore-client/src/main/java/org/apache/hadoop/hive/metastore/client/ThriftHiveMetaStoreClient.java b/standalone-metastore/metastore-client/src/main/java/org/apache/hadoop/hive/metastore/client/ThriftHiveMetaStoreClient.java index 563a4a8c99d1..3ca384d9696b 100644 --- a/standalone-metastore/metastore-client/src/main/java/org/apache/hadoop/hive/metastore/client/ThriftHiveMetaStoreClient.java +++ b/standalone-metastore/metastore-client/src/main/java/org/apache/hadoop/hive/metastore/client/ThriftHiveMetaStoreClient.java @@ -501,6 +501,11 @@ public void alter_table(String catName, String dbName, String tbl_name, Table ne client.alter_table_req(req); } + @Override + public void updateTableParams(List updates) throws TException { + client.update_table_params(updates); + } + @Override public void renamePartition(String catName, String dbname, String tableName, List part_vals, Partition newPart, String validWriteIds, long txnId, boolean makeCopy) throws TException { diff --git a/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp b/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp index f732661b8ef0..03271507b53c 100644 --- a/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp +++ b/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp @@ -3222,14 +3222,14 @@ uint32_t ThriftHiveMetastore_get_databases_result::read(::apache::thrift::protoc if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1965; - ::apache::thrift::protocol::TType _etype1968; - xfer += iprot->readListBegin(_etype1968, _size1965); - this->success.resize(_size1965); - uint32_t _i1969; - for (_i1969 = 0; _i1969 < _size1965; ++_i1969) + uint32_t _size1975; + ::apache::thrift::protocol::TType _etype1978; + xfer += iprot->readListBegin(_etype1978, _size1975); + this->success.resize(_size1975); + uint32_t _i1979; + for (_i1979 = 0; _i1979 < _size1975; ++_i1979) { - xfer += iprot->readString(this->success[_i1969]); + xfer += iprot->readString(this->success[_i1979]); } xfer += iprot->readListEnd(); } @@ -3268,10 +3268,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 _iter1970; - for (_iter1970 = this->success.begin(); _iter1970 != this->success.end(); ++_iter1970) + std::vector ::const_iterator _iter1980; + for (_iter1980 = this->success.begin(); _iter1980 != this->success.end(); ++_iter1980) { - xfer += oprot->writeString((*_iter1970)); + xfer += oprot->writeString((*_iter1980)); } xfer += oprot->writeListEnd(); } @@ -3316,14 +3316,14 @@ uint32_t ThriftHiveMetastore_get_databases_presult::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1971; - ::apache::thrift::protocol::TType _etype1974; - xfer += iprot->readListBegin(_etype1974, _size1971); - (*(this->success)).resize(_size1971); - uint32_t _i1975; - for (_i1975 = 0; _i1975 < _size1971; ++_i1975) + uint32_t _size1981; + ::apache::thrift::protocol::TType _etype1984; + xfer += iprot->readListBegin(_etype1984, _size1981); + (*(this->success)).resize(_size1981); + uint32_t _i1985; + for (_i1985 = 0; _i1985 < _size1981; ++_i1985) { - xfer += iprot->readString((*(this->success))[_i1975]); + xfer += iprot->readString((*(this->success))[_i1985]); } xfer += iprot->readListEnd(); } @@ -3440,14 +3440,14 @@ uint32_t ThriftHiveMetastore_get_all_databases_result::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1976; - ::apache::thrift::protocol::TType _etype1979; - xfer += iprot->readListBegin(_etype1979, _size1976); - this->success.resize(_size1976); - uint32_t _i1980; - for (_i1980 = 0; _i1980 < _size1976; ++_i1980) + uint32_t _size1986; + ::apache::thrift::protocol::TType _etype1989; + xfer += iprot->readListBegin(_etype1989, _size1986); + this->success.resize(_size1986); + uint32_t _i1990; + for (_i1990 = 0; _i1990 < _size1986; ++_i1990) { - xfer += iprot->readString(this->success[_i1980]); + xfer += iprot->readString(this->success[_i1990]); } xfer += iprot->readListEnd(); } @@ -3486,10 +3486,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 _iter1981; - for (_iter1981 = this->success.begin(); _iter1981 != this->success.end(); ++_iter1981) + std::vector ::const_iterator _iter1991; + for (_iter1991 = this->success.begin(); _iter1991 != this->success.end(); ++_iter1991) { - xfer += oprot->writeString((*_iter1981)); + xfer += oprot->writeString((*_iter1991)); } xfer += oprot->writeListEnd(); } @@ -3534,14 +3534,14 @@ uint32_t ThriftHiveMetastore_get_all_databases_presult::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1982; - ::apache::thrift::protocol::TType _etype1985; - xfer += iprot->readListBegin(_etype1985, _size1982); - (*(this->success)).resize(_size1982); - uint32_t _i1986; - for (_i1986 = 0; _i1986 < _size1982; ++_i1986) + uint32_t _size1992; + ::apache::thrift::protocol::TType _etype1995; + xfer += iprot->readListBegin(_etype1995, _size1992); + (*(this->success)).resize(_size1992); + uint32_t _i1996; + for (_i1996 = 0; _i1996 < _size1992; ++_i1996) { - xfer += iprot->readString((*(this->success))[_i1986]); + xfer += iprot->readString((*(this->success))[_i1996]); } xfer += iprot->readListEnd(); } @@ -4976,14 +4976,14 @@ uint32_t ThriftHiveMetastore_get_dataconnectors_result::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1987; - ::apache::thrift::protocol::TType _etype1990; - xfer += iprot->readListBegin(_etype1990, _size1987); - this->success.resize(_size1987); - uint32_t _i1991; - for (_i1991 = 0; _i1991 < _size1987; ++_i1991) + uint32_t _size1997; + ::apache::thrift::protocol::TType _etype2000; + xfer += iprot->readListBegin(_etype2000, _size1997); + this->success.resize(_size1997); + uint32_t _i2001; + for (_i2001 = 0; _i2001 < _size1997; ++_i2001) { - xfer += iprot->readString(this->success[_i1991]); + xfer += iprot->readString(this->success[_i2001]); } xfer += iprot->readListEnd(); } @@ -5022,10 +5022,10 @@ uint32_t ThriftHiveMetastore_get_dataconnectors_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 _iter1992; - for (_iter1992 = this->success.begin(); _iter1992 != this->success.end(); ++_iter1992) + std::vector ::const_iterator _iter2002; + for (_iter2002 = this->success.begin(); _iter2002 != this->success.end(); ++_iter2002) { - xfer += oprot->writeString((*_iter1992)); + xfer += oprot->writeString((*_iter2002)); } xfer += oprot->writeListEnd(); } @@ -5070,14 +5070,14 @@ uint32_t ThriftHiveMetastore_get_dataconnectors_presult::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1993; - ::apache::thrift::protocol::TType _etype1996; - xfer += iprot->readListBegin(_etype1996, _size1993); - (*(this->success)).resize(_size1993); - uint32_t _i1997; - for (_i1997 = 0; _i1997 < _size1993; ++_i1997) + uint32_t _size2003; + ::apache::thrift::protocol::TType _etype2006; + xfer += iprot->readListBegin(_etype2006, _size2003); + (*(this->success)).resize(_size2003); + uint32_t _i2007; + for (_i2007 = 0; _i2007 < _size2003; ++_i2007) { - xfer += iprot->readString((*(this->success))[_i1997]); + xfer += iprot->readString((*(this->success))[_i2007]); } xfer += iprot->readListEnd(); } @@ -6123,17 +6123,17 @@ uint32_t ThriftHiveMetastore_get_type_all_result::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_MAP) { { this->success.clear(); - uint32_t _size1998; - ::apache::thrift::protocol::TType _ktype1999; - ::apache::thrift::protocol::TType _vtype2000; - xfer += iprot->readMapBegin(_ktype1999, _vtype2000, _size1998); - uint32_t _i2002; - for (_i2002 = 0; _i2002 < _size1998; ++_i2002) + uint32_t _size2008; + ::apache::thrift::protocol::TType _ktype2009; + ::apache::thrift::protocol::TType _vtype2010; + xfer += iprot->readMapBegin(_ktype2009, _vtype2010, _size2008); + uint32_t _i2012; + for (_i2012 = 0; _i2012 < _size2008; ++_i2012) { - std::string _key2003; - xfer += iprot->readString(_key2003); - Type& _val2004 = this->success[_key2003]; - xfer += _val2004.read(iprot); + std::string _key2013; + xfer += iprot->readString(_key2013); + Type& _val2014 = this->success[_key2013]; + xfer += _val2014.read(iprot); } xfer += iprot->readMapEnd(); } @@ -6172,11 +6172,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 _iter2005; - for (_iter2005 = this->success.begin(); _iter2005 != this->success.end(); ++_iter2005) + std::map ::const_iterator _iter2015; + for (_iter2015 = this->success.begin(); _iter2015 != this->success.end(); ++_iter2015) { - xfer += oprot->writeString(_iter2005->first); - xfer += _iter2005->second.write(oprot); + xfer += oprot->writeString(_iter2015->first); + xfer += _iter2015->second.write(oprot); } xfer += oprot->writeMapEnd(); } @@ -6221,17 +6221,17 @@ uint32_t ThriftHiveMetastore_get_type_all_presult::read(::apache::thrift::protoc if (ftype == ::apache::thrift::protocol::T_MAP) { { (*(this->success)).clear(); - uint32_t _size2006; - ::apache::thrift::protocol::TType _ktype2007; - ::apache::thrift::protocol::TType _vtype2008; - xfer += iprot->readMapBegin(_ktype2007, _vtype2008, _size2006); - uint32_t _i2010; - for (_i2010 = 0; _i2010 < _size2006; ++_i2010) + uint32_t _size2016; + ::apache::thrift::protocol::TType _ktype2017; + ::apache::thrift::protocol::TType _vtype2018; + xfer += iprot->readMapBegin(_ktype2017, _vtype2018, _size2016); + uint32_t _i2020; + for (_i2020 = 0; _i2020 < _size2016; ++_i2020) { - std::string _key2011; - xfer += iprot->readString(_key2011); - Type& _val2012 = (*(this->success))[_key2011]; - xfer += _val2012.read(iprot); + std::string _key2021; + xfer += iprot->readString(_key2021); + Type& _val2022 = (*(this->success))[_key2021]; + xfer += _val2022.read(iprot); } xfer += iprot->readMapEnd(); } @@ -6385,14 +6385,14 @@ uint32_t ThriftHiveMetastore_get_fields_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2013; - ::apache::thrift::protocol::TType _etype2016; - xfer += iprot->readListBegin(_etype2016, _size2013); - this->success.resize(_size2013); - uint32_t _i2017; - for (_i2017 = 0; _i2017 < _size2013; ++_i2017) + uint32_t _size2023; + ::apache::thrift::protocol::TType _etype2026; + xfer += iprot->readListBegin(_etype2026, _size2023); + this->success.resize(_size2023); + uint32_t _i2027; + for (_i2027 = 0; _i2027 < _size2023; ++_i2027) { - xfer += this->success[_i2017].read(iprot); + xfer += this->success[_i2027].read(iprot); } xfer += iprot->readListEnd(); } @@ -6447,10 +6447,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 _iter2018; - for (_iter2018 = this->success.begin(); _iter2018 != this->success.end(); ++_iter2018) + std::vector ::const_iterator _iter2028; + for (_iter2028 = this->success.begin(); _iter2028 != this->success.end(); ++_iter2028) { - xfer += (*_iter2018).write(oprot); + xfer += (*_iter2028).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6503,14 +6503,14 @@ uint32_t ThriftHiveMetastore_get_fields_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2019; - ::apache::thrift::protocol::TType _etype2022; - xfer += iprot->readListBegin(_etype2022, _size2019); - (*(this->success)).resize(_size2019); - uint32_t _i2023; - for (_i2023 = 0; _i2023 < _size2019; ++_i2023) + uint32_t _size2029; + ::apache::thrift::protocol::TType _etype2032; + xfer += iprot->readListBegin(_etype2032, _size2029); + (*(this->success)).resize(_size2029); + uint32_t _i2033; + for (_i2033 = 0; _i2033 < _size2029; ++_i2033) { - xfer += (*(this->success))[_i2023].read(iprot); + xfer += (*(this->success))[_i2033].read(iprot); } xfer += iprot->readListEnd(); } @@ -6696,14 +6696,14 @@ uint32_t ThriftHiveMetastore_get_fields_with_environment_context_result::read(:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2024; - ::apache::thrift::protocol::TType _etype2027; - xfer += iprot->readListBegin(_etype2027, _size2024); - this->success.resize(_size2024); - uint32_t _i2028; - for (_i2028 = 0; _i2028 < _size2024; ++_i2028) + uint32_t _size2034; + ::apache::thrift::protocol::TType _etype2037; + xfer += iprot->readListBegin(_etype2037, _size2034); + this->success.resize(_size2034); + uint32_t _i2038; + for (_i2038 = 0; _i2038 < _size2034; ++_i2038) { - xfer += this->success[_i2028].read(iprot); + xfer += this->success[_i2038].read(iprot); } xfer += iprot->readListEnd(); } @@ -6758,10 +6758,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 _iter2029; - for (_iter2029 = this->success.begin(); _iter2029 != this->success.end(); ++_iter2029) + std::vector ::const_iterator _iter2039; + for (_iter2039 = this->success.begin(); _iter2039 != this->success.end(); ++_iter2039) { - xfer += (*_iter2029).write(oprot); + xfer += (*_iter2039).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6814,14 +6814,14 @@ uint32_t ThriftHiveMetastore_get_fields_with_environment_context_presult::read(: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2030; - ::apache::thrift::protocol::TType _etype2033; - xfer += iprot->readListBegin(_etype2033, _size2030); - (*(this->success)).resize(_size2030); - uint32_t _i2034; - for (_i2034 = 0; _i2034 < _size2030; ++_i2034) + uint32_t _size2040; + ::apache::thrift::protocol::TType _etype2043; + xfer += iprot->readListBegin(_etype2043, _size2040); + (*(this->success)).resize(_size2040); + uint32_t _i2044; + for (_i2044 = 0; _i2044 < _size2040; ++_i2044) { - xfer += (*(this->success))[_i2034].read(iprot); + xfer += (*(this->success))[_i2044].read(iprot); } xfer += iprot->readListEnd(); } @@ -7238,14 +7238,14 @@ uint32_t ThriftHiveMetastore_get_schema_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2035; - ::apache::thrift::protocol::TType _etype2038; - xfer += iprot->readListBegin(_etype2038, _size2035); - this->success.resize(_size2035); - uint32_t _i2039; - for (_i2039 = 0; _i2039 < _size2035; ++_i2039) + uint32_t _size2045; + ::apache::thrift::protocol::TType _etype2048; + xfer += iprot->readListBegin(_etype2048, _size2045); + this->success.resize(_size2045); + uint32_t _i2049; + for (_i2049 = 0; _i2049 < _size2045; ++_i2049) { - xfer += this->success[_i2039].read(iprot); + xfer += this->success[_i2049].read(iprot); } xfer += iprot->readListEnd(); } @@ -7300,10 +7300,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 _iter2040; - for (_iter2040 = this->success.begin(); _iter2040 != this->success.end(); ++_iter2040) + std::vector ::const_iterator _iter2050; + for (_iter2050 = this->success.begin(); _iter2050 != this->success.end(); ++_iter2050) { - xfer += (*_iter2040).write(oprot); + xfer += (*_iter2050).write(oprot); } xfer += oprot->writeListEnd(); } @@ -7356,14 +7356,14 @@ uint32_t ThriftHiveMetastore_get_schema_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2041; - ::apache::thrift::protocol::TType _etype2044; - xfer += iprot->readListBegin(_etype2044, _size2041); - (*(this->success)).resize(_size2041); - uint32_t _i2045; - for (_i2045 = 0; _i2045 < _size2041; ++_i2045) + uint32_t _size2051; + ::apache::thrift::protocol::TType _etype2054; + xfer += iprot->readListBegin(_etype2054, _size2051); + (*(this->success)).resize(_size2051); + uint32_t _i2055; + for (_i2055 = 0; _i2055 < _size2051; ++_i2055) { - xfer += (*(this->success))[_i2045].read(iprot); + xfer += (*(this->success))[_i2055].read(iprot); } xfer += iprot->readListEnd(); } @@ -7549,14 +7549,14 @@ uint32_t ThriftHiveMetastore_get_schema_with_environment_context_result::read(:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2046; - ::apache::thrift::protocol::TType _etype2049; - xfer += iprot->readListBegin(_etype2049, _size2046); - this->success.resize(_size2046); - uint32_t _i2050; - for (_i2050 = 0; _i2050 < _size2046; ++_i2050) + uint32_t _size2056; + ::apache::thrift::protocol::TType _etype2059; + xfer += iprot->readListBegin(_etype2059, _size2056); + this->success.resize(_size2056); + uint32_t _i2060; + for (_i2060 = 0; _i2060 < _size2056; ++_i2060) { - xfer += this->success[_i2050].read(iprot); + xfer += this->success[_i2060].read(iprot); } xfer += iprot->readListEnd(); } @@ -7611,10 +7611,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 _iter2051; - for (_iter2051 = this->success.begin(); _iter2051 != this->success.end(); ++_iter2051) + std::vector ::const_iterator _iter2061; + for (_iter2061 = this->success.begin(); _iter2061 != this->success.end(); ++_iter2061) { - xfer += (*_iter2051).write(oprot); + xfer += (*_iter2061).write(oprot); } xfer += oprot->writeListEnd(); } @@ -7667,14 +7667,14 @@ uint32_t ThriftHiveMetastore_get_schema_with_environment_context_presult::read(: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2052; - ::apache::thrift::protocol::TType _etype2055; - xfer += iprot->readListBegin(_etype2055, _size2052); - (*(this->success)).resize(_size2052); - uint32_t _i2056; - for (_i2056 = 0; _i2056 < _size2052; ++_i2056) + uint32_t _size2062; + ::apache::thrift::protocol::TType _etype2065; + xfer += iprot->readListBegin(_etype2065, _size2062); + (*(this->success)).resize(_size2062); + uint32_t _i2066; + for (_i2066 = 0; _i2066 < _size2062; ++_i2066) { - xfer += (*(this->success))[_i2056].read(iprot); + xfer += (*(this->success))[_i2066].read(iprot); } xfer += iprot->readListEnd(); } @@ -8514,14 +8514,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->primaryKeys.clear(); - uint32_t _size2057; - ::apache::thrift::protocol::TType _etype2060; - xfer += iprot->readListBegin(_etype2060, _size2057); - this->primaryKeys.resize(_size2057); - uint32_t _i2061; - for (_i2061 = 0; _i2061 < _size2057; ++_i2061) + uint32_t _size2067; + ::apache::thrift::protocol::TType _etype2070; + xfer += iprot->readListBegin(_etype2070, _size2067); + this->primaryKeys.resize(_size2067); + uint32_t _i2071; + for (_i2071 = 0; _i2071 < _size2067; ++_i2071) { - xfer += this->primaryKeys[_i2061].read(iprot); + xfer += this->primaryKeys[_i2071].read(iprot); } xfer += iprot->readListEnd(); } @@ -8534,14 +8534,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->foreignKeys.clear(); - uint32_t _size2062; - ::apache::thrift::protocol::TType _etype2065; - xfer += iprot->readListBegin(_etype2065, _size2062); - this->foreignKeys.resize(_size2062); - uint32_t _i2066; - for (_i2066 = 0; _i2066 < _size2062; ++_i2066) + uint32_t _size2072; + ::apache::thrift::protocol::TType _etype2075; + xfer += iprot->readListBegin(_etype2075, _size2072); + this->foreignKeys.resize(_size2072); + uint32_t _i2076; + for (_i2076 = 0; _i2076 < _size2072; ++_i2076) { - xfer += this->foreignKeys[_i2066].read(iprot); + xfer += this->foreignKeys[_i2076].read(iprot); } xfer += iprot->readListEnd(); } @@ -8554,14 +8554,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->uniqueConstraints.clear(); - uint32_t _size2067; - ::apache::thrift::protocol::TType _etype2070; - xfer += iprot->readListBegin(_etype2070, _size2067); - this->uniqueConstraints.resize(_size2067); - uint32_t _i2071; - for (_i2071 = 0; _i2071 < _size2067; ++_i2071) + uint32_t _size2077; + ::apache::thrift::protocol::TType _etype2080; + xfer += iprot->readListBegin(_etype2080, _size2077); + this->uniqueConstraints.resize(_size2077); + uint32_t _i2081; + for (_i2081 = 0; _i2081 < _size2077; ++_i2081) { - xfer += this->uniqueConstraints[_i2071].read(iprot); + xfer += this->uniqueConstraints[_i2081].read(iprot); } xfer += iprot->readListEnd(); } @@ -8574,14 +8574,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->notNullConstraints.clear(); - uint32_t _size2072; - ::apache::thrift::protocol::TType _etype2075; - xfer += iprot->readListBegin(_etype2075, _size2072); - this->notNullConstraints.resize(_size2072); - uint32_t _i2076; - for (_i2076 = 0; _i2076 < _size2072; ++_i2076) + uint32_t _size2082; + ::apache::thrift::protocol::TType _etype2085; + xfer += iprot->readListBegin(_etype2085, _size2082); + this->notNullConstraints.resize(_size2082); + uint32_t _i2086; + for (_i2086 = 0; _i2086 < _size2082; ++_i2086) { - xfer += this->notNullConstraints[_i2076].read(iprot); + xfer += this->notNullConstraints[_i2086].read(iprot); } xfer += iprot->readListEnd(); } @@ -8594,14 +8594,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->defaultConstraints.clear(); - uint32_t _size2077; - ::apache::thrift::protocol::TType _etype2080; - xfer += iprot->readListBegin(_etype2080, _size2077); - this->defaultConstraints.resize(_size2077); - uint32_t _i2081; - for (_i2081 = 0; _i2081 < _size2077; ++_i2081) + uint32_t _size2087; + ::apache::thrift::protocol::TType _etype2090; + xfer += iprot->readListBegin(_etype2090, _size2087); + this->defaultConstraints.resize(_size2087); + uint32_t _i2091; + for (_i2091 = 0; _i2091 < _size2087; ++_i2091) { - xfer += this->defaultConstraints[_i2081].read(iprot); + xfer += this->defaultConstraints[_i2091].read(iprot); } xfer += iprot->readListEnd(); } @@ -8614,14 +8614,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->checkConstraints.clear(); - uint32_t _size2082; - ::apache::thrift::protocol::TType _etype2085; - xfer += iprot->readListBegin(_etype2085, _size2082); - this->checkConstraints.resize(_size2082); - uint32_t _i2086; - for (_i2086 = 0; _i2086 < _size2082; ++_i2086) + uint32_t _size2092; + ::apache::thrift::protocol::TType _etype2095; + xfer += iprot->readListBegin(_etype2095, _size2092); + this->checkConstraints.resize(_size2092); + uint32_t _i2096; + for (_i2096 = 0; _i2096 < _size2092; ++_i2096) { - xfer += this->checkConstraints[_i2086].read(iprot); + xfer += this->checkConstraints[_i2096].read(iprot); } xfer += iprot->readListEnd(); } @@ -8654,10 +8654,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 _iter2087; - for (_iter2087 = this->primaryKeys.begin(); _iter2087 != this->primaryKeys.end(); ++_iter2087) + std::vector ::const_iterator _iter2097; + for (_iter2097 = this->primaryKeys.begin(); _iter2097 != this->primaryKeys.end(); ++_iter2097) { - xfer += (*_iter2087).write(oprot); + xfer += (*_iter2097).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8666,10 +8666,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 _iter2088; - for (_iter2088 = this->foreignKeys.begin(); _iter2088 != this->foreignKeys.end(); ++_iter2088) + std::vector ::const_iterator _iter2098; + for (_iter2098 = this->foreignKeys.begin(); _iter2098 != this->foreignKeys.end(); ++_iter2098) { - xfer += (*_iter2088).write(oprot); + xfer += (*_iter2098).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8678,10 +8678,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 _iter2089; - for (_iter2089 = this->uniqueConstraints.begin(); _iter2089 != this->uniqueConstraints.end(); ++_iter2089) + std::vector ::const_iterator _iter2099; + for (_iter2099 = this->uniqueConstraints.begin(); _iter2099 != this->uniqueConstraints.end(); ++_iter2099) { - xfer += (*_iter2089).write(oprot); + xfer += (*_iter2099).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8690,10 +8690,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 _iter2090; - for (_iter2090 = this->notNullConstraints.begin(); _iter2090 != this->notNullConstraints.end(); ++_iter2090) + std::vector ::const_iterator _iter2100; + for (_iter2100 = this->notNullConstraints.begin(); _iter2100 != this->notNullConstraints.end(); ++_iter2100) { - xfer += (*_iter2090).write(oprot); + xfer += (*_iter2100).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8702,10 +8702,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache: xfer += oprot->writeFieldBegin("defaultConstraints", ::apache::thrift::protocol::T_LIST, 6); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->defaultConstraints.size())); - std::vector ::const_iterator _iter2091; - for (_iter2091 = this->defaultConstraints.begin(); _iter2091 != this->defaultConstraints.end(); ++_iter2091) + std::vector ::const_iterator _iter2101; + for (_iter2101 = this->defaultConstraints.begin(); _iter2101 != this->defaultConstraints.end(); ++_iter2101) { - xfer += (*_iter2091).write(oprot); + xfer += (*_iter2101).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8714,10 +8714,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache: xfer += oprot->writeFieldBegin("checkConstraints", ::apache::thrift::protocol::T_LIST, 7); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->checkConstraints.size())); - std::vector ::const_iterator _iter2092; - for (_iter2092 = this->checkConstraints.begin(); _iter2092 != this->checkConstraints.end(); ++_iter2092) + std::vector ::const_iterator _iter2102; + for (_iter2102 = this->checkConstraints.begin(); _iter2102 != this->checkConstraints.end(); ++_iter2102) { - xfer += (*_iter2092).write(oprot); + xfer += (*_iter2102).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8745,10 +8745,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 _iter2093; - for (_iter2093 = (*(this->primaryKeys)).begin(); _iter2093 != (*(this->primaryKeys)).end(); ++_iter2093) + std::vector ::const_iterator _iter2103; + for (_iter2103 = (*(this->primaryKeys)).begin(); _iter2103 != (*(this->primaryKeys)).end(); ++_iter2103) { - xfer += (*_iter2093).write(oprot); + xfer += (*_iter2103).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8757,10 +8757,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 _iter2094; - for (_iter2094 = (*(this->foreignKeys)).begin(); _iter2094 != (*(this->foreignKeys)).end(); ++_iter2094) + std::vector ::const_iterator _iter2104; + for (_iter2104 = (*(this->foreignKeys)).begin(); _iter2104 != (*(this->foreignKeys)).end(); ++_iter2104) { - xfer += (*_iter2094).write(oprot); + xfer += (*_iter2104).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8769,10 +8769,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 _iter2095; - for (_iter2095 = (*(this->uniqueConstraints)).begin(); _iter2095 != (*(this->uniqueConstraints)).end(); ++_iter2095) + std::vector ::const_iterator _iter2105; + for (_iter2105 = (*(this->uniqueConstraints)).begin(); _iter2105 != (*(this->uniqueConstraints)).end(); ++_iter2105) { - xfer += (*_iter2095).write(oprot); + xfer += (*_iter2105).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8781,10 +8781,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 _iter2096; - for (_iter2096 = (*(this->notNullConstraints)).begin(); _iter2096 != (*(this->notNullConstraints)).end(); ++_iter2096) + std::vector ::const_iterator _iter2106; + for (_iter2106 = (*(this->notNullConstraints)).begin(); _iter2106 != (*(this->notNullConstraints)).end(); ++_iter2106) { - xfer += (*_iter2096).write(oprot); + xfer += (*_iter2106).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8793,10 +8793,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache xfer += oprot->writeFieldBegin("defaultConstraints", ::apache::thrift::protocol::T_LIST, 6); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->defaultConstraints)).size())); - std::vector ::const_iterator _iter2097; - for (_iter2097 = (*(this->defaultConstraints)).begin(); _iter2097 != (*(this->defaultConstraints)).end(); ++_iter2097) + std::vector ::const_iterator _iter2107; + for (_iter2107 = (*(this->defaultConstraints)).begin(); _iter2107 != (*(this->defaultConstraints)).end(); ++_iter2107) { - xfer += (*_iter2097).write(oprot); + xfer += (*_iter2107).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8805,10 +8805,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache xfer += oprot->writeFieldBegin("checkConstraints", ::apache::thrift::protocol::T_LIST, 7); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->checkConstraints)).size())); - std::vector ::const_iterator _iter2098; - for (_iter2098 = (*(this->checkConstraints)).begin(); _iter2098 != (*(this->checkConstraints)).end(); ++_iter2098) + std::vector ::const_iterator _iter2108; + for (_iter2108 = (*(this->checkConstraints)).begin(); _iter2108 != (*(this->checkConstraints)).end(); ++_iter2108) { - xfer += (*_iter2098).write(oprot); + xfer += (*_iter2108).write(oprot); } xfer += oprot->writeListEnd(); } @@ -11717,14 +11717,14 @@ uint32_t ThriftHiveMetastore_truncate_table_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partNames.clear(); - uint32_t _size2099; - ::apache::thrift::protocol::TType _etype2102; - xfer += iprot->readListBegin(_etype2102, _size2099); - this->partNames.resize(_size2099); - uint32_t _i2103; - for (_i2103 = 0; _i2103 < _size2099; ++_i2103) + uint32_t _size2109; + ::apache::thrift::protocol::TType _etype2112; + xfer += iprot->readListBegin(_etype2112, _size2109); + this->partNames.resize(_size2109); + uint32_t _i2113; + for (_i2113 = 0; _i2113 < _size2109; ++_i2113) { - xfer += iprot->readString(this->partNames[_i2103]); + xfer += iprot->readString(this->partNames[_i2113]); } xfer += iprot->readListEnd(); } @@ -11761,10 +11761,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 _iter2104; - for (_iter2104 = this->partNames.begin(); _iter2104 != this->partNames.end(); ++_iter2104) + std::vector ::const_iterator _iter2114; + for (_iter2114 = this->partNames.begin(); _iter2114 != this->partNames.end(); ++_iter2114) { - xfer += oprot->writeString((*_iter2104)); + xfer += oprot->writeString((*_iter2114)); } xfer += oprot->writeListEnd(); } @@ -11796,10 +11796,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 _iter2105; - for (_iter2105 = (*(this->partNames)).begin(); _iter2105 != (*(this->partNames)).end(); ++_iter2105) + std::vector ::const_iterator _iter2115; + for (_iter2115 = (*(this->partNames)).begin(); _iter2115 != (*(this->partNames)).end(); ++_iter2115) { - xfer += oprot->writeString((*_iter2105)); + xfer += oprot->writeString((*_iter2115)); } xfer += oprot->writeListEnd(); } @@ -12250,14 +12250,14 @@ uint32_t ThriftHiveMetastore_get_tables_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2106; - ::apache::thrift::protocol::TType _etype2109; - xfer += iprot->readListBegin(_etype2109, _size2106); - this->success.resize(_size2106); - uint32_t _i2110; - for (_i2110 = 0; _i2110 < _size2106; ++_i2110) + uint32_t _size2116; + ::apache::thrift::protocol::TType _etype2119; + xfer += iprot->readListBegin(_etype2119, _size2116); + this->success.resize(_size2116); + uint32_t _i2120; + for (_i2120 = 0; _i2120 < _size2116; ++_i2120) { - xfer += iprot->readString(this->success[_i2110]); + xfer += iprot->readString(this->success[_i2120]); } xfer += iprot->readListEnd(); } @@ -12296,10 +12296,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 _iter2111; - for (_iter2111 = this->success.begin(); _iter2111 != this->success.end(); ++_iter2111) + std::vector ::const_iterator _iter2121; + for (_iter2121 = this->success.begin(); _iter2121 != this->success.end(); ++_iter2121) { - xfer += oprot->writeString((*_iter2111)); + xfer += oprot->writeString((*_iter2121)); } xfer += oprot->writeListEnd(); } @@ -12344,14 +12344,14 @@ uint32_t ThriftHiveMetastore_get_tables_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2112; - ::apache::thrift::protocol::TType _etype2115; - xfer += iprot->readListBegin(_etype2115, _size2112); - (*(this->success)).resize(_size2112); - uint32_t _i2116; - for (_i2116 = 0; _i2116 < _size2112; ++_i2116) + uint32_t _size2122; + ::apache::thrift::protocol::TType _etype2125; + xfer += iprot->readListBegin(_etype2125, _size2122); + (*(this->success)).resize(_size2122); + uint32_t _i2126; + for (_i2126 = 0; _i2126 < _size2122; ++_i2126) { - xfer += iprot->readString((*(this->success))[_i2116]); + xfer += iprot->readString((*(this->success))[_i2126]); } xfer += iprot->readListEnd(); } @@ -12521,14 +12521,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 _size2117; - ::apache::thrift::protocol::TType _etype2120; - xfer += iprot->readListBegin(_etype2120, _size2117); - this->success.resize(_size2117); - uint32_t _i2121; - for (_i2121 = 0; _i2121 < _size2117; ++_i2121) + uint32_t _size2127; + ::apache::thrift::protocol::TType _etype2130; + xfer += iprot->readListBegin(_etype2130, _size2127); + this->success.resize(_size2127); + uint32_t _i2131; + for (_i2131 = 0; _i2131 < _size2127; ++_i2131) { - xfer += iprot->readString(this->success[_i2121]); + xfer += iprot->readString(this->success[_i2131]); } xfer += iprot->readListEnd(); } @@ -12567,10 +12567,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 _iter2122; - for (_iter2122 = this->success.begin(); _iter2122 != this->success.end(); ++_iter2122) + std::vector ::const_iterator _iter2132; + for (_iter2132 = this->success.begin(); _iter2132 != this->success.end(); ++_iter2132) { - xfer += oprot->writeString((*_iter2122)); + xfer += oprot->writeString((*_iter2132)); } xfer += oprot->writeListEnd(); } @@ -12615,14 +12615,14 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_presult::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2123; - ::apache::thrift::protocol::TType _etype2126; - xfer += iprot->readListBegin(_etype2126, _size2123); - (*(this->success)).resize(_size2123); - uint32_t _i2127; - for (_i2127 = 0; _i2127 < _size2123; ++_i2127) + uint32_t _size2133; + ::apache::thrift::protocol::TType _etype2136; + xfer += iprot->readListBegin(_etype2136, _size2133); + (*(this->success)).resize(_size2133); + uint32_t _i2137; + for (_i2137 = 0; _i2137 < _size2133; ++_i2137) { - xfer += iprot->readString((*(this->success))[_i2127]); + xfer += iprot->readString((*(this->success))[_i2137]); } xfer += iprot->readListEnd(); } @@ -12739,14 +12739,14 @@ uint32_t ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_res if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2128; - ::apache::thrift::protocol::TType _etype2131; - xfer += iprot->readListBegin(_etype2131, _size2128); - this->success.resize(_size2128); - uint32_t _i2132; - for (_i2132 = 0; _i2132 < _size2128; ++_i2132) + uint32_t _size2138; + ::apache::thrift::protocol::TType _etype2141; + xfer += iprot->readListBegin(_etype2141, _size2138); + this->success.resize(_size2138); + uint32_t _i2142; + for (_i2142 = 0; _i2142 < _size2138; ++_i2142) { - xfer += this->success[_i2132].read(iprot); + xfer += this->success[_i2142].read(iprot); } xfer += iprot->readListEnd(); } @@ -12785,10 +12785,10 @@ uint32_t ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_res 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 _iter2133; - for (_iter2133 = this->success.begin(); _iter2133 != this->success.end(); ++_iter2133) + std::vector
::const_iterator _iter2143; + for (_iter2143 = this->success.begin(); _iter2143 != this->success.end(); ++_iter2143) { - xfer += (*_iter2133).write(oprot); + xfer += (*_iter2143).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12833,14 +12833,14 @@ uint32_t ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_pre if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2134; - ::apache::thrift::protocol::TType _etype2137; - xfer += iprot->readListBegin(_etype2137, _size2134); - (*(this->success)).resize(_size2134); - uint32_t _i2138; - for (_i2138 = 0; _i2138 < _size2134; ++_i2138) + uint32_t _size2144; + ::apache::thrift::protocol::TType _etype2147; + xfer += iprot->readListBegin(_etype2147, _size2144); + (*(this->success)).resize(_size2144); + uint32_t _i2148; + for (_i2148 = 0; _i2148 < _size2144; ++_i2148) { - xfer += (*(this->success))[_i2138].read(iprot); + xfer += (*(this->success))[_i2148].read(iprot); } xfer += iprot->readListEnd(); } @@ -12978,14 +12978,14 @@ uint32_t ThriftHiveMetastore_get_materialized_views_for_rewriting_result::read(: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2139; - ::apache::thrift::protocol::TType _etype2142; - xfer += iprot->readListBegin(_etype2142, _size2139); - this->success.resize(_size2139); - uint32_t _i2143; - for (_i2143 = 0; _i2143 < _size2139; ++_i2143) + uint32_t _size2149; + ::apache::thrift::protocol::TType _etype2152; + xfer += iprot->readListBegin(_etype2152, _size2149); + this->success.resize(_size2149); + uint32_t _i2153; + for (_i2153 = 0; _i2153 < _size2149; ++_i2153) { - xfer += iprot->readString(this->success[_i2143]); + xfer += iprot->readString(this->success[_i2153]); } xfer += iprot->readListEnd(); } @@ -13024,10 +13024,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 _iter2144; - for (_iter2144 = this->success.begin(); _iter2144 != this->success.end(); ++_iter2144) + std::vector ::const_iterator _iter2154; + for (_iter2154 = this->success.begin(); _iter2154 != this->success.end(); ++_iter2154) { - xfer += oprot->writeString((*_iter2144)); + xfer += oprot->writeString((*_iter2154)); } xfer += oprot->writeListEnd(); } @@ -13072,14 +13072,14 @@ uint32_t ThriftHiveMetastore_get_materialized_views_for_rewriting_presult::read( if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2145; - ::apache::thrift::protocol::TType _etype2148; - xfer += iprot->readListBegin(_etype2148, _size2145); - (*(this->success)).resize(_size2145); - uint32_t _i2149; - for (_i2149 = 0; _i2149 < _size2145; ++_i2149) + uint32_t _size2155; + ::apache::thrift::protocol::TType _etype2158; + xfer += iprot->readListBegin(_etype2158, _size2155); + (*(this->success)).resize(_size2155); + uint32_t _i2159; + for (_i2159 = 0; _i2159 < _size2155; ++_i2159) { - xfer += iprot->readString((*(this->success))[_i2149]); + xfer += iprot->readString((*(this->success))[_i2159]); } xfer += iprot->readListEnd(); } @@ -13154,14 +13154,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 _size2150; - ::apache::thrift::protocol::TType _etype2153; - xfer += iprot->readListBegin(_etype2153, _size2150); - this->tbl_types.resize(_size2150); - uint32_t _i2154; - for (_i2154 = 0; _i2154 < _size2150; ++_i2154) + uint32_t _size2160; + ::apache::thrift::protocol::TType _etype2163; + xfer += iprot->readListBegin(_etype2163, _size2160); + this->tbl_types.resize(_size2160); + uint32_t _i2164; + for (_i2164 = 0; _i2164 < _size2160; ++_i2164) { - xfer += iprot->readString(this->tbl_types[_i2154]); + xfer += iprot->readString(this->tbl_types[_i2164]); } xfer += iprot->readListEnd(); } @@ -13198,10 +13198,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 _iter2155; - for (_iter2155 = this->tbl_types.begin(); _iter2155 != this->tbl_types.end(); ++_iter2155) + std::vector ::const_iterator _iter2165; + for (_iter2165 = this->tbl_types.begin(); _iter2165 != this->tbl_types.end(); ++_iter2165) { - xfer += oprot->writeString((*_iter2155)); + xfer += oprot->writeString((*_iter2165)); } xfer += oprot->writeListEnd(); } @@ -13233,10 +13233,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 _iter2156; - for (_iter2156 = (*(this->tbl_types)).begin(); _iter2156 != (*(this->tbl_types)).end(); ++_iter2156) + std::vector ::const_iterator _iter2166; + for (_iter2166 = (*(this->tbl_types)).begin(); _iter2166 != (*(this->tbl_types)).end(); ++_iter2166) { - xfer += oprot->writeString((*_iter2156)); + xfer += oprot->writeString((*_iter2166)); } xfer += oprot->writeListEnd(); } @@ -13277,14 +13277,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2157; - ::apache::thrift::protocol::TType _etype2160; - xfer += iprot->readListBegin(_etype2160, _size2157); - this->success.resize(_size2157); - uint32_t _i2161; - for (_i2161 = 0; _i2161 < _size2157; ++_i2161) + uint32_t _size2167; + ::apache::thrift::protocol::TType _etype2170; + xfer += iprot->readListBegin(_etype2170, _size2167); + this->success.resize(_size2167); + uint32_t _i2171; + for (_i2171 = 0; _i2171 < _size2167; ++_i2171) { - xfer += this->success[_i2161].read(iprot); + xfer += this->success[_i2171].read(iprot); } xfer += iprot->readListEnd(); } @@ -13323,10 +13323,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 _iter2162; - for (_iter2162 = this->success.begin(); _iter2162 != this->success.end(); ++_iter2162) + std::vector ::const_iterator _iter2172; + for (_iter2172 = this->success.begin(); _iter2172 != this->success.end(); ++_iter2172) { - xfer += (*_iter2162).write(oprot); + xfer += (*_iter2172).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13371,14 +13371,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2163; - ::apache::thrift::protocol::TType _etype2166; - xfer += iprot->readListBegin(_etype2166, _size2163); - (*(this->success)).resize(_size2163); - uint32_t _i2167; - for (_i2167 = 0; _i2167 < _size2163; ++_i2167) + uint32_t _size2173; + ::apache::thrift::protocol::TType _etype2176; + xfer += iprot->readListBegin(_etype2176, _size2173); + (*(this->success)).resize(_size2173); + uint32_t _i2177; + for (_i2177 = 0; _i2177 < _size2173; ++_i2177) { - xfer += (*(this->success))[_i2167].read(iprot); + xfer += (*(this->success))[_i2177].read(iprot); } xfer += iprot->readListEnd(); } @@ -13516,14 +13516,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2168; - ::apache::thrift::protocol::TType _etype2171; - xfer += iprot->readListBegin(_etype2171, _size2168); - this->success.resize(_size2168); - uint32_t _i2172; - for (_i2172 = 0; _i2172 < _size2168; ++_i2172) + uint32_t _size2178; + ::apache::thrift::protocol::TType _etype2181; + xfer += iprot->readListBegin(_etype2181, _size2178); + this->success.resize(_size2178); + uint32_t _i2182; + for (_i2182 = 0; _i2182 < _size2178; ++_i2182) { - xfer += iprot->readString(this->success[_i2172]); + xfer += iprot->readString(this->success[_i2182]); } xfer += iprot->readListEnd(); } @@ -13562,10 +13562,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 _iter2173; - for (_iter2173 = this->success.begin(); _iter2173 != this->success.end(); ++_iter2173) + std::vector ::const_iterator _iter2183; + for (_iter2183 = this->success.begin(); _iter2183 != this->success.end(); ++_iter2183) { - xfer += oprot->writeString((*_iter2173)); + xfer += oprot->writeString((*_iter2183)); } xfer += oprot->writeListEnd(); } @@ -13610,14 +13610,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2174; - ::apache::thrift::protocol::TType _etype2177; - xfer += iprot->readListBegin(_etype2177, _size2174); - (*(this->success)).resize(_size2174); - uint32_t _i2178; - for (_i2178 = 0; _i2178 < _size2174; ++_i2178) + uint32_t _size2184; + ::apache::thrift::protocol::TType _etype2187; + xfer += iprot->readListBegin(_etype2187, _size2184); + (*(this->success)).resize(_size2184); + uint32_t _i2188; + for (_i2188 = 0; _i2188 < _size2184; ++_i2188) { - xfer += iprot->readString((*(this->success))[_i2178]); + xfer += iprot->readString((*(this->success))[_i2188]); } xfer += iprot->readListEnd(); } @@ -13755,14 +13755,14 @@ uint32_t ThriftHiveMetastore_get_tables_ext_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2179; - ::apache::thrift::protocol::TType _etype2182; - xfer += iprot->readListBegin(_etype2182, _size2179); - this->success.resize(_size2179); - uint32_t _i2183; - for (_i2183 = 0; _i2183 < _size2179; ++_i2183) + uint32_t _size2189; + ::apache::thrift::protocol::TType _etype2192; + xfer += iprot->readListBegin(_etype2192, _size2189); + this->success.resize(_size2189); + uint32_t _i2193; + for (_i2193 = 0; _i2193 < _size2189; ++_i2193) { - xfer += this->success[_i2183].read(iprot); + xfer += this->success[_i2193].read(iprot); } xfer += iprot->readListEnd(); } @@ -13801,10 +13801,10 @@ uint32_t ThriftHiveMetastore_get_tables_ext_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 _iter2184; - for (_iter2184 = this->success.begin(); _iter2184 != this->success.end(); ++_iter2184) + std::vector ::const_iterator _iter2194; + for (_iter2194 = this->success.begin(); _iter2194 != this->success.end(); ++_iter2194) { - xfer += (*_iter2184).write(oprot); + xfer += (*_iter2194).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13849,14 +13849,14 @@ uint32_t ThriftHiveMetastore_get_tables_ext_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2185; - ::apache::thrift::protocol::TType _etype2188; - xfer += iprot->readListBegin(_etype2188, _size2185); - (*(this->success)).resize(_size2185); - uint32_t _i2189; - for (_i2189 = 0; _i2189 < _size2185; ++_i2189) + uint32_t _size2195; + ::apache::thrift::protocol::TType _etype2198; + xfer += iprot->readListBegin(_etype2198, _size2195); + (*(this->success)).resize(_size2195); + uint32_t _i2199; + for (_i2199 = 0; _i2199 < _size2195; ++_i2199) { - xfer += (*(this->success))[_i2189].read(iprot); + xfer += (*(this->success))[_i2199].read(iprot); } xfer += iprot->readListEnd(); } @@ -15038,14 +15038,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 _size2190; - ::apache::thrift::protocol::TType _etype2193; - xfer += iprot->readListBegin(_etype2193, _size2190); - this->success.resize(_size2190); - uint32_t _i2194; - for (_i2194 = 0; _i2194 < _size2190; ++_i2194) + uint32_t _size2200; + ::apache::thrift::protocol::TType _etype2203; + xfer += iprot->readListBegin(_etype2203, _size2200); + this->success.resize(_size2200); + uint32_t _i2204; + for (_i2204 = 0; _i2204 < _size2200; ++_i2204) { - xfer += iprot->readString(this->success[_i2194]); + xfer += iprot->readString(this->success[_i2204]); } xfer += iprot->readListEnd(); } @@ -15100,10 +15100,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 _iter2195; - for (_iter2195 = this->success.begin(); _iter2195 != this->success.end(); ++_iter2195) + std::vector ::const_iterator _iter2205; + for (_iter2205 = this->success.begin(); _iter2205 != this->success.end(); ++_iter2205) { - xfer += oprot->writeString((*_iter2195)); + xfer += oprot->writeString((*_iter2205)); } xfer += oprot->writeListEnd(); } @@ -15156,14 +15156,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 _size2196; - ::apache::thrift::protocol::TType _etype2199; - xfer += iprot->readListBegin(_etype2199, _size2196); - (*(this->success)).resize(_size2196); - uint32_t _i2200; - for (_i2200 = 0; _i2200 < _size2196; ++_i2200) + uint32_t _size2206; + ::apache::thrift::protocol::TType _etype2209; + xfer += iprot->readListBegin(_etype2209, _size2206); + (*(this->success)).resize(_size2206); + uint32_t _i2210; + for (_i2210 = 0; _i2210 < _size2206; ++_i2210) { - xfer += iprot->readString((*(this->success))[_i2200]); + xfer += iprot->readString((*(this->success))[_i2210]); } xfer += iprot->readListEnd(); } @@ -16185,11 +16185,11 @@ uint32_t ThriftHiveMetastore_alter_table_req_presult::read(::apache::thrift::pro } -ThriftHiveMetastore_add_partition_args::~ThriftHiveMetastore_add_partition_args() noexcept { +ThriftHiveMetastore_update_table_params_args::~ThriftHiveMetastore_update_table_params_args() noexcept { } -uint32_t ThriftHiveMetastore_add_partition_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_update_table_params_args::read(::apache::thrift::protocol::TProtocol* iprot) { ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -16211,9 +16211,21 @@ uint32_t ThriftHiveMetastore_add_partition_args::read(::apache::thrift::protocol switch (fid) { case 1: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->new_part.read(iprot); - this->__isset.new_part = true; + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->updates.clear(); + uint32_t _size2211; + ::apache::thrift::protocol::TType _etype2214; + xfer += iprot->readListBegin(_etype2214, _size2211); + this->updates.resize(_size2211); + uint32_t _i2215; + for (_i2215 = 0; _i2215 < _size2211; ++_i2215) + { + xfer += this->updates[_i2215].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.updates = true; } else { xfer += iprot->skip(ftype); } @@ -16230,13 +16242,21 @@ uint32_t ThriftHiveMetastore_add_partition_args::read(::apache::thrift::protocol return xfer; } -uint32_t ThriftHiveMetastore_add_partition_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_update_table_params_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_partition_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_update_table_params_args"); - xfer += oprot->writeFieldBegin("new_part", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += this->new_part.write(oprot); + xfer += oprot->writeFieldBegin("updates", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->updates.size())); + std::vector ::const_iterator _iter2216; + for (_iter2216 = this->updates.begin(); _iter2216 != this->updates.end(); ++_iter2216) + { + xfer += (*_iter2216).write(oprot); + } + xfer += oprot->writeListEnd(); + } xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -16245,17 +16265,25 @@ uint32_t ThriftHiveMetastore_add_partition_args::write(::apache::thrift::protoco } -ThriftHiveMetastore_add_partition_pargs::~ThriftHiveMetastore_add_partition_pargs() noexcept { +ThriftHiveMetastore_update_table_params_pargs::~ThriftHiveMetastore_update_table_params_pargs() noexcept { } -uint32_t ThriftHiveMetastore_add_partition_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_update_table_params_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_partition_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_update_table_params_pargs"); - xfer += oprot->writeFieldBegin("new_part", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += (*(this->new_part)).write(oprot); + xfer += oprot->writeFieldBegin("updates", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->updates)).size())); + std::vector ::const_iterator _iter2217; + for (_iter2217 = (*(this->updates)).begin(); _iter2217 != (*(this->updates)).end(); ++_iter2217) + { + xfer += (*_iter2217).write(oprot); + } + xfer += oprot->writeListEnd(); + } xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -16264,11 +16292,11 @@ uint32_t ThriftHiveMetastore_add_partition_pargs::write(::apache::thrift::protoc } -ThriftHiveMetastore_add_partition_result::~ThriftHiveMetastore_add_partition_result() noexcept { +ThriftHiveMetastore_update_table_params_result::~ThriftHiveMetastore_update_table_params_result() noexcept { } -uint32_t ThriftHiveMetastore_add_partition_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_update_table_params_result::read(::apache::thrift::protocol::TProtocol* iprot) { ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -16289,14 +16317,6 @@ uint32_t ThriftHiveMetastore_add_partition_result::read(::apache::thrift::protoc } switch (fid) { - case 0: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->success.read(iprot); - this->__isset.success = true; - } else { - xfer += iprot->skip(ftype); - } - break; case 1: if (ftype == ::apache::thrift::protocol::T_STRUCT) { xfer += this->o1.read(iprot); @@ -16305,22 +16325,6 @@ uint32_t ThriftHiveMetastore_add_partition_result::read(::apache::thrift::protoc xfer += iprot->skip(ftype); } break; - case 2: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->o2.read(iprot); - this->__isset.o2 = true; - } else { - xfer += iprot->skip(ftype); - } - break; - case 3: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->o3.read(iprot); - this->__isset.o3 = true; - } else { - xfer += iprot->skip(ftype); - } - break; default: xfer += iprot->skip(ftype); break; @@ -16333,28 +16337,16 @@ uint32_t ThriftHiveMetastore_add_partition_result::read(::apache::thrift::protoc return xfer; } -uint32_t ThriftHiveMetastore_add_partition_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_update_table_params_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_partition_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_update_table_params_result"); - if (this->__isset.success) { - xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); - xfer += this->success.write(oprot); - xfer += oprot->writeFieldEnd(); - } else if (this->__isset.o1) { + if (this->__isset.o1) { xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); xfer += this->o1.write(oprot); xfer += oprot->writeFieldEnd(); - } else if (this->__isset.o2) { - xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); - xfer += this->o2.write(oprot); - xfer += oprot->writeFieldEnd(); - } else if (this->__isset.o3) { - xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); - xfer += this->o3.write(oprot); - xfer += oprot->writeFieldEnd(); } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); @@ -16362,11 +16354,11 @@ uint32_t ThriftHiveMetastore_add_partition_result::write(::apache::thrift::proto } -ThriftHiveMetastore_add_partition_presult::~ThriftHiveMetastore_add_partition_presult() noexcept { +ThriftHiveMetastore_update_table_params_presult::~ThriftHiveMetastore_update_table_params_presult() noexcept { } -uint32_t ThriftHiveMetastore_add_partition_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_update_table_params_presult::read(::apache::thrift::protocol::TProtocol* iprot) { ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -16387,14 +16379,6 @@ uint32_t ThriftHiveMetastore_add_partition_presult::read(::apache::thrift::proto } switch (fid) { - case 0: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += (*(this->success)).read(iprot); - this->__isset.success = true; - } else { - xfer += iprot->skip(ftype); - } - break; case 1: if (ftype == ::apache::thrift::protocol::T_STRUCT) { xfer += this->o1.read(iprot); @@ -16403,22 +16387,6 @@ uint32_t ThriftHiveMetastore_add_partition_presult::read(::apache::thrift::proto xfer += iprot->skip(ftype); } break; - case 2: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->o2.read(iprot); - this->__isset.o2 = true; - } else { - xfer += iprot->skip(ftype); - } - break; - case 3: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->o3.read(iprot); - this->__isset.o3 = true; - } else { - xfer += iprot->skip(ftype); - } - break; default: xfer += iprot->skip(ftype); break; @@ -16432,11 +16400,11 @@ uint32_t ThriftHiveMetastore_add_partition_presult::read(::apache::thrift::proto } -ThriftHiveMetastore_add_partition_with_environment_context_args::~ThriftHiveMetastore_add_partition_with_environment_context_args() noexcept { +ThriftHiveMetastore_add_partition_args::~ThriftHiveMetastore_add_partition_args() noexcept { } -uint32_t ThriftHiveMetastore_add_partition_with_environment_context_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_add_partition_args::read(::apache::thrift::protocol::TProtocol* iprot) { ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -16465,14 +16433,6 @@ uint32_t ThriftHiveMetastore_add_partition_with_environment_context_args::read(: xfer += iprot->skip(ftype); } break; - case 2: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->environment_context.read(iprot); - this->__isset.environment_context = true; - } else { - xfer += iprot->skip(ftype); - } - break; default: xfer += iprot->skip(ftype); break; @@ -16485,53 +16445,45 @@ uint32_t ThriftHiveMetastore_add_partition_with_environment_context_args::read(: return xfer; } -uint32_t ThriftHiveMetastore_add_partition_with_environment_context_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_add_partition_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_partition_with_environment_context_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_partition_args"); xfer += oprot->writeFieldBegin("new_part", ::apache::thrift::protocol::T_STRUCT, 1); xfer += this->new_part.write(oprot); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("environment_context", ::apache::thrift::protocol::T_STRUCT, 2); - xfer += this->environment_context.write(oprot); - xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; } -ThriftHiveMetastore_add_partition_with_environment_context_pargs::~ThriftHiveMetastore_add_partition_with_environment_context_pargs() noexcept { +ThriftHiveMetastore_add_partition_pargs::~ThriftHiveMetastore_add_partition_pargs() noexcept { } -uint32_t ThriftHiveMetastore_add_partition_with_environment_context_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_add_partition_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_partition_with_environment_context_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_partition_pargs"); xfer += oprot->writeFieldBegin("new_part", ::apache::thrift::protocol::T_STRUCT, 1); xfer += (*(this->new_part)).write(oprot); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("environment_context", ::apache::thrift::protocol::T_STRUCT, 2); - xfer += (*(this->environment_context)).write(oprot); - xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; } -ThriftHiveMetastore_add_partition_with_environment_context_result::~ThriftHiveMetastore_add_partition_with_environment_context_result() noexcept { +ThriftHiveMetastore_add_partition_result::~ThriftHiveMetastore_add_partition_result() noexcept { } -uint32_t ThriftHiveMetastore_add_partition_with_environment_context_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_add_partition_result::read(::apache::thrift::protocol::TProtocol* iprot) { ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -16596,11 +16548,11 @@ uint32_t ThriftHiveMetastore_add_partition_with_environment_context_result::read return xfer; } -uint32_t ThriftHiveMetastore_add_partition_with_environment_context_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_add_partition_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_partition_with_environment_context_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_partition_result"); if (this->__isset.success) { xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); @@ -16625,11 +16577,11 @@ uint32_t ThriftHiveMetastore_add_partition_with_environment_context_result::writ } -ThriftHiveMetastore_add_partition_with_environment_context_presult::~ThriftHiveMetastore_add_partition_with_environment_context_presult() noexcept { +ThriftHiveMetastore_add_partition_presult::~ThriftHiveMetastore_add_partition_presult() noexcept { } -uint32_t ThriftHiveMetastore_add_partition_with_environment_context_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_add_partition_presult::read(::apache::thrift::protocol::TProtocol* iprot) { ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -16695,11 +16647,11 @@ uint32_t ThriftHiveMetastore_add_partition_with_environment_context_presult::rea } -ThriftHiveMetastore_add_partitions_args::~ThriftHiveMetastore_add_partitions_args() noexcept { +ThriftHiveMetastore_add_partition_with_environment_context_args::~ThriftHiveMetastore_add_partition_with_environment_context_args() noexcept { } -uint32_t ThriftHiveMetastore_add_partitions_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_add_partition_with_environment_context_args::read(::apache::thrift::protocol::TProtocol* iprot) { ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -16721,21 +16673,17 @@ uint32_t ThriftHiveMetastore_add_partitions_args::read(::apache::thrift::protoco switch (fid) { case 1: - if (ftype == ::apache::thrift::protocol::T_LIST) { - { - this->new_parts.clear(); - uint32_t _size2201; - ::apache::thrift::protocol::TType _etype2204; - xfer += iprot->readListBegin(_etype2204, _size2201); - this->new_parts.resize(_size2201); - uint32_t _i2205; - for (_i2205 = 0; _i2205 < _size2201; ++_i2205) - { - xfer += this->new_parts[_i2205].read(iprot); - } - xfer += iprot->readListEnd(); - } - this->__isset.new_parts = true; + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->new_part.read(iprot); + this->__isset.new_part = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->environment_context.read(iprot); + this->__isset.environment_context = true; } else { xfer += iprot->skip(ftype); } @@ -16752,21 +16700,17 @@ uint32_t ThriftHiveMetastore_add_partitions_args::read(::apache::thrift::protoco return xfer; } -uint32_t ThriftHiveMetastore_add_partitions_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_add_partition_with_environment_context_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_partitions_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_partition_with_environment_context_args"); - 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 _iter2206; - for (_iter2206 = this->new_parts.begin(); _iter2206 != this->new_parts.end(); ++_iter2206) - { - xfer += (*_iter2206).write(oprot); - } - xfer += oprot->writeListEnd(); - } + xfer += oprot->writeFieldBegin("new_part", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->new_part.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("environment_context", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->environment_context.write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -16775,25 +16719,21 @@ uint32_t ThriftHiveMetastore_add_partitions_args::write(::apache::thrift::protoc } -ThriftHiveMetastore_add_partitions_pargs::~ThriftHiveMetastore_add_partitions_pargs() noexcept { +ThriftHiveMetastore_add_partition_with_environment_context_pargs::~ThriftHiveMetastore_add_partition_with_environment_context_pargs() noexcept { } -uint32_t ThriftHiveMetastore_add_partitions_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_add_partition_with_environment_context_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_partitions_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_partition_with_environment_context_pargs"); - 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 _iter2207; - for (_iter2207 = (*(this->new_parts)).begin(); _iter2207 != (*(this->new_parts)).end(); ++_iter2207) - { - xfer += (*_iter2207).write(oprot); - } - xfer += oprot->writeListEnd(); - } + xfer += oprot->writeFieldBegin("new_part", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->new_part)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("environment_context", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += (*(this->environment_context)).write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -16802,11 +16742,286 @@ uint32_t ThriftHiveMetastore_add_partitions_pargs::write(::apache::thrift::proto } -ThriftHiveMetastore_add_partitions_result::~ThriftHiveMetastore_add_partitions_result() noexcept { +ThriftHiveMetastore_add_partition_with_environment_context_result::~ThriftHiveMetastore_add_partition_with_environment_context_result() noexcept { } -uint32_t ThriftHiveMetastore_add_partitions_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_add_partition_with_environment_context_result::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; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_partition_with_environment_context_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_partition_with_environment_context_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_partition_with_environment_context_presult::~ThriftHiveMetastore_add_partition_with_environment_context_presult() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_partition_with_environment_context_presult::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; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_add_partitions_args::~ThriftHiveMetastore_add_partitions_args() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_partitions_args::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; + + + 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_LIST) { + { + this->new_parts.clear(); + uint32_t _size2218; + ::apache::thrift::protocol::TType _etype2221; + xfer += iprot->readListBegin(_etype2221, _size2218); + this->new_parts.resize(_size2218); + uint32_t _i2222; + for (_i2222 = 0; _i2222 < _size2218; ++_i2222) + { + xfer += this->new_parts[_i2222].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.new_parts = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_partitions_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_partitions_args"); + + 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 _iter2223; + for (_iter2223 = this->new_parts.begin(); _iter2223 != this->new_parts.end(); ++_iter2223) + { + xfer += (*_iter2223).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_partitions_pargs::~ThriftHiveMetastore_add_partitions_pargs() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_partitions_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_partitions_pargs"); + + 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 _iter2224; + for (_iter2224 = (*(this->new_parts)).begin(); _iter2224 != (*(this->new_parts)).end(); ++_iter2224) + { + xfer += (*_iter2224).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_partitions_result::~ThriftHiveMetastore_add_partitions_result() noexcept { +} + + +uint32_t ThriftHiveMetastore_add_partitions_result::read(::apache::thrift::protocol::TProtocol* iprot) { ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -16999,14 +17214,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 _size2208; - ::apache::thrift::protocol::TType _etype2211; - xfer += iprot->readListBegin(_etype2211, _size2208); - this->new_parts.resize(_size2208); - uint32_t _i2212; - for (_i2212 = 0; _i2212 < _size2208; ++_i2212) + uint32_t _size2225; + ::apache::thrift::protocol::TType _etype2228; + xfer += iprot->readListBegin(_etype2228, _size2225); + this->new_parts.resize(_size2225); + uint32_t _i2229; + for (_i2229 = 0; _i2229 < _size2225; ++_i2229) { - xfer += this->new_parts[_i2212].read(iprot); + xfer += this->new_parts[_i2229].read(iprot); } xfer += iprot->readListEnd(); } @@ -17035,10 +17250,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 _iter2213; - for (_iter2213 = this->new_parts.begin(); _iter2213 != this->new_parts.end(); ++_iter2213) + std::vector ::const_iterator _iter2230; + for (_iter2230 = this->new_parts.begin(); _iter2230 != this->new_parts.end(); ++_iter2230) { - xfer += (*_iter2213).write(oprot); + xfer += (*_iter2230).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17062,10 +17277,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 _iter2214; - for (_iter2214 = (*(this->new_parts)).begin(); _iter2214 != (*(this->new_parts)).end(); ++_iter2214) + std::vector ::const_iterator _iter2231; + for (_iter2231 = (*(this->new_parts)).begin(); _iter2231 != (*(this->new_parts)).end(); ++_iter2231) { - xfer += (*_iter2214).write(oprot); + xfer += (*_iter2231).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17290,14 +17505,14 @@ uint32_t ThriftHiveMetastore_append_partition_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size2215; - ::apache::thrift::protocol::TType _etype2218; - xfer += iprot->readListBegin(_etype2218, _size2215); - this->part_vals.resize(_size2215); - uint32_t _i2219; - for (_i2219 = 0; _i2219 < _size2215; ++_i2219) + uint32_t _size2232; + ::apache::thrift::protocol::TType _etype2235; + xfer += iprot->readListBegin(_etype2235, _size2232); + this->part_vals.resize(_size2232); + uint32_t _i2236; + for (_i2236 = 0; _i2236 < _size2232; ++_i2236) { - xfer += iprot->readString(this->part_vals[_i2219]); + xfer += iprot->readString(this->part_vals[_i2236]); } xfer += iprot->readListEnd(); } @@ -17334,10 +17549,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 _iter2220; - for (_iter2220 = this->part_vals.begin(); _iter2220 != this->part_vals.end(); ++_iter2220) + std::vector ::const_iterator _iter2237; + for (_iter2237 = this->part_vals.begin(); _iter2237 != this->part_vals.end(); ++_iter2237) { - xfer += oprot->writeString((*_iter2220)); + xfer += oprot->writeString((*_iter2237)); } xfer += oprot->writeListEnd(); } @@ -17369,10 +17584,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 _iter2221; - for (_iter2221 = (*(this->part_vals)).begin(); _iter2221 != (*(this->part_vals)).end(); ++_iter2221) + std::vector ::const_iterator _iter2238; + for (_iter2238 = (*(this->part_vals)).begin(); _iter2238 != (*(this->part_vals)).end(); ++_iter2238) { - xfer += oprot->writeString((*_iter2221)); + xfer += oprot->writeString((*_iter2238)); } xfer += oprot->writeListEnd(); } @@ -17844,14 +18059,14 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::rea if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size2222; - ::apache::thrift::protocol::TType _etype2225; - xfer += iprot->readListBegin(_etype2225, _size2222); - this->part_vals.resize(_size2222); - uint32_t _i2226; - for (_i2226 = 0; _i2226 < _size2222; ++_i2226) + uint32_t _size2239; + ::apache::thrift::protocol::TType _etype2242; + xfer += iprot->readListBegin(_etype2242, _size2239); + this->part_vals.resize(_size2239); + uint32_t _i2243; + for (_i2243 = 0; _i2243 < _size2239; ++_i2243) { - xfer += iprot->readString(this->part_vals[_i2226]); + xfer += iprot->readString(this->part_vals[_i2243]); } xfer += iprot->readListEnd(); } @@ -17896,10 +18111,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 _iter2227; - for (_iter2227 = this->part_vals.begin(); _iter2227 != this->part_vals.end(); ++_iter2227) + std::vector ::const_iterator _iter2244; + for (_iter2244 = this->part_vals.begin(); _iter2244 != this->part_vals.end(); ++_iter2244) { - xfer += oprot->writeString((*_iter2227)); + xfer += oprot->writeString((*_iter2244)); } xfer += oprot->writeListEnd(); } @@ -17935,10 +18150,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 _iter2228; - for (_iter2228 = (*(this->part_vals)).begin(); _iter2228 != (*(this->part_vals)).end(); ++_iter2228) + std::vector ::const_iterator _iter2245; + for (_iter2245 = (*(this->part_vals)).begin(); _iter2245 != (*(this->part_vals)).end(); ++_iter2245) { - xfer += oprot->writeString((*_iter2228)); + xfer += oprot->writeString((*_iter2245)); } xfer += oprot->writeListEnd(); } @@ -18988,14 +19203,14 @@ uint32_t ThriftHiveMetastore_drop_partition_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size2229; - ::apache::thrift::protocol::TType _etype2232; - xfer += iprot->readListBegin(_etype2232, _size2229); - this->part_vals.resize(_size2229); - uint32_t _i2233; - for (_i2233 = 0; _i2233 < _size2229; ++_i2233) + uint32_t _size2246; + ::apache::thrift::protocol::TType _etype2249; + xfer += iprot->readListBegin(_etype2249, _size2246); + this->part_vals.resize(_size2246); + uint32_t _i2250; + for (_i2250 = 0; _i2250 < _size2246; ++_i2250) { - xfer += iprot->readString(this->part_vals[_i2233]); + xfer += iprot->readString(this->part_vals[_i2250]); } xfer += iprot->readListEnd(); } @@ -19040,10 +19255,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 _iter2234; - for (_iter2234 = this->part_vals.begin(); _iter2234 != this->part_vals.end(); ++_iter2234) + std::vector ::const_iterator _iter2251; + for (_iter2251 = this->part_vals.begin(); _iter2251 != this->part_vals.end(); ++_iter2251) { - xfer += oprot->writeString((*_iter2234)); + xfer += oprot->writeString((*_iter2251)); } xfer += oprot->writeListEnd(); } @@ -19079,10 +19294,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 _iter2235; - for (_iter2235 = (*(this->part_vals)).begin(); _iter2235 != (*(this->part_vals)).end(); ++_iter2235) + std::vector ::const_iterator _iter2252; + for (_iter2252 = (*(this->part_vals)).begin(); _iter2252 != (*(this->part_vals)).end(); ++_iter2252) { - xfer += oprot->writeString((*_iter2235)); + xfer += oprot->writeString((*_iter2252)); } xfer += oprot->writeListEnd(); } @@ -19291,14 +19506,14 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::read( if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size2236; - ::apache::thrift::protocol::TType _etype2239; - xfer += iprot->readListBegin(_etype2239, _size2236); - this->part_vals.resize(_size2236); - uint32_t _i2240; - for (_i2240 = 0; _i2240 < _size2236; ++_i2240) + uint32_t _size2253; + ::apache::thrift::protocol::TType _etype2256; + xfer += iprot->readListBegin(_etype2256, _size2253); + this->part_vals.resize(_size2253); + uint32_t _i2257; + for (_i2257 = 0; _i2257 < _size2253; ++_i2257) { - xfer += iprot->readString(this->part_vals[_i2240]); + xfer += iprot->readString(this->part_vals[_i2257]); } xfer += iprot->readListEnd(); } @@ -19351,10 +19566,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 _iter2241; - for (_iter2241 = this->part_vals.begin(); _iter2241 != this->part_vals.end(); ++_iter2241) + std::vector ::const_iterator _iter2258; + for (_iter2258 = this->part_vals.begin(); _iter2258 != this->part_vals.end(); ++_iter2258) { - xfer += oprot->writeString((*_iter2241)); + xfer += oprot->writeString((*_iter2258)); } xfer += oprot->writeListEnd(); } @@ -19394,10 +19609,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 _iter2242; - for (_iter2242 = (*(this->part_vals)).begin(); _iter2242 != (*(this->part_vals)).end(); ++_iter2242) + std::vector ::const_iterator _iter2259; + for (_iter2259 = (*(this->part_vals)).begin(); _iter2259 != (*(this->part_vals)).end(); ++_iter2259) { - xfer += oprot->writeString((*_iter2242)); + xfer += oprot->writeString((*_iter2259)); } xfer += oprot->writeListEnd(); } @@ -20630,14 +20845,14 @@ uint32_t ThriftHiveMetastore_get_partition_args::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size2243; - ::apache::thrift::protocol::TType _etype2246; - xfer += iprot->readListBegin(_etype2246, _size2243); - this->part_vals.resize(_size2243); - uint32_t _i2247; - for (_i2247 = 0; _i2247 < _size2243; ++_i2247) + uint32_t _size2260; + ::apache::thrift::protocol::TType _etype2263; + xfer += iprot->readListBegin(_etype2263, _size2260); + this->part_vals.resize(_size2260); + uint32_t _i2264; + for (_i2264 = 0; _i2264 < _size2260; ++_i2264) { - xfer += iprot->readString(this->part_vals[_i2247]); + xfer += iprot->readString(this->part_vals[_i2264]); } xfer += iprot->readListEnd(); } @@ -20674,10 +20889,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 _iter2248; - for (_iter2248 = this->part_vals.begin(); _iter2248 != this->part_vals.end(); ++_iter2248) + std::vector ::const_iterator _iter2265; + for (_iter2265 = this->part_vals.begin(); _iter2265 != this->part_vals.end(); ++_iter2265) { - xfer += oprot->writeString((*_iter2248)); + xfer += oprot->writeString((*_iter2265)); } xfer += oprot->writeListEnd(); } @@ -20709,10 +20924,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 _iter2249; - for (_iter2249 = (*(this->part_vals)).begin(); _iter2249 != (*(this->part_vals)).end(); ++_iter2249) + std::vector ::const_iterator _iter2266; + for (_iter2266 = (*(this->part_vals)).begin(); _iter2266 != (*(this->part_vals)).end(); ++_iter2266) { - xfer += oprot->writeString((*_iter2249)); + xfer += oprot->writeString((*_iter2266)); } xfer += oprot->writeListEnd(); } @@ -21128,17 +21343,17 @@ uint32_t ThriftHiveMetastore_exchange_partition_args::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size2250; - ::apache::thrift::protocol::TType _ktype2251; - ::apache::thrift::protocol::TType _vtype2252; - xfer += iprot->readMapBegin(_ktype2251, _vtype2252, _size2250); - uint32_t _i2254; - for (_i2254 = 0; _i2254 < _size2250; ++_i2254) + uint32_t _size2267; + ::apache::thrift::protocol::TType _ktype2268; + ::apache::thrift::protocol::TType _vtype2269; + xfer += iprot->readMapBegin(_ktype2268, _vtype2269, _size2267); + uint32_t _i2271; + for (_i2271 = 0; _i2271 < _size2267; ++_i2271) { - std::string _key2255; - xfer += iprot->readString(_key2255); - std::string& _val2256 = this->partitionSpecs[_key2255]; - xfer += iprot->readString(_val2256); + std::string _key2272; + xfer += iprot->readString(_key2272); + std::string& _val2273 = this->partitionSpecs[_key2272]; + xfer += iprot->readString(_val2273); } xfer += iprot->readMapEnd(); } @@ -21199,11 +21414,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 _iter2257; - for (_iter2257 = this->partitionSpecs.begin(); _iter2257 != this->partitionSpecs.end(); ++_iter2257) + std::map ::const_iterator _iter2274; + for (_iter2274 = this->partitionSpecs.begin(); _iter2274 != this->partitionSpecs.end(); ++_iter2274) { - xfer += oprot->writeString(_iter2257->first); - xfer += oprot->writeString(_iter2257->second); + xfer += oprot->writeString(_iter2274->first); + xfer += oprot->writeString(_iter2274->second); } xfer += oprot->writeMapEnd(); } @@ -21243,11 +21458,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 _iter2258; - for (_iter2258 = (*(this->partitionSpecs)).begin(); _iter2258 != (*(this->partitionSpecs)).end(); ++_iter2258) + std::map ::const_iterator _iter2275; + for (_iter2275 = (*(this->partitionSpecs)).begin(); _iter2275 != (*(this->partitionSpecs)).end(); ++_iter2275) { - xfer += oprot->writeString(_iter2258->first); - xfer += oprot->writeString(_iter2258->second); + xfer += oprot->writeString(_iter2275->first); + xfer += oprot->writeString(_iter2275->second); } xfer += oprot->writeMapEnd(); } @@ -21492,17 +21707,17 @@ uint32_t ThriftHiveMetastore_exchange_partitions_args::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size2259; - ::apache::thrift::protocol::TType _ktype2260; - ::apache::thrift::protocol::TType _vtype2261; - xfer += iprot->readMapBegin(_ktype2260, _vtype2261, _size2259); - uint32_t _i2263; - for (_i2263 = 0; _i2263 < _size2259; ++_i2263) + uint32_t _size2276; + ::apache::thrift::protocol::TType _ktype2277; + ::apache::thrift::protocol::TType _vtype2278; + xfer += iprot->readMapBegin(_ktype2277, _vtype2278, _size2276); + uint32_t _i2280; + for (_i2280 = 0; _i2280 < _size2276; ++_i2280) { - std::string _key2264; - xfer += iprot->readString(_key2264); - std::string& _val2265 = this->partitionSpecs[_key2264]; - xfer += iprot->readString(_val2265); + std::string _key2281; + xfer += iprot->readString(_key2281); + std::string& _val2282 = this->partitionSpecs[_key2281]; + xfer += iprot->readString(_val2282); } xfer += iprot->readMapEnd(); } @@ -21563,11 +21778,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 _iter2266; - for (_iter2266 = this->partitionSpecs.begin(); _iter2266 != this->partitionSpecs.end(); ++_iter2266) + std::map ::const_iterator _iter2283; + for (_iter2283 = this->partitionSpecs.begin(); _iter2283 != this->partitionSpecs.end(); ++_iter2283) { - xfer += oprot->writeString(_iter2266->first); - xfer += oprot->writeString(_iter2266->second); + xfer += oprot->writeString(_iter2283->first); + xfer += oprot->writeString(_iter2283->second); } xfer += oprot->writeMapEnd(); } @@ -21607,11 +21822,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 _iter2267; - for (_iter2267 = (*(this->partitionSpecs)).begin(); _iter2267 != (*(this->partitionSpecs)).end(); ++_iter2267) + std::map ::const_iterator _iter2284; + for (_iter2284 = (*(this->partitionSpecs)).begin(); _iter2284 != (*(this->partitionSpecs)).end(); ++_iter2284) { - xfer += oprot->writeString(_iter2267->first); - xfer += oprot->writeString(_iter2267->second); + xfer += oprot->writeString(_iter2284->first); + xfer += oprot->writeString(_iter2284->second); } xfer += oprot->writeMapEnd(); } @@ -21668,14 +21883,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2268; - ::apache::thrift::protocol::TType _etype2271; - xfer += iprot->readListBegin(_etype2271, _size2268); - this->success.resize(_size2268); - uint32_t _i2272; - for (_i2272 = 0; _i2272 < _size2268; ++_i2272) + uint32_t _size2285; + ::apache::thrift::protocol::TType _etype2288; + xfer += iprot->readListBegin(_etype2288, _size2285); + this->success.resize(_size2285); + uint32_t _i2289; + for (_i2289 = 0; _i2289 < _size2285; ++_i2289) { - xfer += this->success[_i2272].read(iprot); + xfer += this->success[_i2289].read(iprot); } xfer += iprot->readListEnd(); } @@ -21738,10 +21953,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 _iter2273; - for (_iter2273 = this->success.begin(); _iter2273 != this->success.end(); ++_iter2273) + std::vector ::const_iterator _iter2290; + for (_iter2290 = this->success.begin(); _iter2290 != this->success.end(); ++_iter2290) { - xfer += (*_iter2273).write(oprot); + xfer += (*_iter2290).write(oprot); } xfer += oprot->writeListEnd(); } @@ -21798,14 +22013,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2274; - ::apache::thrift::protocol::TType _etype2277; - xfer += iprot->readListBegin(_etype2277, _size2274); - (*(this->success)).resize(_size2274); - uint32_t _i2278; - for (_i2278 = 0; _i2278 < _size2274; ++_i2278) + uint32_t _size2291; + ::apache::thrift::protocol::TType _etype2294; + xfer += iprot->readListBegin(_etype2294, _size2291); + (*(this->success)).resize(_size2291); + uint32_t _i2295; + for (_i2295 = 0; _i2295 < _size2291; ++_i2295) { - xfer += (*(this->success))[_i2278].read(iprot); + xfer += (*(this->success))[_i2295].read(iprot); } xfer += iprot->readListEnd(); } @@ -21904,14 +22119,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 _size2279; - ::apache::thrift::protocol::TType _etype2282; - xfer += iprot->readListBegin(_etype2282, _size2279); - this->part_vals.resize(_size2279); - uint32_t _i2283; - for (_i2283 = 0; _i2283 < _size2279; ++_i2283) + uint32_t _size2296; + ::apache::thrift::protocol::TType _etype2299; + xfer += iprot->readListBegin(_etype2299, _size2296); + this->part_vals.resize(_size2296); + uint32_t _i2300; + for (_i2300 = 0; _i2300 < _size2296; ++_i2300) { - xfer += iprot->readString(this->part_vals[_i2283]); + xfer += iprot->readString(this->part_vals[_i2300]); } xfer += iprot->readListEnd(); } @@ -21932,14 +22147,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 _size2284; - ::apache::thrift::protocol::TType _etype2287; - xfer += iprot->readListBegin(_etype2287, _size2284); - this->group_names.resize(_size2284); - uint32_t _i2288; - for (_i2288 = 0; _i2288 < _size2284; ++_i2288) + uint32_t _size2301; + ::apache::thrift::protocol::TType _etype2304; + xfer += iprot->readListBegin(_etype2304, _size2301); + this->group_names.resize(_size2301); + uint32_t _i2305; + for (_i2305 = 0; _i2305 < _size2301; ++_i2305) { - xfer += iprot->readString(this->group_names[_i2288]); + xfer += iprot->readString(this->group_names[_i2305]); } xfer += iprot->readListEnd(); } @@ -21976,10 +22191,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 _iter2289; - for (_iter2289 = this->part_vals.begin(); _iter2289 != this->part_vals.end(); ++_iter2289) + std::vector ::const_iterator _iter2306; + for (_iter2306 = this->part_vals.begin(); _iter2306 != this->part_vals.end(); ++_iter2306) { - xfer += oprot->writeString((*_iter2289)); + xfer += oprot->writeString((*_iter2306)); } xfer += oprot->writeListEnd(); } @@ -21992,10 +22207,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 _iter2290; - for (_iter2290 = this->group_names.begin(); _iter2290 != this->group_names.end(); ++_iter2290) + std::vector ::const_iterator _iter2307; + for (_iter2307 = this->group_names.begin(); _iter2307 != this->group_names.end(); ++_iter2307) { - xfer += oprot->writeString((*_iter2290)); + xfer += oprot->writeString((*_iter2307)); } xfer += oprot->writeListEnd(); } @@ -22027,10 +22242,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 _iter2291; - for (_iter2291 = (*(this->part_vals)).begin(); _iter2291 != (*(this->part_vals)).end(); ++_iter2291) + std::vector ::const_iterator _iter2308; + for (_iter2308 = (*(this->part_vals)).begin(); _iter2308 != (*(this->part_vals)).end(); ++_iter2308) { - xfer += oprot->writeString((*_iter2291)); + xfer += oprot->writeString((*_iter2308)); } xfer += oprot->writeListEnd(); } @@ -22043,10 +22258,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 _iter2292; - for (_iter2292 = (*(this->group_names)).begin(); _iter2292 != (*(this->group_names)).end(); ++_iter2292) + std::vector ::const_iterator _iter2309; + for (_iter2309 = (*(this->group_names)).begin(); _iter2309 != (*(this->group_names)).end(); ++_iter2309) { - xfer += oprot->writeString((*_iter2292)); + xfer += oprot->writeString((*_iter2309)); } xfer += oprot->writeListEnd(); } @@ -22605,14 +22820,14 @@ uint32_t ThriftHiveMetastore_get_partitions_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2293; - ::apache::thrift::protocol::TType _etype2296; - xfer += iprot->readListBegin(_etype2296, _size2293); - this->success.resize(_size2293); - uint32_t _i2297; - for (_i2297 = 0; _i2297 < _size2293; ++_i2297) + uint32_t _size2310; + ::apache::thrift::protocol::TType _etype2313; + xfer += iprot->readListBegin(_etype2313, _size2310); + this->success.resize(_size2310); + uint32_t _i2314; + for (_i2314 = 0; _i2314 < _size2310; ++_i2314) { - xfer += this->success[_i2297].read(iprot); + xfer += this->success[_i2314].read(iprot); } xfer += iprot->readListEnd(); } @@ -22659,10 +22874,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 _iter2298; - for (_iter2298 = this->success.begin(); _iter2298 != this->success.end(); ++_iter2298) + std::vector ::const_iterator _iter2315; + for (_iter2315 = this->success.begin(); _iter2315 != this->success.end(); ++_iter2315) { - xfer += (*_iter2298).write(oprot); + xfer += (*_iter2315).write(oprot); } xfer += oprot->writeListEnd(); } @@ -22711,14 +22926,14 @@ uint32_t ThriftHiveMetastore_get_partitions_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2299; - ::apache::thrift::protocol::TType _etype2302; - xfer += iprot->readListBegin(_etype2302, _size2299); - (*(this->success)).resize(_size2299); - uint32_t _i2303; - for (_i2303 = 0; _i2303 < _size2299; ++_i2303) + uint32_t _size2316; + ::apache::thrift::protocol::TType _etype2319; + xfer += iprot->readListBegin(_etype2319, _size2316); + (*(this->success)).resize(_size2316); + uint32_t _i2320; + for (_i2320 = 0; _i2320 < _size2316; ++_i2320) { - xfer += (*(this->success))[_i2303].read(iprot); + xfer += (*(this->success))[_i2320].read(iprot); } xfer += iprot->readListEnd(); } @@ -23044,14 +23259,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 _size2304; - ::apache::thrift::protocol::TType _etype2307; - xfer += iprot->readListBegin(_etype2307, _size2304); - this->group_names.resize(_size2304); - uint32_t _i2308; - for (_i2308 = 0; _i2308 < _size2304; ++_i2308) + uint32_t _size2321; + ::apache::thrift::protocol::TType _etype2324; + xfer += iprot->readListBegin(_etype2324, _size2321); + this->group_names.resize(_size2321); + uint32_t _i2325; + for (_i2325 = 0; _i2325 < _size2321; ++_i2325) { - xfer += iprot->readString(this->group_names[_i2308]); + xfer += iprot->readString(this->group_names[_i2325]); } xfer += iprot->readListEnd(); } @@ -23096,10 +23311,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 _iter2309; - for (_iter2309 = this->group_names.begin(); _iter2309 != this->group_names.end(); ++_iter2309) + std::vector ::const_iterator _iter2326; + for (_iter2326 = this->group_names.begin(); _iter2326 != this->group_names.end(); ++_iter2326) { - xfer += oprot->writeString((*_iter2309)); + xfer += oprot->writeString((*_iter2326)); } xfer += oprot->writeListEnd(); } @@ -23139,10 +23354,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 _iter2310; - for (_iter2310 = (*(this->group_names)).begin(); _iter2310 != (*(this->group_names)).end(); ++_iter2310) + std::vector ::const_iterator _iter2327; + for (_iter2327 = (*(this->group_names)).begin(); _iter2327 != (*(this->group_names)).end(); ++_iter2327) { - xfer += oprot->writeString((*_iter2310)); + xfer += oprot->writeString((*_iter2327)); } xfer += oprot->writeListEnd(); } @@ -23183,14 +23398,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2311; - ::apache::thrift::protocol::TType _etype2314; - xfer += iprot->readListBegin(_etype2314, _size2311); - this->success.resize(_size2311); - uint32_t _i2315; - for (_i2315 = 0; _i2315 < _size2311; ++_i2315) + uint32_t _size2328; + ::apache::thrift::protocol::TType _etype2331; + xfer += iprot->readListBegin(_etype2331, _size2328); + this->success.resize(_size2328); + uint32_t _i2332; + for (_i2332 = 0; _i2332 < _size2328; ++_i2332) { - xfer += this->success[_i2315].read(iprot); + xfer += this->success[_i2332].read(iprot); } xfer += iprot->readListEnd(); } @@ -23237,10 +23452,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 _iter2316; - for (_iter2316 = this->success.begin(); _iter2316 != this->success.end(); ++_iter2316) + std::vector ::const_iterator _iter2333; + for (_iter2333 = this->success.begin(); _iter2333 != this->success.end(); ++_iter2333) { - xfer += (*_iter2316).write(oprot); + xfer += (*_iter2333).write(oprot); } xfer += oprot->writeListEnd(); } @@ -23289,14 +23504,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2317; - ::apache::thrift::protocol::TType _etype2320; - xfer += iprot->readListBegin(_etype2320, _size2317); - (*(this->success)).resize(_size2317); - uint32_t _i2321; - for (_i2321 = 0; _i2321 < _size2317; ++_i2321) + uint32_t _size2334; + ::apache::thrift::protocol::TType _etype2337; + xfer += iprot->readListBegin(_etype2337, _size2334); + (*(this->success)).resize(_size2334); + uint32_t _i2338; + for (_i2338 = 0; _i2338 < _size2334; ++_i2338) { - xfer += (*(this->success))[_i2321].read(iprot); + xfer += (*(this->success))[_i2338].read(iprot); } xfer += iprot->readListEnd(); } @@ -23474,14 +23689,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_result::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2322; - ::apache::thrift::protocol::TType _etype2325; - xfer += iprot->readListBegin(_etype2325, _size2322); - this->success.resize(_size2322); - uint32_t _i2326; - for (_i2326 = 0; _i2326 < _size2322; ++_i2326) + uint32_t _size2339; + ::apache::thrift::protocol::TType _etype2342; + xfer += iprot->readListBegin(_etype2342, _size2339); + this->success.resize(_size2339); + uint32_t _i2343; + for (_i2343 = 0; _i2343 < _size2339; ++_i2343) { - xfer += this->success[_i2326].read(iprot); + xfer += this->success[_i2343].read(iprot); } xfer += iprot->readListEnd(); } @@ -23528,10 +23743,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 _iter2327; - for (_iter2327 = this->success.begin(); _iter2327 != this->success.end(); ++_iter2327) + std::vector ::const_iterator _iter2344; + for (_iter2344 = this->success.begin(); _iter2344 != this->success.end(); ++_iter2344) { - xfer += (*_iter2327).write(oprot); + xfer += (*_iter2344).write(oprot); } xfer += oprot->writeListEnd(); } @@ -23580,14 +23795,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_presult::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2328; - ::apache::thrift::protocol::TType _etype2331; - xfer += iprot->readListBegin(_etype2331, _size2328); - (*(this->success)).resize(_size2328); - uint32_t _i2332; - for (_i2332 = 0; _i2332 < _size2328; ++_i2332) + uint32_t _size2345; + ::apache::thrift::protocol::TType _etype2348; + xfer += iprot->readListBegin(_etype2348, _size2345); + (*(this->success)).resize(_size2345); + uint32_t _i2349; + for (_i2349 = 0; _i2349 < _size2345; ++_i2349) { - xfer += (*(this->success))[_i2332].read(iprot); + xfer += (*(this->success))[_i2349].read(iprot); } xfer += iprot->readListEnd(); } @@ -23765,14 +23980,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2333; - ::apache::thrift::protocol::TType _etype2336; - xfer += iprot->readListBegin(_etype2336, _size2333); - this->success.resize(_size2333); - uint32_t _i2337; - for (_i2337 = 0; _i2337 < _size2333; ++_i2337) + uint32_t _size2350; + ::apache::thrift::protocol::TType _etype2353; + xfer += iprot->readListBegin(_etype2353, _size2350); + this->success.resize(_size2350); + uint32_t _i2354; + for (_i2354 = 0; _i2354 < _size2350; ++_i2354) { - xfer += iprot->readString(this->success[_i2337]); + xfer += iprot->readString(this->success[_i2354]); } xfer += iprot->readListEnd(); } @@ -23819,10 +24034,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 _iter2338; - for (_iter2338 = this->success.begin(); _iter2338 != this->success.end(); ++_iter2338) + std::vector ::const_iterator _iter2355; + for (_iter2355 = this->success.begin(); _iter2355 != this->success.end(); ++_iter2355) { - xfer += oprot->writeString((*_iter2338)); + xfer += oprot->writeString((*_iter2355)); } xfer += oprot->writeListEnd(); } @@ -23871,14 +24086,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2339; - ::apache::thrift::protocol::TType _etype2342; - xfer += iprot->readListBegin(_etype2342, _size2339); - (*(this->success)).resize(_size2339); - uint32_t _i2343; - for (_i2343 = 0; _i2343 < _size2339; ++_i2343) + uint32_t _size2356; + ::apache::thrift::protocol::TType _etype2359; + xfer += iprot->readListBegin(_etype2359, _size2356); + (*(this->success)).resize(_size2356); + uint32_t _i2360; + for (_i2360 = 0; _i2360 < _size2356; ++_i2360) { - xfer += iprot->readString((*(this->success))[_i2343]); + xfer += iprot->readString((*(this->success))[_i2360]); } xfer += iprot->readListEnd(); } @@ -24024,14 +24239,14 @@ uint32_t ThriftHiveMetastore_fetch_partition_names_req_result::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2344; - ::apache::thrift::protocol::TType _etype2347; - xfer += iprot->readListBegin(_etype2347, _size2344); - this->success.resize(_size2344); - uint32_t _i2348; - for (_i2348 = 0; _i2348 < _size2344; ++_i2348) + uint32_t _size2361; + ::apache::thrift::protocol::TType _etype2364; + xfer += iprot->readListBegin(_etype2364, _size2361); + this->success.resize(_size2361); + uint32_t _i2365; + for (_i2365 = 0; _i2365 < _size2361; ++_i2365) { - xfer += iprot->readString(this->success[_i2348]); + xfer += iprot->readString(this->success[_i2365]); } xfer += iprot->readListEnd(); } @@ -24078,10 +24293,10 @@ uint32_t ThriftHiveMetastore_fetch_partition_names_req_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 _iter2349; - for (_iter2349 = this->success.begin(); _iter2349 != this->success.end(); ++_iter2349) + std::vector ::const_iterator _iter2366; + for (_iter2366 = this->success.begin(); _iter2366 != this->success.end(); ++_iter2366) { - xfer += oprot->writeString((*_iter2349)); + xfer += oprot->writeString((*_iter2366)); } xfer += oprot->writeListEnd(); } @@ -24130,14 +24345,14 @@ uint32_t ThriftHiveMetastore_fetch_partition_names_req_presult::read(::apache::t if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2350; - ::apache::thrift::protocol::TType _etype2353; - xfer += iprot->readListBegin(_etype2353, _size2350); - (*(this->success)).resize(_size2350); - uint32_t _i2354; - for (_i2354 = 0; _i2354 < _size2350; ++_i2354) + uint32_t _size2367; + ::apache::thrift::protocol::TType _etype2370; + xfer += iprot->readListBegin(_etype2370, _size2367); + (*(this->success)).resize(_size2367); + uint32_t _i2371; + for (_i2371 = 0; _i2371 < _size2367; ++_i2371) { - xfer += iprot->readString((*(this->success))[_i2354]); + xfer += iprot->readString((*(this->success))[_i2371]); } xfer += iprot->readListEnd(); } @@ -24447,14 +24662,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 _size2355; - ::apache::thrift::protocol::TType _etype2358; - xfer += iprot->readListBegin(_etype2358, _size2355); - this->part_vals.resize(_size2355); - uint32_t _i2359; - for (_i2359 = 0; _i2359 < _size2355; ++_i2359) + uint32_t _size2372; + ::apache::thrift::protocol::TType _etype2375; + xfer += iprot->readListBegin(_etype2375, _size2372); + this->part_vals.resize(_size2372); + uint32_t _i2376; + for (_i2376 = 0; _i2376 < _size2372; ++_i2376) { - xfer += iprot->readString(this->part_vals[_i2359]); + xfer += iprot->readString(this->part_vals[_i2376]); } xfer += iprot->readListEnd(); } @@ -24499,10 +24714,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 _iter2360; - for (_iter2360 = this->part_vals.begin(); _iter2360 != this->part_vals.end(); ++_iter2360) + std::vector ::const_iterator _iter2377; + for (_iter2377 = this->part_vals.begin(); _iter2377 != this->part_vals.end(); ++_iter2377) { - xfer += oprot->writeString((*_iter2360)); + xfer += oprot->writeString((*_iter2377)); } xfer += oprot->writeListEnd(); } @@ -24538,10 +24753,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 _iter2361; - for (_iter2361 = (*(this->part_vals)).begin(); _iter2361 != (*(this->part_vals)).end(); ++_iter2361) + std::vector ::const_iterator _iter2378; + for (_iter2378 = (*(this->part_vals)).begin(); _iter2378 != (*(this->part_vals)).end(); ++_iter2378) { - xfer += oprot->writeString((*_iter2361)); + xfer += oprot->writeString((*_iter2378)); } xfer += oprot->writeListEnd(); } @@ -24586,14 +24801,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_result::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2362; - ::apache::thrift::protocol::TType _etype2365; - xfer += iprot->readListBegin(_etype2365, _size2362); - this->success.resize(_size2362); - uint32_t _i2366; - for (_i2366 = 0; _i2366 < _size2362; ++_i2366) + uint32_t _size2379; + ::apache::thrift::protocol::TType _etype2382; + xfer += iprot->readListBegin(_etype2382, _size2379); + this->success.resize(_size2379); + uint32_t _i2383; + for (_i2383 = 0; _i2383 < _size2379; ++_i2383) { - xfer += this->success[_i2366].read(iprot); + xfer += this->success[_i2383].read(iprot); } xfer += iprot->readListEnd(); } @@ -24640,10 +24855,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 _iter2367; - for (_iter2367 = this->success.begin(); _iter2367 != this->success.end(); ++_iter2367) + std::vector ::const_iterator _iter2384; + for (_iter2384 = this->success.begin(); _iter2384 != this->success.end(); ++_iter2384) { - xfer += (*_iter2367).write(oprot); + xfer += (*_iter2384).write(oprot); } xfer += oprot->writeListEnd(); } @@ -24692,14 +24907,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_presult::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2368; - ::apache::thrift::protocol::TType _etype2371; - xfer += iprot->readListBegin(_etype2371, _size2368); - (*(this->success)).resize(_size2368); - uint32_t _i2372; - for (_i2372 = 0; _i2372 < _size2368; ++_i2372) + uint32_t _size2385; + ::apache::thrift::protocol::TType _etype2388; + xfer += iprot->readListBegin(_etype2388, _size2385); + (*(this->success)).resize(_size2385); + uint32_t _i2389; + for (_i2389 = 0; _i2389 < _size2385; ++_i2389) { - xfer += (*(this->success))[_i2372].read(iprot); + xfer += (*(this->success))[_i2389].read(iprot); } xfer += iprot->readListEnd(); } @@ -24782,14 +24997,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 _size2373; - ::apache::thrift::protocol::TType _etype2376; - xfer += iprot->readListBegin(_etype2376, _size2373); - this->part_vals.resize(_size2373); - uint32_t _i2377; - for (_i2377 = 0; _i2377 < _size2373; ++_i2377) + uint32_t _size2390; + ::apache::thrift::protocol::TType _etype2393; + xfer += iprot->readListBegin(_etype2393, _size2390); + this->part_vals.resize(_size2390); + uint32_t _i2394; + for (_i2394 = 0; _i2394 < _size2390; ++_i2394) { - xfer += iprot->readString(this->part_vals[_i2377]); + xfer += iprot->readString(this->part_vals[_i2394]); } xfer += iprot->readListEnd(); } @@ -24818,14 +25033,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 _size2378; - ::apache::thrift::protocol::TType _etype2381; - xfer += iprot->readListBegin(_etype2381, _size2378); - this->group_names.resize(_size2378); - uint32_t _i2382; - for (_i2382 = 0; _i2382 < _size2378; ++_i2382) + uint32_t _size2395; + ::apache::thrift::protocol::TType _etype2398; + xfer += iprot->readListBegin(_etype2398, _size2395); + this->group_names.resize(_size2395); + uint32_t _i2399; + for (_i2399 = 0; _i2399 < _size2395; ++_i2399) { - xfer += iprot->readString(this->group_names[_i2382]); + xfer += iprot->readString(this->group_names[_i2399]); } xfer += iprot->readListEnd(); } @@ -24862,10 +25077,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 _iter2383; - for (_iter2383 = this->part_vals.begin(); _iter2383 != this->part_vals.end(); ++_iter2383) + std::vector ::const_iterator _iter2400; + for (_iter2400 = this->part_vals.begin(); _iter2400 != this->part_vals.end(); ++_iter2400) { - xfer += oprot->writeString((*_iter2383)); + xfer += oprot->writeString((*_iter2400)); } xfer += oprot->writeListEnd(); } @@ -24882,10 +25097,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 _iter2384; - for (_iter2384 = this->group_names.begin(); _iter2384 != this->group_names.end(); ++_iter2384) + std::vector ::const_iterator _iter2401; + for (_iter2401 = this->group_names.begin(); _iter2401 != this->group_names.end(); ++_iter2401) { - xfer += oprot->writeString((*_iter2384)); + xfer += oprot->writeString((*_iter2401)); } xfer += oprot->writeListEnd(); } @@ -24917,10 +25132,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 _iter2385; - for (_iter2385 = (*(this->part_vals)).begin(); _iter2385 != (*(this->part_vals)).end(); ++_iter2385) + std::vector ::const_iterator _iter2402; + for (_iter2402 = (*(this->part_vals)).begin(); _iter2402 != (*(this->part_vals)).end(); ++_iter2402) { - xfer += oprot->writeString((*_iter2385)); + xfer += oprot->writeString((*_iter2402)); } xfer += oprot->writeListEnd(); } @@ -24937,10 +25152,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 _iter2386; - for (_iter2386 = (*(this->group_names)).begin(); _iter2386 != (*(this->group_names)).end(); ++_iter2386) + std::vector ::const_iterator _iter2403; + for (_iter2403 = (*(this->group_names)).begin(); _iter2403 != (*(this->group_names)).end(); ++_iter2403) { - xfer += oprot->writeString((*_iter2386)); + xfer += oprot->writeString((*_iter2403)); } xfer += oprot->writeListEnd(); } @@ -24981,14 +25196,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_result::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2387; - ::apache::thrift::protocol::TType _etype2390; - xfer += iprot->readListBegin(_etype2390, _size2387); - this->success.resize(_size2387); - uint32_t _i2391; - for (_i2391 = 0; _i2391 < _size2387; ++_i2391) + uint32_t _size2404; + ::apache::thrift::protocol::TType _etype2407; + xfer += iprot->readListBegin(_etype2407, _size2404); + this->success.resize(_size2404); + uint32_t _i2408; + for (_i2408 = 0; _i2408 < _size2404; ++_i2408) { - xfer += this->success[_i2391].read(iprot); + xfer += this->success[_i2408].read(iprot); } xfer += iprot->readListEnd(); } @@ -25035,10 +25250,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 _iter2392; - for (_iter2392 = this->success.begin(); _iter2392 != this->success.end(); ++_iter2392) + std::vector ::const_iterator _iter2409; + for (_iter2409 = this->success.begin(); _iter2409 != this->success.end(); ++_iter2409) { - xfer += (*_iter2392).write(oprot); + xfer += (*_iter2409).write(oprot); } xfer += oprot->writeListEnd(); } @@ -25087,14 +25302,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_presult::read(::apache: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2393; - ::apache::thrift::protocol::TType _etype2396; - xfer += iprot->readListBegin(_etype2396, _size2393); - (*(this->success)).resize(_size2393); - uint32_t _i2397; - for (_i2397 = 0; _i2397 < _size2393; ++_i2397) + uint32_t _size2410; + ::apache::thrift::protocol::TType _etype2413; + xfer += iprot->readListBegin(_etype2413, _size2410); + (*(this->success)).resize(_size2410); + uint32_t _i2414; + for (_i2414 = 0; _i2414 < _size2410; ++_i2414) { - xfer += (*(this->success))[_i2397].read(iprot); + xfer += (*(this->success))[_i2414].read(iprot); } xfer += iprot->readListEnd(); } @@ -25404,14 +25619,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 _size2398; - ::apache::thrift::protocol::TType _etype2401; - xfer += iprot->readListBegin(_etype2401, _size2398); - this->part_vals.resize(_size2398); - uint32_t _i2402; - for (_i2402 = 0; _i2402 < _size2398; ++_i2402) + uint32_t _size2415; + ::apache::thrift::protocol::TType _etype2418; + xfer += iprot->readListBegin(_etype2418, _size2415); + this->part_vals.resize(_size2415); + uint32_t _i2419; + for (_i2419 = 0; _i2419 < _size2415; ++_i2419) { - xfer += iprot->readString(this->part_vals[_i2402]); + xfer += iprot->readString(this->part_vals[_i2419]); } xfer += iprot->readListEnd(); } @@ -25456,10 +25671,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 _iter2403; - for (_iter2403 = this->part_vals.begin(); _iter2403 != this->part_vals.end(); ++_iter2403) + std::vector ::const_iterator _iter2420; + for (_iter2420 = this->part_vals.begin(); _iter2420 != this->part_vals.end(); ++_iter2420) { - xfer += oprot->writeString((*_iter2403)); + xfer += oprot->writeString((*_iter2420)); } xfer += oprot->writeListEnd(); } @@ -25495,10 +25710,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 _iter2404; - for (_iter2404 = (*(this->part_vals)).begin(); _iter2404 != (*(this->part_vals)).end(); ++_iter2404) + std::vector ::const_iterator _iter2421; + for (_iter2421 = (*(this->part_vals)).begin(); _iter2421 != (*(this->part_vals)).end(); ++_iter2421) { - xfer += oprot->writeString((*_iter2404)); + xfer += oprot->writeString((*_iter2421)); } xfer += oprot->writeListEnd(); } @@ -25543,14 +25758,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2405; - ::apache::thrift::protocol::TType _etype2408; - xfer += iprot->readListBegin(_etype2408, _size2405); - this->success.resize(_size2405); - uint32_t _i2409; - for (_i2409 = 0; _i2409 < _size2405; ++_i2409) + uint32_t _size2422; + ::apache::thrift::protocol::TType _etype2425; + xfer += iprot->readListBegin(_etype2425, _size2422); + this->success.resize(_size2422); + uint32_t _i2426; + for (_i2426 = 0; _i2426 < _size2422; ++_i2426) { - xfer += iprot->readString(this->success[_i2409]); + xfer += iprot->readString(this->success[_i2426]); } xfer += iprot->readListEnd(); } @@ -25597,10 +25812,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 _iter2410; - for (_iter2410 = this->success.begin(); _iter2410 != this->success.end(); ++_iter2410) + std::vector ::const_iterator _iter2427; + for (_iter2427 = this->success.begin(); _iter2427 != this->success.end(); ++_iter2427) { - xfer += oprot->writeString((*_iter2410)); + xfer += oprot->writeString((*_iter2427)); } xfer += oprot->writeListEnd(); } @@ -25649,14 +25864,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2411; - ::apache::thrift::protocol::TType _etype2414; - xfer += iprot->readListBegin(_etype2414, _size2411); - (*(this->success)).resize(_size2411); - uint32_t _i2415; - for (_i2415 = 0; _i2415 < _size2411; ++_i2415) + uint32_t _size2428; + ::apache::thrift::protocol::TType _etype2431; + xfer += iprot->readListBegin(_etype2431, _size2428); + (*(this->success)).resize(_size2428); + uint32_t _i2432; + for (_i2432 = 0; _i2432 < _size2428; ++_i2432) { - xfer += iprot->readString((*(this->success))[_i2415]); + xfer += iprot->readString((*(this->success))[_i2432]); } xfer += iprot->readListEnd(); } @@ -26029,14 +26244,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_req_result::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2416; - ::apache::thrift::protocol::TType _etype2419; - xfer += iprot->readListBegin(_etype2419, _size2416); - this->success.resize(_size2416); - uint32_t _i2420; - for (_i2420 = 0; _i2420 < _size2416; ++_i2420) + uint32_t _size2433; + ::apache::thrift::protocol::TType _etype2436; + xfer += iprot->readListBegin(_etype2436, _size2433); + this->success.resize(_size2433); + uint32_t _i2437; + for (_i2437 = 0; _i2437 < _size2433; ++_i2437) { - xfer += iprot->readString(this->success[_i2420]); + xfer += iprot->readString(this->success[_i2437]); } xfer += iprot->readListEnd(); } @@ -26083,10 +26298,10 @@ uint32_t ThriftHiveMetastore_get_partition_names_req_result::write(::apache::thr 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 _iter2421; - for (_iter2421 = this->success.begin(); _iter2421 != this->success.end(); ++_iter2421) + std::vector ::const_iterator _iter2438; + for (_iter2438 = this->success.begin(); _iter2438 != this->success.end(); ++_iter2438) { - xfer += oprot->writeString((*_iter2421)); + xfer += oprot->writeString((*_iter2438)); } xfer += oprot->writeListEnd(); } @@ -26135,14 +26350,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_req_presult::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2422; - ::apache::thrift::protocol::TType _etype2425; - xfer += iprot->readListBegin(_etype2425, _size2422); - (*(this->success)).resize(_size2422); - uint32_t _i2426; - for (_i2426 = 0; _i2426 < _size2422; ++_i2426) + uint32_t _size2439; + ::apache::thrift::protocol::TType _etype2442; + xfer += iprot->readListBegin(_etype2442, _size2439); + (*(this->success)).resize(_size2439); + uint32_t _i2443; + for (_i2443 = 0; _i2443 < _size2439; ++_i2443) { - xfer += iprot->readString((*(this->success))[_i2426]); + xfer += iprot->readString((*(this->success))[_i2443]); } xfer += iprot->readListEnd(); } @@ -26336,14 +26551,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2427; - ::apache::thrift::protocol::TType _etype2430; - xfer += iprot->readListBegin(_etype2430, _size2427); - this->success.resize(_size2427); - uint32_t _i2431; - for (_i2431 = 0; _i2431 < _size2427; ++_i2431) + uint32_t _size2444; + ::apache::thrift::protocol::TType _etype2447; + xfer += iprot->readListBegin(_etype2447, _size2444); + this->success.resize(_size2444); + uint32_t _i2448; + for (_i2448 = 0; _i2448 < _size2444; ++_i2448) { - xfer += this->success[_i2431].read(iprot); + xfer += this->success[_i2448].read(iprot); } xfer += iprot->readListEnd(); } @@ -26390,10 +26605,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 _iter2432; - for (_iter2432 = this->success.begin(); _iter2432 != this->success.end(); ++_iter2432) + std::vector ::const_iterator _iter2449; + for (_iter2449 = this->success.begin(); _iter2449 != this->success.end(); ++_iter2449) { - xfer += (*_iter2432).write(oprot); + xfer += (*_iter2449).write(oprot); } xfer += oprot->writeListEnd(); } @@ -26442,14 +26657,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2433; - ::apache::thrift::protocol::TType _etype2436; - xfer += iprot->readListBegin(_etype2436, _size2433); - (*(this->success)).resize(_size2433); - uint32_t _i2437; - for (_i2437 = 0; _i2437 < _size2433; ++_i2437) + uint32_t _size2450; + ::apache::thrift::protocol::TType _etype2453; + xfer += iprot->readListBegin(_etype2453, _size2450); + (*(this->success)).resize(_size2450); + uint32_t _i2454; + for (_i2454 = 0; _i2454 < _size2450; ++_i2454) { - xfer += (*(this->success))[_i2437].read(iprot); + xfer += (*(this->success))[_i2454].read(iprot); } xfer += iprot->readListEnd(); } @@ -26595,14 +26810,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_req_result::read(::apache: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2438; - ::apache::thrift::protocol::TType _etype2441; - xfer += iprot->readListBegin(_etype2441, _size2438); - this->success.resize(_size2438); - uint32_t _i2442; - for (_i2442 = 0; _i2442 < _size2438; ++_i2442) + uint32_t _size2455; + ::apache::thrift::protocol::TType _etype2458; + xfer += iprot->readListBegin(_etype2458, _size2455); + this->success.resize(_size2455); + uint32_t _i2459; + for (_i2459 = 0; _i2459 < _size2455; ++_i2459) { - xfer += this->success[_i2442].read(iprot); + xfer += this->success[_i2459].read(iprot); } xfer += iprot->readListEnd(); } @@ -26649,10 +26864,10 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_req_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 _iter2443; - for (_iter2443 = this->success.begin(); _iter2443 != this->success.end(); ++_iter2443) + std::vector ::const_iterator _iter2460; + for (_iter2460 = this->success.begin(); _iter2460 != this->success.end(); ++_iter2460) { - xfer += (*_iter2443).write(oprot); + xfer += (*_iter2460).write(oprot); } xfer += oprot->writeListEnd(); } @@ -26701,14 +26916,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_req_presult::read(::apache if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2444; - ::apache::thrift::protocol::TType _etype2447; - xfer += iprot->readListBegin(_etype2447, _size2444); - (*(this->success)).resize(_size2444); - uint32_t _i2448; - for (_i2448 = 0; _i2448 < _size2444; ++_i2448) + uint32_t _size2461; + ::apache::thrift::protocol::TType _etype2464; + xfer += iprot->readListBegin(_etype2464, _size2461); + (*(this->success)).resize(_size2461); + uint32_t _i2465; + for (_i2465 = 0; _i2465 < _size2461; ++_i2465) { - xfer += (*(this->success))[_i2448].read(iprot); + xfer += (*(this->success))[_i2465].read(iprot); } xfer += iprot->readListEnd(); } @@ -26902,14 +27117,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 _size2449; - ::apache::thrift::protocol::TType _etype2452; - xfer += iprot->readListBegin(_etype2452, _size2449); - this->success.resize(_size2449); - uint32_t _i2453; - for (_i2453 = 0; _i2453 < _size2449; ++_i2453) + uint32_t _size2466; + ::apache::thrift::protocol::TType _etype2469; + xfer += iprot->readListBegin(_etype2469, _size2466); + this->success.resize(_size2466); + uint32_t _i2470; + for (_i2470 = 0; _i2470 < _size2466; ++_i2470) { - xfer += this->success[_i2453].read(iprot); + xfer += this->success[_i2470].read(iprot); } xfer += iprot->readListEnd(); } @@ -26956,10 +27171,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 _iter2454; - for (_iter2454 = this->success.begin(); _iter2454 != this->success.end(); ++_iter2454) + std::vector ::const_iterator _iter2471; + for (_iter2471 = this->success.begin(); _iter2471 != this->success.end(); ++_iter2471) { - xfer += (*_iter2454).write(oprot); + xfer += (*_iter2471).write(oprot); } xfer += oprot->writeListEnd(); } @@ -27008,14 +27223,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 _size2455; - ::apache::thrift::protocol::TType _etype2458; - xfer += iprot->readListBegin(_etype2458, _size2455); - (*(this->success)).resize(_size2455); - uint32_t _i2459; - for (_i2459 = 0; _i2459 < _size2455; ++_i2459) + uint32_t _size2472; + ::apache::thrift::protocol::TType _etype2475; + xfer += iprot->readListBegin(_etype2475, _size2472); + (*(this->success)).resize(_size2472); + uint32_t _i2476; + for (_i2476 = 0; _i2476 < _size2472; ++_i2476) { - xfer += (*(this->success))[_i2459].read(iprot); + xfer += (*(this->success))[_i2476].read(iprot); } xfer += iprot->readListEnd(); } @@ -27811,14 +28026,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_args::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { this->names.clear(); - uint32_t _size2460; - ::apache::thrift::protocol::TType _etype2463; - xfer += iprot->readListBegin(_etype2463, _size2460); - this->names.resize(_size2460); - uint32_t _i2464; - for (_i2464 = 0; _i2464 < _size2460; ++_i2464) + uint32_t _size2477; + ::apache::thrift::protocol::TType _etype2480; + xfer += iprot->readListBegin(_etype2480, _size2477); + this->names.resize(_size2477); + uint32_t _i2481; + for (_i2481 = 0; _i2481 < _size2477; ++_i2481) { - xfer += iprot->readString(this->names[_i2464]); + xfer += iprot->readString(this->names[_i2481]); } xfer += iprot->readListEnd(); } @@ -27855,10 +28070,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 _iter2465; - for (_iter2465 = this->names.begin(); _iter2465 != this->names.end(); ++_iter2465) + std::vector ::const_iterator _iter2482; + for (_iter2482 = this->names.begin(); _iter2482 != this->names.end(); ++_iter2482) { - xfer += oprot->writeString((*_iter2465)); + xfer += oprot->writeString((*_iter2482)); } xfer += oprot->writeListEnd(); } @@ -27890,10 +28105,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 _iter2466; - for (_iter2466 = (*(this->names)).begin(); _iter2466 != (*(this->names)).end(); ++_iter2466) + std::vector ::const_iterator _iter2483; + for (_iter2483 = (*(this->names)).begin(); _iter2483 != (*(this->names)).end(); ++_iter2483) { - xfer += oprot->writeString((*_iter2466)); + xfer += oprot->writeString((*_iter2483)); } xfer += oprot->writeListEnd(); } @@ -27934,14 +28149,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_result::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2467; - ::apache::thrift::protocol::TType _etype2470; - xfer += iprot->readListBegin(_etype2470, _size2467); - this->success.resize(_size2467); - uint32_t _i2471; - for (_i2471 = 0; _i2471 < _size2467; ++_i2471) + uint32_t _size2484; + ::apache::thrift::protocol::TType _etype2487; + xfer += iprot->readListBegin(_etype2487, _size2484); + this->success.resize(_size2484); + uint32_t _i2488; + for (_i2488 = 0; _i2488 < _size2484; ++_i2488) { - xfer += this->success[_i2471].read(iprot); + xfer += this->success[_i2488].read(iprot); } xfer += iprot->readListEnd(); } @@ -27996,10 +28211,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 _iter2472; - for (_iter2472 = this->success.begin(); _iter2472 != this->success.end(); ++_iter2472) + std::vector ::const_iterator _iter2489; + for (_iter2489 = this->success.begin(); _iter2489 != this->success.end(); ++_iter2489) { - xfer += (*_iter2472).write(oprot); + xfer += (*_iter2489).write(oprot); } xfer += oprot->writeListEnd(); } @@ -28052,14 +28267,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_presult::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2473; - ::apache::thrift::protocol::TType _etype2476; - xfer += iprot->readListBegin(_etype2476, _size2473); - (*(this->success)).resize(_size2473); - uint32_t _i2477; - for (_i2477 = 0; _i2477 < _size2473; ++_i2477) + uint32_t _size2490; + ::apache::thrift::protocol::TType _etype2493; + xfer += iprot->readListBegin(_etype2493, _size2490); + (*(this->success)).resize(_size2490); + uint32_t _i2494; + for (_i2494 = 0; _i2494 < _size2490; ++_i2494) { - xfer += (*(this->success))[_i2477].read(iprot); + xfer += (*(this->success))[_i2494].read(iprot); } xfer += iprot->readListEnd(); } @@ -29090,14 +29305,14 @@ uint32_t ThriftHiveMetastore_alter_partitions_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size2478; - ::apache::thrift::protocol::TType _etype2481; - xfer += iprot->readListBegin(_etype2481, _size2478); - this->new_parts.resize(_size2478); - uint32_t _i2482; - for (_i2482 = 0; _i2482 < _size2478; ++_i2482) + uint32_t _size2495; + ::apache::thrift::protocol::TType _etype2498; + xfer += iprot->readListBegin(_etype2498, _size2495); + this->new_parts.resize(_size2495); + uint32_t _i2499; + for (_i2499 = 0; _i2499 < _size2495; ++_i2499) { - xfer += this->new_parts[_i2482].read(iprot); + xfer += this->new_parts[_i2499].read(iprot); } xfer += iprot->readListEnd(); } @@ -29134,10 +29349,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 _iter2483; - for (_iter2483 = this->new_parts.begin(); _iter2483 != this->new_parts.end(); ++_iter2483) + std::vector ::const_iterator _iter2500; + for (_iter2500 = this->new_parts.begin(); _iter2500 != this->new_parts.end(); ++_iter2500) { - xfer += (*_iter2483).write(oprot); + xfer += (*_iter2500).write(oprot); } xfer += oprot->writeListEnd(); } @@ -29169,10 +29384,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 _iter2484; - for (_iter2484 = (*(this->new_parts)).begin(); _iter2484 != (*(this->new_parts)).end(); ++_iter2484) + std::vector ::const_iterator _iter2501; + for (_iter2501 = (*(this->new_parts)).begin(); _iter2501 != (*(this->new_parts)).end(); ++_iter2501) { - xfer += (*_iter2484).write(oprot); + xfer += (*_iter2501).write(oprot); } xfer += oprot->writeListEnd(); } @@ -29357,14 +29572,14 @@ uint32_t ThriftHiveMetastore_alter_partitions_with_environment_context_args::rea if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size2485; - ::apache::thrift::protocol::TType _etype2488; - xfer += iprot->readListBegin(_etype2488, _size2485); - this->new_parts.resize(_size2485); - uint32_t _i2489; - for (_i2489 = 0; _i2489 < _size2485; ++_i2489) + uint32_t _size2502; + ::apache::thrift::protocol::TType _etype2505; + xfer += iprot->readListBegin(_etype2505, _size2502); + this->new_parts.resize(_size2502); + uint32_t _i2506; + for (_i2506 = 0; _i2506 < _size2502; ++_i2506) { - xfer += this->new_parts[_i2489].read(iprot); + xfer += this->new_parts[_i2506].read(iprot); } xfer += iprot->readListEnd(); } @@ -29409,10 +29624,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 _iter2490; - for (_iter2490 = this->new_parts.begin(); _iter2490 != this->new_parts.end(); ++_iter2490) + std::vector ::const_iterator _iter2507; + for (_iter2507 = this->new_parts.begin(); _iter2507 != this->new_parts.end(); ++_iter2507) { - xfer += (*_iter2490).write(oprot); + xfer += (*_iter2507).write(oprot); } xfer += oprot->writeListEnd(); } @@ -29448,10 +29663,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 _iter2491; - for (_iter2491 = (*(this->new_parts)).begin(); _iter2491 != (*(this->new_parts)).end(); ++_iter2491) + std::vector ::const_iterator _iter2508; + for (_iter2508 = (*(this->new_parts)).begin(); _iter2508 != (*(this->new_parts)).end(); ++_iter2508) { - xfer += (*_iter2491).write(oprot); + xfer += (*_iter2508).write(oprot); } xfer += oprot->writeListEnd(); } @@ -30122,14 +30337,14 @@ uint32_t ThriftHiveMetastore_rename_partition_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size2492; - ::apache::thrift::protocol::TType _etype2495; - xfer += iprot->readListBegin(_etype2495, _size2492); - this->part_vals.resize(_size2492); - uint32_t _i2496; - for (_i2496 = 0; _i2496 < _size2492; ++_i2496) + uint32_t _size2509; + ::apache::thrift::protocol::TType _etype2512; + xfer += iprot->readListBegin(_etype2512, _size2509); + this->part_vals.resize(_size2509); + uint32_t _i2513; + for (_i2513 = 0; _i2513 < _size2509; ++_i2513) { - xfer += iprot->readString(this->part_vals[_i2496]); + xfer += iprot->readString(this->part_vals[_i2513]); } xfer += iprot->readListEnd(); } @@ -30174,10 +30389,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 _iter2497; - for (_iter2497 = this->part_vals.begin(); _iter2497 != this->part_vals.end(); ++_iter2497) + std::vector ::const_iterator _iter2514; + for (_iter2514 = this->part_vals.begin(); _iter2514 != this->part_vals.end(); ++_iter2514) { - xfer += oprot->writeString((*_iter2497)); + xfer += oprot->writeString((*_iter2514)); } xfer += oprot->writeListEnd(); } @@ -30213,10 +30428,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 _iter2498; - for (_iter2498 = (*(this->part_vals)).begin(); _iter2498 != (*(this->part_vals)).end(); ++_iter2498) + std::vector ::const_iterator _iter2515; + for (_iter2515 = (*(this->part_vals)).begin(); _iter2515 != (*(this->part_vals)).end(); ++_iter2515) { - xfer += oprot->writeString((*_iter2498)); + xfer += oprot->writeString((*_iter2515)); } xfer += oprot->writeListEnd(); } @@ -30616,14 +30831,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 _size2499; - ::apache::thrift::protocol::TType _etype2502; - xfer += iprot->readListBegin(_etype2502, _size2499); - this->part_vals.resize(_size2499); - uint32_t _i2503; - for (_i2503 = 0; _i2503 < _size2499; ++_i2503) + uint32_t _size2516; + ::apache::thrift::protocol::TType _etype2519; + xfer += iprot->readListBegin(_etype2519, _size2516); + this->part_vals.resize(_size2516); + uint32_t _i2520; + for (_i2520 = 0; _i2520 < _size2516; ++_i2520) { - xfer += iprot->readString(this->part_vals[_i2503]); + xfer += iprot->readString(this->part_vals[_i2520]); } xfer += iprot->readListEnd(); } @@ -30660,10 +30875,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 _iter2504; - for (_iter2504 = this->part_vals.begin(); _iter2504 != this->part_vals.end(); ++_iter2504) + std::vector ::const_iterator _iter2521; + for (_iter2521 = this->part_vals.begin(); _iter2521 != this->part_vals.end(); ++_iter2521) { - xfer += oprot->writeString((*_iter2504)); + xfer += oprot->writeString((*_iter2521)); } xfer += oprot->writeListEnd(); } @@ -30691,10 +30906,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 _iter2505; - for (_iter2505 = (*(this->part_vals)).begin(); _iter2505 != (*(this->part_vals)).end(); ++_iter2505) + std::vector ::const_iterator _iter2522; + for (_iter2522 = (*(this->part_vals)).begin(); _iter2522 != (*(this->part_vals)).end(); ++_iter2522) { - xfer += oprot->writeString((*_iter2505)); + xfer += oprot->writeString((*_iter2522)); } xfer += oprot->writeListEnd(); } @@ -31169,14 +31384,14 @@ uint32_t ThriftHiveMetastore_partition_name_to_vals_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2506; - ::apache::thrift::protocol::TType _etype2509; - xfer += iprot->readListBegin(_etype2509, _size2506); - this->success.resize(_size2506); - uint32_t _i2510; - for (_i2510 = 0; _i2510 < _size2506; ++_i2510) + uint32_t _size2523; + ::apache::thrift::protocol::TType _etype2526; + xfer += iprot->readListBegin(_etype2526, _size2523); + this->success.resize(_size2523); + uint32_t _i2527; + for (_i2527 = 0; _i2527 < _size2523; ++_i2527) { - xfer += iprot->readString(this->success[_i2510]); + xfer += iprot->readString(this->success[_i2527]); } xfer += iprot->readListEnd(); } @@ -31215,10 +31430,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 _iter2511; - for (_iter2511 = this->success.begin(); _iter2511 != this->success.end(); ++_iter2511) + std::vector ::const_iterator _iter2528; + for (_iter2528 = this->success.begin(); _iter2528 != this->success.end(); ++_iter2528) { - xfer += oprot->writeString((*_iter2511)); + xfer += oprot->writeString((*_iter2528)); } xfer += oprot->writeListEnd(); } @@ -31263,14 +31478,14 @@ uint32_t ThriftHiveMetastore_partition_name_to_vals_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2512; - ::apache::thrift::protocol::TType _etype2515; - xfer += iprot->readListBegin(_etype2515, _size2512); - (*(this->success)).resize(_size2512); - uint32_t _i2516; - for (_i2516 = 0; _i2516 < _size2512; ++_i2516) + uint32_t _size2529; + ::apache::thrift::protocol::TType _etype2532; + xfer += iprot->readListBegin(_etype2532, _size2529); + (*(this->success)).resize(_size2529); + uint32_t _i2533; + for (_i2533 = 0; _i2533 < _size2529; ++_i2533) { - xfer += iprot->readString((*(this->success))[_i2516]); + xfer += iprot->readString((*(this->success))[_i2533]); } xfer += iprot->readListEnd(); } @@ -31408,17 +31623,17 @@ uint32_t ThriftHiveMetastore_partition_name_to_spec_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_MAP) { { this->success.clear(); - uint32_t _size2517; - ::apache::thrift::protocol::TType _ktype2518; - ::apache::thrift::protocol::TType _vtype2519; - xfer += iprot->readMapBegin(_ktype2518, _vtype2519, _size2517); - uint32_t _i2521; - for (_i2521 = 0; _i2521 < _size2517; ++_i2521) + uint32_t _size2534; + ::apache::thrift::protocol::TType _ktype2535; + ::apache::thrift::protocol::TType _vtype2536; + xfer += iprot->readMapBegin(_ktype2535, _vtype2536, _size2534); + uint32_t _i2538; + for (_i2538 = 0; _i2538 < _size2534; ++_i2538) { - std::string _key2522; - xfer += iprot->readString(_key2522); - std::string& _val2523 = this->success[_key2522]; - xfer += iprot->readString(_val2523); + std::string _key2539; + xfer += iprot->readString(_key2539); + std::string& _val2540 = this->success[_key2539]; + xfer += iprot->readString(_val2540); } xfer += iprot->readMapEnd(); } @@ -31457,11 +31672,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 _iter2524; - for (_iter2524 = this->success.begin(); _iter2524 != this->success.end(); ++_iter2524) + std::map ::const_iterator _iter2541; + for (_iter2541 = this->success.begin(); _iter2541 != this->success.end(); ++_iter2541) { - xfer += oprot->writeString(_iter2524->first); - xfer += oprot->writeString(_iter2524->second); + xfer += oprot->writeString(_iter2541->first); + xfer += oprot->writeString(_iter2541->second); } xfer += oprot->writeMapEnd(); } @@ -31506,17 +31721,17 @@ uint32_t ThriftHiveMetastore_partition_name_to_spec_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_MAP) { { (*(this->success)).clear(); - uint32_t _size2525; - ::apache::thrift::protocol::TType _ktype2526; - ::apache::thrift::protocol::TType _vtype2527; - xfer += iprot->readMapBegin(_ktype2526, _vtype2527, _size2525); - uint32_t _i2529; - for (_i2529 = 0; _i2529 < _size2525; ++_i2529) + uint32_t _size2542; + ::apache::thrift::protocol::TType _ktype2543; + ::apache::thrift::protocol::TType _vtype2544; + xfer += iprot->readMapBegin(_ktype2543, _vtype2544, _size2542); + uint32_t _i2546; + for (_i2546 = 0; _i2546 < _size2542; ++_i2546) { - std::string _key2530; - xfer += iprot->readString(_key2530); - std::string& _val2531 = (*(this->success))[_key2530]; - xfer += iprot->readString(_val2531); + std::string _key2547; + xfer += iprot->readString(_key2547); + std::string& _val2548 = (*(this->success))[_key2547]; + xfer += iprot->readString(_val2548); } xfer += iprot->readMapEnd(); } @@ -31591,17 +31806,17 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_args::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_MAP) { { this->part_vals.clear(); - uint32_t _size2532; - ::apache::thrift::protocol::TType _ktype2533; - ::apache::thrift::protocol::TType _vtype2534; - xfer += iprot->readMapBegin(_ktype2533, _vtype2534, _size2532); - uint32_t _i2536; - for (_i2536 = 0; _i2536 < _size2532; ++_i2536) + uint32_t _size2549; + ::apache::thrift::protocol::TType _ktype2550; + ::apache::thrift::protocol::TType _vtype2551; + xfer += iprot->readMapBegin(_ktype2550, _vtype2551, _size2549); + uint32_t _i2553; + for (_i2553 = 0; _i2553 < _size2549; ++_i2553) { - std::string _key2537; - xfer += iprot->readString(_key2537); - std::string& _val2538 = this->part_vals[_key2537]; - xfer += iprot->readString(_val2538); + std::string _key2554; + xfer += iprot->readString(_key2554); + std::string& _val2555 = this->part_vals[_key2554]; + xfer += iprot->readString(_val2555); } xfer += iprot->readMapEnd(); } @@ -31612,9 +31827,9 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_args::read(::apache::thrift:: break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast2539; - xfer += iprot->readI32(ecast2539); - this->eventType = static_cast(ecast2539); + int32_t ecast2556; + xfer += iprot->readI32(ecast2556); + this->eventType = static_cast(ecast2556); this->__isset.eventType = true; } else { xfer += iprot->skip(ftype); @@ -31648,11 +31863,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 _iter2540; - for (_iter2540 = this->part_vals.begin(); _iter2540 != this->part_vals.end(); ++_iter2540) + std::map ::const_iterator _iter2557; + for (_iter2557 = this->part_vals.begin(); _iter2557 != this->part_vals.end(); ++_iter2557) { - xfer += oprot->writeString(_iter2540->first); - xfer += oprot->writeString(_iter2540->second); + xfer += oprot->writeString(_iter2557->first); + xfer += oprot->writeString(_iter2557->second); } xfer += oprot->writeMapEnd(); } @@ -31688,11 +31903,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 _iter2541; - for (_iter2541 = (*(this->part_vals)).begin(); _iter2541 != (*(this->part_vals)).end(); ++_iter2541) + std::map ::const_iterator _iter2558; + for (_iter2558 = (*(this->part_vals)).begin(); _iter2558 != (*(this->part_vals)).end(); ++_iter2558) { - xfer += oprot->writeString(_iter2541->first); - xfer += oprot->writeString(_iter2541->second); + xfer += oprot->writeString(_iter2558->first); + xfer += oprot->writeString(_iter2558->second); } xfer += oprot->writeMapEnd(); } @@ -31961,17 +32176,17 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_MAP) { { this->part_vals.clear(); - uint32_t _size2542; - ::apache::thrift::protocol::TType _ktype2543; - ::apache::thrift::protocol::TType _vtype2544; - xfer += iprot->readMapBegin(_ktype2543, _vtype2544, _size2542); - uint32_t _i2546; - for (_i2546 = 0; _i2546 < _size2542; ++_i2546) + uint32_t _size2559; + ::apache::thrift::protocol::TType _ktype2560; + ::apache::thrift::protocol::TType _vtype2561; + xfer += iprot->readMapBegin(_ktype2560, _vtype2561, _size2559); + uint32_t _i2563; + for (_i2563 = 0; _i2563 < _size2559; ++_i2563) { - std::string _key2547; - xfer += iprot->readString(_key2547); - std::string& _val2548 = this->part_vals[_key2547]; - xfer += iprot->readString(_val2548); + std::string _key2564; + xfer += iprot->readString(_key2564); + std::string& _val2565 = this->part_vals[_key2564]; + xfer += iprot->readString(_val2565); } xfer += iprot->readMapEnd(); } @@ -31982,9 +32197,9 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::read(::apache::thri break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast2549; - xfer += iprot->readI32(ecast2549); - this->eventType = static_cast(ecast2549); + int32_t ecast2566; + xfer += iprot->readI32(ecast2566); + this->eventType = static_cast(ecast2566); this->__isset.eventType = true; } else { xfer += iprot->skip(ftype); @@ -32018,11 +32233,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 _iter2550; - for (_iter2550 = this->part_vals.begin(); _iter2550 != this->part_vals.end(); ++_iter2550) + std::map ::const_iterator _iter2567; + for (_iter2567 = this->part_vals.begin(); _iter2567 != this->part_vals.end(); ++_iter2567) { - xfer += oprot->writeString(_iter2550->first); - xfer += oprot->writeString(_iter2550->second); + xfer += oprot->writeString(_iter2567->first); + xfer += oprot->writeString(_iter2567->second); } xfer += oprot->writeMapEnd(); } @@ -32058,11 +32273,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 _iter2551; - for (_iter2551 = (*(this->part_vals)).begin(); _iter2551 != (*(this->part_vals)).end(); ++_iter2551) + std::map ::const_iterator _iter2568; + for (_iter2568 = (*(this->part_vals)).begin(); _iter2568 != (*(this->part_vals)).end(); ++_iter2568) { - xfer += oprot->writeString(_iter2551->first); - xfer += oprot->writeString(_iter2551->second); + xfer += oprot->writeString(_iter2568->first); + xfer += oprot->writeString(_iter2568->second); } xfer += oprot->writeMapEnd(); } @@ -38458,14 +38673,14 @@ uint32_t ThriftHiveMetastore_get_functions_result::read(::apache::thrift::protoc if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2552; - ::apache::thrift::protocol::TType _etype2555; - xfer += iprot->readListBegin(_etype2555, _size2552); - this->success.resize(_size2552); - uint32_t _i2556; - for (_i2556 = 0; _i2556 < _size2552; ++_i2556) + uint32_t _size2569; + ::apache::thrift::protocol::TType _etype2572; + xfer += iprot->readListBegin(_etype2572, _size2569); + this->success.resize(_size2569); + uint32_t _i2573; + for (_i2573 = 0; _i2573 < _size2569; ++_i2573) { - xfer += iprot->readString(this->success[_i2556]); + xfer += iprot->readString(this->success[_i2573]); } xfer += iprot->readListEnd(); } @@ -38504,10 +38719,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 _iter2557; - for (_iter2557 = this->success.begin(); _iter2557 != this->success.end(); ++_iter2557) + std::vector ::const_iterator _iter2574; + for (_iter2574 = this->success.begin(); _iter2574 != this->success.end(); ++_iter2574) { - xfer += oprot->writeString((*_iter2557)); + xfer += oprot->writeString((*_iter2574)); } xfer += oprot->writeListEnd(); } @@ -38552,14 +38767,14 @@ uint32_t ThriftHiveMetastore_get_functions_presult::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2558; - ::apache::thrift::protocol::TType _etype2561; - xfer += iprot->readListBegin(_etype2561, _size2558); - (*(this->success)).resize(_size2558); - uint32_t _i2562; - for (_i2562 = 0; _i2562 < _size2558; ++_i2562) + uint32_t _size2575; + ::apache::thrift::protocol::TType _etype2578; + xfer += iprot->readListBegin(_etype2578, _size2575); + (*(this->success)).resize(_size2575); + uint32_t _i2579; + for (_i2579 = 0; _i2579 < _size2575; ++_i2579) { - xfer += iprot->readString((*(this->success))[_i2562]); + xfer += iprot->readString((*(this->success))[_i2579]); } xfer += iprot->readListEnd(); } @@ -39726,14 +39941,14 @@ uint32_t ThriftHiveMetastore_get_role_names_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2563; - ::apache::thrift::protocol::TType _etype2566; - xfer += iprot->readListBegin(_etype2566, _size2563); - this->success.resize(_size2563); - uint32_t _i2567; - for (_i2567 = 0; _i2567 < _size2563; ++_i2567) + uint32_t _size2580; + ::apache::thrift::protocol::TType _etype2583; + xfer += iprot->readListBegin(_etype2583, _size2580); + this->success.resize(_size2580); + uint32_t _i2584; + for (_i2584 = 0; _i2584 < _size2580; ++_i2584) { - xfer += iprot->readString(this->success[_i2567]); + xfer += iprot->readString(this->success[_i2584]); } xfer += iprot->readListEnd(); } @@ -39772,10 +39987,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 _iter2568; - for (_iter2568 = this->success.begin(); _iter2568 != this->success.end(); ++_iter2568) + std::vector ::const_iterator _iter2585; + for (_iter2585 = this->success.begin(); _iter2585 != this->success.end(); ++_iter2585) { - xfer += oprot->writeString((*_iter2568)); + xfer += oprot->writeString((*_iter2585)); } xfer += oprot->writeListEnd(); } @@ -39820,14 +40035,14 @@ uint32_t ThriftHiveMetastore_get_role_names_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2569; - ::apache::thrift::protocol::TType _etype2572; - xfer += iprot->readListBegin(_etype2572, _size2569); - (*(this->success)).resize(_size2569); - uint32_t _i2573; - for (_i2573 = 0; _i2573 < _size2569; ++_i2573) + uint32_t _size2586; + ::apache::thrift::protocol::TType _etype2589; + xfer += iprot->readListBegin(_etype2589, _size2586); + (*(this->success)).resize(_size2586); + uint32_t _i2590; + for (_i2590 = 0; _i2590 < _size2586; ++_i2590) { - xfer += iprot->readString((*(this->success))[_i2573]); + xfer += iprot->readString((*(this->success))[_i2590]); } xfer += iprot->readListEnd(); } @@ -39900,9 +40115,9 @@ uint32_t ThriftHiveMetastore_grant_role_args::read(::apache::thrift::protocol::T break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast2574; - xfer += iprot->readI32(ecast2574); - this->principal_type = static_cast(ecast2574); + int32_t ecast2591; + xfer += iprot->readI32(ecast2591); + this->principal_type = static_cast(ecast2591); this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -39918,9 +40133,9 @@ uint32_t ThriftHiveMetastore_grant_role_args::read(::apache::thrift::protocol::T break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast2575; - xfer += iprot->readI32(ecast2575); - this->grantorType = static_cast(ecast2575); + int32_t ecast2592; + xfer += iprot->readI32(ecast2592); + this->grantorType = static_cast(ecast2592); this->__isset.grantorType = true; } else { xfer += iprot->skip(ftype); @@ -40191,9 +40406,9 @@ uint32_t ThriftHiveMetastore_revoke_role_args::read(::apache::thrift::protocol:: break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast2576; - xfer += iprot->readI32(ecast2576); - this->principal_type = static_cast(ecast2576); + int32_t ecast2593; + xfer += iprot->readI32(ecast2593); + this->principal_type = static_cast(ecast2593); this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -40424,9 +40639,9 @@ uint32_t ThriftHiveMetastore_list_roles_args::read(::apache::thrift::protocol::T break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast2577; - xfer += iprot->readI32(ecast2577); - this->principal_type = static_cast(ecast2577); + int32_t ecast2594; + xfer += iprot->readI32(ecast2594); + this->principal_type = static_cast(ecast2594); this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -40515,14 +40730,14 @@ uint32_t ThriftHiveMetastore_list_roles_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2578; - ::apache::thrift::protocol::TType _etype2581; - xfer += iprot->readListBegin(_etype2581, _size2578); - this->success.resize(_size2578); - uint32_t _i2582; - for (_i2582 = 0; _i2582 < _size2578; ++_i2582) + uint32_t _size2595; + ::apache::thrift::protocol::TType _etype2598; + xfer += iprot->readListBegin(_etype2598, _size2595); + this->success.resize(_size2595); + uint32_t _i2599; + for (_i2599 = 0; _i2599 < _size2595; ++_i2599) { - xfer += this->success[_i2582].read(iprot); + xfer += this->success[_i2599].read(iprot); } xfer += iprot->readListEnd(); } @@ -40561,10 +40776,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 _iter2583; - for (_iter2583 = this->success.begin(); _iter2583 != this->success.end(); ++_iter2583) + std::vector ::const_iterator _iter2600; + for (_iter2600 = this->success.begin(); _iter2600 != this->success.end(); ++_iter2600) { - xfer += (*_iter2583).write(oprot); + xfer += (*_iter2600).write(oprot); } xfer += oprot->writeListEnd(); } @@ -40609,14 +40824,14 @@ uint32_t ThriftHiveMetastore_list_roles_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2584; - ::apache::thrift::protocol::TType _etype2587; - xfer += iprot->readListBegin(_etype2587, _size2584); - (*(this->success)).resize(_size2584); - uint32_t _i2588; - for (_i2588 = 0; _i2588 < _size2584; ++_i2588) + uint32_t _size2601; + ::apache::thrift::protocol::TType _etype2604; + xfer += iprot->readListBegin(_etype2604, _size2601); + (*(this->success)).resize(_size2601); + uint32_t _i2605; + for (_i2605 = 0; _i2605 < _size2601; ++_i2605) { - xfer += (*(this->success))[_i2588].read(iprot); + xfer += (*(this->success))[_i2605].read(iprot); } xfer += iprot->readListEnd(); } @@ -41312,14 +41527,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 _size2589; - ::apache::thrift::protocol::TType _etype2592; - xfer += iprot->readListBegin(_etype2592, _size2589); - this->group_names.resize(_size2589); - uint32_t _i2593; - for (_i2593 = 0; _i2593 < _size2589; ++_i2593) + uint32_t _size2606; + ::apache::thrift::protocol::TType _etype2609; + xfer += iprot->readListBegin(_etype2609, _size2606); + this->group_names.resize(_size2606); + uint32_t _i2610; + for (_i2610 = 0; _i2610 < _size2606; ++_i2610) { - xfer += iprot->readString(this->group_names[_i2593]); + xfer += iprot->readString(this->group_names[_i2610]); } xfer += iprot->readListEnd(); } @@ -41356,10 +41571,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 _iter2594; - for (_iter2594 = this->group_names.begin(); _iter2594 != this->group_names.end(); ++_iter2594) + std::vector ::const_iterator _iter2611; + for (_iter2611 = this->group_names.begin(); _iter2611 != this->group_names.end(); ++_iter2611) { - xfer += oprot->writeString((*_iter2594)); + xfer += oprot->writeString((*_iter2611)); } xfer += oprot->writeListEnd(); } @@ -41391,10 +41606,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 _iter2595; - for (_iter2595 = (*(this->group_names)).begin(); _iter2595 != (*(this->group_names)).end(); ++_iter2595) + std::vector ::const_iterator _iter2612; + for (_iter2612 = (*(this->group_names)).begin(); _iter2612 != (*(this->group_names)).end(); ++_iter2612) { - xfer += oprot->writeString((*_iter2595)); + xfer += oprot->writeString((*_iter2612)); } xfer += oprot->writeListEnd(); } @@ -41569,9 +41784,9 @@ uint32_t ThriftHiveMetastore_list_privileges_args::read(::apache::thrift::protoc break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast2596; - xfer += iprot->readI32(ecast2596); - this->principal_type = static_cast(ecast2596); + int32_t ecast2613; + xfer += iprot->readI32(ecast2613); + this->principal_type = static_cast(ecast2613); this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -41676,14 +41891,14 @@ uint32_t ThriftHiveMetastore_list_privileges_result::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2597; - ::apache::thrift::protocol::TType _etype2600; - xfer += iprot->readListBegin(_etype2600, _size2597); - this->success.resize(_size2597); - uint32_t _i2601; - for (_i2601 = 0; _i2601 < _size2597; ++_i2601) + uint32_t _size2614; + ::apache::thrift::protocol::TType _etype2617; + xfer += iprot->readListBegin(_etype2617, _size2614); + this->success.resize(_size2614); + uint32_t _i2618; + for (_i2618 = 0; _i2618 < _size2614; ++_i2618) { - xfer += this->success[_i2601].read(iprot); + xfer += this->success[_i2618].read(iprot); } xfer += iprot->readListEnd(); } @@ -41722,10 +41937,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 _iter2602; - for (_iter2602 = this->success.begin(); _iter2602 != this->success.end(); ++_iter2602) + std::vector ::const_iterator _iter2619; + for (_iter2619 = this->success.begin(); _iter2619 != this->success.end(); ++_iter2619) { - xfer += (*_iter2602).write(oprot); + xfer += (*_iter2619).write(oprot); } xfer += oprot->writeListEnd(); } @@ -41770,14 +41985,14 @@ uint32_t ThriftHiveMetastore_list_privileges_presult::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2603; - ::apache::thrift::protocol::TType _etype2606; - xfer += iprot->readListBegin(_etype2606, _size2603); - (*(this->success)).resize(_size2603); - uint32_t _i2607; - for (_i2607 = 0; _i2607 < _size2603; ++_i2607) + uint32_t _size2620; + ::apache::thrift::protocol::TType _etype2623; + xfer += iprot->readListBegin(_etype2623, _size2620); + (*(this->success)).resize(_size2620); + uint32_t _i2624; + for (_i2624 = 0; _i2624 < _size2620; ++_i2624) { - xfer += (*(this->success))[_i2607].read(iprot); + xfer += (*(this->success))[_i2624].read(iprot); } xfer += iprot->readListEnd(); } @@ -42704,14 +42919,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 _size2608; - ::apache::thrift::protocol::TType _etype2611; - xfer += iprot->readListBegin(_etype2611, _size2608); - this->group_names.resize(_size2608); - uint32_t _i2612; - for (_i2612 = 0; _i2612 < _size2608; ++_i2612) + uint32_t _size2625; + ::apache::thrift::protocol::TType _etype2628; + xfer += iprot->readListBegin(_etype2628, _size2625); + this->group_names.resize(_size2625); + uint32_t _i2629; + for (_i2629 = 0; _i2629 < _size2625; ++_i2629) { - xfer += iprot->readString(this->group_names[_i2612]); + xfer += iprot->readString(this->group_names[_i2629]); } xfer += iprot->readListEnd(); } @@ -42744,10 +42959,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 _iter2613; - for (_iter2613 = this->group_names.begin(); _iter2613 != this->group_names.end(); ++_iter2613) + std::vector ::const_iterator _iter2630; + for (_iter2630 = this->group_names.begin(); _iter2630 != this->group_names.end(); ++_iter2630) { - xfer += oprot->writeString((*_iter2613)); + xfer += oprot->writeString((*_iter2630)); } xfer += oprot->writeListEnd(); } @@ -42775,10 +42990,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 _iter2614; - for (_iter2614 = (*(this->group_names)).begin(); _iter2614 != (*(this->group_names)).end(); ++_iter2614) + std::vector ::const_iterator _iter2631; + for (_iter2631 = (*(this->group_names)).begin(); _iter2631 != (*(this->group_names)).end(); ++_iter2631) { - xfer += oprot->writeString((*_iter2614)); + xfer += oprot->writeString((*_iter2631)); } xfer += oprot->writeListEnd(); } @@ -42819,14 +43034,14 @@ uint32_t ThriftHiveMetastore_set_ugi_result::read(::apache::thrift::protocol::TP if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2615; - ::apache::thrift::protocol::TType _etype2618; - xfer += iprot->readListBegin(_etype2618, _size2615); - this->success.resize(_size2615); - uint32_t _i2619; - for (_i2619 = 0; _i2619 < _size2615; ++_i2619) + uint32_t _size2632; + ::apache::thrift::protocol::TType _etype2635; + xfer += iprot->readListBegin(_etype2635, _size2632); + this->success.resize(_size2632); + uint32_t _i2636; + for (_i2636 = 0; _i2636 < _size2632; ++_i2636) { - xfer += iprot->readString(this->success[_i2619]); + xfer += iprot->readString(this->success[_i2636]); } xfer += iprot->readListEnd(); } @@ -42865,10 +43080,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 _iter2620; - for (_iter2620 = this->success.begin(); _iter2620 != this->success.end(); ++_iter2620) + std::vector ::const_iterator _iter2637; + for (_iter2637 = this->success.begin(); _iter2637 != this->success.end(); ++_iter2637) { - xfer += oprot->writeString((*_iter2620)); + xfer += oprot->writeString((*_iter2637)); } xfer += oprot->writeListEnd(); } @@ -42913,14 +43128,14 @@ uint32_t ThriftHiveMetastore_set_ugi_presult::read(::apache::thrift::protocol::T if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2621; - ::apache::thrift::protocol::TType _etype2624; - xfer += iprot->readListBegin(_etype2624, _size2621); - (*(this->success)).resize(_size2621); - uint32_t _i2625; - for (_i2625 = 0; _i2625 < _size2621; ++_i2625) + uint32_t _size2638; + ::apache::thrift::protocol::TType _etype2641; + xfer += iprot->readListBegin(_etype2641, _size2638); + (*(this->success)).resize(_size2638); + uint32_t _i2642; + for (_i2642 = 0; _i2642 < _size2638; ++_i2642) { - xfer += iprot->readString((*(this->success))[_i2625]); + xfer += iprot->readString((*(this->success))[_i2642]); } xfer += iprot->readListEnd(); } @@ -44231,14 +44446,14 @@ uint32_t ThriftHiveMetastore_get_all_token_identifiers_result::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2626; - ::apache::thrift::protocol::TType _etype2629; - xfer += iprot->readListBegin(_etype2629, _size2626); - this->success.resize(_size2626); - uint32_t _i2630; - for (_i2630 = 0; _i2630 < _size2626; ++_i2630) + uint32_t _size2643; + ::apache::thrift::protocol::TType _etype2646; + xfer += iprot->readListBegin(_etype2646, _size2643); + this->success.resize(_size2643); + uint32_t _i2647; + for (_i2647 = 0; _i2647 < _size2643; ++_i2647) { - xfer += iprot->readString(this->success[_i2630]); + xfer += iprot->readString(this->success[_i2647]); } xfer += iprot->readListEnd(); } @@ -44269,10 +44484,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 _iter2631; - for (_iter2631 = this->success.begin(); _iter2631 != this->success.end(); ++_iter2631) + std::vector ::const_iterator _iter2648; + for (_iter2648 = this->success.begin(); _iter2648 != this->success.end(); ++_iter2648) { - xfer += oprot->writeString((*_iter2631)); + xfer += oprot->writeString((*_iter2648)); } xfer += oprot->writeListEnd(); } @@ -44313,14 +44528,14 @@ uint32_t ThriftHiveMetastore_get_all_token_identifiers_presult::read(::apache::t if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2632; - ::apache::thrift::protocol::TType _etype2635; - xfer += iprot->readListBegin(_etype2635, _size2632); - (*(this->success)).resize(_size2632); - uint32_t _i2636; - for (_i2636 = 0; _i2636 < _size2632; ++_i2636) + uint32_t _size2649; + ::apache::thrift::protocol::TType _etype2652; + xfer += iprot->readListBegin(_etype2652, _size2649); + (*(this->success)).resize(_size2649); + uint32_t _i2653; + for (_i2653 = 0; _i2653 < _size2649; ++_i2653) { - xfer += iprot->readString((*(this->success))[_i2636]); + xfer += iprot->readString((*(this->success))[_i2653]); } xfer += iprot->readListEnd(); } @@ -45046,14 +45261,14 @@ uint32_t ThriftHiveMetastore_get_master_keys_result::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2637; - ::apache::thrift::protocol::TType _etype2640; - xfer += iprot->readListBegin(_etype2640, _size2637); - this->success.resize(_size2637); - uint32_t _i2641; - for (_i2641 = 0; _i2641 < _size2637; ++_i2641) + uint32_t _size2654; + ::apache::thrift::protocol::TType _etype2657; + xfer += iprot->readListBegin(_etype2657, _size2654); + this->success.resize(_size2654); + uint32_t _i2658; + for (_i2658 = 0; _i2658 < _size2654; ++_i2658) { - xfer += iprot->readString(this->success[_i2641]); + xfer += iprot->readString(this->success[_i2658]); } xfer += iprot->readListEnd(); } @@ -45084,10 +45299,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 _iter2642; - for (_iter2642 = this->success.begin(); _iter2642 != this->success.end(); ++_iter2642) + std::vector ::const_iterator _iter2659; + for (_iter2659 = this->success.begin(); _iter2659 != this->success.end(); ++_iter2659) { - xfer += oprot->writeString((*_iter2642)); + xfer += oprot->writeString((*_iter2659)); } xfer += oprot->writeListEnd(); } @@ -45128,14 +45343,14 @@ uint32_t ThriftHiveMetastore_get_master_keys_presult::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2643; - ::apache::thrift::protocol::TType _etype2646; - xfer += iprot->readListBegin(_etype2646, _size2643); - (*(this->success)).resize(_size2643); - uint32_t _i2647; - for (_i2647 = 0; _i2647 < _size2643; ++_i2647) + uint32_t _size2660; + ::apache::thrift::protocol::TType _etype2663; + xfer += iprot->readListBegin(_etype2663, _size2660); + (*(this->success)).resize(_size2660); + uint32_t _i2664; + for (_i2664 = 0; _i2664 < _size2660; ++_i2664) { - xfer += iprot->readString((*(this->success))[_i2647]); + xfer += iprot->readString((*(this->success))[_i2664]); } xfer += iprot->readListEnd(); } @@ -46884,17 +47099,17 @@ uint32_t ThriftHiveMetastore_add_write_ids_to_min_history_args::read(::apache::t if (ftype == ::apache::thrift::protocol::T_MAP) { { this->writeIds.clear(); - uint32_t _size2648; - ::apache::thrift::protocol::TType _ktype2649; - ::apache::thrift::protocol::TType _vtype2650; - xfer += iprot->readMapBegin(_ktype2649, _vtype2650, _size2648); - uint32_t _i2652; - for (_i2652 = 0; _i2652 < _size2648; ++_i2652) + uint32_t _size2665; + ::apache::thrift::protocol::TType _ktype2666; + ::apache::thrift::protocol::TType _vtype2667; + xfer += iprot->readMapBegin(_ktype2666, _vtype2667, _size2665); + uint32_t _i2669; + for (_i2669 = 0; _i2669 < _size2665; ++_i2669) { - std::string _key2653; - xfer += iprot->readString(_key2653); - int64_t& _val2654 = this->writeIds[_key2653]; - xfer += iprot->readI64(_val2654); + std::string _key2670; + xfer += iprot->readString(_key2670); + int64_t& _val2671 = this->writeIds[_key2670]; + xfer += iprot->readI64(_val2671); } xfer += iprot->readMapEnd(); } @@ -46927,11 +47142,11 @@ uint32_t ThriftHiveMetastore_add_write_ids_to_min_history_args::write(::apache:: xfer += oprot->writeFieldBegin("writeIds", ::apache::thrift::protocol::T_MAP, 2); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_I64, static_cast(this->writeIds.size())); - std::map ::const_iterator _iter2655; - for (_iter2655 = this->writeIds.begin(); _iter2655 != this->writeIds.end(); ++_iter2655) + std::map ::const_iterator _iter2672; + for (_iter2672 = this->writeIds.begin(); _iter2672 != this->writeIds.end(); ++_iter2672) { - xfer += oprot->writeString(_iter2655->first); - xfer += oprot->writeI64(_iter2655->second); + xfer += oprot->writeString(_iter2672->first); + xfer += oprot->writeI64(_iter2672->second); } xfer += oprot->writeMapEnd(); } @@ -46959,11 +47174,11 @@ uint32_t ThriftHiveMetastore_add_write_ids_to_min_history_pargs::write(::apache: xfer += oprot->writeFieldBegin("writeIds", ::apache::thrift::protocol::T_MAP, 2); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_I64, static_cast((*(this->writeIds)).size())); - std::map ::const_iterator _iter2656; - for (_iter2656 = (*(this->writeIds)).begin(); _iter2656 != (*(this->writeIds)).end(); ++_iter2656) + std::map ::const_iterator _iter2673; + for (_iter2673 = (*(this->writeIds)).begin(); _iter2673 != (*(this->writeIds)).end(); ++_iter2673) { - xfer += oprot->writeString(_iter2656->first); - xfer += oprot->writeI64(_iter2656->second); + xfer += oprot->writeString(_iter2673->first); + xfer += oprot->writeI64(_iter2673->second); } xfer += oprot->writeMapEnd(); } @@ -50863,14 +51078,14 @@ uint32_t ThriftHiveMetastore_find_columns_with_stats_result::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2657; - ::apache::thrift::protocol::TType _etype2660; - xfer += iprot->readListBegin(_etype2660, _size2657); - this->success.resize(_size2657); - uint32_t _i2661; - for (_i2661 = 0; _i2661 < _size2657; ++_i2661) + uint32_t _size2674; + ::apache::thrift::protocol::TType _etype2677; + xfer += iprot->readListBegin(_etype2677, _size2674); + this->success.resize(_size2674); + uint32_t _i2678; + for (_i2678 = 0; _i2678 < _size2674; ++_i2678) { - xfer += iprot->readString(this->success[_i2661]); + xfer += iprot->readString(this->success[_i2678]); } xfer += iprot->readListEnd(); } @@ -50901,10 +51116,10 @@ uint32_t ThriftHiveMetastore_find_columns_with_stats_result::write(::apache::thr 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 _iter2662; - for (_iter2662 = this->success.begin(); _iter2662 != this->success.end(); ++_iter2662) + std::vector ::const_iterator _iter2679; + for (_iter2679 = this->success.begin(); _iter2679 != this->success.end(); ++_iter2679) { - xfer += oprot->writeString((*_iter2662)); + xfer += oprot->writeString((*_iter2679)); } xfer += oprot->writeListEnd(); } @@ -50945,14 +51160,14 @@ uint32_t ThriftHiveMetastore_find_columns_with_stats_presult::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2663; - ::apache::thrift::protocol::TType _etype2666; - xfer += iprot->readListBegin(_etype2666, _size2663); - (*(this->success)).resize(_size2663); - uint32_t _i2667; - for (_i2667 = 0; _i2667 < _size2663; ++_i2667) + uint32_t _size2680; + ::apache::thrift::protocol::TType _etype2683; + xfer += iprot->readListBegin(_etype2683, _size2680); + (*(this->success)).resize(_size2680); + uint32_t _i2684; + for (_i2684 = 0; _i2684 < _size2680; ++_i2684) { - xfer += iprot->readString((*(this->success))[_i2667]); + xfer += iprot->readString((*(this->success))[_i2684]); } xfer += iprot->readListEnd(); } @@ -60875,14 +61090,14 @@ uint32_t ThriftHiveMetastore_get_schema_all_versions_result::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2668; - ::apache::thrift::protocol::TType _etype2671; - xfer += iprot->readListBegin(_etype2671, _size2668); - this->success.resize(_size2668); - uint32_t _i2672; - for (_i2672 = 0; _i2672 < _size2668; ++_i2672) + uint32_t _size2685; + ::apache::thrift::protocol::TType _etype2688; + xfer += iprot->readListBegin(_etype2688, _size2685); + this->success.resize(_size2685); + uint32_t _i2689; + for (_i2689 = 0; _i2689 < _size2685; ++_i2689) { - xfer += this->success[_i2672].read(iprot); + xfer += this->success[_i2689].read(iprot); } xfer += iprot->readListEnd(); } @@ -60929,10 +61144,10 @@ uint32_t ThriftHiveMetastore_get_schema_all_versions_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 _iter2673; - for (_iter2673 = this->success.begin(); _iter2673 != this->success.end(); ++_iter2673) + std::vector ::const_iterator _iter2690; + for (_iter2690 = this->success.begin(); _iter2690 != this->success.end(); ++_iter2690) { - xfer += (*_iter2673).write(oprot); + xfer += (*_iter2690).write(oprot); } xfer += oprot->writeListEnd(); } @@ -60981,14 +61196,14 @@ uint32_t ThriftHiveMetastore_get_schema_all_versions_presult::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2674; - ::apache::thrift::protocol::TType _etype2677; - xfer += iprot->readListBegin(_etype2677, _size2674); - (*(this->success)).resize(_size2674); - uint32_t _i2678; - for (_i2678 = 0; _i2678 < _size2674; ++_i2678) + uint32_t _size2691; + ::apache::thrift::protocol::TType _etype2694; + xfer += iprot->readListBegin(_etype2694, _size2691); + (*(this->success)).resize(_size2691); + uint32_t _i2695; + for (_i2695 = 0; _i2695 < _size2691; ++_i2695) { - xfer += (*(this->success))[_i2678].read(iprot); + xfer += (*(this->success))[_i2695].read(iprot); } xfer += iprot->readListEnd(); } @@ -63041,14 +63256,14 @@ uint32_t ThriftHiveMetastore_get_runtime_stats_result::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2679; - ::apache::thrift::protocol::TType _etype2682; - xfer += iprot->readListBegin(_etype2682, _size2679); - this->success.resize(_size2679); - uint32_t _i2683; - for (_i2683 = 0; _i2683 < _size2679; ++_i2683) + uint32_t _size2696; + ::apache::thrift::protocol::TType _etype2699; + xfer += iprot->readListBegin(_etype2699, _size2696); + this->success.resize(_size2696); + uint32_t _i2700; + for (_i2700 = 0; _i2700 < _size2696; ++_i2700) { - xfer += this->success[_i2683].read(iprot); + xfer += this->success[_i2700].read(iprot); } xfer += iprot->readListEnd(); } @@ -63087,10 +63302,10 @@ uint32_t ThriftHiveMetastore_get_runtime_stats_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 _iter2684; - for (_iter2684 = this->success.begin(); _iter2684 != this->success.end(); ++_iter2684) + std::vector ::const_iterator _iter2701; + for (_iter2701 = this->success.begin(); _iter2701 != this->success.end(); ++_iter2701) { - xfer += (*_iter2684).write(oprot); + xfer += (*_iter2701).write(oprot); } xfer += oprot->writeListEnd(); } @@ -63135,14 +63350,14 @@ uint32_t ThriftHiveMetastore_get_runtime_stats_presult::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2685; - ::apache::thrift::protocol::TType _etype2688; - xfer += iprot->readListBegin(_etype2688, _size2685); - (*(this->success)).resize(_size2685); - uint32_t _i2689; - for (_i2689 = 0; _i2689 < _size2685; ++_i2689) + uint32_t _size2702; + ::apache::thrift::protocol::TType _etype2705; + xfer += iprot->readListBegin(_etype2705, _size2702); + (*(this->success)).resize(_size2702); + uint32_t _i2706; + for (_i2706 = 0; _i2706 < _size2702; ++_i2706) { - xfer += (*(this->success))[_i2689].read(iprot); + xfer += (*(this->success))[_i2706].read(iprot); } xfer += iprot->readListEnd(); } @@ -65577,14 +65792,14 @@ uint32_t ThriftHiveMetastore_get_all_stored_procedures_result::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2690; - ::apache::thrift::protocol::TType _etype2693; - xfer += iprot->readListBegin(_etype2693, _size2690); - this->success.resize(_size2690); - uint32_t _i2694; - for (_i2694 = 0; _i2694 < _size2690; ++_i2694) + uint32_t _size2707; + ::apache::thrift::protocol::TType _etype2710; + xfer += iprot->readListBegin(_etype2710, _size2707); + this->success.resize(_size2707); + uint32_t _i2711; + for (_i2711 = 0; _i2711 < _size2707; ++_i2711) { - xfer += iprot->readString(this->success[_i2694]); + xfer += iprot->readString(this->success[_i2711]); } xfer += iprot->readListEnd(); } @@ -65623,10 +65838,10 @@ uint32_t ThriftHiveMetastore_get_all_stored_procedures_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 _iter2695; - for (_iter2695 = this->success.begin(); _iter2695 != this->success.end(); ++_iter2695) + std::vector ::const_iterator _iter2712; + for (_iter2712 = this->success.begin(); _iter2712 != this->success.end(); ++_iter2712) { - xfer += oprot->writeString((*_iter2695)); + xfer += oprot->writeString((*_iter2712)); } xfer += oprot->writeListEnd(); } @@ -65671,14 +65886,14 @@ uint32_t ThriftHiveMetastore_get_all_stored_procedures_presult::read(::apache::t if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2696; - ::apache::thrift::protocol::TType _etype2699; - xfer += iprot->readListBegin(_etype2699, _size2696); - (*(this->success)).resize(_size2696); - uint32_t _i2700; - for (_i2700 = 0; _i2700 < _size2696; ++_i2700) + uint32_t _size2713; + ::apache::thrift::protocol::TType _etype2716; + xfer += iprot->readListBegin(_etype2716, _size2713); + (*(this->success)).resize(_size2713); + uint32_t _i2717; + for (_i2717 = 0; _i2717 < _size2713; ++_i2717) { - xfer += iprot->readString((*(this->success))[_i2700]); + xfer += iprot->readString((*(this->success))[_i2717]); } xfer += iprot->readListEnd(); } @@ -66230,14 +66445,14 @@ uint32_t ThriftHiveMetastore_get_all_packages_result::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2701; - ::apache::thrift::protocol::TType _etype2704; - xfer += iprot->readListBegin(_etype2704, _size2701); - this->success.resize(_size2701); - uint32_t _i2705; - for (_i2705 = 0; _i2705 < _size2701; ++_i2705) + uint32_t _size2718; + ::apache::thrift::protocol::TType _etype2721; + xfer += iprot->readListBegin(_etype2721, _size2718); + this->success.resize(_size2718); + uint32_t _i2722; + for (_i2722 = 0; _i2722 < _size2718; ++_i2722) { - xfer += iprot->readString(this->success[_i2705]); + xfer += iprot->readString(this->success[_i2722]); } xfer += iprot->readListEnd(); } @@ -66276,10 +66491,10 @@ uint32_t ThriftHiveMetastore_get_all_packages_result::write(::apache::thrift::pr 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 _iter2706; - for (_iter2706 = this->success.begin(); _iter2706 != this->success.end(); ++_iter2706) + std::vector ::const_iterator _iter2723; + for (_iter2723 = this->success.begin(); _iter2723 != this->success.end(); ++_iter2723) { - xfer += oprot->writeString((*_iter2706)); + xfer += oprot->writeString((*_iter2723)); } xfer += oprot->writeListEnd(); } @@ -66324,14 +66539,14 @@ uint32_t ThriftHiveMetastore_get_all_packages_presult::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2707; - ::apache::thrift::protocol::TType _etype2710; - xfer += iprot->readListBegin(_etype2710, _size2707); - (*(this->success)).resize(_size2707); - uint32_t _i2711; - for (_i2711 = 0; _i2711 < _size2707; ++_i2711) + uint32_t _size2724; + ::apache::thrift::protocol::TType _etype2727; + xfer += iprot->readListBegin(_etype2727, _size2724); + (*(this->success)).resize(_size2724); + uint32_t _i2728; + for (_i2728 = 0; _i2728 < _size2724; ++_i2728) { - xfer += iprot->readString((*(this->success))[_i2711]); + xfer += iprot->readString((*(this->success))[_i2728]); } xfer += iprot->readListEnd(); } @@ -66656,14 +66871,14 @@ uint32_t ThriftHiveMetastore_get_all_write_event_info_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2712; - ::apache::thrift::protocol::TType _etype2715; - xfer += iprot->readListBegin(_etype2715, _size2712); - this->success.resize(_size2712); - uint32_t _i2716; - for (_i2716 = 0; _i2716 < _size2712; ++_i2716) + uint32_t _size2729; + ::apache::thrift::protocol::TType _etype2732; + xfer += iprot->readListBegin(_etype2732, _size2729); + this->success.resize(_size2729); + uint32_t _i2733; + for (_i2733 = 0; _i2733 < _size2729; ++_i2733) { - xfer += this->success[_i2716].read(iprot); + xfer += this->success[_i2733].read(iprot); } xfer += iprot->readListEnd(); } @@ -66702,10 +66917,10 @@ uint32_t ThriftHiveMetastore_get_all_write_event_info_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 _iter2717; - for (_iter2717 = this->success.begin(); _iter2717 != this->success.end(); ++_iter2717) + std::vector ::const_iterator _iter2734; + for (_iter2734 = this->success.begin(); _iter2734 != this->success.end(); ++_iter2734) { - xfer += (*_iter2717).write(oprot); + xfer += (*_iter2734).write(oprot); } xfer += oprot->writeListEnd(); } @@ -66750,14 +66965,14 @@ uint32_t ThriftHiveMetastore_get_all_write_event_info_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2718; - ::apache::thrift::protocol::TType _etype2721; - xfer += iprot->readListBegin(_etype2721, _size2718); - (*(this->success)).resize(_size2718); - uint32_t _i2722; - for (_i2722 = 0; _i2722 < _size2718; ++_i2722) + uint32_t _size2735; + ::apache::thrift::protocol::TType _etype2738; + xfer += iprot->readListBegin(_etype2738, _size2735); + (*(this->success)).resize(_size2735); + uint32_t _i2739; + for (_i2739 = 0; _i2739 < _size2735; ++_i2739) { - xfer += (*(this->success))[_i2722].read(iprot); + xfer += (*(this->success))[_i2739].read(iprot); } xfer += iprot->readListEnd(); } @@ -71203,6 +71418,62 @@ void ThriftHiveMetastoreClient::recv_alter_table_req(AlterTableResponse& _return throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "alter_table_req failed: unknown result"); } +void ThriftHiveMetastoreClient::update_table_params(const std::vector & updates) +{ + send_update_table_params(updates); + recv_update_table_params(); +} + +void ThriftHiveMetastoreClient::send_update_table_params(const std::vector & updates) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("update_table_params", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_update_table_params_pargs args; + args.updates = &updates; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_update_table_params() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("update_table_params") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_update_table_params_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + return; +} + void ThriftHiveMetastoreClient::add_partition(Partition& _return, const Partition& new_part) { send_add_partition(new_part); @@ -88843,6 +89114,62 @@ void ThriftHiveMetastoreProcessor::process_alter_table_req(int32_t seqid, ::apac } } +void ThriftHiveMetastoreProcessor::process_update_table_params(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = nullptr; + if (this->eventHandler_.get() != nullptr) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.update_table_params", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.update_table_params"); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.update_table_params"); + } + + ThriftHiveMetastore_update_table_params_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.update_table_params", bytes); + } + + ThriftHiveMetastore_update_table_params_result result; + try { + iface_->update_table_params(args.updates); + } catch (MetaException &o1) { + result.o1 = std::move(o1); + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.update_table_params"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("update_table_params", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.update_table_params"); + } + + oprot->writeMessageBegin("update_table_params", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != nullptr) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.update_table_params", bytes); + } +} + void ThriftHiveMetastoreProcessor::process_add_partition(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) { void* ctx = nullptr; @@ -106316,7 +106643,272 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_tables(std::vectorreadMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("get_tables") != 0) { + if (fname.compare("get_tables") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_tables_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_tables failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_tables_by_type(std::vector & _return, const std::string& db_name, const std::string& pattern, const std::string& tableType) +{ + int32_t seqid = send_get_tables_by_type(db_name, pattern, tableType); + recv_get_tables_by_type(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_tables_by_type(const std::string& db_name, const std::string& pattern, const std::string& tableType) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_tables_by_type", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_tables_by_type_pargs args; + args.db_name = &db_name; + args.pattern = &pattern; + args.tableType = &tableType; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_tables_by_type(std::vector & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_tables_by_type") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_tables_by_type_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_tables_by_type failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_all_materialized_view_objects_for_rewriting(std::vector
& _return) +{ + int32_t seqid = send_get_all_materialized_view_objects_for_rewriting(); + recv_get_all_materialized_view_objects_for_rewriting(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_all_materialized_view_objects_for_rewriting() +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_all_materialized_view_objects_for_rewriting", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_all_materialized_view_objects_for_rewriting(std::vector
& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_all_materialized_view_objects_for_rewriting") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_all_materialized_view_objects_for_rewriting failed: unknown result"); + } + // seqid != rseqid + this->sync_->updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_->waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_materialized_views_for_rewriting(std::vector & _return, const std::string& db_name) +{ + int32_t seqid = send_get_materialized_views_for_rewriting(db_name); + recv_get_materialized_views_for_rewriting(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_materialized_views_for_rewriting(const std::string& db_name) +{ + int32_t cseqid = this->sync_->generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); + oprot_->writeMessageBegin("get_materialized_views_for_rewriting", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_materialized_views_for_rewriting_pargs args; + args.db_name = &db_name; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_materialized_views_for_rewriting(std::vector & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); + + while(true) { + if(!this->sync_->getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_materialized_views_for_rewriting") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -106325,7 +106917,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_tables(std::vectorreadMessageEnd(); @@ -106341,7 +106933,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_tables(std::vectorsync_->updatePending(fname, mtype, rseqid); @@ -106351,22 +106943,22 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_tables(std::vector & _return, const std::string& db_name, const std::string& pattern, const std::string& tableType) +void ThriftHiveMetastoreConcurrentClient::get_table_meta(std::vector & _return, const std::string& db_patterns, const std::string& tbl_patterns, const std::vector & tbl_types) { - int32_t seqid = send_get_tables_by_type(db_name, pattern, tableType); - recv_get_tables_by_type(_return, seqid); + int32_t seqid = send_get_table_meta(db_patterns, tbl_patterns, tbl_types); + recv_get_table_meta(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_get_tables_by_type(const std::string& db_name, const std::string& pattern, const std::string& tableType) +int32_t ThriftHiveMetastoreConcurrentClient::send_get_table_meta(const std::string& db_patterns, const std::string& tbl_patterns, const std::vector & tbl_types) { int32_t cseqid = this->sync_->generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); - oprot_->writeMessageBegin("get_tables_by_type", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("get_table_meta", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_get_tables_by_type_pargs args; - args.db_name = &db_name; - args.pattern = &pattern; - args.tableType = &tableType; + ThriftHiveMetastore_get_table_meta_pargs args; + args.db_patterns = &db_patterns; + args.tbl_patterns = &tbl_patterns; + args.tbl_types = &tbl_types; args.write(oprot_); oprot_->writeMessageEnd(); @@ -106377,7 +106969,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_get_tables_by_type(const std:: return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_get_tables_by_type(std::vector & _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_get_table_meta(std::vector & _return, const int32_t seqid) { int32_t rseqid = 0; @@ -106406,7 +106998,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_tables_by_type(std::vectorreadMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("get_tables_by_type") != 0) { + if (fname.compare("get_table_meta") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -106415,7 +107007,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_tables_by_type(std::vectorreadMessageEnd(); @@ -106431,7 +107023,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_tables_by_type(std::vectorsync_->updatePending(fname, mtype, rseqid); @@ -106441,19 +107033,20 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_tables_by_type(std::vector & _return) +void ThriftHiveMetastoreConcurrentClient::get_all_tables(std::vector & _return, const std::string& db_name) { - int32_t seqid = send_get_all_materialized_view_objects_for_rewriting(); - recv_get_all_materialized_view_objects_for_rewriting(_return, seqid); + int32_t seqid = send_get_all_tables(db_name); + recv_get_all_tables(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_get_all_materialized_view_objects_for_rewriting() +int32_t ThriftHiveMetastoreConcurrentClient::send_get_all_tables(const std::string& db_name) { int32_t cseqid = this->sync_->generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); - oprot_->writeMessageBegin("get_all_materialized_view_objects_for_rewriting", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("get_all_tables", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_pargs args; + ThriftHiveMetastore_get_all_tables_pargs args; + args.db_name = &db_name; args.write(oprot_); oprot_->writeMessageEnd(); @@ -106464,7 +107057,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_get_all_materialized_view_obje return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_get_all_materialized_view_objects_for_rewriting(std::vector
& _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_get_all_tables(std::vector & _return, const int32_t seqid) { int32_t rseqid = 0; @@ -106493,7 +107086,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_all_materialized_view_objects iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("get_all_materialized_view_objects_for_rewriting") != 0) { + if (fname.compare("get_all_tables") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -106502,7 +107095,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_all_materialized_view_objects using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_presult result; + ThriftHiveMetastore_get_all_tables_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -106518,7 +107111,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_all_materialized_view_objects throw result.o1; } // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_all_materialized_view_objects_for_rewriting failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_all_tables failed: unknown result"); } // seqid != rseqid this->sync_->updatePending(fname, mtype, rseqid); @@ -106528,20 +107121,20 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_all_materialized_view_objects } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::get_materialized_views_for_rewriting(std::vector & _return, const std::string& db_name) +void ThriftHiveMetastoreConcurrentClient::get_tables_ext(std::vector & _return, const GetTablesExtRequest& req) { - int32_t seqid = send_get_materialized_views_for_rewriting(db_name); - recv_get_materialized_views_for_rewriting(_return, seqid); + int32_t seqid = send_get_tables_ext(req); + recv_get_tables_ext(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_get_materialized_views_for_rewriting(const std::string& db_name) +int32_t ThriftHiveMetastoreConcurrentClient::send_get_tables_ext(const GetTablesExtRequest& req) { int32_t cseqid = this->sync_->generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); - oprot_->writeMessageBegin("get_materialized_views_for_rewriting", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("get_tables_ext", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_get_materialized_views_for_rewriting_pargs args; - args.db_name = &db_name; + ThriftHiveMetastore_get_tables_ext_pargs args; + args.req = &req; args.write(oprot_); oprot_->writeMessageEnd(); @@ -106552,7 +107145,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_get_materialized_views_for_rew return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_get_materialized_views_for_rewriting(std::vector & _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_get_tables_ext(std::vector & _return, const int32_t seqid) { int32_t rseqid = 0; @@ -106581,7 +107174,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_materialized_views_for_rewrit iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("get_materialized_views_for_rewriting") != 0) { + if (fname.compare("get_tables_ext") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -106590,7 +107183,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_materialized_views_for_rewrit using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_get_materialized_views_for_rewriting_presult result; + ThriftHiveMetastore_get_tables_ext_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -106606,7 +107199,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_materialized_views_for_rewrit throw result.o1; } // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_materialized_views_for_rewriting failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_tables_ext failed: unknown result"); } // seqid != rseqid this->sync_->updatePending(fname, mtype, rseqid); @@ -106616,22 +107209,20 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_materialized_views_for_rewrit } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::get_table_meta(std::vector & _return, const std::string& db_patterns, const std::string& tbl_patterns, const std::vector & tbl_types) +void ThriftHiveMetastoreConcurrentClient::get_table_req(GetTableResult& _return, const GetTableRequest& req) { - int32_t seqid = send_get_table_meta(db_patterns, tbl_patterns, tbl_types); - recv_get_table_meta(_return, seqid); + int32_t seqid = send_get_table_req(req); + recv_get_table_req(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_get_table_meta(const std::string& db_patterns, const std::string& tbl_patterns, const std::vector & tbl_types) +int32_t ThriftHiveMetastoreConcurrentClient::send_get_table_req(const GetTableRequest& req) { int32_t cseqid = this->sync_->generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); - oprot_->writeMessageBegin("get_table_meta", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("get_table_req", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_get_table_meta_pargs args; - args.db_patterns = &db_patterns; - args.tbl_patterns = &tbl_patterns; - args.tbl_types = &tbl_types; + ThriftHiveMetastore_get_table_req_pargs args; + args.req = &req; args.write(oprot_); oprot_->writeMessageEnd(); @@ -106642,7 +107233,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_get_table_meta(const std::stri return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_get_table_meta(std::vector & _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_get_table_req(GetTableResult& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -106671,7 +107262,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_table_meta(std::vectorreadMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("get_table_meta") != 0) { + if (fname.compare("get_table_req") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -106680,7 +107271,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_table_meta(std::vectorreadMessageEnd(); @@ -106695,8 +107286,12 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_table_meta(std::vectorsync_->updatePending(fname, mtype, rseqid); @@ -106706,20 +107301,20 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_table_meta(std::vector & _return, const std::string& db_name) +void ThriftHiveMetastoreConcurrentClient::get_table_objects_by_name_req(GetTablesResult& _return, const GetTablesRequest& req) { - int32_t seqid = send_get_all_tables(db_name); - recv_get_all_tables(_return, seqid); + int32_t seqid = send_get_table_objects_by_name_req(req); + recv_get_table_objects_by_name_req(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_get_all_tables(const std::string& db_name) +int32_t ThriftHiveMetastoreConcurrentClient::send_get_table_objects_by_name_req(const GetTablesRequest& req) { int32_t cseqid = this->sync_->generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); - oprot_->writeMessageBegin("get_all_tables", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("get_table_objects_by_name_req", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_get_all_tables_pargs args; - args.db_name = &db_name; + ThriftHiveMetastore_get_table_objects_by_name_req_pargs args; + args.req = &req; args.write(oprot_); oprot_->writeMessageEnd(); @@ -106730,7 +107325,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_get_all_tables(const std::stri return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_get_all_tables(std::vector & _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_get_table_objects_by_name_req(GetTablesResult& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -106759,7 +107354,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_all_tables(std::vectorreadMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("get_all_tables") != 0) { + if (fname.compare("get_table_objects_by_name_req") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -106768,7 +107363,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_all_tables(std::vectorreadMessageEnd(); @@ -106783,96 +107378,16 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_all_tables(std::vectorsync_->updatePending(fname, mtype, rseqid); - - // this will temporarily unlock the readMutex, and let other clients get work done - this->sync_->waitForWork(seqid); - } // end while(true) -} - -void ThriftHiveMetastoreConcurrentClient::get_tables_ext(std::vector & _return, const GetTablesExtRequest& req) -{ - int32_t seqid = send_get_tables_ext(req); - recv_get_tables_ext(_return, seqid); -} - -int32_t ThriftHiveMetastoreConcurrentClient::send_get_tables_ext(const GetTablesExtRequest& req) -{ - int32_t cseqid = this->sync_->generateSeqId(); - ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); - oprot_->writeMessageBegin("get_tables_ext", ::apache::thrift::protocol::T_CALL, cseqid); - - ThriftHiveMetastore_get_tables_ext_pargs args; - args.req = &req; - args.write(oprot_); - - oprot_->writeMessageEnd(); - oprot_->getTransport()->writeEnd(); - oprot_->getTransport()->flush(); - - sentry.commit(); - return cseqid; -} - -void ThriftHiveMetastoreConcurrentClient::recv_get_tables_ext(std::vector & _return, const int32_t seqid) -{ - - int32_t rseqid = 0; - std::string fname; - ::apache::thrift::protocol::TMessageType mtype; - - // the read mutex gets dropped and reacquired as part of waitForWork() - // The destructor of this sentry wakes up other clients - ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); - - while(true) { - if(!this->sync_->getPending(fname, mtype, rseqid)) { - iprot_->readMessageBegin(fname, mtype, rseqid); - } - if(seqid == rseqid) { - if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { - ::apache::thrift::TApplicationException x; - x.read(iprot_); - iprot_->readMessageEnd(); - iprot_->getTransport()->readEnd(); - sentry.commit(); - throw x; - } - if (mtype != ::apache::thrift::protocol::T_REPLY) { - iprot_->skip(::apache::thrift::protocol::T_STRUCT); - iprot_->readMessageEnd(); - iprot_->getTransport()->readEnd(); - } - if (fname.compare("get_tables_ext") != 0) { - iprot_->skip(::apache::thrift::protocol::T_STRUCT); - iprot_->readMessageEnd(); - iprot_->getTransport()->readEnd(); - - // in a bad state, don't commit - using ::apache::thrift::protocol::TProtocolException; - throw TProtocolException(TProtocolException::INVALID_DATA); - } - ThriftHiveMetastore_get_tables_ext_presult result; - result.success = &_return; - result.read(iprot_); - iprot_->readMessageEnd(); - iprot_->getTransport()->readEnd(); - - if (result.__isset.success) { - // _return pointer has now been filled + if (result.__isset.o2) { sentry.commit(); - return; + throw result.o2; } - if (result.__isset.o1) { + if (result.__isset.o3) { sentry.commit(); - throw result.o1; + throw result.o3; } // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_tables_ext failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_table_objects_by_name_req failed: unknown result"); } // seqid != rseqid this->sync_->updatePending(fname, mtype, rseqid); @@ -106882,20 +107397,21 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_tables_ext(std::vectorsync_->generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); - oprot_->writeMessageBegin("get_table_req", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("get_materialization_invalidation_info", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_get_table_req_pargs args; - args.req = &req; + ThriftHiveMetastore_get_materialization_invalidation_info_pargs args; + args.creation_metadata = &creation_metadata; + args.validTxnList = &validTxnList; args.write(oprot_); oprot_->writeMessageEnd(); @@ -106906,7 +107422,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_get_table_req(const GetTableRe return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_get_table_req(GetTableResult& _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_get_materialization_invalidation_info(Materialization& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -106935,7 +107451,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_table_req(GetTableResult& _re iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("get_table_req") != 0) { + if (fname.compare("get_materialization_invalidation_info") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -106944,7 +107460,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_table_req(GetTableResult& _re using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_get_table_req_presult result; + ThriftHiveMetastore_get_materialization_invalidation_info_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -106963,8 +107479,12 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_table_req(GetTableResult& _re sentry.commit(); throw result.o2; } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_table_req failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_materialization_invalidation_info failed: unknown result"); } // seqid != rseqid this->sync_->updatePending(fname, mtype, rseqid); @@ -106974,20 +107494,23 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_table_req(GetTableResult& _re } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::get_table_objects_by_name_req(GetTablesResult& _return, const GetTablesRequest& req) +void ThriftHiveMetastoreConcurrentClient::update_creation_metadata(const std::string& catName, const std::string& dbname, const std::string& tbl_name, const CreationMetadata& creation_metadata) { - int32_t seqid = send_get_table_objects_by_name_req(req); - recv_get_table_objects_by_name_req(_return, seqid); + int32_t seqid = send_update_creation_metadata(catName, dbname, tbl_name, creation_metadata); + recv_update_creation_metadata(seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_get_table_objects_by_name_req(const GetTablesRequest& req) +int32_t ThriftHiveMetastoreConcurrentClient::send_update_creation_metadata(const std::string& catName, const std::string& dbname, const std::string& tbl_name, const CreationMetadata& creation_metadata) { int32_t cseqid = this->sync_->generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); - oprot_->writeMessageBegin("get_table_objects_by_name_req", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("update_creation_metadata", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_get_table_objects_by_name_req_pargs args; - args.req = &req; + ThriftHiveMetastore_update_creation_metadata_pargs args; + args.catName = &catName; + args.dbname = &dbname; + args.tbl_name = &tbl_name; + args.creation_metadata = &creation_metadata; args.write(oprot_); oprot_->writeMessageEnd(); @@ -106998,7 +107521,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_get_table_objects_by_name_req( return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_get_table_objects_by_name_req(GetTablesResult& _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_update_creation_metadata(const int32_t seqid) { int32_t rseqid = 0; @@ -107027,7 +107550,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_table_objects_by_name_req(Get iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("get_table_objects_by_name_req") != 0) { + if (fname.compare("update_creation_metadata") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -107036,17 +107559,11 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_table_objects_by_name_req(Get using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_get_table_objects_by_name_req_presult result; - result.success = &_return; + ThriftHiveMetastore_update_creation_metadata_presult result; result.read(iprot_); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); - if (result.__isset.success) { - // _return pointer has now been filled - sentry.commit(); - return; - } if (result.__isset.o1) { sentry.commit(); throw result.o1; @@ -107059,8 +107576,8 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_table_objects_by_name_req(Get sentry.commit(); throw result.o3; } - // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_table_objects_by_name_req failed: unknown result"); + sentry.commit(); + return; } // seqid != rseqid this->sync_->updatePending(fname, mtype, rseqid); @@ -107070,21 +107587,22 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_table_objects_by_name_req(Get } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::get_materialization_invalidation_info(Materialization& _return, const CreationMetadata& creation_metadata, const std::string& validTxnList) +void ThriftHiveMetastoreConcurrentClient::get_table_names_by_filter(std::vector & _return, const std::string& dbname, const std::string& filter, const int16_t max_tables) { - int32_t seqid = send_get_materialization_invalidation_info(creation_metadata, validTxnList); - recv_get_materialization_invalidation_info(_return, seqid); + int32_t seqid = send_get_table_names_by_filter(dbname, filter, max_tables); + recv_get_table_names_by_filter(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_get_materialization_invalidation_info(const CreationMetadata& creation_metadata, const std::string& validTxnList) +int32_t ThriftHiveMetastoreConcurrentClient::send_get_table_names_by_filter(const std::string& dbname, const std::string& filter, const int16_t max_tables) { int32_t cseqid = this->sync_->generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); - oprot_->writeMessageBegin("get_materialization_invalidation_info", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("get_table_names_by_filter", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_get_materialization_invalidation_info_pargs args; - args.creation_metadata = &creation_metadata; - args.validTxnList = &validTxnList; + ThriftHiveMetastore_get_table_names_by_filter_pargs args; + args.dbname = &dbname; + args.filter = &filter; + args.max_tables = &max_tables; args.write(oprot_); oprot_->writeMessageEnd(); @@ -107095,7 +107613,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_get_materialization_invalidati return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_get_materialization_invalidation_info(Materialization& _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_get_table_names_by_filter(std::vector & _return, const int32_t seqid) { int32_t rseqid = 0; @@ -107124,7 +107642,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_materialization_invalidation_ iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("get_materialization_invalidation_info") != 0) { + if (fname.compare("get_table_names_by_filter") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -107133,7 +107651,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_materialization_invalidation_ using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_get_materialization_invalidation_info_presult result; + ThriftHiveMetastore_get_table_names_by_filter_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -107157,7 +107675,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_materialization_invalidation_ throw result.o3; } // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_materialization_invalidation_info failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_table_names_by_filter failed: unknown result"); } // seqid != rseqid this->sync_->updatePending(fname, mtype, rseqid); @@ -107167,23 +107685,22 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_materialization_invalidation_ } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::update_creation_metadata(const std::string& catName, const std::string& dbname, const std::string& tbl_name, const CreationMetadata& creation_metadata) +void ThriftHiveMetastoreConcurrentClient::alter_table(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl) { - int32_t seqid = send_update_creation_metadata(catName, dbname, tbl_name, creation_metadata); - recv_update_creation_metadata(seqid); + int32_t seqid = send_alter_table(dbname, tbl_name, new_tbl); + recv_alter_table(seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_update_creation_metadata(const std::string& catName, const std::string& dbname, const std::string& tbl_name, const CreationMetadata& creation_metadata) +int32_t ThriftHiveMetastoreConcurrentClient::send_alter_table(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl) { int32_t cseqid = this->sync_->generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); - oprot_->writeMessageBegin("update_creation_metadata", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("alter_table", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_update_creation_metadata_pargs args; - args.catName = &catName; + ThriftHiveMetastore_alter_table_pargs args; args.dbname = &dbname; args.tbl_name = &tbl_name; - args.creation_metadata = &creation_metadata; + args.new_tbl = &new_tbl; args.write(oprot_); oprot_->writeMessageEnd(); @@ -107194,7 +107711,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_update_creation_metadata(const return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_update_creation_metadata(const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_alter_table(const int32_t seqid) { int32_t rseqid = 0; @@ -107223,7 +107740,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_update_creation_metadata(const in iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("update_creation_metadata") != 0) { + if (fname.compare("alter_table") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -107232,7 +107749,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_update_creation_metadata(const in using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_update_creation_metadata_presult result; + ThriftHiveMetastore_alter_table_presult result; result.read(iprot_); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -107245,10 +107762,6 @@ void ThriftHiveMetastoreConcurrentClient::recv_update_creation_metadata(const in sentry.commit(); throw result.o2; } - if (result.__isset.o3) { - sentry.commit(); - throw result.o3; - } sentry.commit(); return; } @@ -107260,120 +107773,23 @@ void ThriftHiveMetastoreConcurrentClient::recv_update_creation_metadata(const in } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::get_table_names_by_filter(std::vector & _return, const std::string& dbname, const std::string& filter, const int16_t max_tables) -{ - int32_t seqid = send_get_table_names_by_filter(dbname, filter, max_tables); - recv_get_table_names_by_filter(_return, seqid); -} - -int32_t ThriftHiveMetastoreConcurrentClient::send_get_table_names_by_filter(const std::string& dbname, const std::string& filter, const int16_t max_tables) -{ - int32_t cseqid = this->sync_->generateSeqId(); - ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); - oprot_->writeMessageBegin("get_table_names_by_filter", ::apache::thrift::protocol::T_CALL, cseqid); - - ThriftHiveMetastore_get_table_names_by_filter_pargs args; - args.dbname = &dbname; - args.filter = &filter; - args.max_tables = &max_tables; - args.write(oprot_); - - oprot_->writeMessageEnd(); - oprot_->getTransport()->writeEnd(); - oprot_->getTransport()->flush(); - - sentry.commit(); - return cseqid; -} - -void ThriftHiveMetastoreConcurrentClient::recv_get_table_names_by_filter(std::vector & _return, const int32_t seqid) -{ - - int32_t rseqid = 0; - std::string fname; - ::apache::thrift::protocol::TMessageType mtype; - - // the read mutex gets dropped and reacquired as part of waitForWork() - // The destructor of this sentry wakes up other clients - ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid); - - while(true) { - if(!this->sync_->getPending(fname, mtype, rseqid)) { - iprot_->readMessageBegin(fname, mtype, rseqid); - } - if(seqid == rseqid) { - if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { - ::apache::thrift::TApplicationException x; - x.read(iprot_); - iprot_->readMessageEnd(); - iprot_->getTransport()->readEnd(); - sentry.commit(); - throw x; - } - if (mtype != ::apache::thrift::protocol::T_REPLY) { - iprot_->skip(::apache::thrift::protocol::T_STRUCT); - iprot_->readMessageEnd(); - iprot_->getTransport()->readEnd(); - } - if (fname.compare("get_table_names_by_filter") != 0) { - iprot_->skip(::apache::thrift::protocol::T_STRUCT); - iprot_->readMessageEnd(); - iprot_->getTransport()->readEnd(); - - // in a bad state, don't commit - using ::apache::thrift::protocol::TProtocolException; - throw TProtocolException(TProtocolException::INVALID_DATA); - } - ThriftHiveMetastore_get_table_names_by_filter_presult result; - result.success = &_return; - result.read(iprot_); - iprot_->readMessageEnd(); - iprot_->getTransport()->readEnd(); - - if (result.__isset.success) { - // _return pointer has now been filled - sentry.commit(); - return; - } - if (result.__isset.o1) { - sentry.commit(); - throw result.o1; - } - if (result.__isset.o2) { - sentry.commit(); - throw result.o2; - } - if (result.__isset.o3) { - sentry.commit(); - throw result.o3; - } - // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_table_names_by_filter failed: unknown result"); - } - // seqid != rseqid - this->sync_->updatePending(fname, mtype, rseqid); - - // this will temporarily unlock the readMutex, and let other clients get work done - this->sync_->waitForWork(seqid); - } // end while(true) -} - -void ThriftHiveMetastoreConcurrentClient::alter_table(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl) +void ThriftHiveMetastoreConcurrentClient::alter_table_with_environment_context(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const EnvironmentContext& environment_context) { - int32_t seqid = send_alter_table(dbname, tbl_name, new_tbl); - recv_alter_table(seqid); + int32_t seqid = send_alter_table_with_environment_context(dbname, tbl_name, new_tbl, environment_context); + recv_alter_table_with_environment_context(seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_alter_table(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl) +int32_t ThriftHiveMetastoreConcurrentClient::send_alter_table_with_environment_context(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const EnvironmentContext& environment_context) { int32_t cseqid = this->sync_->generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); - oprot_->writeMessageBegin("alter_table", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("alter_table_with_environment_context", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_alter_table_pargs args; + ThriftHiveMetastore_alter_table_with_environment_context_pargs args; args.dbname = &dbname; args.tbl_name = &tbl_name; args.new_tbl = &new_tbl; + args.environment_context = &environment_context; args.write(oprot_); oprot_->writeMessageEnd(); @@ -107384,7 +107800,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_alter_table(const std::string& return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_alter_table(const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_alter_table_with_environment_context(const int32_t seqid) { int32_t rseqid = 0; @@ -107413,7 +107829,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_alter_table(const int32_t seqid) iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("alter_table") != 0) { + if (fname.compare("alter_table_with_environment_context") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -107422,7 +107838,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_alter_table(const int32_t seqid) using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_alter_table_presult result; + ThriftHiveMetastore_alter_table_with_environment_context_presult result; result.read(iprot_); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -107446,23 +107862,23 @@ void ThriftHiveMetastoreConcurrentClient::recv_alter_table(const int32_t seqid) } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::alter_table_with_environment_context(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const EnvironmentContext& environment_context) +void ThriftHiveMetastoreConcurrentClient::alter_table_with_cascade(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const bool cascade) { - int32_t seqid = send_alter_table_with_environment_context(dbname, tbl_name, new_tbl, environment_context); - recv_alter_table_with_environment_context(seqid); + int32_t seqid = send_alter_table_with_cascade(dbname, tbl_name, new_tbl, cascade); + recv_alter_table_with_cascade(seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_alter_table_with_environment_context(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const EnvironmentContext& environment_context) +int32_t ThriftHiveMetastoreConcurrentClient::send_alter_table_with_cascade(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const bool cascade) { int32_t cseqid = this->sync_->generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); - oprot_->writeMessageBegin("alter_table_with_environment_context", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("alter_table_with_cascade", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_alter_table_with_environment_context_pargs args; + ThriftHiveMetastore_alter_table_with_cascade_pargs args; args.dbname = &dbname; args.tbl_name = &tbl_name; args.new_tbl = &new_tbl; - args.environment_context = &environment_context; + args.cascade = &cascade; args.write(oprot_); oprot_->writeMessageEnd(); @@ -107473,7 +107889,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_alter_table_with_environment_c return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_alter_table_with_environment_context(const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_alter_table_with_cascade(const int32_t seqid) { int32_t rseqid = 0; @@ -107502,7 +107918,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_alter_table_with_environment_cont iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("alter_table_with_environment_context") != 0) { + if (fname.compare("alter_table_with_cascade") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -107511,7 +107927,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_alter_table_with_environment_cont using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_alter_table_with_environment_context_presult result; + ThriftHiveMetastore_alter_table_with_cascade_presult result; result.read(iprot_); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -107535,23 +107951,20 @@ void ThriftHiveMetastoreConcurrentClient::recv_alter_table_with_environment_cont } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::alter_table_with_cascade(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const bool cascade) +void ThriftHiveMetastoreConcurrentClient::alter_table_req(AlterTableResponse& _return, const AlterTableRequest& req) { - int32_t seqid = send_alter_table_with_cascade(dbname, tbl_name, new_tbl, cascade); - recv_alter_table_with_cascade(seqid); + int32_t seqid = send_alter_table_req(req); + recv_alter_table_req(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_alter_table_with_cascade(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const bool cascade) +int32_t ThriftHiveMetastoreConcurrentClient::send_alter_table_req(const AlterTableRequest& req) { int32_t cseqid = this->sync_->generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); - oprot_->writeMessageBegin("alter_table_with_cascade", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("alter_table_req", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_alter_table_with_cascade_pargs args; - args.dbname = &dbname; - args.tbl_name = &tbl_name; - args.new_tbl = &new_tbl; - args.cascade = &cascade; + ThriftHiveMetastore_alter_table_req_pargs args; + args.req = &req; args.write(oprot_); oprot_->writeMessageEnd(); @@ -107562,7 +107975,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_alter_table_with_cascade(const return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_alter_table_with_cascade(const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_alter_table_req(AlterTableResponse& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -107591,7 +108004,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_alter_table_with_cascade(const in iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("alter_table_with_cascade") != 0) { + if (fname.compare("alter_table_req") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -107600,11 +108013,17 @@ void ThriftHiveMetastoreConcurrentClient::recv_alter_table_with_cascade(const in using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_alter_table_with_cascade_presult result; + ThriftHiveMetastore_alter_table_req_presult result; + result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } if (result.__isset.o1) { sentry.commit(); throw result.o1; @@ -107613,8 +108032,8 @@ void ThriftHiveMetastoreConcurrentClient::recv_alter_table_with_cascade(const in sentry.commit(); throw result.o2; } - sentry.commit(); - return; + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "alter_table_req failed: unknown result"); } // seqid != rseqid this->sync_->updatePending(fname, mtype, rseqid); @@ -107624,20 +108043,20 @@ void ThriftHiveMetastoreConcurrentClient::recv_alter_table_with_cascade(const in } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::alter_table_req(AlterTableResponse& _return, const AlterTableRequest& req) +void ThriftHiveMetastoreConcurrentClient::update_table_params(const std::vector & updates) { - int32_t seqid = send_alter_table_req(req); - recv_alter_table_req(_return, seqid); + int32_t seqid = send_update_table_params(updates); + recv_update_table_params(seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_alter_table_req(const AlterTableRequest& req) +int32_t ThriftHiveMetastoreConcurrentClient::send_update_table_params(const std::vector & updates) { int32_t cseqid = this->sync_->generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get()); - oprot_->writeMessageBegin("alter_table_req", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("update_table_params", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_alter_table_req_pargs args; - args.req = &req; + ThriftHiveMetastore_update_table_params_pargs args; + args.updates = &updates; args.write(oprot_); oprot_->writeMessageEnd(); @@ -107648,7 +108067,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_alter_table_req(const AlterTab return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_alter_table_req(AlterTableResponse& _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_update_table_params(const int32_t seqid) { int32_t rseqid = 0; @@ -107677,7 +108096,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_alter_table_req(AlterTableRespons iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("alter_table_req") != 0) { + if (fname.compare("update_table_params") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -107686,27 +108105,17 @@ void ThriftHiveMetastoreConcurrentClient::recv_alter_table_req(AlterTableRespons using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_alter_table_req_presult result; - result.success = &_return; + ThriftHiveMetastore_update_table_params_presult result; result.read(iprot_); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); - if (result.__isset.success) { - // _return pointer has now been filled - sentry.commit(); - return; - } if (result.__isset.o1) { sentry.commit(); throw result.o1; } - if (result.__isset.o2) { - sentry.commit(); - throw result.o2; - } - // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "alter_table_req failed: unknown result"); + sentry.commit(); + return; } // seqid != rseqid this->sync_->updatePending(fname, mtype, rseqid); diff --git a/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h b/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h index 883393b3eb91..1a742f5e9c5a 100644 --- a/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h +++ b/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h @@ -93,6 +93,7 @@ class ThriftHiveMetastoreIf : virtual public ::facebook::fb303::FacebookService virtual void alter_table_with_environment_context(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const EnvironmentContext& environment_context) = 0; virtual void alter_table_with_cascade(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const bool cascade) = 0; virtual void alter_table_req(AlterTableResponse& _return, const AlterTableRequest& req) = 0; + virtual void update_table_params(const std::vector & updates) = 0; virtual void add_partition(Partition& _return, const Partition& new_part) = 0; virtual void add_partition_with_environment_context(Partition& _return, const Partition& new_part, const EnvironmentContext& environment_context) = 0; virtual int32_t add_partitions(const std::vector & new_parts) = 0; @@ -542,6 +543,9 @@ class ThriftHiveMetastoreNull : virtual public ThriftHiveMetastoreIf , virtual p void alter_table_req(AlterTableResponse& /* _return */, const AlterTableRequest& /* req */) override { return; } + void update_table_params(const std::vector & /* updates */) override { + return; + } void add_partition(Partition& /* _return */, const Partition& /* new_part */) override { return; } @@ -9422,6 +9426,110 @@ class ThriftHiveMetastore_alter_table_req_presult { }; +typedef struct _ThriftHiveMetastore_update_table_params_args__isset { + _ThriftHiveMetastore_update_table_params_args__isset() : updates(false) {} + bool updates :1; +} _ThriftHiveMetastore_update_table_params_args__isset; + +class ThriftHiveMetastore_update_table_params_args { + public: + + ThriftHiveMetastore_update_table_params_args(const ThriftHiveMetastore_update_table_params_args&); + ThriftHiveMetastore_update_table_params_args& operator=(const ThriftHiveMetastore_update_table_params_args&); + ThriftHiveMetastore_update_table_params_args() noexcept { + } + + virtual ~ThriftHiveMetastore_update_table_params_args() noexcept; + std::vector updates; + + _ThriftHiveMetastore_update_table_params_args__isset __isset; + + void __set_updates(const std::vector & val); + + bool operator == (const ThriftHiveMetastore_update_table_params_args & rhs) const + { + if (!(updates == rhs.updates)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_update_table_params_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_update_table_params_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_update_table_params_pargs { + public: + + + virtual ~ThriftHiveMetastore_update_table_params_pargs() noexcept; + const std::vector * updates; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_update_table_params_result__isset { + _ThriftHiveMetastore_update_table_params_result__isset() : o1(false) {} + bool o1 :1; +} _ThriftHiveMetastore_update_table_params_result__isset; + +class ThriftHiveMetastore_update_table_params_result { + public: + + ThriftHiveMetastore_update_table_params_result(const ThriftHiveMetastore_update_table_params_result&); + ThriftHiveMetastore_update_table_params_result& operator=(const ThriftHiveMetastore_update_table_params_result&); + ThriftHiveMetastore_update_table_params_result() noexcept { + } + + virtual ~ThriftHiveMetastore_update_table_params_result() noexcept; + MetaException o1; + + _ThriftHiveMetastore_update_table_params_result__isset __isset; + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_update_table_params_result & rhs) const + { + if (!(o1 == rhs.o1)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_update_table_params_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_update_table_params_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_update_table_params_presult__isset { + _ThriftHiveMetastore_update_table_params_presult__isset() : o1(false) {} + bool o1 :1; +} _ThriftHiveMetastore_update_table_params_presult__isset; + +class ThriftHiveMetastore_update_table_params_presult { + public: + + + virtual ~ThriftHiveMetastore_update_table_params_presult() noexcept; + MetaException o1; + + _ThriftHiveMetastore_update_table_params_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + typedef struct _ThriftHiveMetastore_add_partition_args__isset { _ThriftHiveMetastore_add_partition_args__isset() : new_part(false) {} bool new_part :1; @@ -35892,6 +36000,9 @@ class ThriftHiveMetastoreClient : virtual public ThriftHiveMetastoreIf, public void alter_table_req(AlterTableResponse& _return, const AlterTableRequest& req) override; void send_alter_table_req(const AlterTableRequest& req); void recv_alter_table_req(AlterTableResponse& _return); + void update_table_params(const std::vector & updates) override; + void send_update_table_params(const std::vector & updates); + void recv_update_table_params(); void add_partition(Partition& _return, const Partition& new_part) override; void send_add_partition(const Partition& new_part); void recv_add_partition(Partition& _return); @@ -36620,6 +36731,7 @@ class ThriftHiveMetastoreProcessor : public ::facebook::fb303::FacebookServiceP void process_alter_table_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_alter_table_with_cascade(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_alter_table_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_update_table_params(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_add_partition(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_add_partition_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_add_partitions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); @@ -36908,6 +37020,7 @@ class ThriftHiveMetastoreProcessor : public ::facebook::fb303::FacebookServiceP processMap_["alter_table_with_environment_context"] = &ThriftHiveMetastoreProcessor::process_alter_table_with_environment_context; processMap_["alter_table_with_cascade"] = &ThriftHiveMetastoreProcessor::process_alter_table_with_cascade; processMap_["alter_table_req"] = &ThriftHiveMetastoreProcessor::process_alter_table_req; + processMap_["update_table_params"] = &ThriftHiveMetastoreProcessor::process_update_table_params; processMap_["add_partition"] = &ThriftHiveMetastoreProcessor::process_add_partition; processMap_["add_partition_with_environment_context"] = &ThriftHiveMetastoreProcessor::process_add_partition_with_environment_context; processMap_["add_partitions"] = &ThriftHiveMetastoreProcessor::process_add_partitions; @@ -37796,6 +37909,15 @@ class ThriftHiveMetastoreMultiface : virtual public ThriftHiveMetastoreIf, publi return; } + void update_table_params(const std::vector & updates) override { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->update_table_params(updates); + } + ifaces_[i]->update_table_params(updates); + } + void add_partition(Partition& _return, const Partition& new_part) override { size_t sz = ifaces_.size(); size_t i = 0; @@ -40104,6 +40226,9 @@ class ThriftHiveMetastoreConcurrentClient : virtual public ThriftHiveMetastoreIf void alter_table_req(AlterTableResponse& _return, const AlterTableRequest& req) override; int32_t send_alter_table_req(const AlterTableRequest& req); void recv_alter_table_req(AlterTableResponse& _return, const int32_t seqid); + void update_table_params(const std::vector & updates) override; + int32_t send_update_table_params(const std::vector & updates); + void recv_update_table_params(const int32_t seqid); void add_partition(Partition& _return, const Partition& new_part) override; int32_t send_add_partition(const Partition& new_part); void recv_add_partition(Partition& _return, const int32_t seqid); diff --git a/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp b/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp index 81f734c47154..3cb85ea9f467 100644 --- a/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp +++ b/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp @@ -355,6 +355,11 @@ class ThriftHiveMetastoreHandler : virtual public ThriftHiveMetastoreIf { printf("alter_table_req\n"); } + void update_table_params(const std::vector & updates) { + // Your implementation goes here + printf("update_table_params\n"); + } + void add_partition(Partition& _return, const Partition& new_part) { // Your implementation goes here printf("add_partition\n"); diff --git a/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/hive_metastore_types.cpp b/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/hive_metastore_types.cpp index aa1c1b9040cb..eb9d12c96e3c 100644 --- a/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/hive_metastore_types.cpp +++ b/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/hive_metastore_types.cpp @@ -49328,6 +49328,237 @@ void AlterTableResponse::printTo(std::ostream& out) const { } +TableParamsUpdate::~TableParamsUpdate() noexcept { +} + + +void TableParamsUpdate::__set_cat_name(const std::string& val) { + this->cat_name = val; +__isset.cat_name = true; +} + +void TableParamsUpdate::__set_db_name(const std::string& val) { + this->db_name = val; +} + +void TableParamsUpdate::__set_table_name(const std::string& val) { + this->table_name = val; +} + +void TableParamsUpdate::__set_params(const std::map & val) { + this->params = val; +} + +void TableParamsUpdate::__set_expected_param_key(const std::string& val) { + this->expected_param_key = val; +__isset.expected_param_key = true; +} + +void TableParamsUpdate::__set_expected_param_value(const std::string& val) { + this->expected_param_value = val; +__isset.expected_param_value = true; +} +std::ostream& operator<<(std::ostream& out, const TableParamsUpdate& obj) +{ + obj.printTo(out); + return out; +} + + +uint32_t TableParamsUpdate::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_db_name = false; + bool isset_table_name = false; + bool isset_params = 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_STRING) { + xfer += iprot->readString(this->cat_name); + this->__isset.cat_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + isset_db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->table_name); + isset_table_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + this->params.clear(); + uint32_t _size1751; + ::apache::thrift::protocol::TType _ktype1752; + ::apache::thrift::protocol::TType _vtype1753; + xfer += iprot->readMapBegin(_ktype1752, _vtype1753, _size1751); + uint32_t _i1755; + for (_i1755 = 0; _i1755 < _size1751; ++_i1755) + { + std::string _key1756; + xfer += iprot->readString(_key1756); + std::string& _val1757 = this->params[_key1756]; + xfer += iprot->readString(_val1757); + } + xfer += iprot->readMapEnd(); + } + isset_params = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->expected_param_key); + this->__isset.expected_param_key = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->expected_param_value); + this->__isset.expected_param_value = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_db_name) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_table_name) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_params) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t TableParamsUpdate::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("TableParamsUpdate"); + + if (this->__isset.cat_name) { + xfer += oprot->writeFieldBegin("cat_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->cat_name); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("table_name", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->table_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("params", ::apache::thrift::protocol::T_MAP, 4); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->params.size())); + std::map ::const_iterator _iter1758; + for (_iter1758 = this->params.begin(); _iter1758 != this->params.end(); ++_iter1758) + { + xfer += oprot->writeString(_iter1758->first); + xfer += oprot->writeString(_iter1758->second); + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + + if (this->__isset.expected_param_key) { + xfer += oprot->writeFieldBegin("expected_param_key", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->expected_param_key); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.expected_param_value) { + xfer += oprot->writeFieldBegin("expected_param_value", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->expected_param_value); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(TableParamsUpdate &a, TableParamsUpdate &b) { + using ::std::swap; + swap(a.cat_name, b.cat_name); + swap(a.db_name, b.db_name); + swap(a.table_name, b.table_name); + swap(a.params, b.params); + swap(a.expected_param_key, b.expected_param_key); + swap(a.expected_param_value, b.expected_param_value); + swap(a.__isset, b.__isset); +} + +TableParamsUpdate::TableParamsUpdate(const TableParamsUpdate& other1759) { + cat_name = other1759.cat_name; + db_name = other1759.db_name; + table_name = other1759.table_name; + params = other1759.params; + expected_param_key = other1759.expected_param_key; + expected_param_value = other1759.expected_param_value; + __isset = other1759.__isset; +} +TableParamsUpdate& TableParamsUpdate::operator=(const TableParamsUpdate& other1760) { + cat_name = other1760.cat_name; + db_name = other1760.db_name; + table_name = other1760.table_name; + params = other1760.params; + expected_param_key = other1760.expected_param_key; + expected_param_value = other1760.expected_param_value; + __isset = other1760.__isset; + return *this; +} +void TableParamsUpdate::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "TableParamsUpdate("; + out << "cat_name="; (__isset.cat_name ? (out << to_string(cat_name)) : (out << "")); + out << ", " << "db_name=" << to_string(db_name); + out << ", " << "table_name=" << to_string(table_name); + out << ", " << "params=" << to_string(params); + out << ", " << "expected_param_key="; (__isset.expected_param_key ? (out << to_string(expected_param_key)) : (out << "")); + out << ", " << "expected_param_value="; (__isset.expected_param_value ? (out << to_string(expected_param_value)) : (out << "")); + out << ")"; +} + + GetPartitionsFilterSpec::~GetPartitionsFilterSpec() noexcept { } @@ -49371,9 +49602,9 @@ uint32_t GetPartitionsFilterSpec::read(::apache::thrift::protocol::TProtocol* ip { case 7: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1751; - xfer += iprot->readI32(ecast1751); - this->filterMode = static_cast(ecast1751); + int32_t ecast1761; + xfer += iprot->readI32(ecast1761); + this->filterMode = static_cast(ecast1761); this->__isset.filterMode = true; } else { xfer += iprot->skip(ftype); @@ -49383,14 +49614,14 @@ uint32_t GetPartitionsFilterSpec::read(::apache::thrift::protocol::TProtocol* ip if (ftype == ::apache::thrift::protocol::T_LIST) { { this->filters.clear(); - uint32_t _size1752; - ::apache::thrift::protocol::TType _etype1755; - xfer += iprot->readListBegin(_etype1755, _size1752); - this->filters.resize(_size1752); - uint32_t _i1756; - for (_i1756 = 0; _i1756 < _size1752; ++_i1756) + uint32_t _size1762; + ::apache::thrift::protocol::TType _etype1765; + xfer += iprot->readListBegin(_etype1765, _size1762); + this->filters.resize(_size1762); + uint32_t _i1766; + for (_i1766 = 0; _i1766 < _size1762; ++_i1766) { - xfer += iprot->readString(this->filters[_i1756]); + xfer += iprot->readString(this->filters[_i1766]); } xfer += iprot->readListEnd(); } @@ -49425,10 +49656,10 @@ uint32_t GetPartitionsFilterSpec::write(::apache::thrift::protocol::TProtocol* o xfer += oprot->writeFieldBegin("filters", ::apache::thrift::protocol::T_LIST, 8); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->filters.size())); - std::vector ::const_iterator _iter1757; - for (_iter1757 = this->filters.begin(); _iter1757 != this->filters.end(); ++_iter1757) + std::vector ::const_iterator _iter1767; + for (_iter1767 = this->filters.begin(); _iter1767 != this->filters.end(); ++_iter1767) { - xfer += oprot->writeString((*_iter1757)); + xfer += oprot->writeString((*_iter1767)); } xfer += oprot->writeListEnd(); } @@ -49446,15 +49677,15 @@ void swap(GetPartitionsFilterSpec &a, GetPartitionsFilterSpec &b) { swap(a.__isset, b.__isset); } -GetPartitionsFilterSpec::GetPartitionsFilterSpec(const GetPartitionsFilterSpec& other1758) { - filterMode = other1758.filterMode; - filters = other1758.filters; - __isset = other1758.__isset; +GetPartitionsFilterSpec::GetPartitionsFilterSpec(const GetPartitionsFilterSpec& other1768) { + filterMode = other1768.filterMode; + filters = other1768.filters; + __isset = other1768.__isset; } -GetPartitionsFilterSpec& GetPartitionsFilterSpec::operator=(const GetPartitionsFilterSpec& other1759) { - filterMode = other1759.filterMode; - filters = other1759.filters; - __isset = other1759.__isset; +GetPartitionsFilterSpec& GetPartitionsFilterSpec::operator=(const GetPartitionsFilterSpec& other1769) { + filterMode = other1769.filterMode; + filters = other1769.filters; + __isset = other1769.__isset; return *this; } void GetPartitionsFilterSpec::printTo(std::ostream& out) const { @@ -49505,14 +49736,14 @@ uint32_t GetPartitionsResponse::read(::apache::thrift::protocol::TProtocol* ipro if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionSpec.clear(); - uint32_t _size1760; - ::apache::thrift::protocol::TType _etype1763; - xfer += iprot->readListBegin(_etype1763, _size1760); - this->partitionSpec.resize(_size1760); - uint32_t _i1764; - for (_i1764 = 0; _i1764 < _size1760; ++_i1764) + uint32_t _size1770; + ::apache::thrift::protocol::TType _etype1773; + xfer += iprot->readListBegin(_etype1773, _size1770); + this->partitionSpec.resize(_size1770); + uint32_t _i1774; + for (_i1774 = 0; _i1774 < _size1770; ++_i1774) { - xfer += this->partitionSpec[_i1764].read(iprot); + xfer += this->partitionSpec[_i1774].read(iprot); } xfer += iprot->readListEnd(); } @@ -49541,10 +49772,10 @@ uint32_t GetPartitionsResponse::write(::apache::thrift::protocol::TProtocol* opr xfer += oprot->writeFieldBegin("partitionSpec", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitionSpec.size())); - std::vector ::const_iterator _iter1765; - for (_iter1765 = this->partitionSpec.begin(); _iter1765 != this->partitionSpec.end(); ++_iter1765) + std::vector ::const_iterator _iter1775; + for (_iter1775 = this->partitionSpec.begin(); _iter1775 != this->partitionSpec.end(); ++_iter1775) { - xfer += (*_iter1765).write(oprot); + xfer += (*_iter1775).write(oprot); } xfer += oprot->writeListEnd(); } @@ -49561,13 +49792,13 @@ void swap(GetPartitionsResponse &a, GetPartitionsResponse &b) { swap(a.__isset, b.__isset); } -GetPartitionsResponse::GetPartitionsResponse(const GetPartitionsResponse& other1766) { - partitionSpec = other1766.partitionSpec; - __isset = other1766.__isset; +GetPartitionsResponse::GetPartitionsResponse(const GetPartitionsResponse& other1776) { + partitionSpec = other1776.partitionSpec; + __isset = other1776.__isset; } -GetPartitionsResponse& GetPartitionsResponse::operator=(const GetPartitionsResponse& other1767) { - partitionSpec = other1767.partitionSpec; - __isset = other1767.__isset; +GetPartitionsResponse& GetPartitionsResponse::operator=(const GetPartitionsResponse& other1777) { + partitionSpec = other1777.partitionSpec; + __isset = other1777.__isset; return *this; } void GetPartitionsResponse::printTo(std::ostream& out) const { @@ -49704,14 +49935,14 @@ uint32_t GetPartitionsRequest::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->groupNames.clear(); - uint32_t _size1768; - ::apache::thrift::protocol::TType _etype1771; - xfer += iprot->readListBegin(_etype1771, _size1768); - this->groupNames.resize(_size1768); - uint32_t _i1772; - for (_i1772 = 0; _i1772 < _size1768; ++_i1772) + uint32_t _size1778; + ::apache::thrift::protocol::TType _etype1781; + xfer += iprot->readListBegin(_etype1781, _size1778); + this->groupNames.resize(_size1778); + uint32_t _i1782; + for (_i1782 = 0; _i1782 < _size1778; ++_i1782) { - xfer += iprot->readString(this->groupNames[_i1772]); + xfer += iprot->readString(this->groupNames[_i1782]); } xfer += iprot->readListEnd(); } @@ -49740,14 +49971,14 @@ uint32_t GetPartitionsRequest::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->processorCapabilities.clear(); - uint32_t _size1773; - ::apache::thrift::protocol::TType _etype1776; - xfer += iprot->readListBegin(_etype1776, _size1773); - this->processorCapabilities.resize(_size1773); - uint32_t _i1777; - for (_i1777 = 0; _i1777 < _size1773; ++_i1777) + uint32_t _size1783; + ::apache::thrift::protocol::TType _etype1786; + xfer += iprot->readListBegin(_etype1786, _size1783); + this->processorCapabilities.resize(_size1783); + uint32_t _i1787; + for (_i1787 = 0; _i1787 < _size1783; ++_i1787) { - xfer += iprot->readString(this->processorCapabilities[_i1777]); + xfer += iprot->readString(this->processorCapabilities[_i1787]); } xfer += iprot->readListEnd(); } @@ -49816,10 +50047,10 @@ uint32_t GetPartitionsRequest::write(::apache::thrift::protocol::TProtocol* opro xfer += oprot->writeFieldBegin("groupNames", ::apache::thrift::protocol::T_LIST, 6); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->groupNames.size())); - std::vector ::const_iterator _iter1778; - for (_iter1778 = this->groupNames.begin(); _iter1778 != this->groupNames.end(); ++_iter1778) + std::vector ::const_iterator _iter1788; + for (_iter1788 = this->groupNames.begin(); _iter1788 != this->groupNames.end(); ++_iter1788) { - xfer += oprot->writeString((*_iter1778)); + xfer += oprot->writeString((*_iter1788)); } xfer += oprot->writeListEnd(); } @@ -49837,10 +50068,10 @@ uint32_t GetPartitionsRequest::write(::apache::thrift::protocol::TProtocol* opro xfer += oprot->writeFieldBegin("processorCapabilities", ::apache::thrift::protocol::T_LIST, 9); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->processorCapabilities.size())); - std::vector ::const_iterator _iter1779; - for (_iter1779 = this->processorCapabilities.begin(); _iter1779 != this->processorCapabilities.end(); ++_iter1779) + std::vector ::const_iterator _iter1789; + for (_iter1789 = this->processorCapabilities.begin(); _iter1789 != this->processorCapabilities.end(); ++_iter1789) { - xfer += oprot->writeString((*_iter1779)); + xfer += oprot->writeString((*_iter1789)); } xfer += oprot->writeListEnd(); } @@ -49877,33 +50108,33 @@ void swap(GetPartitionsRequest &a, GetPartitionsRequest &b) { swap(a.__isset, b.__isset); } -GetPartitionsRequest::GetPartitionsRequest(const GetPartitionsRequest& other1780) { - catName = other1780.catName; - dbName = other1780.dbName; - tblName = other1780.tblName; - withAuth = other1780.withAuth; - user = other1780.user; - groupNames = other1780.groupNames; - projectionSpec = other1780.projectionSpec; - filterSpec = other1780.filterSpec; - processorCapabilities = other1780.processorCapabilities; - processorIdentifier = other1780.processorIdentifier; - validWriteIdList = other1780.validWriteIdList; - __isset = other1780.__isset; -} -GetPartitionsRequest& GetPartitionsRequest::operator=(const GetPartitionsRequest& other1781) { - catName = other1781.catName; - dbName = other1781.dbName; - tblName = other1781.tblName; - withAuth = other1781.withAuth; - user = other1781.user; - groupNames = other1781.groupNames; - projectionSpec = other1781.projectionSpec; - filterSpec = other1781.filterSpec; - processorCapabilities = other1781.processorCapabilities; - processorIdentifier = other1781.processorIdentifier; - validWriteIdList = other1781.validWriteIdList; - __isset = other1781.__isset; +GetPartitionsRequest::GetPartitionsRequest(const GetPartitionsRequest& other1790) { + catName = other1790.catName; + dbName = other1790.dbName; + tblName = other1790.tblName; + withAuth = other1790.withAuth; + user = other1790.user; + groupNames = other1790.groupNames; + projectionSpec = other1790.projectionSpec; + filterSpec = other1790.filterSpec; + processorCapabilities = other1790.processorCapabilities; + processorIdentifier = other1790.processorIdentifier; + validWriteIdList = other1790.validWriteIdList; + __isset = other1790.__isset; +} +GetPartitionsRequest& GetPartitionsRequest::operator=(const GetPartitionsRequest& other1791) { + catName = other1791.catName; + dbName = other1791.dbName; + tblName = other1791.tblName; + withAuth = other1791.withAuth; + user = other1791.user; + groupNames = other1791.groupNames; + projectionSpec = other1791.projectionSpec; + filterSpec = other1791.filterSpec; + processorCapabilities = other1791.processorCapabilities; + processorIdentifier = other1791.processorIdentifier; + validWriteIdList = other1791.validWriteIdList; + __isset = other1791.__isset; return *this; } void GetPartitionsRequest::printTo(std::ostream& out) const { @@ -50098,23 +50329,23 @@ void swap(GetFieldsRequest &a, GetFieldsRequest &b) { swap(a.__isset, b.__isset); } -GetFieldsRequest::GetFieldsRequest(const GetFieldsRequest& other1782) { - catName = other1782.catName; - dbName = other1782.dbName; - tblName = other1782.tblName; - envContext = other1782.envContext; - validWriteIdList = other1782.validWriteIdList; - id = other1782.id; - __isset = other1782.__isset; +GetFieldsRequest::GetFieldsRequest(const GetFieldsRequest& other1792) { + catName = other1792.catName; + dbName = other1792.dbName; + tblName = other1792.tblName; + envContext = other1792.envContext; + validWriteIdList = other1792.validWriteIdList; + id = other1792.id; + __isset = other1792.__isset; } -GetFieldsRequest& GetFieldsRequest::operator=(const GetFieldsRequest& other1783) { - catName = other1783.catName; - dbName = other1783.dbName; - tblName = other1783.tblName; - envContext = other1783.envContext; - validWriteIdList = other1783.validWriteIdList; - id = other1783.id; - __isset = other1783.__isset; +GetFieldsRequest& GetFieldsRequest::operator=(const GetFieldsRequest& other1793) { + catName = other1793.catName; + dbName = other1793.dbName; + tblName = other1793.tblName; + envContext = other1793.envContext; + validWriteIdList = other1793.validWriteIdList; + id = other1793.id; + __isset = other1793.__isset; return *this; } void GetFieldsRequest::printTo(std::ostream& out) const { @@ -50170,14 +50401,14 @@ uint32_t GetFieldsResponse::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fields.clear(); - uint32_t _size1784; - ::apache::thrift::protocol::TType _etype1787; - xfer += iprot->readListBegin(_etype1787, _size1784); - this->fields.resize(_size1784); - uint32_t _i1788; - for (_i1788 = 0; _i1788 < _size1784; ++_i1788) + uint32_t _size1794; + ::apache::thrift::protocol::TType _etype1797; + xfer += iprot->readListBegin(_etype1797, _size1794); + this->fields.resize(_size1794); + uint32_t _i1798; + for (_i1798 = 0; _i1798 < _size1794; ++_i1798) { - xfer += this->fields[_i1788].read(iprot); + xfer += this->fields[_i1798].read(iprot); } xfer += iprot->readListEnd(); } @@ -50208,10 +50439,10 @@ uint32_t GetFieldsResponse::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("fields", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->fields.size())); - std::vector ::const_iterator _iter1789; - for (_iter1789 = this->fields.begin(); _iter1789 != this->fields.end(); ++_iter1789) + std::vector ::const_iterator _iter1799; + for (_iter1799 = this->fields.begin(); _iter1799 != this->fields.end(); ++_iter1799) { - xfer += (*_iter1789).write(oprot); + xfer += (*_iter1799).write(oprot); } xfer += oprot->writeListEnd(); } @@ -50227,11 +50458,11 @@ void swap(GetFieldsResponse &a, GetFieldsResponse &b) { swap(a.fields, b.fields); } -GetFieldsResponse::GetFieldsResponse(const GetFieldsResponse& other1790) { - fields = other1790.fields; +GetFieldsResponse::GetFieldsResponse(const GetFieldsResponse& other1800) { + fields = other1800.fields; } -GetFieldsResponse& GetFieldsResponse::operator=(const GetFieldsResponse& other1791) { - fields = other1791.fields; +GetFieldsResponse& GetFieldsResponse::operator=(const GetFieldsResponse& other1801) { + fields = other1801.fields; return *this; } void GetFieldsResponse::printTo(std::ostream& out) const { @@ -50416,23 +50647,23 @@ void swap(GetSchemaRequest &a, GetSchemaRequest &b) { swap(a.__isset, b.__isset); } -GetSchemaRequest::GetSchemaRequest(const GetSchemaRequest& other1792) { - catName = other1792.catName; - dbName = other1792.dbName; - tblName = other1792.tblName; - envContext = other1792.envContext; - validWriteIdList = other1792.validWriteIdList; - id = other1792.id; - __isset = other1792.__isset; +GetSchemaRequest::GetSchemaRequest(const GetSchemaRequest& other1802) { + catName = other1802.catName; + dbName = other1802.dbName; + tblName = other1802.tblName; + envContext = other1802.envContext; + validWriteIdList = other1802.validWriteIdList; + id = other1802.id; + __isset = other1802.__isset; } -GetSchemaRequest& GetSchemaRequest::operator=(const GetSchemaRequest& other1793) { - catName = other1793.catName; - dbName = other1793.dbName; - tblName = other1793.tblName; - envContext = other1793.envContext; - validWriteIdList = other1793.validWriteIdList; - id = other1793.id; - __isset = other1793.__isset; +GetSchemaRequest& GetSchemaRequest::operator=(const GetSchemaRequest& other1803) { + catName = other1803.catName; + dbName = other1803.dbName; + tblName = other1803.tblName; + envContext = other1803.envContext; + validWriteIdList = other1803.validWriteIdList; + id = other1803.id; + __isset = other1803.__isset; return *this; } void GetSchemaRequest::printTo(std::ostream& out) const { @@ -50488,14 +50719,14 @@ uint32_t GetSchemaResponse::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fields.clear(); - uint32_t _size1794; - ::apache::thrift::protocol::TType _etype1797; - xfer += iprot->readListBegin(_etype1797, _size1794); - this->fields.resize(_size1794); - uint32_t _i1798; - for (_i1798 = 0; _i1798 < _size1794; ++_i1798) + uint32_t _size1804; + ::apache::thrift::protocol::TType _etype1807; + xfer += iprot->readListBegin(_etype1807, _size1804); + this->fields.resize(_size1804); + uint32_t _i1808; + for (_i1808 = 0; _i1808 < _size1804; ++_i1808) { - xfer += this->fields[_i1798].read(iprot); + xfer += this->fields[_i1808].read(iprot); } xfer += iprot->readListEnd(); } @@ -50526,10 +50757,10 @@ uint32_t GetSchemaResponse::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("fields", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->fields.size())); - std::vector ::const_iterator _iter1799; - for (_iter1799 = this->fields.begin(); _iter1799 != this->fields.end(); ++_iter1799) + std::vector ::const_iterator _iter1809; + for (_iter1809 = this->fields.begin(); _iter1809 != this->fields.end(); ++_iter1809) { - xfer += (*_iter1799).write(oprot); + xfer += (*_iter1809).write(oprot); } xfer += oprot->writeListEnd(); } @@ -50545,11 +50776,11 @@ void swap(GetSchemaResponse &a, GetSchemaResponse &b) { swap(a.fields, b.fields); } -GetSchemaResponse::GetSchemaResponse(const GetSchemaResponse& other1800) { - fields = other1800.fields; +GetSchemaResponse::GetSchemaResponse(const GetSchemaResponse& other1810) { + fields = other1810.fields; } -GetSchemaResponse& GetSchemaResponse::operator=(const GetSchemaResponse& other1801) { - fields = other1801.fields; +GetSchemaResponse& GetSchemaResponse::operator=(const GetSchemaResponse& other1811) { + fields = other1811.fields; return *this; } void GetSchemaResponse::printTo(std::ostream& out) const { @@ -50649,14 +50880,14 @@ uint32_t GetPartitionRequest::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partVals.clear(); - uint32_t _size1802; - ::apache::thrift::protocol::TType _etype1805; - xfer += iprot->readListBegin(_etype1805, _size1802); - this->partVals.resize(_size1802); - uint32_t _i1806; - for (_i1806 = 0; _i1806 < _size1802; ++_i1806) + uint32_t _size1812; + ::apache::thrift::protocol::TType _etype1815; + xfer += iprot->readListBegin(_etype1815, _size1812); + this->partVals.resize(_size1812); + uint32_t _i1816; + for (_i1816 = 0; _i1816 < _size1812; ++_i1816) { - xfer += iprot->readString(this->partVals[_i1806]); + xfer += iprot->readString(this->partVals[_i1816]); } xfer += iprot->readListEnd(); } @@ -50720,10 +50951,10 @@ uint32_t GetPartitionRequest::write(::apache::thrift::protocol::TProtocol* oprot xfer += oprot->writeFieldBegin("partVals", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partVals.size())); - std::vector ::const_iterator _iter1807; - for (_iter1807 = this->partVals.begin(); _iter1807 != this->partVals.end(); ++_iter1807) + std::vector ::const_iterator _iter1817; + for (_iter1817 = this->partVals.begin(); _iter1817 != this->partVals.end(); ++_iter1817) { - xfer += oprot->writeString((*_iter1807)); + xfer += oprot->writeString((*_iter1817)); } xfer += oprot->writeListEnd(); } @@ -50755,23 +50986,23 @@ void swap(GetPartitionRequest &a, GetPartitionRequest &b) { swap(a.__isset, b.__isset); } -GetPartitionRequest::GetPartitionRequest(const GetPartitionRequest& other1808) { - catName = other1808.catName; - dbName = other1808.dbName; - tblName = other1808.tblName; - partVals = other1808.partVals; - validWriteIdList = other1808.validWriteIdList; - id = other1808.id; - __isset = other1808.__isset; +GetPartitionRequest::GetPartitionRequest(const GetPartitionRequest& other1818) { + catName = other1818.catName; + dbName = other1818.dbName; + tblName = other1818.tblName; + partVals = other1818.partVals; + validWriteIdList = other1818.validWriteIdList; + id = other1818.id; + __isset = other1818.__isset; } -GetPartitionRequest& GetPartitionRequest::operator=(const GetPartitionRequest& other1809) { - catName = other1809.catName; - dbName = other1809.dbName; - tblName = other1809.tblName; - partVals = other1809.partVals; - validWriteIdList = other1809.validWriteIdList; - id = other1809.id; - __isset = other1809.__isset; +GetPartitionRequest& GetPartitionRequest::operator=(const GetPartitionRequest& other1819) { + catName = other1819.catName; + dbName = other1819.dbName; + tblName = other1819.tblName; + partVals = other1819.partVals; + validWriteIdList = other1819.validWriteIdList; + id = other1819.id; + __isset = other1819.__isset; return *this; } void GetPartitionRequest::printTo(std::ostream& out) const { @@ -50864,11 +51095,11 @@ void swap(GetPartitionResponse &a, GetPartitionResponse &b) { swap(a.partition, b.partition); } -GetPartitionResponse::GetPartitionResponse(const GetPartitionResponse& other1810) { - partition = other1810.partition; +GetPartitionResponse::GetPartitionResponse(const GetPartitionResponse& other1820) { + partition = other1820.partition; } -GetPartitionResponse& GetPartitionResponse::operator=(const GetPartitionResponse& other1811) { - partition = other1811.partition; +GetPartitionResponse& GetPartitionResponse::operator=(const GetPartitionResponse& other1821) { + partition = other1821.partition; return *this; } void GetPartitionResponse::printTo(std::ostream& out) const { @@ -51110,29 +51341,29 @@ void swap(PartitionsRequest &a, PartitionsRequest &b) { swap(a.__isset, b.__isset); } -PartitionsRequest::PartitionsRequest(const PartitionsRequest& other1812) { - catName = other1812.catName; - dbName = other1812.dbName; - tblName = other1812.tblName; - maxParts = other1812.maxParts; - validWriteIdList = other1812.validWriteIdList; - id = other1812.id; - skipColumnSchemaForPartition = other1812.skipColumnSchemaForPartition; - includeParamKeyPattern = other1812.includeParamKeyPattern; - excludeParamKeyPattern = other1812.excludeParamKeyPattern; - __isset = other1812.__isset; -} -PartitionsRequest& PartitionsRequest::operator=(const PartitionsRequest& other1813) { - catName = other1813.catName; - dbName = other1813.dbName; - tblName = other1813.tblName; - maxParts = other1813.maxParts; - validWriteIdList = other1813.validWriteIdList; - id = other1813.id; - skipColumnSchemaForPartition = other1813.skipColumnSchemaForPartition; - includeParamKeyPattern = other1813.includeParamKeyPattern; - excludeParamKeyPattern = other1813.excludeParamKeyPattern; - __isset = other1813.__isset; +PartitionsRequest::PartitionsRequest(const PartitionsRequest& other1822) { + catName = other1822.catName; + dbName = other1822.dbName; + tblName = other1822.tblName; + maxParts = other1822.maxParts; + validWriteIdList = other1822.validWriteIdList; + id = other1822.id; + skipColumnSchemaForPartition = other1822.skipColumnSchemaForPartition; + includeParamKeyPattern = other1822.includeParamKeyPattern; + excludeParamKeyPattern = other1822.excludeParamKeyPattern; + __isset = other1822.__isset; +} +PartitionsRequest& PartitionsRequest::operator=(const PartitionsRequest& other1823) { + catName = other1823.catName; + dbName = other1823.dbName; + tblName = other1823.tblName; + maxParts = other1823.maxParts; + validWriteIdList = other1823.validWriteIdList; + id = other1823.id; + skipColumnSchemaForPartition = other1823.skipColumnSchemaForPartition; + includeParamKeyPattern = other1823.includeParamKeyPattern; + excludeParamKeyPattern = other1823.excludeParamKeyPattern; + __isset = other1823.__isset; return *this; } void PartitionsRequest::printTo(std::ostream& out) const { @@ -51191,14 +51422,14 @@ uint32_t PartitionsResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size1814; - ::apache::thrift::protocol::TType _etype1817; - xfer += iprot->readListBegin(_etype1817, _size1814); - this->partitions.resize(_size1814); - uint32_t _i1818; - for (_i1818 = 0; _i1818 < _size1814; ++_i1818) + uint32_t _size1824; + ::apache::thrift::protocol::TType _etype1827; + xfer += iprot->readListBegin(_etype1827, _size1824); + this->partitions.resize(_size1824); + uint32_t _i1828; + for (_i1828 = 0; _i1828 < _size1824; ++_i1828) { - xfer += this->partitions[_i1818].read(iprot); + xfer += this->partitions[_i1828].read(iprot); } xfer += iprot->readListEnd(); } @@ -51229,10 +51460,10 @@ uint32_t PartitionsResponse::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitions.size())); - std::vector ::const_iterator _iter1819; - for (_iter1819 = this->partitions.begin(); _iter1819 != this->partitions.end(); ++_iter1819) + std::vector ::const_iterator _iter1829; + for (_iter1829 = this->partitions.begin(); _iter1829 != this->partitions.end(); ++_iter1829) { - xfer += (*_iter1819).write(oprot); + xfer += (*_iter1829).write(oprot); } xfer += oprot->writeListEnd(); } @@ -51248,11 +51479,11 @@ void swap(PartitionsResponse &a, PartitionsResponse &b) { swap(a.partitions, b.partitions); } -PartitionsResponse::PartitionsResponse(const PartitionsResponse& other1820) { - partitions = other1820.partitions; +PartitionsResponse::PartitionsResponse(const PartitionsResponse& other1830) { + partitions = other1830.partitions; } -PartitionsResponse& PartitionsResponse::operator=(const PartitionsResponse& other1821) { - partitions = other1821.partitions; +PartitionsResponse& PartitionsResponse::operator=(const PartitionsResponse& other1831) { + partitions = other1831.partitions; return *this; } void PartitionsResponse::printTo(std::ostream& out) const { @@ -51467,27 +51698,27 @@ void swap(GetPartitionsByFilterRequest &a, GetPartitionsByFilterRequest &b) { swap(a.__isset, b.__isset); } -GetPartitionsByFilterRequest::GetPartitionsByFilterRequest(const GetPartitionsByFilterRequest& other1822) { - catName = other1822.catName; - dbName = other1822.dbName; - tblName = other1822.tblName; - filter = other1822.filter; - maxParts = other1822.maxParts; - skipColumnSchemaForPartition = other1822.skipColumnSchemaForPartition; - includeParamKeyPattern = other1822.includeParamKeyPattern; - excludeParamKeyPattern = other1822.excludeParamKeyPattern; - __isset = other1822.__isset; -} -GetPartitionsByFilterRequest& GetPartitionsByFilterRequest::operator=(const GetPartitionsByFilterRequest& other1823) { - catName = other1823.catName; - dbName = other1823.dbName; - tblName = other1823.tblName; - filter = other1823.filter; - maxParts = other1823.maxParts; - skipColumnSchemaForPartition = other1823.skipColumnSchemaForPartition; - includeParamKeyPattern = other1823.includeParamKeyPattern; - excludeParamKeyPattern = other1823.excludeParamKeyPattern; - __isset = other1823.__isset; +GetPartitionsByFilterRequest::GetPartitionsByFilterRequest(const GetPartitionsByFilterRequest& other1832) { + catName = other1832.catName; + dbName = other1832.dbName; + tblName = other1832.tblName; + filter = other1832.filter; + maxParts = other1832.maxParts; + skipColumnSchemaForPartition = other1832.skipColumnSchemaForPartition; + includeParamKeyPattern = other1832.includeParamKeyPattern; + excludeParamKeyPattern = other1832.excludeParamKeyPattern; + __isset = other1832.__isset; +} +GetPartitionsByFilterRequest& GetPartitionsByFilterRequest::operator=(const GetPartitionsByFilterRequest& other1833) { + catName = other1833.catName; + dbName = other1833.dbName; + tblName = other1833.tblName; + filter = other1833.filter; + maxParts = other1833.maxParts; + skipColumnSchemaForPartition = other1833.skipColumnSchemaForPartition; + includeParamKeyPattern = other1833.includeParamKeyPattern; + excludeParamKeyPattern = other1833.excludeParamKeyPattern; + __isset = other1833.__isset; return *this; } void GetPartitionsByFilterRequest::printTo(std::ostream& out) const { @@ -51599,14 +51830,14 @@ uint32_t GetPartitionNamesPsRequest::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partValues.clear(); - uint32_t _size1824; - ::apache::thrift::protocol::TType _etype1827; - xfer += iprot->readListBegin(_etype1827, _size1824); - this->partValues.resize(_size1824); - uint32_t _i1828; - for (_i1828 = 0; _i1828 < _size1824; ++_i1828) + uint32_t _size1834; + ::apache::thrift::protocol::TType _etype1837; + xfer += iprot->readListBegin(_etype1837, _size1834); + this->partValues.resize(_size1834); + uint32_t _i1838; + for (_i1838 = 0; _i1838 < _size1834; ++_i1838) { - xfer += iprot->readString(this->partValues[_i1828]); + xfer += iprot->readString(this->partValues[_i1838]); } xfer += iprot->readListEnd(); } @@ -51677,10 +51908,10 @@ uint32_t GetPartitionNamesPsRequest::write(::apache::thrift::protocol::TProtocol xfer += oprot->writeFieldBegin("partValues", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partValues.size())); - std::vector ::const_iterator _iter1829; - for (_iter1829 = this->partValues.begin(); _iter1829 != this->partValues.end(); ++_iter1829) + std::vector ::const_iterator _iter1839; + for (_iter1839 = this->partValues.begin(); _iter1839 != this->partValues.end(); ++_iter1839) { - xfer += oprot->writeString((*_iter1829)); + xfer += oprot->writeString((*_iter1839)); } xfer += oprot->writeListEnd(); } @@ -51718,25 +51949,25 @@ void swap(GetPartitionNamesPsRequest &a, GetPartitionNamesPsRequest &b) { swap(a.__isset, b.__isset); } -GetPartitionNamesPsRequest::GetPartitionNamesPsRequest(const GetPartitionNamesPsRequest& other1830) { - catName = other1830.catName; - dbName = other1830.dbName; - tblName = other1830.tblName; - partValues = other1830.partValues; - maxParts = other1830.maxParts; - validWriteIdList = other1830.validWriteIdList; - id = other1830.id; - __isset = other1830.__isset; +GetPartitionNamesPsRequest::GetPartitionNamesPsRequest(const GetPartitionNamesPsRequest& other1840) { + catName = other1840.catName; + dbName = other1840.dbName; + tblName = other1840.tblName; + partValues = other1840.partValues; + maxParts = other1840.maxParts; + validWriteIdList = other1840.validWriteIdList; + id = other1840.id; + __isset = other1840.__isset; } -GetPartitionNamesPsRequest& GetPartitionNamesPsRequest::operator=(const GetPartitionNamesPsRequest& other1831) { - catName = other1831.catName; - dbName = other1831.dbName; - tblName = other1831.tblName; - partValues = other1831.partValues; - maxParts = other1831.maxParts; - validWriteIdList = other1831.validWriteIdList; - id = other1831.id; - __isset = other1831.__isset; +GetPartitionNamesPsRequest& GetPartitionNamesPsRequest::operator=(const GetPartitionNamesPsRequest& other1841) { + catName = other1841.catName; + dbName = other1841.dbName; + tblName = other1841.tblName; + partValues = other1841.partValues; + maxParts = other1841.maxParts; + validWriteIdList = other1841.validWriteIdList; + id = other1841.id; + __isset = other1841.__isset; return *this; } void GetPartitionNamesPsRequest::printTo(std::ostream& out) const { @@ -51793,14 +52024,14 @@ uint32_t GetPartitionNamesPsResponse::read(::apache::thrift::protocol::TProtocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->names.clear(); - uint32_t _size1832; - ::apache::thrift::protocol::TType _etype1835; - xfer += iprot->readListBegin(_etype1835, _size1832); - this->names.resize(_size1832); - uint32_t _i1836; - for (_i1836 = 0; _i1836 < _size1832; ++_i1836) + uint32_t _size1842; + ::apache::thrift::protocol::TType _etype1845; + xfer += iprot->readListBegin(_etype1845, _size1842); + this->names.resize(_size1842); + uint32_t _i1846; + for (_i1846 = 0; _i1846 < _size1842; ++_i1846) { - xfer += iprot->readString(this->names[_i1836]); + xfer += iprot->readString(this->names[_i1846]); } xfer += iprot->readListEnd(); } @@ -51831,10 +52062,10 @@ uint32_t GetPartitionNamesPsResponse::write(::apache::thrift::protocol::TProtoco xfer += oprot->writeFieldBegin("names", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->names.size())); - std::vector ::const_iterator _iter1837; - for (_iter1837 = this->names.begin(); _iter1837 != this->names.end(); ++_iter1837) + std::vector ::const_iterator _iter1847; + for (_iter1847 = this->names.begin(); _iter1847 != this->names.end(); ++_iter1847) { - xfer += oprot->writeString((*_iter1837)); + xfer += oprot->writeString((*_iter1847)); } xfer += oprot->writeListEnd(); } @@ -51850,11 +52081,11 @@ void swap(GetPartitionNamesPsResponse &a, GetPartitionNamesPsResponse &b) { swap(a.names, b.names); } -GetPartitionNamesPsResponse::GetPartitionNamesPsResponse(const GetPartitionNamesPsResponse& other1838) { - names = other1838.names; +GetPartitionNamesPsResponse::GetPartitionNamesPsResponse(const GetPartitionNamesPsResponse& other1848) { + names = other1848.names; } -GetPartitionNamesPsResponse& GetPartitionNamesPsResponse::operator=(const GetPartitionNamesPsResponse& other1839) { - names = other1839.names; +GetPartitionNamesPsResponse& GetPartitionNamesPsResponse::operator=(const GetPartitionNamesPsResponse& other1849) { + names = other1849.names; return *this; } void GetPartitionNamesPsResponse::printTo(std::ostream& out) const { @@ -51989,14 +52220,14 @@ uint32_t GetPartitionsPsWithAuthRequest::read(::apache::thrift::protocol::TProto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partVals.clear(); - uint32_t _size1840; - ::apache::thrift::protocol::TType _etype1843; - xfer += iprot->readListBegin(_etype1843, _size1840); - this->partVals.resize(_size1840); - uint32_t _i1844; - for (_i1844 = 0; _i1844 < _size1840; ++_i1844) + uint32_t _size1850; + ::apache::thrift::protocol::TType _etype1853; + xfer += iprot->readListBegin(_etype1853, _size1850); + this->partVals.resize(_size1850); + uint32_t _i1854; + for (_i1854 = 0; _i1854 < _size1850; ++_i1854) { - xfer += iprot->readString(this->partVals[_i1844]); + xfer += iprot->readString(this->partVals[_i1854]); } xfer += iprot->readListEnd(); } @@ -52025,14 +52256,14 @@ uint32_t GetPartitionsPsWithAuthRequest::read(::apache::thrift::protocol::TProto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->groupNames.clear(); - uint32_t _size1845; - ::apache::thrift::protocol::TType _etype1848; - xfer += iprot->readListBegin(_etype1848, _size1845); - this->groupNames.resize(_size1845); - uint32_t _i1849; - for (_i1849 = 0; _i1849 < _size1845; ++_i1849) + uint32_t _size1855; + ::apache::thrift::protocol::TType _etype1858; + xfer += iprot->readListBegin(_etype1858, _size1855); + this->groupNames.resize(_size1855); + uint32_t _i1859; + for (_i1859 = 0; _i1859 < _size1855; ++_i1859) { - xfer += iprot->readString(this->groupNames[_i1849]); + xfer += iprot->readString(this->groupNames[_i1859]); } xfer += iprot->readListEnd(); } @@ -52085,14 +52316,14 @@ uint32_t GetPartitionsPsWithAuthRequest::read(::apache::thrift::protocol::TProto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partNames.clear(); - uint32_t _size1850; - ::apache::thrift::protocol::TType _etype1853; - xfer += iprot->readListBegin(_etype1853, _size1850); - this->partNames.resize(_size1850); - uint32_t _i1854; - for (_i1854 = 0; _i1854 < _size1850; ++_i1854) + uint32_t _size1860; + ::apache::thrift::protocol::TType _etype1863; + xfer += iprot->readListBegin(_etype1863, _size1860); + this->partNames.resize(_size1860); + uint32_t _i1864; + for (_i1864 = 0; _i1864 < _size1860; ++_i1864) { - xfer += iprot->readString(this->partNames[_i1854]); + xfer += iprot->readString(this->partNames[_i1864]); } xfer += iprot->readListEnd(); } @@ -52139,10 +52370,10 @@ uint32_t GetPartitionsPsWithAuthRequest::write(::apache::thrift::protocol::TProt xfer += oprot->writeFieldBegin("partVals", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partVals.size())); - std::vector ::const_iterator _iter1855; - for (_iter1855 = this->partVals.begin(); _iter1855 != this->partVals.end(); ++_iter1855) + std::vector ::const_iterator _iter1865; + for (_iter1865 = this->partVals.begin(); _iter1865 != this->partVals.end(); ++_iter1865) { - xfer += oprot->writeString((*_iter1855)); + xfer += oprot->writeString((*_iter1865)); } xfer += oprot->writeListEnd(); } @@ -52162,10 +52393,10 @@ uint32_t GetPartitionsPsWithAuthRequest::write(::apache::thrift::protocol::TProt xfer += oprot->writeFieldBegin("groupNames", ::apache::thrift::protocol::T_LIST, 7); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->groupNames.size())); - std::vector ::const_iterator _iter1856; - for (_iter1856 = this->groupNames.begin(); _iter1856 != this->groupNames.end(); ++_iter1856) + std::vector ::const_iterator _iter1866; + for (_iter1866 = this->groupNames.begin(); _iter1866 != this->groupNames.end(); ++_iter1866) { - xfer += oprot->writeString((*_iter1856)); + xfer += oprot->writeString((*_iter1866)); } xfer += oprot->writeListEnd(); } @@ -52200,10 +52431,10 @@ uint32_t GetPartitionsPsWithAuthRequest::write(::apache::thrift::protocol::TProt xfer += oprot->writeFieldBegin("partNames", ::apache::thrift::protocol::T_LIST, 13); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partNames.size())); - std::vector ::const_iterator _iter1857; - for (_iter1857 = this->partNames.begin(); _iter1857 != this->partNames.end(); ++_iter1857) + std::vector ::const_iterator _iter1867; + for (_iter1867 = this->partNames.begin(); _iter1867 != this->partNames.end(); ++_iter1867) { - xfer += oprot->writeString((*_iter1857)); + xfer += oprot->writeString((*_iter1867)); } xfer += oprot->writeListEnd(); } @@ -52232,37 +52463,37 @@ void swap(GetPartitionsPsWithAuthRequest &a, GetPartitionsPsWithAuthRequest &b) swap(a.__isset, b.__isset); } -GetPartitionsPsWithAuthRequest::GetPartitionsPsWithAuthRequest(const GetPartitionsPsWithAuthRequest& other1858) { - catName = other1858.catName; - dbName = other1858.dbName; - tblName = other1858.tblName; - partVals = other1858.partVals; - maxParts = other1858.maxParts; - userName = other1858.userName; - groupNames = other1858.groupNames; - validWriteIdList = other1858.validWriteIdList; - id = other1858.id; - skipColumnSchemaForPartition = other1858.skipColumnSchemaForPartition; - includeParamKeyPattern = other1858.includeParamKeyPattern; - excludeParamKeyPattern = other1858.excludeParamKeyPattern; - partNames = other1858.partNames; - __isset = other1858.__isset; -} -GetPartitionsPsWithAuthRequest& GetPartitionsPsWithAuthRequest::operator=(const GetPartitionsPsWithAuthRequest& other1859) { - catName = other1859.catName; - dbName = other1859.dbName; - tblName = other1859.tblName; - partVals = other1859.partVals; - maxParts = other1859.maxParts; - userName = other1859.userName; - groupNames = other1859.groupNames; - validWriteIdList = other1859.validWriteIdList; - id = other1859.id; - skipColumnSchemaForPartition = other1859.skipColumnSchemaForPartition; - includeParamKeyPattern = other1859.includeParamKeyPattern; - excludeParamKeyPattern = other1859.excludeParamKeyPattern; - partNames = other1859.partNames; - __isset = other1859.__isset; +GetPartitionsPsWithAuthRequest::GetPartitionsPsWithAuthRequest(const GetPartitionsPsWithAuthRequest& other1868) { + catName = other1868.catName; + dbName = other1868.dbName; + tblName = other1868.tblName; + partVals = other1868.partVals; + maxParts = other1868.maxParts; + userName = other1868.userName; + groupNames = other1868.groupNames; + validWriteIdList = other1868.validWriteIdList; + id = other1868.id; + skipColumnSchemaForPartition = other1868.skipColumnSchemaForPartition; + includeParamKeyPattern = other1868.includeParamKeyPattern; + excludeParamKeyPattern = other1868.excludeParamKeyPattern; + partNames = other1868.partNames; + __isset = other1868.__isset; +} +GetPartitionsPsWithAuthRequest& GetPartitionsPsWithAuthRequest::operator=(const GetPartitionsPsWithAuthRequest& other1869) { + catName = other1869.catName; + dbName = other1869.dbName; + tblName = other1869.tblName; + partVals = other1869.partVals; + maxParts = other1869.maxParts; + userName = other1869.userName; + groupNames = other1869.groupNames; + validWriteIdList = other1869.validWriteIdList; + id = other1869.id; + skipColumnSchemaForPartition = other1869.skipColumnSchemaForPartition; + includeParamKeyPattern = other1869.includeParamKeyPattern; + excludeParamKeyPattern = other1869.excludeParamKeyPattern; + partNames = other1869.partNames; + __isset = other1869.__isset; return *this; } void GetPartitionsPsWithAuthRequest::printTo(std::ostream& out) const { @@ -52325,14 +52556,14 @@ uint32_t GetPartitionsPsWithAuthResponse::read(::apache::thrift::protocol::TProt if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size1860; - ::apache::thrift::protocol::TType _etype1863; - xfer += iprot->readListBegin(_etype1863, _size1860); - this->partitions.resize(_size1860); - uint32_t _i1864; - for (_i1864 = 0; _i1864 < _size1860; ++_i1864) + uint32_t _size1870; + ::apache::thrift::protocol::TType _etype1873; + xfer += iprot->readListBegin(_etype1873, _size1870); + this->partitions.resize(_size1870); + uint32_t _i1874; + for (_i1874 = 0; _i1874 < _size1870; ++_i1874) { - xfer += this->partitions[_i1864].read(iprot); + xfer += this->partitions[_i1874].read(iprot); } xfer += iprot->readListEnd(); } @@ -52363,10 +52594,10 @@ uint32_t GetPartitionsPsWithAuthResponse::write(::apache::thrift::protocol::TPro xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitions.size())); - std::vector ::const_iterator _iter1865; - for (_iter1865 = this->partitions.begin(); _iter1865 != this->partitions.end(); ++_iter1865) + std::vector ::const_iterator _iter1875; + for (_iter1875 = this->partitions.begin(); _iter1875 != this->partitions.end(); ++_iter1875) { - xfer += (*_iter1865).write(oprot); + xfer += (*_iter1875).write(oprot); } xfer += oprot->writeListEnd(); } @@ -52382,11 +52613,11 @@ void swap(GetPartitionsPsWithAuthResponse &a, GetPartitionsPsWithAuthResponse &b swap(a.partitions, b.partitions); } -GetPartitionsPsWithAuthResponse::GetPartitionsPsWithAuthResponse(const GetPartitionsPsWithAuthResponse& other1866) { - partitions = other1866.partitions; +GetPartitionsPsWithAuthResponse::GetPartitionsPsWithAuthResponse(const GetPartitionsPsWithAuthResponse& other1876) { + partitions = other1876.partitions; } -GetPartitionsPsWithAuthResponse& GetPartitionsPsWithAuthResponse::operator=(const GetPartitionsPsWithAuthResponse& other1867) { - partitions = other1867.partitions; +GetPartitionsPsWithAuthResponse& GetPartitionsPsWithAuthResponse::operator=(const GetPartitionsPsWithAuthResponse& other1877) { + partitions = other1877.partitions; return *this; } void GetPartitionsPsWithAuthResponse::printTo(std::ostream& out) const { @@ -52572,23 +52803,23 @@ void swap(ReplicationMetrics &a, ReplicationMetrics &b) { swap(a.__isset, b.__isset); } -ReplicationMetrics::ReplicationMetrics(const ReplicationMetrics& other1868) { - scheduledExecutionId = other1868.scheduledExecutionId; - policy = other1868.policy; - dumpExecutionId = other1868.dumpExecutionId; - metadata = other1868.metadata; - progress = other1868.progress; - messageFormat = other1868.messageFormat; - __isset = other1868.__isset; +ReplicationMetrics::ReplicationMetrics(const ReplicationMetrics& other1878) { + scheduledExecutionId = other1878.scheduledExecutionId; + policy = other1878.policy; + dumpExecutionId = other1878.dumpExecutionId; + metadata = other1878.metadata; + progress = other1878.progress; + messageFormat = other1878.messageFormat; + __isset = other1878.__isset; } -ReplicationMetrics& ReplicationMetrics::operator=(const ReplicationMetrics& other1869) { - scheduledExecutionId = other1869.scheduledExecutionId; - policy = other1869.policy; - dumpExecutionId = other1869.dumpExecutionId; - metadata = other1869.metadata; - progress = other1869.progress; - messageFormat = other1869.messageFormat; - __isset = other1869.__isset; +ReplicationMetrics& ReplicationMetrics::operator=(const ReplicationMetrics& other1879) { + scheduledExecutionId = other1879.scheduledExecutionId; + policy = other1879.policy; + dumpExecutionId = other1879.dumpExecutionId; + metadata = other1879.metadata; + progress = other1879.progress; + messageFormat = other1879.messageFormat; + __isset = other1879.__isset; return *this; } void ReplicationMetrics::printTo(std::ostream& out) const { @@ -52644,14 +52875,14 @@ uint32_t ReplicationMetricList::read(::apache::thrift::protocol::TProtocol* ipro if (ftype == ::apache::thrift::protocol::T_LIST) { { this->replicationMetricList.clear(); - uint32_t _size1870; - ::apache::thrift::protocol::TType _etype1873; - xfer += iprot->readListBegin(_etype1873, _size1870); - this->replicationMetricList.resize(_size1870); - uint32_t _i1874; - for (_i1874 = 0; _i1874 < _size1870; ++_i1874) + uint32_t _size1880; + ::apache::thrift::protocol::TType _etype1883; + xfer += iprot->readListBegin(_etype1883, _size1880); + this->replicationMetricList.resize(_size1880); + uint32_t _i1884; + for (_i1884 = 0; _i1884 < _size1880; ++_i1884) { - xfer += this->replicationMetricList[_i1874].read(iprot); + xfer += this->replicationMetricList[_i1884].read(iprot); } xfer += iprot->readListEnd(); } @@ -52682,10 +52913,10 @@ uint32_t ReplicationMetricList::write(::apache::thrift::protocol::TProtocol* opr xfer += oprot->writeFieldBegin("replicationMetricList", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->replicationMetricList.size())); - std::vector ::const_iterator _iter1875; - for (_iter1875 = this->replicationMetricList.begin(); _iter1875 != this->replicationMetricList.end(); ++_iter1875) + std::vector ::const_iterator _iter1885; + for (_iter1885 = this->replicationMetricList.begin(); _iter1885 != this->replicationMetricList.end(); ++_iter1885) { - xfer += (*_iter1875).write(oprot); + xfer += (*_iter1885).write(oprot); } xfer += oprot->writeListEnd(); } @@ -52701,11 +52932,11 @@ void swap(ReplicationMetricList &a, ReplicationMetricList &b) { swap(a.replicationMetricList, b.replicationMetricList); } -ReplicationMetricList::ReplicationMetricList(const ReplicationMetricList& other1876) { - replicationMetricList = other1876.replicationMetricList; +ReplicationMetricList::ReplicationMetricList(const ReplicationMetricList& other1886) { + replicationMetricList = other1886.replicationMetricList; } -ReplicationMetricList& ReplicationMetricList::operator=(const ReplicationMetricList& other1877) { - replicationMetricList = other1877.replicationMetricList; +ReplicationMetricList& ReplicationMetricList::operator=(const ReplicationMetricList& other1887) { + replicationMetricList = other1887.replicationMetricList; return *this; } void ReplicationMetricList::printTo(std::ostream& out) const { @@ -52831,17 +53062,17 @@ void swap(GetReplicationMetricsRequest &a, GetReplicationMetricsRequest &b) { swap(a.__isset, b.__isset); } -GetReplicationMetricsRequest::GetReplicationMetricsRequest(const GetReplicationMetricsRequest& other1878) { - scheduledExecutionId = other1878.scheduledExecutionId; - policy = other1878.policy; - dumpExecutionId = other1878.dumpExecutionId; - __isset = other1878.__isset; +GetReplicationMetricsRequest::GetReplicationMetricsRequest(const GetReplicationMetricsRequest& other1888) { + scheduledExecutionId = other1888.scheduledExecutionId; + policy = other1888.policy; + dumpExecutionId = other1888.dumpExecutionId; + __isset = other1888.__isset; } -GetReplicationMetricsRequest& GetReplicationMetricsRequest::operator=(const GetReplicationMetricsRequest& other1879) { - scheduledExecutionId = other1879.scheduledExecutionId; - policy = other1879.policy; - dumpExecutionId = other1879.dumpExecutionId; - __isset = other1879.__isset; +GetReplicationMetricsRequest& GetReplicationMetricsRequest::operator=(const GetReplicationMetricsRequest& other1889) { + scheduledExecutionId = other1889.scheduledExecutionId; + policy = other1889.policy; + dumpExecutionId = other1889.dumpExecutionId; + __isset = other1889.__isset; return *this; } void GetReplicationMetricsRequest::printTo(std::ostream& out) const { @@ -52894,16 +53125,16 @@ uint32_t GetOpenTxnsRequest::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->excludeTxnTypes.clear(); - uint32_t _size1880; - ::apache::thrift::protocol::TType _etype1883; - xfer += iprot->readListBegin(_etype1883, _size1880); - this->excludeTxnTypes.resize(_size1880); - uint32_t _i1884; - for (_i1884 = 0; _i1884 < _size1880; ++_i1884) + uint32_t _size1890; + ::apache::thrift::protocol::TType _etype1893; + xfer += iprot->readListBegin(_etype1893, _size1890); + this->excludeTxnTypes.resize(_size1890); + uint32_t _i1894; + for (_i1894 = 0; _i1894 < _size1890; ++_i1894) { - int32_t ecast1885; - xfer += iprot->readI32(ecast1885); - this->excludeTxnTypes[_i1884] = static_cast(ecast1885); + int32_t ecast1895; + xfer += iprot->readI32(ecast1895); + this->excludeTxnTypes[_i1894] = static_cast(ecast1895); } xfer += iprot->readListEnd(); } @@ -52933,10 +53164,10 @@ uint32_t GetOpenTxnsRequest::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("excludeTxnTypes", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I32, static_cast(this->excludeTxnTypes.size())); - std::vector ::const_iterator _iter1886; - for (_iter1886 = this->excludeTxnTypes.begin(); _iter1886 != this->excludeTxnTypes.end(); ++_iter1886) + std::vector ::const_iterator _iter1896; + for (_iter1896 = this->excludeTxnTypes.begin(); _iter1896 != this->excludeTxnTypes.end(); ++_iter1896) { - xfer += oprot->writeI32(static_cast((*_iter1886))); + xfer += oprot->writeI32(static_cast((*_iter1896))); } xfer += oprot->writeListEnd(); } @@ -52953,13 +53184,13 @@ void swap(GetOpenTxnsRequest &a, GetOpenTxnsRequest &b) { swap(a.__isset, b.__isset); } -GetOpenTxnsRequest::GetOpenTxnsRequest(const GetOpenTxnsRequest& other1887) { - excludeTxnTypes = other1887.excludeTxnTypes; - __isset = other1887.__isset; +GetOpenTxnsRequest::GetOpenTxnsRequest(const GetOpenTxnsRequest& other1897) { + excludeTxnTypes = other1897.excludeTxnTypes; + __isset = other1897.__isset; } -GetOpenTxnsRequest& GetOpenTxnsRequest::operator=(const GetOpenTxnsRequest& other1888) { - excludeTxnTypes = other1888.excludeTxnTypes; - __isset = other1888.__isset; +GetOpenTxnsRequest& GetOpenTxnsRequest::operator=(const GetOpenTxnsRequest& other1898) { + excludeTxnTypes = other1898.excludeTxnTypes; + __isset = other1898.__isset; return *this; } void GetOpenTxnsRequest::printTo(std::ostream& out) const { @@ -53087,15 +53318,15 @@ void swap(StoredProcedureRequest &a, StoredProcedureRequest &b) { swap(a.procName, b.procName); } -StoredProcedureRequest::StoredProcedureRequest(const StoredProcedureRequest& other1889) { - catName = other1889.catName; - dbName = other1889.dbName; - procName = other1889.procName; +StoredProcedureRequest::StoredProcedureRequest(const StoredProcedureRequest& other1899) { + catName = other1899.catName; + dbName = other1899.dbName; + procName = other1899.procName; } -StoredProcedureRequest& StoredProcedureRequest::operator=(const StoredProcedureRequest& other1890) { - catName = other1890.catName; - dbName = other1890.dbName; - procName = other1890.procName; +StoredProcedureRequest& StoredProcedureRequest::operator=(const StoredProcedureRequest& other1900) { + catName = other1900.catName; + dbName = other1900.dbName; + procName = other1900.procName; return *this; } void StoredProcedureRequest::printTo(std::ostream& out) const { @@ -53205,15 +53436,15 @@ void swap(ListStoredProcedureRequest &a, ListStoredProcedureRequest &b) { swap(a.__isset, b.__isset); } -ListStoredProcedureRequest::ListStoredProcedureRequest(const ListStoredProcedureRequest& other1891) { - catName = other1891.catName; - dbName = other1891.dbName; - __isset = other1891.__isset; +ListStoredProcedureRequest::ListStoredProcedureRequest(const ListStoredProcedureRequest& other1901) { + catName = other1901.catName; + dbName = other1901.dbName; + __isset = other1901.__isset; } -ListStoredProcedureRequest& ListStoredProcedureRequest::operator=(const ListStoredProcedureRequest& other1892) { - catName = other1892.catName; - dbName = other1892.dbName; - __isset = other1892.__isset; +ListStoredProcedureRequest& ListStoredProcedureRequest::operator=(const ListStoredProcedureRequest& other1902) { + catName = other1902.catName; + dbName = other1902.dbName; + __isset = other1902.__isset; return *this; } void ListStoredProcedureRequest::printTo(std::ostream& out) const { @@ -53368,21 +53599,21 @@ void swap(StoredProcedure &a, StoredProcedure &b) { swap(a.__isset, b.__isset); } -StoredProcedure::StoredProcedure(const StoredProcedure& other1893) { - name = other1893.name; - dbName = other1893.dbName; - catName = other1893.catName; - ownerName = other1893.ownerName; - source = other1893.source; - __isset = other1893.__isset; +StoredProcedure::StoredProcedure(const StoredProcedure& other1903) { + name = other1903.name; + dbName = other1903.dbName; + catName = other1903.catName; + ownerName = other1903.ownerName; + source = other1903.source; + __isset = other1903.__isset; } -StoredProcedure& StoredProcedure::operator=(const StoredProcedure& other1894) { - name = other1894.name; - dbName = other1894.dbName; - catName = other1894.catName; - ownerName = other1894.ownerName; - source = other1894.source; - __isset = other1894.__isset; +StoredProcedure& StoredProcedure::operator=(const StoredProcedure& other1904) { + name = other1904.name; + dbName = other1904.dbName; + catName = other1904.catName; + ownerName = other1904.ownerName; + source = other1904.source; + __isset = other1904.__isset; return *this; } void StoredProcedure::printTo(std::ostream& out) const { @@ -53557,23 +53788,23 @@ void swap(AddPackageRequest &a, AddPackageRequest &b) { swap(a.__isset, b.__isset); } -AddPackageRequest::AddPackageRequest(const AddPackageRequest& other1895) { - catName = other1895.catName; - dbName = other1895.dbName; - packageName = other1895.packageName; - ownerName = other1895.ownerName; - header = other1895.header; - body = other1895.body; - __isset = other1895.__isset; +AddPackageRequest::AddPackageRequest(const AddPackageRequest& other1905) { + catName = other1905.catName; + dbName = other1905.dbName; + packageName = other1905.packageName; + ownerName = other1905.ownerName; + header = other1905.header; + body = other1905.body; + __isset = other1905.__isset; } -AddPackageRequest& AddPackageRequest::operator=(const AddPackageRequest& other1896) { - catName = other1896.catName; - dbName = other1896.dbName; - packageName = other1896.packageName; - ownerName = other1896.ownerName; - header = other1896.header; - body = other1896.body; - __isset = other1896.__isset; +AddPackageRequest& AddPackageRequest::operator=(const AddPackageRequest& other1906) { + catName = other1906.catName; + dbName = other1906.dbName; + packageName = other1906.packageName; + ownerName = other1906.ownerName; + header = other1906.header; + body = other1906.body; + __isset = other1906.__isset; return *this; } void AddPackageRequest::printTo(std::ostream& out) const { @@ -53706,15 +53937,15 @@ void swap(GetPackageRequest &a, GetPackageRequest &b) { swap(a.packageName, b.packageName); } -GetPackageRequest::GetPackageRequest(const GetPackageRequest& other1897) { - catName = other1897.catName; - dbName = other1897.dbName; - packageName = other1897.packageName; +GetPackageRequest::GetPackageRequest(const GetPackageRequest& other1907) { + catName = other1907.catName; + dbName = other1907.dbName; + packageName = other1907.packageName; } -GetPackageRequest& GetPackageRequest::operator=(const GetPackageRequest& other1898) { - catName = other1898.catName; - dbName = other1898.dbName; - packageName = other1898.packageName; +GetPackageRequest& GetPackageRequest::operator=(const GetPackageRequest& other1908) { + catName = other1908.catName; + dbName = other1908.dbName; + packageName = other1908.packageName; return *this; } void GetPackageRequest::printTo(std::ostream& out) const { @@ -53844,15 +54075,15 @@ void swap(DropPackageRequest &a, DropPackageRequest &b) { swap(a.packageName, b.packageName); } -DropPackageRequest::DropPackageRequest(const DropPackageRequest& other1899) { - catName = other1899.catName; - dbName = other1899.dbName; - packageName = other1899.packageName; +DropPackageRequest::DropPackageRequest(const DropPackageRequest& other1909) { + catName = other1909.catName; + dbName = other1909.dbName; + packageName = other1909.packageName; } -DropPackageRequest& DropPackageRequest::operator=(const DropPackageRequest& other1900) { - catName = other1900.catName; - dbName = other1900.dbName; - packageName = other1900.packageName; +DropPackageRequest& DropPackageRequest::operator=(const DropPackageRequest& other1910) { + catName = other1910.catName; + dbName = other1910.dbName; + packageName = other1910.packageName; return *this; } void DropPackageRequest::printTo(std::ostream& out) const { @@ -53962,15 +54193,15 @@ void swap(ListPackageRequest &a, ListPackageRequest &b) { swap(a.__isset, b.__isset); } -ListPackageRequest::ListPackageRequest(const ListPackageRequest& other1901) { - catName = other1901.catName; - dbName = other1901.dbName; - __isset = other1901.__isset; +ListPackageRequest::ListPackageRequest(const ListPackageRequest& other1911) { + catName = other1911.catName; + dbName = other1911.dbName; + __isset = other1911.__isset; } -ListPackageRequest& ListPackageRequest::operator=(const ListPackageRequest& other1902) { - catName = other1902.catName; - dbName = other1902.dbName; - __isset = other1902.__isset; +ListPackageRequest& ListPackageRequest::operator=(const ListPackageRequest& other1912) { + catName = other1912.catName; + dbName = other1912.dbName; + __isset = other1912.__isset; return *this; } void ListPackageRequest::printTo(std::ostream& out) const { @@ -54142,23 +54373,23 @@ void swap(Package &a, Package &b) { swap(a.__isset, b.__isset); } -Package::Package(const Package& other1903) { - catName = other1903.catName; - dbName = other1903.dbName; - packageName = other1903.packageName; - ownerName = other1903.ownerName; - header = other1903.header; - body = other1903.body; - __isset = other1903.__isset; +Package::Package(const Package& other1913) { + catName = other1913.catName; + dbName = other1913.dbName; + packageName = other1913.packageName; + ownerName = other1913.ownerName; + header = other1913.header; + body = other1913.body; + __isset = other1913.__isset; } -Package& Package::operator=(const Package& other1904) { - catName = other1904.catName; - dbName = other1904.dbName; - packageName = other1904.packageName; - ownerName = other1904.ownerName; - header = other1904.header; - body = other1904.body; - __isset = other1904.__isset; +Package& Package::operator=(const Package& other1914) { + catName = other1914.catName; + dbName = other1914.dbName; + packageName = other1914.packageName; + ownerName = other1914.ownerName; + header = other1914.header; + body = other1914.body; + __isset = other1914.__isset; return *this; } void Package::printTo(std::ostream& out) const { @@ -54290,17 +54521,17 @@ void swap(GetAllWriteEventInfoRequest &a, GetAllWriteEventInfoRequest &b) { swap(a.__isset, b.__isset); } -GetAllWriteEventInfoRequest::GetAllWriteEventInfoRequest(const GetAllWriteEventInfoRequest& other1905) { - txnId = other1905.txnId; - dbName = other1905.dbName; - tableName = other1905.tableName; - __isset = other1905.__isset; +GetAllWriteEventInfoRequest::GetAllWriteEventInfoRequest(const GetAllWriteEventInfoRequest& other1915) { + txnId = other1915.txnId; + dbName = other1915.dbName; + tableName = other1915.tableName; + __isset = other1915.__isset; } -GetAllWriteEventInfoRequest& GetAllWriteEventInfoRequest::operator=(const GetAllWriteEventInfoRequest& other1906) { - txnId = other1906.txnId; - dbName = other1906.dbName; - tableName = other1906.tableName; - __isset = other1906.__isset; +GetAllWriteEventInfoRequest& GetAllWriteEventInfoRequest::operator=(const GetAllWriteEventInfoRequest& other1916) { + txnId = other1916.txnId; + dbName = other1916.dbName; + tableName = other1916.tableName; + __isset = other1916.__isset; return *this; } void GetAllWriteEventInfoRequest::printTo(std::ostream& out) const { @@ -54407,14 +54638,14 @@ uint32_t DeleteColumnStatisticsRequest::read(::apache::thrift::protocol::TProtoc if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_names.clear(); - uint32_t _size1907; - ::apache::thrift::protocol::TType _etype1910; - xfer += iprot->readListBegin(_etype1910, _size1907); - this->part_names.resize(_size1907); - uint32_t _i1911; - for (_i1911 = 0; _i1911 < _size1907; ++_i1911) + uint32_t _size1917; + ::apache::thrift::protocol::TType _etype1920; + xfer += iprot->readListBegin(_etype1920, _size1917); + this->part_names.resize(_size1917); + uint32_t _i1921; + for (_i1921 = 0; _i1921 < _size1917; ++_i1921) { - xfer += iprot->readString(this->part_names[_i1911]); + xfer += iprot->readString(this->part_names[_i1921]); } xfer += iprot->readListEnd(); } @@ -54427,14 +54658,14 @@ uint32_t DeleteColumnStatisticsRequest::read(::apache::thrift::protocol::TProtoc if (ftype == ::apache::thrift::protocol::T_LIST) { { this->col_names.clear(); - uint32_t _size1912; - ::apache::thrift::protocol::TType _etype1915; - xfer += iprot->readListBegin(_etype1915, _size1912); - this->col_names.resize(_size1912); - uint32_t _i1916; - for (_i1916 = 0; _i1916 < _size1912; ++_i1916) + uint32_t _size1922; + ::apache::thrift::protocol::TType _etype1925; + xfer += iprot->readListBegin(_etype1925, _size1922); + this->col_names.resize(_size1922); + uint32_t _i1926; + for (_i1926 = 0; _i1926 < _size1922; ++_i1926) { - xfer += iprot->readString(this->col_names[_i1916]); + xfer += iprot->readString(this->col_names[_i1926]); } xfer += iprot->readListEnd(); } @@ -54497,10 +54728,10 @@ uint32_t DeleteColumnStatisticsRequest::write(::apache::thrift::protocol::TProto xfer += oprot->writeFieldBegin("part_names", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_names.size())); - std::vector ::const_iterator _iter1917; - for (_iter1917 = this->part_names.begin(); _iter1917 != this->part_names.end(); ++_iter1917) + std::vector ::const_iterator _iter1927; + for (_iter1927 = this->part_names.begin(); _iter1927 != this->part_names.end(); ++_iter1927) { - xfer += oprot->writeString((*_iter1917)); + xfer += oprot->writeString((*_iter1927)); } xfer += oprot->writeListEnd(); } @@ -54510,10 +54741,10 @@ uint32_t DeleteColumnStatisticsRequest::write(::apache::thrift::protocol::TProto xfer += oprot->writeFieldBegin("col_names", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->col_names.size())); - std::vector ::const_iterator _iter1918; - for (_iter1918 = this->col_names.begin(); _iter1918 != this->col_names.end(); ++_iter1918) + std::vector ::const_iterator _iter1928; + for (_iter1928 = this->col_names.begin(); _iter1928 != this->col_names.end(); ++_iter1928) { - xfer += oprot->writeString((*_iter1918)); + xfer += oprot->writeString((*_iter1928)); } xfer += oprot->writeListEnd(); } @@ -54546,25 +54777,25 @@ void swap(DeleteColumnStatisticsRequest &a, DeleteColumnStatisticsRequest &b) { swap(a.__isset, b.__isset); } -DeleteColumnStatisticsRequest::DeleteColumnStatisticsRequest(const DeleteColumnStatisticsRequest& other1919) { - cat_name = other1919.cat_name; - db_name = other1919.db_name; - tbl_name = other1919.tbl_name; - part_names = other1919.part_names; - col_names = other1919.col_names; - engine = other1919.engine; - tableLevel = other1919.tableLevel; - __isset = other1919.__isset; +DeleteColumnStatisticsRequest::DeleteColumnStatisticsRequest(const DeleteColumnStatisticsRequest& other1929) { + cat_name = other1929.cat_name; + db_name = other1929.db_name; + tbl_name = other1929.tbl_name; + part_names = other1929.part_names; + col_names = other1929.col_names; + engine = other1929.engine; + tableLevel = other1929.tableLevel; + __isset = other1929.__isset; } -DeleteColumnStatisticsRequest& DeleteColumnStatisticsRequest::operator=(const DeleteColumnStatisticsRequest& other1920) { - cat_name = other1920.cat_name; - db_name = other1920.db_name; - tbl_name = other1920.tbl_name; - part_names = other1920.part_names; - col_names = other1920.col_names; - engine = other1920.engine; - tableLevel = other1920.tableLevel; - __isset = other1920.__isset; +DeleteColumnStatisticsRequest& DeleteColumnStatisticsRequest::operator=(const DeleteColumnStatisticsRequest& other1930) { + cat_name = other1930.cat_name; + db_name = other1930.db_name; + tbl_name = other1930.tbl_name; + part_names = other1930.part_names; + col_names = other1930.col_names; + engine = other1930.engine; + tableLevel = other1930.tableLevel; + __isset = other1930.__isset; return *this; } void DeleteColumnStatisticsRequest::printTo(std::ostream& out) const { @@ -54620,17 +54851,17 @@ uint32_t ReplayedTxnsForPolicyResult::read(::apache::thrift::protocol::TProtocol if (ftype == ::apache::thrift::protocol::T_MAP) { { this->replTxnMapEntry.clear(); - uint32_t _size1921; - ::apache::thrift::protocol::TType _ktype1922; - ::apache::thrift::protocol::TType _vtype1923; - xfer += iprot->readMapBegin(_ktype1922, _vtype1923, _size1921); - uint32_t _i1925; - for (_i1925 = 0; _i1925 < _size1921; ++_i1925) + uint32_t _size1931; + ::apache::thrift::protocol::TType _ktype1932; + ::apache::thrift::protocol::TType _vtype1933; + xfer += iprot->readMapBegin(_ktype1932, _vtype1933, _size1931); + uint32_t _i1935; + for (_i1935 = 0; _i1935 < _size1931; ++_i1935) { - std::string _key1926; - xfer += iprot->readString(_key1926); - std::string& _val1927 = this->replTxnMapEntry[_key1926]; - xfer += iprot->readString(_val1927); + std::string _key1936; + xfer += iprot->readString(_key1936); + std::string& _val1937 = this->replTxnMapEntry[_key1936]; + xfer += iprot->readString(_val1937); } xfer += iprot->readMapEnd(); } @@ -54659,11 +54890,11 @@ uint32_t ReplayedTxnsForPolicyResult::write(::apache::thrift::protocol::TProtoco xfer += oprot->writeFieldBegin("replTxnMapEntry", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->replTxnMapEntry.size())); - std::map ::const_iterator _iter1928; - for (_iter1928 = this->replTxnMapEntry.begin(); _iter1928 != this->replTxnMapEntry.end(); ++_iter1928) + std::map ::const_iterator _iter1938; + for (_iter1938 = this->replTxnMapEntry.begin(); _iter1938 != this->replTxnMapEntry.end(); ++_iter1938) { - xfer += oprot->writeString(_iter1928->first); - xfer += oprot->writeString(_iter1928->second); + xfer += oprot->writeString(_iter1938->first); + xfer += oprot->writeString(_iter1938->second); } xfer += oprot->writeMapEnd(); } @@ -54680,13 +54911,13 @@ void swap(ReplayedTxnsForPolicyResult &a, ReplayedTxnsForPolicyResult &b) { swap(a.__isset, b.__isset); } -ReplayedTxnsForPolicyResult::ReplayedTxnsForPolicyResult(const ReplayedTxnsForPolicyResult& other1929) { - replTxnMapEntry = other1929.replTxnMapEntry; - __isset = other1929.__isset; +ReplayedTxnsForPolicyResult::ReplayedTxnsForPolicyResult(const ReplayedTxnsForPolicyResult& other1939) { + replTxnMapEntry = other1939.replTxnMapEntry; + __isset = other1939.__isset; } -ReplayedTxnsForPolicyResult& ReplayedTxnsForPolicyResult::operator=(const ReplayedTxnsForPolicyResult& other1930) { - replTxnMapEntry = other1930.replTxnMapEntry; - __isset = other1930.__isset; +ReplayedTxnsForPolicyResult& ReplayedTxnsForPolicyResult::operator=(const ReplayedTxnsForPolicyResult& other1940) { + replTxnMapEntry = other1940.replTxnMapEntry; + __isset = other1940.__isset; return *this; } void ReplayedTxnsForPolicyResult::printTo(std::ostream& out) const { @@ -54772,13 +55003,13 @@ void swap(MetaException &a, MetaException &b) { swap(a.__isset, b.__isset); } -MetaException::MetaException(const MetaException& other1931) : TException() { - message = other1931.message; - __isset = other1931.__isset; +MetaException::MetaException(const MetaException& other1941) : TException() { + message = other1941.message; + __isset = other1941.__isset; } -MetaException& MetaException::operator=(const MetaException& other1932) { - message = other1932.message; - __isset = other1932.__isset; +MetaException& MetaException::operator=(const MetaException& other1942) { + message = other1942.message; + __isset = other1942.__isset; return *this; } void MetaException::printTo(std::ostream& out) const { @@ -54875,13 +55106,13 @@ void swap(UnknownTableException &a, UnknownTableException &b) { swap(a.__isset, b.__isset); } -UnknownTableException::UnknownTableException(const UnknownTableException& other1933) : TException() { - message = other1933.message; - __isset = other1933.__isset; +UnknownTableException::UnknownTableException(const UnknownTableException& other1943) : TException() { + message = other1943.message; + __isset = other1943.__isset; } -UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other1934) { - message = other1934.message; - __isset = other1934.__isset; +UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other1944) { + message = other1944.message; + __isset = other1944.__isset; return *this; } void UnknownTableException::printTo(std::ostream& out) const { @@ -54978,13 +55209,13 @@ void swap(UnknownDBException &a, UnknownDBException &b) { swap(a.__isset, b.__isset); } -UnknownDBException::UnknownDBException(const UnknownDBException& other1935) : TException() { - message = other1935.message; - __isset = other1935.__isset; +UnknownDBException::UnknownDBException(const UnknownDBException& other1945) : TException() { + message = other1945.message; + __isset = other1945.__isset; } -UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other1936) { - message = other1936.message; - __isset = other1936.__isset; +UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other1946) { + message = other1946.message; + __isset = other1946.__isset; return *this; } void UnknownDBException::printTo(std::ostream& out) const { @@ -55081,13 +55312,13 @@ void swap(AlreadyExistsException &a, AlreadyExistsException &b) { swap(a.__isset, b.__isset); } -AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other1937) : TException() { - message = other1937.message; - __isset = other1937.__isset; +AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other1947) : TException() { + message = other1947.message; + __isset = other1947.__isset; } -AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other1938) { - message = other1938.message; - __isset = other1938.__isset; +AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other1948) { + message = other1948.message; + __isset = other1948.__isset; return *this; } void AlreadyExistsException::printTo(std::ostream& out) const { @@ -55184,13 +55415,13 @@ void swap(InvalidPartitionException &a, InvalidPartitionException &b) { swap(a.__isset, b.__isset); } -InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other1939) : TException() { - message = other1939.message; - __isset = other1939.__isset; +InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other1949) : TException() { + message = other1949.message; + __isset = other1949.__isset; } -InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other1940) { - message = other1940.message; - __isset = other1940.__isset; +InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other1950) { + message = other1950.message; + __isset = other1950.__isset; return *this; } void InvalidPartitionException::printTo(std::ostream& out) const { @@ -55287,13 +55518,13 @@ void swap(UnknownPartitionException &a, UnknownPartitionException &b) { swap(a.__isset, b.__isset); } -UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other1941) : TException() { - message = other1941.message; - __isset = other1941.__isset; +UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other1951) : TException() { + message = other1951.message; + __isset = other1951.__isset; } -UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other1942) { - message = other1942.message; - __isset = other1942.__isset; +UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other1952) { + message = other1952.message; + __isset = other1952.__isset; return *this; } void UnknownPartitionException::printTo(std::ostream& out) const { @@ -55390,13 +55621,13 @@ void swap(InvalidObjectException &a, InvalidObjectException &b) { swap(a.__isset, b.__isset); } -InvalidObjectException::InvalidObjectException(const InvalidObjectException& other1943) : TException() { - message = other1943.message; - __isset = other1943.__isset; +InvalidObjectException::InvalidObjectException(const InvalidObjectException& other1953) : TException() { + message = other1953.message; + __isset = other1953.__isset; } -InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other1944) { - message = other1944.message; - __isset = other1944.__isset; +InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other1954) { + message = other1954.message; + __isset = other1954.__isset; return *this; } void InvalidObjectException::printTo(std::ostream& out) const { @@ -55493,13 +55724,13 @@ void swap(NoSuchObjectException &a, NoSuchObjectException &b) { swap(a.__isset, b.__isset); } -NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other1945) : TException() { - message = other1945.message; - __isset = other1945.__isset; +NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other1955) : TException() { + message = other1955.message; + __isset = other1955.__isset; } -NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other1946) { - message = other1946.message; - __isset = other1946.__isset; +NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other1956) { + message = other1956.message; + __isset = other1956.__isset; return *this; } void NoSuchObjectException::printTo(std::ostream& out) const { @@ -55596,13 +55827,13 @@ void swap(InvalidOperationException &a, InvalidOperationException &b) { swap(a.__isset, b.__isset); } -InvalidOperationException::InvalidOperationException(const InvalidOperationException& other1947) : TException() { - message = other1947.message; - __isset = other1947.__isset; +InvalidOperationException::InvalidOperationException(const InvalidOperationException& other1957) : TException() { + message = other1957.message; + __isset = other1957.__isset; } -InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other1948) { - message = other1948.message; - __isset = other1948.__isset; +InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other1958) { + message = other1958.message; + __isset = other1958.__isset; return *this; } void InvalidOperationException::printTo(std::ostream& out) const { @@ -55699,13 +55930,13 @@ void swap(ConfigValSecurityException &a, ConfigValSecurityException &b) { swap(a.__isset, b.__isset); } -ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other1949) : TException() { - message = other1949.message; - __isset = other1949.__isset; +ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other1959) : TException() { + message = other1959.message; + __isset = other1959.__isset; } -ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other1950) { - message = other1950.message; - __isset = other1950.__isset; +ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other1960) { + message = other1960.message; + __isset = other1960.__isset; return *this; } void ConfigValSecurityException::printTo(std::ostream& out) const { @@ -55802,13 +56033,13 @@ void swap(InvalidInputException &a, InvalidInputException &b) { swap(a.__isset, b.__isset); } -InvalidInputException::InvalidInputException(const InvalidInputException& other1951) : TException() { - message = other1951.message; - __isset = other1951.__isset; +InvalidInputException::InvalidInputException(const InvalidInputException& other1961) : TException() { + message = other1961.message; + __isset = other1961.__isset; } -InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other1952) { - message = other1952.message; - __isset = other1952.__isset; +InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other1962) { + message = other1962.message; + __isset = other1962.__isset; return *this; } void InvalidInputException::printTo(std::ostream& out) const { @@ -55905,13 +56136,13 @@ void swap(NoSuchTxnException &a, NoSuchTxnException &b) { swap(a.__isset, b.__isset); } -NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other1953) : TException() { - message = other1953.message; - __isset = other1953.__isset; +NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other1963) : TException() { + message = other1963.message; + __isset = other1963.__isset; } -NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other1954) { - message = other1954.message; - __isset = other1954.__isset; +NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other1964) { + message = other1964.message; + __isset = other1964.__isset; return *this; } void NoSuchTxnException::printTo(std::ostream& out) const { @@ -56008,13 +56239,13 @@ void swap(TxnAbortedException &a, TxnAbortedException &b) { swap(a.__isset, b.__isset); } -TxnAbortedException::TxnAbortedException(const TxnAbortedException& other1955) : TException() { - message = other1955.message; - __isset = other1955.__isset; +TxnAbortedException::TxnAbortedException(const TxnAbortedException& other1965) : TException() { + message = other1965.message; + __isset = other1965.__isset; } -TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other1956) { - message = other1956.message; - __isset = other1956.__isset; +TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other1966) { + message = other1966.message; + __isset = other1966.__isset; return *this; } void TxnAbortedException::printTo(std::ostream& out) const { @@ -56111,13 +56342,13 @@ void swap(TxnOpenException &a, TxnOpenException &b) { swap(a.__isset, b.__isset); } -TxnOpenException::TxnOpenException(const TxnOpenException& other1957) : TException() { - message = other1957.message; - __isset = other1957.__isset; +TxnOpenException::TxnOpenException(const TxnOpenException& other1967) : TException() { + message = other1967.message; + __isset = other1967.__isset; } -TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other1958) { - message = other1958.message; - __isset = other1958.__isset; +TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other1968) { + message = other1968.message; + __isset = other1968.__isset; return *this; } void TxnOpenException::printTo(std::ostream& out) const { @@ -56214,13 +56445,13 @@ void swap(NoSuchLockException &a, NoSuchLockException &b) { swap(a.__isset, b.__isset); } -NoSuchLockException::NoSuchLockException(const NoSuchLockException& other1959) : TException() { - message = other1959.message; - __isset = other1959.__isset; +NoSuchLockException::NoSuchLockException(const NoSuchLockException& other1969) : TException() { + message = other1969.message; + __isset = other1969.__isset; } -NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other1960) { - message = other1960.message; - __isset = other1960.__isset; +NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other1970) { + message = other1970.message; + __isset = other1970.__isset; return *this; } void NoSuchLockException::printTo(std::ostream& out) const { @@ -56317,13 +56548,13 @@ void swap(CompactionAbortedException &a, CompactionAbortedException &b) { swap(a.__isset, b.__isset); } -CompactionAbortedException::CompactionAbortedException(const CompactionAbortedException& other1961) : TException() { - message = other1961.message; - __isset = other1961.__isset; +CompactionAbortedException::CompactionAbortedException(const CompactionAbortedException& other1971) : TException() { + message = other1971.message; + __isset = other1971.__isset; } -CompactionAbortedException& CompactionAbortedException::operator=(const CompactionAbortedException& other1962) { - message = other1962.message; - __isset = other1962.__isset; +CompactionAbortedException& CompactionAbortedException::operator=(const CompactionAbortedException& other1972) { + message = other1972.message; + __isset = other1972.__isset; return *this; } void CompactionAbortedException::printTo(std::ostream& out) const { @@ -56420,13 +56651,13 @@ void swap(NoSuchCompactionException &a, NoSuchCompactionException &b) { swap(a.__isset, b.__isset); } -NoSuchCompactionException::NoSuchCompactionException(const NoSuchCompactionException& other1963) : TException() { - message = other1963.message; - __isset = other1963.__isset; +NoSuchCompactionException::NoSuchCompactionException(const NoSuchCompactionException& other1973) : TException() { + message = other1973.message; + __isset = other1973.__isset; } -NoSuchCompactionException& NoSuchCompactionException::operator=(const NoSuchCompactionException& other1964) { - message = other1964.message; - __isset = other1964.__isset; +NoSuchCompactionException& NoSuchCompactionException::operator=(const NoSuchCompactionException& other1974) { + message = other1974.message; + __isset = other1974.__isset; return *this; } void NoSuchCompactionException::printTo(std::ostream& out) const { diff --git a/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/hive_metastore_types.h b/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/hive_metastore_types.h index 33446e3f22d3..803ea0d96712 100644 --- a/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/hive_metastore_types.h +++ b/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/hive_metastore_types.h @@ -1012,6 +1012,8 @@ class AlterTableRequest; class AlterTableResponse; +class TableParamsUpdate; + class GetPartitionsFilterSpec; class GetPartitionsResponse; @@ -19418,6 +19420,86 @@ void swap(AlterTableResponse &a, AlterTableResponse &b); std::ostream& operator<<(std::ostream& out, const AlterTableResponse& obj); +typedef struct _TableParamsUpdate__isset { + _TableParamsUpdate__isset() : cat_name(false), expected_param_key(false), expected_param_value(false) {} + bool cat_name :1; + bool expected_param_key :1; + bool expected_param_value :1; +} _TableParamsUpdate__isset; + +class TableParamsUpdate : public virtual ::apache::thrift::TBase { + public: + + TableParamsUpdate(const TableParamsUpdate&); + TableParamsUpdate& operator=(const TableParamsUpdate&); + TableParamsUpdate() noexcept + : cat_name(), + db_name(), + table_name(), + expected_param_key(), + expected_param_value() { + } + + virtual ~TableParamsUpdate() noexcept; + std::string cat_name; + std::string db_name; + std::string table_name; + std::map params; + std::string expected_param_key; + std::string expected_param_value; + + _TableParamsUpdate__isset __isset; + + void __set_cat_name(const std::string& val); + + void __set_db_name(const std::string& val); + + void __set_table_name(const std::string& val); + + void __set_params(const std::map & val); + + void __set_expected_param_key(const std::string& val); + + void __set_expected_param_value(const std::string& val); + + bool operator == (const TableParamsUpdate & rhs) const + { + if (__isset.cat_name != rhs.__isset.cat_name) + return false; + else if (__isset.cat_name && !(cat_name == rhs.cat_name)) + return false; + if (!(db_name == rhs.db_name)) + return false; + if (!(table_name == rhs.table_name)) + return false; + if (!(params == rhs.params)) + return false; + if (__isset.expected_param_key != rhs.__isset.expected_param_key) + return false; + else if (__isset.expected_param_key && !(expected_param_key == rhs.expected_param_key)) + return false; + if (__isset.expected_param_value != rhs.__isset.expected_param_value) + return false; + else if (__isset.expected_param_value && !(expected_param_value == rhs.expected_param_value)) + return false; + return true; + } + bool operator != (const TableParamsUpdate &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TableParamsUpdate & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TableParamsUpdate &a, TableParamsUpdate &b); + +std::ostream& operator<<(std::ostream& out, const TableParamsUpdate& obj); + typedef struct _GetPartitionsFilterSpec__isset { _GetPartitionsFilterSpec__isset() : filterMode(false), filters(false) {} bool filterMode :1; diff --git a/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/DeleteColumnStatisticsRequest.java b/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/DeleteColumnStatisticsRequest.java index 6966d4610457..3d525da424bb 100644 --- a/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/DeleteColumnStatisticsRequest.java +++ b/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/DeleteColumnStatisticsRequest.java @@ -862,13 +862,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, DeleteColumnStatist case 4: // PART_NAMES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1610 = iprot.readListBegin(); - struct.part_names = new java.util.ArrayList(_list1610.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1611; - for (int _i1612 = 0; _i1612 < _list1610.size; ++_i1612) + org.apache.thrift.protocol.TList _list1620 = iprot.readListBegin(); + struct.part_names = new java.util.ArrayList(_list1620.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1621; + for (int _i1622 = 0; _i1622 < _list1620.size; ++_i1622) { - _elem1611 = iprot.readString(); - struct.part_names.add(_elem1611); + _elem1621 = iprot.readString(); + struct.part_names.add(_elem1621); } iprot.readListEnd(); } @@ -880,13 +880,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, DeleteColumnStatist case 5: // COL_NAMES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1613 = iprot.readListBegin(); - struct.col_names = new java.util.ArrayList(_list1613.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1614; - for (int _i1615 = 0; _i1615 < _list1613.size; ++_i1615) + org.apache.thrift.protocol.TList _list1623 = iprot.readListBegin(); + struct.col_names = new java.util.ArrayList(_list1623.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1624; + for (int _i1625 = 0; _i1625 < _list1623.size; ++_i1625) { - _elem1614 = iprot.readString(); - struct.col_names.add(_elem1614); + _elem1624 = iprot.readString(); + struct.col_names.add(_elem1624); } iprot.readListEnd(); } @@ -946,9 +946,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, DeleteColumnStatis oprot.writeFieldBegin(PART_NAMES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.part_names.size())); - for (java.lang.String _iter1616 : struct.part_names) + for (java.lang.String _iter1626 : struct.part_names) { - oprot.writeString(_iter1616); + oprot.writeString(_iter1626); } oprot.writeListEnd(); } @@ -960,9 +960,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, DeleteColumnStatis oprot.writeFieldBegin(COL_NAMES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.col_names.size())); - for (java.lang.String _iter1617 : struct.col_names) + for (java.lang.String _iter1627 : struct.col_names) { - oprot.writeString(_iter1617); + oprot.writeString(_iter1627); } oprot.writeListEnd(); } @@ -1023,18 +1023,18 @@ public void write(org.apache.thrift.protocol.TProtocol prot, DeleteColumnStatist if (struct.isSetPart_names()) { { oprot.writeI32(struct.part_names.size()); - for (java.lang.String _iter1618 : struct.part_names) + for (java.lang.String _iter1628 : struct.part_names) { - oprot.writeString(_iter1618); + oprot.writeString(_iter1628); } } } if (struct.isSetCol_names()) { { oprot.writeI32(struct.col_names.size()); - for (java.lang.String _iter1619 : struct.col_names) + for (java.lang.String _iter1629 : struct.col_names) { - oprot.writeString(_iter1619); + oprot.writeString(_iter1629); } } } @@ -1060,26 +1060,26 @@ public void read(org.apache.thrift.protocol.TProtocol prot, DeleteColumnStatisti } if (incoming.get(1)) { { - org.apache.thrift.protocol.TList _list1620 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.part_names = new java.util.ArrayList(_list1620.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1621; - for (int _i1622 = 0; _i1622 < _list1620.size; ++_i1622) + org.apache.thrift.protocol.TList _list1630 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.part_names = new java.util.ArrayList(_list1630.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1631; + for (int _i1632 = 0; _i1632 < _list1630.size; ++_i1632) { - _elem1621 = iprot.readString(); - struct.part_names.add(_elem1621); + _elem1631 = iprot.readString(); + struct.part_names.add(_elem1631); } } struct.setPart_namesIsSet(true); } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list1623 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.col_names = new java.util.ArrayList(_list1623.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1624; - for (int _i1625 = 0; _i1625 < _list1623.size; ++_i1625) + org.apache.thrift.protocol.TList _list1633 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.col_names = new java.util.ArrayList(_list1633.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1634; + for (int _i1635 = 0; _i1635 < _list1633.size; ++_i1635) { - _elem1624 = iprot.readString(); - struct.col_names.add(_elem1624); + _elem1634 = iprot.readString(); + struct.col_names.add(_elem1634); } } struct.setCol_namesIsSet(true); diff --git a/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetFieldsResponse.java b/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetFieldsResponse.java index 37540b7c46b6..fac3a01da634 100644 --- a/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetFieldsResponse.java +++ b/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetFieldsResponse.java @@ -329,14 +329,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, GetFieldsResponse s case 1: // FIELDS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1514 = iprot.readListBegin(); - struct.fields = new java.util.ArrayList(_list1514.size); - @org.apache.thrift.annotation.Nullable FieldSchema _elem1515; - for (int _i1516 = 0; _i1516 < _list1514.size; ++_i1516) + org.apache.thrift.protocol.TList _list1524 = iprot.readListBegin(); + struct.fields = new java.util.ArrayList(_list1524.size); + @org.apache.thrift.annotation.Nullable FieldSchema _elem1525; + for (int _i1526 = 0; _i1526 < _list1524.size; ++_i1526) { - _elem1515 = new FieldSchema(); - _elem1515.read(iprot); - struct.fields.add(_elem1515); + _elem1525 = new FieldSchema(); + _elem1525.read(iprot); + struct.fields.add(_elem1525); } iprot.readListEnd(); } @@ -362,9 +362,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, GetFieldsResponse oprot.writeFieldBegin(FIELDS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.fields.size())); - for (FieldSchema _iter1517 : struct.fields) + for (FieldSchema _iter1527 : struct.fields) { - _iter1517.write(oprot); + _iter1527.write(oprot); } oprot.writeListEnd(); } @@ -389,9 +389,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, GetFieldsResponse s org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot; { oprot.writeI32(struct.fields.size()); - for (FieldSchema _iter1518 : struct.fields) + for (FieldSchema _iter1528 : struct.fields) { - _iter1518.write(oprot); + _iter1528.write(oprot); } } } @@ -400,14 +400,14 @@ public void write(org.apache.thrift.protocol.TProtocol prot, GetFieldsResponse s public void read(org.apache.thrift.protocol.TProtocol prot, GetFieldsResponse struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot; { - org.apache.thrift.protocol.TList _list1519 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.fields = new java.util.ArrayList(_list1519.size); - @org.apache.thrift.annotation.Nullable FieldSchema _elem1520; - for (int _i1521 = 0; _i1521 < _list1519.size; ++_i1521) + org.apache.thrift.protocol.TList _list1529 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.fields = new java.util.ArrayList(_list1529.size); + @org.apache.thrift.annotation.Nullable FieldSchema _elem1530; + for (int _i1531 = 0; _i1531 < _list1529.size; ++_i1531) { - _elem1520 = new FieldSchema(); - _elem1520.read(iprot); - struct.fields.add(_elem1520); + _elem1530 = new FieldSchema(); + _elem1530.read(iprot); + struct.fields.add(_elem1530); } } struct.setFieldsIsSet(true); diff --git a/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetOpenTxnsRequest.java b/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetOpenTxnsRequest.java index 59dbaddf83f9..a0b39c375007 100644 --- a/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetOpenTxnsRequest.java +++ b/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetOpenTxnsRequest.java @@ -321,15 +321,15 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, GetOpenTxnsRequest case 1: // EXCLUDE_TXN_TYPES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1602 = iprot.readListBegin(); - struct.excludeTxnTypes = new java.util.ArrayList(_list1602.size); - @org.apache.thrift.annotation.Nullable TxnType _elem1603; - for (int _i1604 = 0; _i1604 < _list1602.size; ++_i1604) + org.apache.thrift.protocol.TList _list1612 = iprot.readListBegin(); + struct.excludeTxnTypes = new java.util.ArrayList(_list1612.size); + @org.apache.thrift.annotation.Nullable TxnType _elem1613; + for (int _i1614 = 0; _i1614 < _list1612.size; ++_i1614) { - _elem1603 = org.apache.hadoop.hive.metastore.api.TxnType.findByValue(iprot.readI32()); - if (_elem1603 != null) + _elem1613 = org.apache.hadoop.hive.metastore.api.TxnType.findByValue(iprot.readI32()); + if (_elem1613 != null) { - struct.excludeTxnTypes.add(_elem1603); + struct.excludeTxnTypes.add(_elem1613); } } iprot.readListEnd(); @@ -357,9 +357,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, GetOpenTxnsRequest oprot.writeFieldBegin(EXCLUDE_TXN_TYPES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, struct.excludeTxnTypes.size())); - for (TxnType _iter1605 : struct.excludeTxnTypes) + for (TxnType _iter1615 : struct.excludeTxnTypes) { - oprot.writeI32(_iter1605.getValue()); + oprot.writeI32(_iter1615.getValue()); } oprot.writeListEnd(); } @@ -391,9 +391,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, GetOpenTxnsRequest if (struct.isSetExcludeTxnTypes()) { { oprot.writeI32(struct.excludeTxnTypes.size()); - for (TxnType _iter1606 : struct.excludeTxnTypes) + for (TxnType _iter1616 : struct.excludeTxnTypes) { - oprot.writeI32(_iter1606.getValue()); + oprot.writeI32(_iter1616.getValue()); } } } @@ -405,15 +405,15 @@ public void read(org.apache.thrift.protocol.TProtocol prot, GetOpenTxnsRequest s java.util.BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1607 = iprot.readListBegin(org.apache.thrift.protocol.TType.I32); - struct.excludeTxnTypes = new java.util.ArrayList(_list1607.size); - @org.apache.thrift.annotation.Nullable TxnType _elem1608; - for (int _i1609 = 0; _i1609 < _list1607.size; ++_i1609) + org.apache.thrift.protocol.TList _list1617 = iprot.readListBegin(org.apache.thrift.protocol.TType.I32); + struct.excludeTxnTypes = new java.util.ArrayList(_list1617.size); + @org.apache.thrift.annotation.Nullable TxnType _elem1618; + for (int _i1619 = 0; _i1619 < _list1617.size; ++_i1619) { - _elem1608 = org.apache.hadoop.hive.metastore.api.TxnType.findByValue(iprot.readI32()); - if (_elem1608 != null) + _elem1618 = org.apache.hadoop.hive.metastore.api.TxnType.findByValue(iprot.readI32()); + if (_elem1618 != null) { - struct.excludeTxnTypes.add(_elem1608); + struct.excludeTxnTypes.add(_elem1618); } } } diff --git a/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetPartitionNamesPsRequest.java b/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetPartitionNamesPsRequest.java index e9c8020ff97f..6b2c7728f214 100644 --- a/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetPartitionNamesPsRequest.java +++ b/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetPartitionNamesPsRequest.java @@ -837,13 +837,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, GetPartitionNamesPs case 4: // PART_VALUES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1546 = iprot.readListBegin(); - struct.partValues = new java.util.ArrayList(_list1546.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1547; - for (int _i1548 = 0; _i1548 < _list1546.size; ++_i1548) + org.apache.thrift.protocol.TList _list1556 = iprot.readListBegin(); + struct.partValues = new java.util.ArrayList(_list1556.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1557; + for (int _i1558 = 0; _i1558 < _list1556.size; ++_i1558) { - _elem1547 = iprot.readString(); - struct.partValues.add(_elem1547); + _elem1557 = iprot.readString(); + struct.partValues.add(_elem1557); } iprot.readListEnd(); } @@ -911,9 +911,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, GetPartitionNamesP oprot.writeFieldBegin(PART_VALUES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.partValues.size())); - for (java.lang.String _iter1549 : struct.partValues) + for (java.lang.String _iter1559 : struct.partValues) { - oprot.writeString(_iter1549); + oprot.writeString(_iter1559); } oprot.writeListEnd(); } @@ -979,9 +979,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, GetPartitionNamesPs if (struct.isSetPartValues()) { { oprot.writeI32(struct.partValues.size()); - for (java.lang.String _iter1550 : struct.partValues) + for (java.lang.String _iter1560 : struct.partValues) { - oprot.writeString(_iter1550); + oprot.writeString(_iter1560); } } } @@ -1010,13 +1010,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, GetPartitionNamesPsR } if (incoming.get(1)) { { - org.apache.thrift.protocol.TList _list1551 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.partValues = new java.util.ArrayList(_list1551.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1552; - for (int _i1553 = 0; _i1553 < _list1551.size; ++_i1553) + org.apache.thrift.protocol.TList _list1561 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.partValues = new java.util.ArrayList(_list1561.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1562; + for (int _i1563 = 0; _i1563 < _list1561.size; ++_i1563) { - _elem1552 = iprot.readString(); - struct.partValues.add(_elem1552); + _elem1562 = iprot.readString(); + struct.partValues.add(_elem1562); } } struct.setPartValuesIsSet(true); diff --git a/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetPartitionNamesPsResponse.java b/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetPartitionNamesPsResponse.java index 332937b5f54a..daf65d2c12ef 100644 --- a/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetPartitionNamesPsResponse.java +++ b/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetPartitionNamesPsResponse.java @@ -326,13 +326,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, GetPartitionNamesPs case 1: // NAMES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1554 = iprot.readListBegin(); - struct.names = new java.util.ArrayList(_list1554.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1555; - for (int _i1556 = 0; _i1556 < _list1554.size; ++_i1556) + org.apache.thrift.protocol.TList _list1564 = iprot.readListBegin(); + struct.names = new java.util.ArrayList(_list1564.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1565; + for (int _i1566 = 0; _i1566 < _list1564.size; ++_i1566) { - _elem1555 = iprot.readString(); - struct.names.add(_elem1555); + _elem1565 = iprot.readString(); + struct.names.add(_elem1565); } iprot.readListEnd(); } @@ -358,9 +358,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, GetPartitionNamesP oprot.writeFieldBegin(NAMES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.names.size())); - for (java.lang.String _iter1557 : struct.names) + for (java.lang.String _iter1567 : struct.names) { - oprot.writeString(_iter1557); + oprot.writeString(_iter1567); } oprot.writeListEnd(); } @@ -385,9 +385,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, GetPartitionNamesPs org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot; { oprot.writeI32(struct.names.size()); - for (java.lang.String _iter1558 : struct.names) + for (java.lang.String _iter1568 : struct.names) { - oprot.writeString(_iter1558); + oprot.writeString(_iter1568); } } } @@ -396,13 +396,13 @@ public void write(org.apache.thrift.protocol.TProtocol prot, GetPartitionNamesPs public void read(org.apache.thrift.protocol.TProtocol prot, GetPartitionNamesPsResponse struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot; { - org.apache.thrift.protocol.TList _list1559 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.names = new java.util.ArrayList(_list1559.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1560; - for (int _i1561 = 0; _i1561 < _list1559.size; ++_i1561) + org.apache.thrift.protocol.TList _list1569 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.names = new java.util.ArrayList(_list1569.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1570; + for (int _i1571 = 0; _i1571 < _list1569.size; ++_i1571) { - _elem1560 = iprot.readString(); - struct.names.add(_elem1560); + _elem1570 = iprot.readString(); + struct.names.add(_elem1570); } } struct.setNamesIsSet(true); diff --git a/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetPartitionRequest.java b/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetPartitionRequest.java index 61e7ed74ed23..0b3047f0cfc5 100644 --- a/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetPartitionRequest.java +++ b/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetPartitionRequest.java @@ -764,13 +764,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, GetPartitionRequest case 4: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1530 = iprot.readListBegin(); - struct.partVals = new java.util.ArrayList(_list1530.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1531; - for (int _i1532 = 0; _i1532 < _list1530.size; ++_i1532) + org.apache.thrift.protocol.TList _list1540 = iprot.readListBegin(); + struct.partVals = new java.util.ArrayList(_list1540.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1541; + for (int _i1542 = 0; _i1542 < _list1540.size; ++_i1542) { - _elem1531 = iprot.readString(); - struct.partVals.add(_elem1531); + _elem1541 = iprot.readString(); + struct.partVals.add(_elem1541); } iprot.readListEnd(); } @@ -829,9 +829,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, GetPartitionReques oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.partVals.size())); - for (java.lang.String _iter1533 : struct.partVals) + for (java.lang.String _iter1543 : struct.partVals) { - oprot.writeString(_iter1533); + oprot.writeString(_iter1543); } oprot.writeListEnd(); } @@ -870,9 +870,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, GetPartitionRequest oprot.writeString(struct.tblName); { oprot.writeI32(struct.partVals.size()); - for (java.lang.String _iter1534 : struct.partVals) + for (java.lang.String _iter1544 : struct.partVals) { - oprot.writeString(_iter1534); + oprot.writeString(_iter1544); } } java.util.BitSet optionals = new java.util.BitSet(); @@ -905,13 +905,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, GetPartitionRequest struct.tblName = iprot.readString(); struct.setTblNameIsSet(true); { - org.apache.thrift.protocol.TList _list1535 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.partVals = new java.util.ArrayList(_list1535.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1536; - for (int _i1537 = 0; _i1537 < _list1535.size; ++_i1537) + org.apache.thrift.protocol.TList _list1545 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.partVals = new java.util.ArrayList(_list1545.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1546; + for (int _i1547 = 0; _i1547 < _list1545.size; ++_i1547) { - _elem1536 = iprot.readString(); - struct.partVals.add(_elem1536); + _elem1546 = iprot.readString(); + struct.partVals.add(_elem1546); } } struct.setPartValsIsSet(true); diff --git a/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetPartitionsFilterSpec.java b/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetPartitionsFilterSpec.java index 8538c034ac1e..7d4b749a566e 100644 --- a/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetPartitionsFilterSpec.java +++ b/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetPartitionsFilterSpec.java @@ -419,13 +419,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, GetPartitionsFilter case 8: // FILTERS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1482 = iprot.readListBegin(); - struct.filters = new java.util.ArrayList(_list1482.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1483; - for (int _i1484 = 0; _i1484 < _list1482.size; ++_i1484) + org.apache.thrift.protocol.TList _list1492 = iprot.readListBegin(); + struct.filters = new java.util.ArrayList(_list1492.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1493; + for (int _i1494 = 0; _i1494 < _list1492.size; ++_i1494) { - _elem1483 = iprot.readString(); - struct.filters.add(_elem1483); + _elem1493 = iprot.readString(); + struct.filters.add(_elem1493); } iprot.readListEnd(); } @@ -459,9 +459,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, GetPartitionsFilte oprot.writeFieldBegin(FILTERS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.filters.size())); - for (java.lang.String _iter1485 : struct.filters) + for (java.lang.String _iter1495 : struct.filters) { - oprot.writeString(_iter1485); + oprot.writeString(_iter1495); } oprot.writeListEnd(); } @@ -499,9 +499,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, GetPartitionsFilter if (struct.isSetFilters()) { { oprot.writeI32(struct.filters.size()); - for (java.lang.String _iter1486 : struct.filters) + for (java.lang.String _iter1496 : struct.filters) { - oprot.writeString(_iter1486); + oprot.writeString(_iter1496); } } } @@ -517,13 +517,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, GetPartitionsFilterS } if (incoming.get(1)) { { - org.apache.thrift.protocol.TList _list1487 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.filters = new java.util.ArrayList(_list1487.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1488; - for (int _i1489 = 0; _i1489 < _list1487.size; ++_i1489) + org.apache.thrift.protocol.TList _list1497 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.filters = new java.util.ArrayList(_list1497.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1498; + for (int _i1499 = 0; _i1499 < _list1497.size; ++_i1499) { - _elem1488 = iprot.readString(); - struct.filters.add(_elem1488); + _elem1498 = iprot.readString(); + struct.filters.add(_elem1498); } } struct.setFiltersIsSet(true); diff --git a/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetPartitionsPsWithAuthRequest.java b/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetPartitionsPsWithAuthRequest.java index f5040c73bf8f..97dadd66aed8 100644 --- a/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetPartitionsPsWithAuthRequest.java +++ b/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetPartitionsPsWithAuthRequest.java @@ -1353,13 +1353,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, GetPartitionsPsWith case 4: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1562 = iprot.readListBegin(); - struct.partVals = new java.util.ArrayList(_list1562.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1563; - for (int _i1564 = 0; _i1564 < _list1562.size; ++_i1564) + org.apache.thrift.protocol.TList _list1572 = iprot.readListBegin(); + struct.partVals = new java.util.ArrayList(_list1572.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1573; + for (int _i1574 = 0; _i1574 < _list1572.size; ++_i1574) { - _elem1563 = iprot.readString(); - struct.partVals.add(_elem1563); + _elem1573 = iprot.readString(); + struct.partVals.add(_elem1573); } iprot.readListEnd(); } @@ -1387,13 +1387,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, GetPartitionsPsWith case 7: // GROUP_NAMES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1565 = iprot.readListBegin(); - struct.groupNames = new java.util.ArrayList(_list1565.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1566; - for (int _i1567 = 0; _i1567 < _list1565.size; ++_i1567) + org.apache.thrift.protocol.TList _list1575 = iprot.readListBegin(); + struct.groupNames = new java.util.ArrayList(_list1575.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1576; + for (int _i1577 = 0; _i1577 < _list1575.size; ++_i1577) { - _elem1566 = iprot.readString(); - struct.groupNames.add(_elem1566); + _elem1576 = iprot.readString(); + struct.groupNames.add(_elem1576); } iprot.readListEnd(); } @@ -1445,13 +1445,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, GetPartitionsPsWith case 13: // PART_NAMES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1568 = iprot.readListBegin(); - struct.partNames = new java.util.ArrayList(_list1568.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1569; - for (int _i1570 = 0; _i1570 < _list1568.size; ++_i1570) + org.apache.thrift.protocol.TList _list1578 = iprot.readListBegin(); + struct.partNames = new java.util.ArrayList(_list1578.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1579; + for (int _i1580 = 0; _i1580 < _list1578.size; ++_i1580) { - _elem1569 = iprot.readString(); - struct.partNames.add(_elem1569); + _elem1579 = iprot.readString(); + struct.partNames.add(_elem1579); } iprot.readListEnd(); } @@ -1495,9 +1495,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, GetPartitionsPsWit oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.partVals.size())); - for (java.lang.String _iter1571 : struct.partVals) + for (java.lang.String _iter1581 : struct.partVals) { - oprot.writeString(_iter1571); + oprot.writeString(_iter1581); } oprot.writeListEnd(); } @@ -1521,9 +1521,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, GetPartitionsPsWit oprot.writeFieldBegin(GROUP_NAMES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.groupNames.size())); - for (java.lang.String _iter1572 : struct.groupNames) + for (java.lang.String _iter1582 : struct.groupNames) { - oprot.writeString(_iter1572); + oprot.writeString(_iter1582); } oprot.writeListEnd(); } @@ -1566,9 +1566,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, GetPartitionsPsWit oprot.writeFieldBegin(PART_NAMES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.partNames.size())); - for (java.lang.String _iter1573 : struct.partNames) + for (java.lang.String _iter1583 : struct.partNames) { - oprot.writeString(_iter1573); + oprot.writeString(_iter1583); } oprot.writeListEnd(); } @@ -1635,9 +1635,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, GetPartitionsPsWith if (struct.isSetPartVals()) { { oprot.writeI32(struct.partVals.size()); - for (java.lang.String _iter1574 : struct.partVals) + for (java.lang.String _iter1584 : struct.partVals) { - oprot.writeString(_iter1574); + oprot.writeString(_iter1584); } } } @@ -1650,9 +1650,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, GetPartitionsPsWith if (struct.isSetGroupNames()) { { oprot.writeI32(struct.groupNames.size()); - for (java.lang.String _iter1575 : struct.groupNames) + for (java.lang.String _iter1585 : struct.groupNames) { - oprot.writeString(_iter1575); + oprot.writeString(_iter1585); } } } @@ -1674,9 +1674,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, GetPartitionsPsWith if (struct.isSetPartNames()) { { oprot.writeI32(struct.partNames.size()); - for (java.lang.String _iter1576 : struct.partNames) + for (java.lang.String _iter1586 : struct.partNames) { - oprot.writeString(_iter1576); + oprot.writeString(_iter1586); } } } @@ -1696,13 +1696,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, GetPartitionsPsWithA } if (incoming.get(1)) { { - org.apache.thrift.protocol.TList _list1577 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.partVals = new java.util.ArrayList(_list1577.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1578; - for (int _i1579 = 0; _i1579 < _list1577.size; ++_i1579) + org.apache.thrift.protocol.TList _list1587 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.partVals = new java.util.ArrayList(_list1587.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1588; + for (int _i1589 = 0; _i1589 < _list1587.size; ++_i1589) { - _elem1578 = iprot.readString(); - struct.partVals.add(_elem1578); + _elem1588 = iprot.readString(); + struct.partVals.add(_elem1588); } } struct.setPartValsIsSet(true); @@ -1717,13 +1717,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, GetPartitionsPsWithA } if (incoming.get(4)) { { - org.apache.thrift.protocol.TList _list1580 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.groupNames = new java.util.ArrayList(_list1580.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1581; - for (int _i1582 = 0; _i1582 < _list1580.size; ++_i1582) + org.apache.thrift.protocol.TList _list1590 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.groupNames = new java.util.ArrayList(_list1590.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1591; + for (int _i1592 = 0; _i1592 < _list1590.size; ++_i1592) { - _elem1581 = iprot.readString(); - struct.groupNames.add(_elem1581); + _elem1591 = iprot.readString(); + struct.groupNames.add(_elem1591); } } struct.setGroupNamesIsSet(true); @@ -1750,13 +1750,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, GetPartitionsPsWithA } if (incoming.get(10)) { { - org.apache.thrift.protocol.TList _list1583 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.partNames = new java.util.ArrayList(_list1583.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1584; - for (int _i1585 = 0; _i1585 < _list1583.size; ++_i1585) + org.apache.thrift.protocol.TList _list1593 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.partNames = new java.util.ArrayList(_list1593.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1594; + for (int _i1595 = 0; _i1595 < _list1593.size; ++_i1595) { - _elem1584 = iprot.readString(); - struct.partNames.add(_elem1584); + _elem1594 = iprot.readString(); + struct.partNames.add(_elem1594); } } struct.setPartNamesIsSet(true); diff --git a/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetPartitionsPsWithAuthResponse.java b/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetPartitionsPsWithAuthResponse.java index f5b250c9745b..0901ec7cc17d 100644 --- a/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetPartitionsPsWithAuthResponse.java +++ b/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetPartitionsPsWithAuthResponse.java @@ -329,14 +329,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, GetPartitionsPsWith case 1: // PARTITIONS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1586 = iprot.readListBegin(); - struct.partitions = new java.util.ArrayList(_list1586.size); - @org.apache.thrift.annotation.Nullable Partition _elem1587; - for (int _i1588 = 0; _i1588 < _list1586.size; ++_i1588) + org.apache.thrift.protocol.TList _list1596 = iprot.readListBegin(); + struct.partitions = new java.util.ArrayList(_list1596.size); + @org.apache.thrift.annotation.Nullable Partition _elem1597; + for (int _i1598 = 0; _i1598 < _list1596.size; ++_i1598) { - _elem1587 = new Partition(); - _elem1587.read(iprot); - struct.partitions.add(_elem1587); + _elem1597 = new Partition(); + _elem1597.read(iprot); + struct.partitions.add(_elem1597); } iprot.readListEnd(); } @@ -362,9 +362,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, GetPartitionsPsWit oprot.writeFieldBegin(PARTITIONS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.partitions.size())); - for (Partition _iter1589 : struct.partitions) + for (Partition _iter1599 : struct.partitions) { - _iter1589.write(oprot); + _iter1599.write(oprot); } oprot.writeListEnd(); } @@ -389,9 +389,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, GetPartitionsPsWith org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot; { oprot.writeI32(struct.partitions.size()); - for (Partition _iter1590 : struct.partitions) + for (Partition _iter1600 : struct.partitions) { - _iter1590.write(oprot); + _iter1600.write(oprot); } } } @@ -400,14 +400,14 @@ public void write(org.apache.thrift.protocol.TProtocol prot, GetPartitionsPsWith public void read(org.apache.thrift.protocol.TProtocol prot, GetPartitionsPsWithAuthResponse struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot; { - org.apache.thrift.protocol.TList _list1591 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.partitions = new java.util.ArrayList(_list1591.size); - @org.apache.thrift.annotation.Nullable Partition _elem1592; - for (int _i1593 = 0; _i1593 < _list1591.size; ++_i1593) + org.apache.thrift.protocol.TList _list1601 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.partitions = new java.util.ArrayList(_list1601.size); + @org.apache.thrift.annotation.Nullable Partition _elem1602; + for (int _i1603 = 0; _i1603 < _list1601.size; ++_i1603) { - _elem1592 = new Partition(); - _elem1592.read(iprot); - struct.partitions.add(_elem1592); + _elem1602 = new Partition(); + _elem1602.read(iprot); + struct.partitions.add(_elem1602); } } struct.setPartitionsIsSet(true); diff --git a/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetPartitionsRequest.java b/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetPartitionsRequest.java index 77f37111e6a7..115123896931 100644 --- a/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetPartitionsRequest.java +++ b/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetPartitionsRequest.java @@ -1195,13 +1195,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, GetPartitionsReques case 6: // GROUP_NAMES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1498 = iprot.readListBegin(); - struct.groupNames = new java.util.ArrayList(_list1498.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1499; - for (int _i1500 = 0; _i1500 < _list1498.size; ++_i1500) + org.apache.thrift.protocol.TList _list1508 = iprot.readListBegin(); + struct.groupNames = new java.util.ArrayList(_list1508.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1509; + for (int _i1510 = 0; _i1510 < _list1508.size; ++_i1510) { - _elem1499 = iprot.readString(); - struct.groupNames.add(_elem1499); + _elem1509 = iprot.readString(); + struct.groupNames.add(_elem1509); } iprot.readListEnd(); } @@ -1231,13 +1231,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, GetPartitionsReques case 9: // PROCESSOR_CAPABILITIES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1501 = iprot.readListBegin(); - struct.processorCapabilities = new java.util.ArrayList(_list1501.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1502; - for (int _i1503 = 0; _i1503 < _list1501.size; ++_i1503) + org.apache.thrift.protocol.TList _list1511 = iprot.readListBegin(); + struct.processorCapabilities = new java.util.ArrayList(_list1511.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1512; + for (int _i1513 = 0; _i1513 < _list1511.size; ++_i1513) { - _elem1502 = iprot.readString(); - struct.processorCapabilities.add(_elem1502); + _elem1512 = iprot.readString(); + struct.processorCapabilities.add(_elem1512); } iprot.readListEnd(); } @@ -1309,9 +1309,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, GetPartitionsReque oprot.writeFieldBegin(GROUP_NAMES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.groupNames.size())); - for (java.lang.String _iter1504 : struct.groupNames) + for (java.lang.String _iter1514 : struct.groupNames) { - oprot.writeString(_iter1504); + oprot.writeString(_iter1514); } oprot.writeListEnd(); } @@ -1333,9 +1333,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, GetPartitionsReque oprot.writeFieldBegin(PROCESSOR_CAPABILITIES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.processorCapabilities.size())); - for (java.lang.String _iter1505 : struct.processorCapabilities) + for (java.lang.String _iter1515 : struct.processorCapabilities) { - oprot.writeString(_iter1505); + oprot.writeString(_iter1515); } oprot.writeListEnd(); } @@ -1426,9 +1426,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, GetPartitionsReques if (struct.isSetGroupNames()) { { oprot.writeI32(struct.groupNames.size()); - for (java.lang.String _iter1506 : struct.groupNames) + for (java.lang.String _iter1516 : struct.groupNames) { - oprot.writeString(_iter1506); + oprot.writeString(_iter1516); } } } @@ -1441,9 +1441,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, GetPartitionsReques if (struct.isSetProcessorCapabilities()) { { oprot.writeI32(struct.processorCapabilities.size()); - for (java.lang.String _iter1507 : struct.processorCapabilities) + for (java.lang.String _iter1517 : struct.processorCapabilities) { - oprot.writeString(_iter1507); + oprot.writeString(_iter1517); } } } @@ -1481,13 +1481,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, GetPartitionsRequest } if (incoming.get(5)) { { - org.apache.thrift.protocol.TList _list1508 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.groupNames = new java.util.ArrayList(_list1508.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1509; - for (int _i1510 = 0; _i1510 < _list1508.size; ++_i1510) + org.apache.thrift.protocol.TList _list1518 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.groupNames = new java.util.ArrayList(_list1518.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1519; + for (int _i1520 = 0; _i1520 < _list1518.size; ++_i1520) { - _elem1509 = iprot.readString(); - struct.groupNames.add(_elem1509); + _elem1519 = iprot.readString(); + struct.groupNames.add(_elem1519); } } struct.setGroupNamesIsSet(true); @@ -1504,13 +1504,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, GetPartitionsRequest } if (incoming.get(8)) { { - org.apache.thrift.protocol.TList _list1511 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.processorCapabilities = new java.util.ArrayList(_list1511.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1512; - for (int _i1513 = 0; _i1513 < _list1511.size; ++_i1513) + org.apache.thrift.protocol.TList _list1521 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.processorCapabilities = new java.util.ArrayList(_list1521.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1522; + for (int _i1523 = 0; _i1523 < _list1521.size; ++_i1523) { - _elem1512 = iprot.readString(); - struct.processorCapabilities.add(_elem1512); + _elem1522 = iprot.readString(); + struct.processorCapabilities.add(_elem1522); } } struct.setProcessorCapabilitiesIsSet(true); diff --git a/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetPartitionsResponse.java b/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetPartitionsResponse.java index 8a60c34d2912..c9dbf3b33b3c 100644 --- a/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetPartitionsResponse.java +++ b/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetPartitionsResponse.java @@ -325,14 +325,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, GetPartitionsRespon case 1: // PARTITION_SPEC if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1490 = iprot.readListBegin(); - struct.partitionSpec = new java.util.ArrayList(_list1490.size); - @org.apache.thrift.annotation.Nullable PartitionSpec _elem1491; - for (int _i1492 = 0; _i1492 < _list1490.size; ++_i1492) + org.apache.thrift.protocol.TList _list1500 = iprot.readListBegin(); + struct.partitionSpec = new java.util.ArrayList(_list1500.size); + @org.apache.thrift.annotation.Nullable PartitionSpec _elem1501; + for (int _i1502 = 0; _i1502 < _list1500.size; ++_i1502) { - _elem1491 = new PartitionSpec(); - _elem1491.read(iprot); - struct.partitionSpec.add(_elem1491); + _elem1501 = new PartitionSpec(); + _elem1501.read(iprot); + struct.partitionSpec.add(_elem1501); } iprot.readListEnd(); } @@ -358,9 +358,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, GetPartitionsRespo oprot.writeFieldBegin(PARTITION_SPEC_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.partitionSpec.size())); - for (PartitionSpec _iter1493 : struct.partitionSpec) + for (PartitionSpec _iter1503 : struct.partitionSpec) { - _iter1493.write(oprot); + _iter1503.write(oprot); } oprot.writeListEnd(); } @@ -391,9 +391,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, GetPartitionsRespon if (struct.isSetPartitionSpec()) { { oprot.writeI32(struct.partitionSpec.size()); - for (PartitionSpec _iter1494 : struct.partitionSpec) + for (PartitionSpec _iter1504 : struct.partitionSpec) { - _iter1494.write(oprot); + _iter1504.write(oprot); } } } @@ -405,14 +405,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, GetPartitionsRespons java.util.BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1495 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.partitionSpec = new java.util.ArrayList(_list1495.size); - @org.apache.thrift.annotation.Nullable PartitionSpec _elem1496; - for (int _i1497 = 0; _i1497 < _list1495.size; ++_i1497) + org.apache.thrift.protocol.TList _list1505 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.partitionSpec = new java.util.ArrayList(_list1505.size); + @org.apache.thrift.annotation.Nullable PartitionSpec _elem1506; + for (int _i1507 = 0; _i1507 < _list1505.size; ++_i1507) { - _elem1496 = new PartitionSpec(); - _elem1496.read(iprot); - struct.partitionSpec.add(_elem1496); + _elem1506 = new PartitionSpec(); + _elem1506.read(iprot); + struct.partitionSpec.add(_elem1506); } } struct.setPartitionSpecIsSet(true); diff --git a/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetSchemaResponse.java b/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetSchemaResponse.java index 189db1d5a4ae..1725bc4f88fe 100644 --- a/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetSchemaResponse.java +++ b/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetSchemaResponse.java @@ -329,14 +329,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, GetSchemaResponse s case 1: // FIELDS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1522 = iprot.readListBegin(); - struct.fields = new java.util.ArrayList(_list1522.size); - @org.apache.thrift.annotation.Nullable FieldSchema _elem1523; - for (int _i1524 = 0; _i1524 < _list1522.size; ++_i1524) + org.apache.thrift.protocol.TList _list1532 = iprot.readListBegin(); + struct.fields = new java.util.ArrayList(_list1532.size); + @org.apache.thrift.annotation.Nullable FieldSchema _elem1533; + for (int _i1534 = 0; _i1534 < _list1532.size; ++_i1534) { - _elem1523 = new FieldSchema(); - _elem1523.read(iprot); - struct.fields.add(_elem1523); + _elem1533 = new FieldSchema(); + _elem1533.read(iprot); + struct.fields.add(_elem1533); } iprot.readListEnd(); } @@ -362,9 +362,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, GetSchemaResponse oprot.writeFieldBegin(FIELDS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.fields.size())); - for (FieldSchema _iter1525 : struct.fields) + for (FieldSchema _iter1535 : struct.fields) { - _iter1525.write(oprot); + _iter1535.write(oprot); } oprot.writeListEnd(); } @@ -389,9 +389,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, GetSchemaResponse s org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot; { oprot.writeI32(struct.fields.size()); - for (FieldSchema _iter1526 : struct.fields) + for (FieldSchema _iter1536 : struct.fields) { - _iter1526.write(oprot); + _iter1536.write(oprot); } } } @@ -400,14 +400,14 @@ public void write(org.apache.thrift.protocol.TProtocol prot, GetSchemaResponse s public void read(org.apache.thrift.protocol.TProtocol prot, GetSchemaResponse struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot; { - org.apache.thrift.protocol.TList _list1527 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.fields = new java.util.ArrayList(_list1527.size); - @org.apache.thrift.annotation.Nullable FieldSchema _elem1528; - for (int _i1529 = 0; _i1529 < _list1527.size; ++_i1529) + org.apache.thrift.protocol.TList _list1537 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.fields = new java.util.ArrayList(_list1537.size); + @org.apache.thrift.annotation.Nullable FieldSchema _elem1538; + for (int _i1539 = 0; _i1539 < _list1537.size; ++_i1539) { - _elem1528 = new FieldSchema(); - _elem1528.read(iprot); - struct.fields.add(_elem1528); + _elem1538 = new FieldSchema(); + _elem1538.read(iprot); + struct.fields.add(_elem1538); } } struct.setFieldsIsSet(true); diff --git a/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/PartitionsResponse.java b/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/PartitionsResponse.java index 84a0405decfb..ab0e9cea5aee 100644 --- a/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/PartitionsResponse.java +++ b/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/PartitionsResponse.java @@ -329,14 +329,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, PartitionsResponse case 1: // PARTITIONS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1538 = iprot.readListBegin(); - struct.partitions = new java.util.ArrayList(_list1538.size); - @org.apache.thrift.annotation.Nullable Partition _elem1539; - for (int _i1540 = 0; _i1540 < _list1538.size; ++_i1540) + org.apache.thrift.protocol.TList _list1548 = iprot.readListBegin(); + struct.partitions = new java.util.ArrayList(_list1548.size); + @org.apache.thrift.annotation.Nullable Partition _elem1549; + for (int _i1550 = 0; _i1550 < _list1548.size; ++_i1550) { - _elem1539 = new Partition(); - _elem1539.read(iprot); - struct.partitions.add(_elem1539); + _elem1549 = new Partition(); + _elem1549.read(iprot); + struct.partitions.add(_elem1549); } iprot.readListEnd(); } @@ -362,9 +362,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, PartitionsResponse oprot.writeFieldBegin(PARTITIONS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.partitions.size())); - for (Partition _iter1541 : struct.partitions) + for (Partition _iter1551 : struct.partitions) { - _iter1541.write(oprot); + _iter1551.write(oprot); } oprot.writeListEnd(); } @@ -389,9 +389,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, PartitionsResponse org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot; { oprot.writeI32(struct.partitions.size()); - for (Partition _iter1542 : struct.partitions) + for (Partition _iter1552 : struct.partitions) { - _iter1542.write(oprot); + _iter1552.write(oprot); } } } @@ -400,14 +400,14 @@ public void write(org.apache.thrift.protocol.TProtocol prot, PartitionsResponse public void read(org.apache.thrift.protocol.TProtocol prot, PartitionsResponse struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot; { - org.apache.thrift.protocol.TList _list1543 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.partitions = new java.util.ArrayList(_list1543.size); - @org.apache.thrift.annotation.Nullable Partition _elem1544; - for (int _i1545 = 0; _i1545 < _list1543.size; ++_i1545) + org.apache.thrift.protocol.TList _list1553 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.partitions = new java.util.ArrayList(_list1553.size); + @org.apache.thrift.annotation.Nullable Partition _elem1554; + for (int _i1555 = 0; _i1555 < _list1553.size; ++_i1555) { - _elem1544 = new Partition(); - _elem1544.read(iprot); - struct.partitions.add(_elem1544); + _elem1554 = new Partition(); + _elem1554.read(iprot); + struct.partitions.add(_elem1554); } } struct.setPartitionsIsSet(true); diff --git a/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ReplayedTxnsForPolicyResult.java b/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ReplayedTxnsForPolicyResult.java index 9c06468f2181..c665bcfd4966 100644 --- a/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ReplayedTxnsForPolicyResult.java +++ b/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ReplayedTxnsForPolicyResult.java @@ -318,15 +318,15 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, ReplayedTxnsForPoli case 1: // REPL_TXN_MAP_ENTRY if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map1626 = iprot.readMapBegin(); - struct.replTxnMapEntry = new java.util.HashMap(2*_map1626.size); - @org.apache.thrift.annotation.Nullable java.lang.String _key1627; - @org.apache.thrift.annotation.Nullable java.lang.String _val1628; - for (int _i1629 = 0; _i1629 < _map1626.size; ++_i1629) + org.apache.thrift.protocol.TMap _map1636 = iprot.readMapBegin(); + struct.replTxnMapEntry = new java.util.HashMap(2*_map1636.size); + @org.apache.thrift.annotation.Nullable java.lang.String _key1637; + @org.apache.thrift.annotation.Nullable java.lang.String _val1638; + for (int _i1639 = 0; _i1639 < _map1636.size; ++_i1639) { - _key1627 = iprot.readString(); - _val1628 = iprot.readString(); - struct.replTxnMapEntry.put(_key1627, _val1628); + _key1637 = iprot.readString(); + _val1638 = iprot.readString(); + struct.replTxnMapEntry.put(_key1637, _val1638); } iprot.readMapEnd(); } @@ -352,10 +352,10 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, ReplayedTxnsForPol oprot.writeFieldBegin(REPL_TXN_MAP_ENTRY_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.replTxnMapEntry.size())); - for (java.util.Map.Entry _iter1630 : struct.replTxnMapEntry.entrySet()) + for (java.util.Map.Entry _iter1640 : struct.replTxnMapEntry.entrySet()) { - oprot.writeString(_iter1630.getKey()); - oprot.writeString(_iter1630.getValue()); + oprot.writeString(_iter1640.getKey()); + oprot.writeString(_iter1640.getValue()); } oprot.writeMapEnd(); } @@ -386,10 +386,10 @@ public void write(org.apache.thrift.protocol.TProtocol prot, ReplayedTxnsForPoli if (struct.isSetReplTxnMapEntry()) { { oprot.writeI32(struct.replTxnMapEntry.size()); - for (java.util.Map.Entry _iter1631 : struct.replTxnMapEntry.entrySet()) + for (java.util.Map.Entry _iter1641 : struct.replTxnMapEntry.entrySet()) { - oprot.writeString(_iter1631.getKey()); - oprot.writeString(_iter1631.getValue()); + oprot.writeString(_iter1641.getKey()); + oprot.writeString(_iter1641.getValue()); } } } @@ -401,15 +401,15 @@ public void read(org.apache.thrift.protocol.TProtocol prot, ReplayedTxnsForPolic java.util.BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { { - org.apache.thrift.protocol.TMap _map1632 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); - struct.replTxnMapEntry = new java.util.HashMap(2*_map1632.size); - @org.apache.thrift.annotation.Nullable java.lang.String _key1633; - @org.apache.thrift.annotation.Nullable java.lang.String _val1634; - for (int _i1635 = 0; _i1635 < _map1632.size; ++_i1635) + org.apache.thrift.protocol.TMap _map1642 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); + struct.replTxnMapEntry = new java.util.HashMap(2*_map1642.size); + @org.apache.thrift.annotation.Nullable java.lang.String _key1643; + @org.apache.thrift.annotation.Nullable java.lang.String _val1644; + for (int _i1645 = 0; _i1645 < _map1642.size; ++_i1645) { - _key1633 = iprot.readString(); - _val1634 = iprot.readString(); - struct.replTxnMapEntry.put(_key1633, _val1634); + _key1643 = iprot.readString(); + _val1644 = iprot.readString(); + struct.replTxnMapEntry.put(_key1643, _val1644); } } struct.setReplTxnMapEntryIsSet(true); diff --git a/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ReplicationMetricList.java b/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ReplicationMetricList.java index 57acf12f88bc..32d2c259027d 100644 --- a/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ReplicationMetricList.java +++ b/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ReplicationMetricList.java @@ -329,14 +329,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, ReplicationMetricLi case 1: // REPLICATION_METRIC_LIST if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1594 = iprot.readListBegin(); - struct.replicationMetricList = new java.util.ArrayList(_list1594.size); - @org.apache.thrift.annotation.Nullable ReplicationMetrics _elem1595; - for (int _i1596 = 0; _i1596 < _list1594.size; ++_i1596) + org.apache.thrift.protocol.TList _list1604 = iprot.readListBegin(); + struct.replicationMetricList = new java.util.ArrayList(_list1604.size); + @org.apache.thrift.annotation.Nullable ReplicationMetrics _elem1605; + for (int _i1606 = 0; _i1606 < _list1604.size; ++_i1606) { - _elem1595 = new ReplicationMetrics(); - _elem1595.read(iprot); - struct.replicationMetricList.add(_elem1595); + _elem1605 = new ReplicationMetrics(); + _elem1605.read(iprot); + struct.replicationMetricList.add(_elem1605); } iprot.readListEnd(); } @@ -362,9 +362,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, ReplicationMetricL oprot.writeFieldBegin(REPLICATION_METRIC_LIST_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.replicationMetricList.size())); - for (ReplicationMetrics _iter1597 : struct.replicationMetricList) + for (ReplicationMetrics _iter1607 : struct.replicationMetricList) { - _iter1597.write(oprot); + _iter1607.write(oprot); } oprot.writeListEnd(); } @@ -389,9 +389,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, ReplicationMetricLi org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot; { oprot.writeI32(struct.replicationMetricList.size()); - for (ReplicationMetrics _iter1598 : struct.replicationMetricList) + for (ReplicationMetrics _iter1608 : struct.replicationMetricList) { - _iter1598.write(oprot); + _iter1608.write(oprot); } } } @@ -400,14 +400,14 @@ public void write(org.apache.thrift.protocol.TProtocol prot, ReplicationMetricLi public void read(org.apache.thrift.protocol.TProtocol prot, ReplicationMetricList struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot; { - org.apache.thrift.protocol.TList _list1599 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.replicationMetricList = new java.util.ArrayList(_list1599.size); - @org.apache.thrift.annotation.Nullable ReplicationMetrics _elem1600; - for (int _i1601 = 0; _i1601 < _list1599.size; ++_i1601) + org.apache.thrift.protocol.TList _list1609 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.replicationMetricList = new java.util.ArrayList(_list1609.size); + @org.apache.thrift.annotation.Nullable ReplicationMetrics _elem1610; + for (int _i1611 = 0; _i1611 < _list1609.size; ++_i1611) { - _elem1600 = new ReplicationMetrics(); - _elem1600.read(iprot); - struct.replicationMetricList.add(_elem1600); + _elem1610 = new ReplicationMetrics(); + _elem1610.read(iprot); + struct.replicationMetricList.add(_elem1610); } } struct.setReplicationMetricListIsSet(true); diff --git a/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/TableParamsUpdate.java b/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/TableParamsUpdate.java new file mode 100644 index 000000000000..d1fb3b779cb6 --- /dev/null +++ b/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/TableParamsUpdate.java @@ -0,0 +1,942 @@ +/** + * Autogenerated by Thrift Compiler (0.16.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +package org.apache.hadoop.hive.metastore.api; + +@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"}) +@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.16.0)") +@org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public class TableParamsUpdate 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("TableParamsUpdate"); + + private static final org.apache.thrift.protocol.TField CAT_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("cat_name", org.apache.thrift.protocol.TType.STRING, (short)1); + private static final org.apache.thrift.protocol.TField DB_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("db_name", org.apache.thrift.protocol.TType.STRING, (short)2); + private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("table_name", org.apache.thrift.protocol.TType.STRING, (short)3); + private static final org.apache.thrift.protocol.TField PARAMS_FIELD_DESC = new org.apache.thrift.protocol.TField("params", org.apache.thrift.protocol.TType.MAP, (short)4); + private static final org.apache.thrift.protocol.TField EXPECTED_PARAM_KEY_FIELD_DESC = new org.apache.thrift.protocol.TField("expected_param_key", org.apache.thrift.protocol.TType.STRING, (short)5); + private static final org.apache.thrift.protocol.TField EXPECTED_PARAM_VALUE_FIELD_DESC = new org.apache.thrift.protocol.TField("expected_param_value", org.apache.thrift.protocol.TType.STRING, (short)6); + + private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new TableParamsUpdateStandardSchemeFactory(); + private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new TableParamsUpdateTupleSchemeFactory(); + + private @org.apache.thrift.annotation.Nullable java.lang.String cat_name; // optional + private @org.apache.thrift.annotation.Nullable java.lang.String db_name; // required + private @org.apache.thrift.annotation.Nullable java.lang.String table_name; // required + private @org.apache.thrift.annotation.Nullable java.util.Map params; // required + private @org.apache.thrift.annotation.Nullable java.lang.String expected_param_key; // optional + private @org.apache.thrift.annotation.Nullable java.lang.String expected_param_value; // 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 { + CAT_NAME((short)1, "cat_name"), + DB_NAME((short)2, "db_name"), + TABLE_NAME((short)3, "table_name"), + PARAMS((short)4, "params"), + EXPECTED_PARAM_KEY((short)5, "expected_param_key"), + EXPECTED_PARAM_VALUE((short)6, "expected_param_value"); + + private static final java.util.Map byName = new java.util.HashMap(); + + static { + for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + @org.apache.thrift.annotation.Nullable + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 1: // CAT_NAME + return CAT_NAME; + case 2: // DB_NAME + return DB_NAME; + case 3: // TABLE_NAME + return TABLE_NAME; + case 4: // PARAMS + return PARAMS; + case 5: // EXPECTED_PARAM_KEY + return EXPECTED_PARAM_KEY; + case 6: // EXPECTED_PARAM_VALUE + return EXPECTED_PARAM_VALUE; + 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 java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + @org.apache.thrift.annotation.Nullable + public static _Fields findByName(java.lang.String name) { + return byName.get(name); + } + + private final short _thriftId; + private final java.lang.String _fieldName; + + _Fields(short thriftId, java.lang.String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public java.lang.String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + private static final _Fields optionals[] = {_Fields.CAT_NAME,_Fields.EXPECTED_PARAM_KEY,_Fields.EXPECTED_PARAM_VALUE}; + public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.CAT_NAME, new org.apache.thrift.meta_data.FieldMetaData("cat_name", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.DB_NAME, new org.apache.thrift.meta_data.FieldMetaData("db_name", org.apache.thrift.TFieldRequirementType.REQUIRED, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("table_name", org.apache.thrift.TFieldRequirementType.REQUIRED, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.PARAMS, new org.apache.thrift.meta_data.FieldMetaData("params", org.apache.thrift.TFieldRequirementType.REQUIRED, + new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING), + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)))); + tmpMap.put(_Fields.EXPECTED_PARAM_KEY, new org.apache.thrift.meta_data.FieldMetaData("expected_param_key", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.EXPECTED_PARAM_VALUE, new org.apache.thrift.meta_data.FieldMetaData("expected_param_value", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + metaDataMap = java.util.Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TableParamsUpdate.class, metaDataMap); + } + + public TableParamsUpdate() { + } + + public TableParamsUpdate( + java.lang.String db_name, + java.lang.String table_name, + java.util.Map params) + { + this(); + this.db_name = db_name; + this.table_name = table_name; + this.params = params; + } + + /** + * Performs a deep copy on other. + */ + public TableParamsUpdate(TableParamsUpdate other) { + if (other.isSetCat_name()) { + this.cat_name = other.cat_name; + } + if (other.isSetDb_name()) { + this.db_name = other.db_name; + } + if (other.isSetTable_name()) { + this.table_name = other.table_name; + } + if (other.isSetParams()) { + java.util.Map __this__params = new java.util.HashMap(other.params); + this.params = __this__params; + } + if (other.isSetExpected_param_key()) { + this.expected_param_key = other.expected_param_key; + } + if (other.isSetExpected_param_value()) { + this.expected_param_value = other.expected_param_value; + } + } + + public TableParamsUpdate deepCopy() { + return new TableParamsUpdate(this); + } + + @Override + public void clear() { + this.cat_name = null; + this.db_name = null; + this.table_name = null; + this.params = null; + this.expected_param_key = null; + this.expected_param_value = null; + } + + @org.apache.thrift.annotation.Nullable + public java.lang.String getCat_name() { + return this.cat_name; + } + + public void setCat_name(@org.apache.thrift.annotation.Nullable java.lang.String cat_name) { + this.cat_name = cat_name; + } + + public void unsetCat_name() { + this.cat_name = null; + } + + /** Returns true if field cat_name is set (has been assigned a value) and false otherwise */ + public boolean isSetCat_name() { + return this.cat_name != null; + } + + public void setCat_nameIsSet(boolean value) { + if (!value) { + this.cat_name = null; + } + } + + @org.apache.thrift.annotation.Nullable + public java.lang.String getDb_name() { + return this.db_name; + } + + public void setDb_name(@org.apache.thrift.annotation.Nullable java.lang.String db_name) { + this.db_name = db_name; + } + + public void unsetDb_name() { + this.db_name = null; + } + + /** Returns true if field db_name is set (has been assigned a value) and false otherwise */ + public boolean isSetDb_name() { + return this.db_name != null; + } + + public void setDb_nameIsSet(boolean value) { + if (!value) { + this.db_name = null; + } + } + + @org.apache.thrift.annotation.Nullable + public java.lang.String getTable_name() { + return this.table_name; + } + + public void setTable_name(@org.apache.thrift.annotation.Nullable java.lang.String table_name) { + this.table_name = table_name; + } + + public void unsetTable_name() { + this.table_name = null; + } + + /** Returns true if field table_name is set (has been assigned a value) and false otherwise */ + public boolean isSetTable_name() { + return this.table_name != null; + } + + public void setTable_nameIsSet(boolean value) { + if (!value) { + this.table_name = null; + } + } + + public int getParamsSize() { + return (this.params == null) ? 0 : this.params.size(); + } + + public void putToParams(java.lang.String key, java.lang.String val) { + if (this.params == null) { + this.params = new java.util.HashMap(); + } + this.params.put(key, val); + } + + @org.apache.thrift.annotation.Nullable + public java.util.Map getParams() { + return this.params; + } + + public void setParams(@org.apache.thrift.annotation.Nullable java.util.Map params) { + this.params = params; + } + + public void unsetParams() { + this.params = null; + } + + /** Returns true if field params is set (has been assigned a value) and false otherwise */ + public boolean isSetParams() { + return this.params != null; + } + + public void setParamsIsSet(boolean value) { + if (!value) { + this.params = null; + } + } + + @org.apache.thrift.annotation.Nullable + public java.lang.String getExpected_param_key() { + return this.expected_param_key; + } + + public void setExpected_param_key(@org.apache.thrift.annotation.Nullable java.lang.String expected_param_key) { + this.expected_param_key = expected_param_key; + } + + public void unsetExpected_param_key() { + this.expected_param_key = null; + } + + /** Returns true if field expected_param_key is set (has been assigned a value) and false otherwise */ + public boolean isSetExpected_param_key() { + return this.expected_param_key != null; + } + + public void setExpected_param_keyIsSet(boolean value) { + if (!value) { + this.expected_param_key = null; + } + } + + @org.apache.thrift.annotation.Nullable + public java.lang.String getExpected_param_value() { + return this.expected_param_value; + } + + public void setExpected_param_value(@org.apache.thrift.annotation.Nullable java.lang.String expected_param_value) { + this.expected_param_value = expected_param_value; + } + + public void unsetExpected_param_value() { + this.expected_param_value = null; + } + + /** Returns true if field expected_param_value is set (has been assigned a value) and false otherwise */ + public boolean isSetExpected_param_value() { + return this.expected_param_value != null; + } + + public void setExpected_param_valueIsSet(boolean value) { + if (!value) { + this.expected_param_value = null; + } + } + + public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) { + switch (field) { + case CAT_NAME: + if (value == null) { + unsetCat_name(); + } else { + setCat_name((java.lang.String)value); + } + break; + + case DB_NAME: + if (value == null) { + unsetDb_name(); + } else { + setDb_name((java.lang.String)value); + } + break; + + case TABLE_NAME: + if (value == null) { + unsetTable_name(); + } else { + setTable_name((java.lang.String)value); + } + break; + + case PARAMS: + if (value == null) { + unsetParams(); + } else { + setParams((java.util.Map)value); + } + break; + + case EXPECTED_PARAM_KEY: + if (value == null) { + unsetExpected_param_key(); + } else { + setExpected_param_key((java.lang.String)value); + } + break; + + case EXPECTED_PARAM_VALUE: + if (value == null) { + unsetExpected_param_value(); + } else { + setExpected_param_value((java.lang.String)value); + } + break; + + } + } + + @org.apache.thrift.annotation.Nullable + public java.lang.Object getFieldValue(_Fields field) { + switch (field) { + case CAT_NAME: + return getCat_name(); + + case DB_NAME: + return getDb_name(); + + case TABLE_NAME: + return getTable_name(); + + case PARAMS: + return getParams(); + + case EXPECTED_PARAM_KEY: + return getExpected_param_key(); + + case EXPECTED_PARAM_VALUE: + return getExpected_param_value(); + + } + throw new java.lang.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 java.lang.IllegalArgumentException(); + } + + switch (field) { + case CAT_NAME: + return isSetCat_name(); + case DB_NAME: + return isSetDb_name(); + case TABLE_NAME: + return isSetTable_name(); + case PARAMS: + return isSetParams(); + case EXPECTED_PARAM_KEY: + return isSetExpected_param_key(); + case EXPECTED_PARAM_VALUE: + return isSetExpected_param_value(); + } + throw new java.lang.IllegalStateException(); + } + + @Override + public boolean equals(java.lang.Object that) { + if (that instanceof TableParamsUpdate) + return this.equals((TableParamsUpdate)that); + return false; + } + + public boolean equals(TableParamsUpdate that) { + if (that == null) + return false; + if (this == that) + return true; + + boolean this_present_cat_name = true && this.isSetCat_name(); + boolean that_present_cat_name = true && that.isSetCat_name(); + if (this_present_cat_name || that_present_cat_name) { + if (!(this_present_cat_name && that_present_cat_name)) + return false; + if (!this.cat_name.equals(that.cat_name)) + return false; + } + + boolean this_present_db_name = true && this.isSetDb_name(); + boolean that_present_db_name = true && that.isSetDb_name(); + if (this_present_db_name || that_present_db_name) { + if (!(this_present_db_name && that_present_db_name)) + return false; + if (!this.db_name.equals(that.db_name)) + return false; + } + + boolean this_present_table_name = true && this.isSetTable_name(); + boolean that_present_table_name = true && that.isSetTable_name(); + if (this_present_table_name || that_present_table_name) { + if (!(this_present_table_name && that_present_table_name)) + return false; + if (!this.table_name.equals(that.table_name)) + return false; + } + + boolean this_present_params = true && this.isSetParams(); + boolean that_present_params = true && that.isSetParams(); + if (this_present_params || that_present_params) { + if (!(this_present_params && that_present_params)) + return false; + if (!this.params.equals(that.params)) + return false; + } + + boolean this_present_expected_param_key = true && this.isSetExpected_param_key(); + boolean that_present_expected_param_key = true && that.isSetExpected_param_key(); + if (this_present_expected_param_key || that_present_expected_param_key) { + if (!(this_present_expected_param_key && that_present_expected_param_key)) + return false; + if (!this.expected_param_key.equals(that.expected_param_key)) + return false; + } + + boolean this_present_expected_param_value = true && this.isSetExpected_param_value(); + boolean that_present_expected_param_value = true && that.isSetExpected_param_value(); + if (this_present_expected_param_value || that_present_expected_param_value) { + if (!(this_present_expected_param_value && that_present_expected_param_value)) + return false; + if (!this.expected_param_value.equals(that.expected_param_value)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + int hashCode = 1; + + hashCode = hashCode * 8191 + ((isSetCat_name()) ? 131071 : 524287); + if (isSetCat_name()) + hashCode = hashCode * 8191 + cat_name.hashCode(); + + hashCode = hashCode * 8191 + ((isSetDb_name()) ? 131071 : 524287); + if (isSetDb_name()) + hashCode = hashCode * 8191 + db_name.hashCode(); + + hashCode = hashCode * 8191 + ((isSetTable_name()) ? 131071 : 524287); + if (isSetTable_name()) + hashCode = hashCode * 8191 + table_name.hashCode(); + + hashCode = hashCode * 8191 + ((isSetParams()) ? 131071 : 524287); + if (isSetParams()) + hashCode = hashCode * 8191 + params.hashCode(); + + hashCode = hashCode * 8191 + ((isSetExpected_param_key()) ? 131071 : 524287); + if (isSetExpected_param_key()) + hashCode = hashCode * 8191 + expected_param_key.hashCode(); + + hashCode = hashCode * 8191 + ((isSetExpected_param_value()) ? 131071 : 524287); + if (isSetExpected_param_value()) + hashCode = hashCode * 8191 + expected_param_value.hashCode(); + + return hashCode; + } + + @Override + public int compareTo(TableParamsUpdate other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = java.lang.Boolean.compare(isSetCat_name(), other.isSetCat_name()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetCat_name()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.cat_name, other.cat_name); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = java.lang.Boolean.compare(isSetDb_name(), other.isSetDb_name()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetDb_name()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.db_name, other.db_name); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = java.lang.Boolean.compare(isSetTable_name(), other.isSetTable_name()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetTable_name()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table_name, other.table_name); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = java.lang.Boolean.compare(isSetParams(), other.isSetParams()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetParams()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.params, other.params); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = java.lang.Boolean.compare(isSetExpected_param_key(), other.isSetExpected_param_key()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetExpected_param_key()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.expected_param_key, other.expected_param_key); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = java.lang.Boolean.compare(isSetExpected_param_value(), other.isSetExpected_param_value()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetExpected_param_value()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.expected_param_value, other.expected_param_value); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + @org.apache.thrift.annotation.Nullable + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + scheme(iprot).read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + scheme(oprot).write(oprot, this); + } + + @Override + public java.lang.String toString() { + java.lang.StringBuilder sb = new java.lang.StringBuilder("TableParamsUpdate("); + boolean first = true; + + if (isSetCat_name()) { + sb.append("cat_name:"); + if (this.cat_name == null) { + sb.append("null"); + } else { + sb.append(this.cat_name); + } + first = false; + } + if (!first) sb.append(", "); + sb.append("db_name:"); + if (this.db_name == null) { + sb.append("null"); + } else { + sb.append(this.db_name); + } + first = false; + if (!first) sb.append(", "); + sb.append("table_name:"); + if (this.table_name == null) { + sb.append("null"); + } else { + sb.append(this.table_name); + } + first = false; + if (!first) sb.append(", "); + sb.append("params:"); + if (this.params == null) { + sb.append("null"); + } else { + sb.append(this.params); + } + first = false; + if (isSetExpected_param_key()) { + if (!first) sb.append(", "); + sb.append("expected_param_key:"); + if (this.expected_param_key == null) { + sb.append("null"); + } else { + sb.append(this.expected_param_key); + } + first = false; + } + if (isSetExpected_param_value()) { + if (!first) sb.append(", "); + sb.append("expected_param_value:"); + if (this.expected_param_value == null) { + sb.append("null"); + } else { + sb.append(this.expected_param_value); + } + first = false; + } + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + if (!isSetDb_name()) { + throw new org.apache.thrift.protocol.TProtocolException("Required field 'db_name' is unset! Struct:" + toString()); + } + + if (!isSetTable_name()) { + throw new org.apache.thrift.protocol.TProtocolException("Required field 'table_name' is unset! Struct:" + toString()); + } + + if (!isSetParams()) { + throw new org.apache.thrift.protocol.TProtocolException("Required field 'params' 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, java.lang.ClassNotFoundException { + try { + 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 TableParamsUpdateStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory { + public TableParamsUpdateStandardScheme getScheme() { + return new TableParamsUpdateStandardScheme(); + } + } + + private static class TableParamsUpdateStandardScheme extends org.apache.thrift.scheme.StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, TableParamsUpdate 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: // CAT_NAME + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.cat_name = iprot.readString(); + struct.setCat_nameIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // DB_NAME + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.db_name = iprot.readString(); + struct.setDb_nameIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 3: // TABLE_NAME + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.table_name = iprot.readString(); + struct.setTable_nameIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 4: // PARAMS + if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { + { + org.apache.thrift.protocol.TMap _map1482 = iprot.readMapBegin(); + struct.params = new java.util.HashMap(2*_map1482.size); + @org.apache.thrift.annotation.Nullable java.lang.String _key1483; + @org.apache.thrift.annotation.Nullable java.lang.String _val1484; + for (int _i1485 = 0; _i1485 < _map1482.size; ++_i1485) + { + _key1483 = iprot.readString(); + _val1484 = iprot.readString(); + struct.params.put(_key1483, _val1484); + } + iprot.readMapEnd(); + } + struct.setParamsIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 5: // EXPECTED_PARAM_KEY + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.expected_param_key = iprot.readString(); + struct.setExpected_param_keyIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 6: // EXPECTED_PARAM_VALUE + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.expected_param_value = iprot.readString(); + struct.setExpected_param_valueIsSet(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, TableParamsUpdate struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.cat_name != null) { + if (struct.isSetCat_name()) { + oprot.writeFieldBegin(CAT_NAME_FIELD_DESC); + oprot.writeString(struct.cat_name); + oprot.writeFieldEnd(); + } + } + if (struct.db_name != null) { + oprot.writeFieldBegin(DB_NAME_FIELD_DESC); + oprot.writeString(struct.db_name); + oprot.writeFieldEnd(); + } + if (struct.table_name != null) { + oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC); + oprot.writeString(struct.table_name); + oprot.writeFieldEnd(); + } + if (struct.params != null) { + oprot.writeFieldBegin(PARAMS_FIELD_DESC); + { + oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.params.size())); + for (java.util.Map.Entry _iter1486 : struct.params.entrySet()) + { + oprot.writeString(_iter1486.getKey()); + oprot.writeString(_iter1486.getValue()); + } + oprot.writeMapEnd(); + } + oprot.writeFieldEnd(); + } + if (struct.expected_param_key != null) { + if (struct.isSetExpected_param_key()) { + oprot.writeFieldBegin(EXPECTED_PARAM_KEY_FIELD_DESC); + oprot.writeString(struct.expected_param_key); + oprot.writeFieldEnd(); + } + } + if (struct.expected_param_value != null) { + if (struct.isSetExpected_param_value()) { + oprot.writeFieldBegin(EXPECTED_PARAM_VALUE_FIELD_DESC); + oprot.writeString(struct.expected_param_value); + oprot.writeFieldEnd(); + } + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class TableParamsUpdateTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory { + public TableParamsUpdateTupleScheme getScheme() { + return new TableParamsUpdateTupleScheme(); + } + } + + private static class TableParamsUpdateTupleScheme extends org.apache.thrift.scheme.TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, TableParamsUpdate struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot; + oprot.writeString(struct.db_name); + oprot.writeString(struct.table_name); + { + oprot.writeI32(struct.params.size()); + for (java.util.Map.Entry _iter1487 : struct.params.entrySet()) + { + oprot.writeString(_iter1487.getKey()); + oprot.writeString(_iter1487.getValue()); + } + } + java.util.BitSet optionals = new java.util.BitSet(); + if (struct.isSetCat_name()) { + optionals.set(0); + } + if (struct.isSetExpected_param_key()) { + optionals.set(1); + } + if (struct.isSetExpected_param_value()) { + optionals.set(2); + } + oprot.writeBitSet(optionals, 3); + if (struct.isSetCat_name()) { + oprot.writeString(struct.cat_name); + } + if (struct.isSetExpected_param_key()) { + oprot.writeString(struct.expected_param_key); + } + if (struct.isSetExpected_param_value()) { + oprot.writeString(struct.expected_param_value); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, TableParamsUpdate struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot; + struct.db_name = iprot.readString(); + struct.setDb_nameIsSet(true); + struct.table_name = iprot.readString(); + struct.setTable_nameIsSet(true); + { + org.apache.thrift.protocol.TMap _map1488 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); + struct.params = new java.util.HashMap(2*_map1488.size); + @org.apache.thrift.annotation.Nullable java.lang.String _key1489; + @org.apache.thrift.annotation.Nullable java.lang.String _val1490; + for (int _i1491 = 0; _i1491 < _map1488.size; ++_i1491) + { + _key1489 = iprot.readString(); + _val1490 = iprot.readString(); + struct.params.put(_key1489, _val1490); + } + } + struct.setParamsIsSet(true); + java.util.BitSet incoming = iprot.readBitSet(3); + if (incoming.get(0)) { + struct.cat_name = iprot.readString(); + struct.setCat_nameIsSet(true); + } + if (incoming.get(1)) { + struct.expected_param_key = iprot.readString(); + struct.setExpected_param_keyIsSet(true); + } + if (incoming.get(2)) { + struct.expected_param_value = iprot.readString(); + struct.setExpected_param_valueIsSet(true); + } + } + } + + private static S scheme(org.apache.thrift.protocol.TProtocol proto) { + return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme(); + } +} + diff --git a/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java b/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java index 1b66df058ce4..9e690e8ec94f 100644 --- a/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java +++ b/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java @@ -149,6 +149,8 @@ public AlterTableResponse alter_table_req(AlterTableRequest req) throws InvalidOperationException, MetaException, org.apache.thrift.TException; + public void update_table_params(java.util.List updates) throws MetaException, org.apache.thrift.TException; + public Partition add_partition(Partition new_part) throws InvalidObjectException, AlreadyExistsException, MetaException, org.apache.thrift.TException; public Partition add_partition_with_environment_context(Partition new_part, EnvironmentContext environment_context) throws InvalidObjectException, AlreadyExistsException, MetaException, org.apache.thrift.TException; @@ -721,6 +723,8 @@ public void alter_table_req(AlterTableRequest req, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void update_table_params(java.util.List updates, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void add_partition(Partition new_part, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; public void add_partition_with_environment_context(Partition new_part, EnvironmentContext environment_context, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; @@ -3102,6 +3106,29 @@ public AlterTableResponse recv_alter_table_req() throws InvalidOperationExceptio throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "alter_table_req failed: unknown result"); } + public void update_table_params(java.util.List updates) throws MetaException, org.apache.thrift.TException + { + send_update_table_params(updates); + recv_update_table_params(); + } + + public void send_update_table_params(java.util.List updates) throws org.apache.thrift.TException + { + update_table_params_args args = new update_table_params_args(); + args.setUpdates(updates); + sendBase("update_table_params", args); + } + + public void recv_update_table_params() throws MetaException, org.apache.thrift.TException + { + update_table_params_result result = new update_table_params_result(); + receiveBase(result, "update_table_params"); + if (result.o1 != null) { + throw result.o1; + } + return; + } + public Partition add_partition(Partition new_part) throws InvalidObjectException, AlreadyExistsException, MetaException, org.apache.thrift.TException { send_add_partition(new_part); @@ -11487,6 +11514,38 @@ public AlterTableResponse getResult() throws InvalidOperationException, MetaExce } } + public void update_table_params(java.util.List updates, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + update_table_params_call method_call = new update_table_params_call(updates, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class update_table_params_call extends org.apache.thrift.async.TAsyncMethodCall { + private java.util.List updates; + public update_table_params_call(java.util.List updates, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.updates = updates; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("update_table_params", org.apache.thrift.protocol.TMessageType.CALL, 0)); + update_table_params_args args = new update_table_params_args(); + args.setUpdates(updates); + args.write(prot); + prot.writeMessageEnd(); + } + + public Void getResult() throws MetaException, org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new java.lang.IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return null; + } + } + public void add_partition(Partition new_part, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { checkReady(); add_partition_call method_call = new add_partition_call(new_part, resultHandler, this, ___protocolFactory, ___transport); @@ -18895,6 +18954,7 @@ protected Processor(I iface, java.util.Map extends org.apache.thrift.ProcessFunction { + public update_table_params() { + super("update_table_params"); + } + + public update_table_params_args getEmptyArgsInstance() { + return new update_table_params_args(); + } + + protected boolean isOneway() { + return false; + } + + @Override + protected boolean rethrowUnhandledExceptions() { + return false; + } + + public update_table_params_result getResult(I iface, update_table_params_args args) throws org.apache.thrift.TException { + update_table_params_result result = new update_table_params_result(); + try { + iface.update_table_params(args.updates); + } catch (MetaException o1) { + result.o1 = o1; + } + return result; + } + } + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class add_partition extends org.apache.thrift.ProcessFunction { public add_partition() { super("add_partition"); @@ -27869,6 +27958,7 @@ protected AsyncProcessor(I iface, java.util.Map extends org.apache.thrift.AsyncProcessFunction { + public update_table_params() { + super("update_table_params"); + } + + public update_table_params_args getEmptyArgsInstance() { + return new update_table_params_args(); + } + + public org.apache.thrift.async.AsyncMethodCallback getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new org.apache.thrift.async.AsyncMethodCallback() { + public void onComplete(Void o) { + update_table_params_result result = new update_table_params_result(); + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); + } catch (org.apache.thrift.transport.TTransportException e) { + _LOGGER.error("TTransportException writing to internal frame buffer", e); + fb.close(); + } catch (java.lang.Exception e) { + _LOGGER.error("Exception writing to internal frame buffer", e); + onError(e); + } + } + public void onError(java.lang.Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TSerializable msg; + update_table_params_result result = new update_table_params_result(); + if (e instanceof MetaException) { + result.o1 = (MetaException) e; + result.setO1IsSet(true); + msg = result; + } else if (e instanceof org.apache.thrift.transport.TTransportException) { + _LOGGER.error("TTransportException inside handler", e); + fb.close(); + return; + } else if (e instanceof org.apache.thrift.TApplicationException) { + _LOGGER.error("TApplicationException inside handler", e); + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TApplicationException)e; + } else { + _LOGGER.error("Exception inside handler", e); + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb,msg,msgType,seqid); + } catch (java.lang.Exception ex) { + _LOGGER.error("Exception writing to internal frame buffer", ex); + fb.close(); + } + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, update_table_params_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + iface.update_table_params(args.updates,resultHandler); + } + } + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class add_partition extends org.apache.thrift.AsyncProcessFunction { public add_partition() { super("add_partition"); @@ -61062,13 +61216,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 _list1636 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list1636.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1637; - for (int _i1638 = 0; _i1638 < _list1636.size; ++_i1638) + org.apache.thrift.protocol.TList _list1646 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list1646.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1647; + for (int _i1648 = 0; _i1648 < _list1646.size; ++_i1648) { - _elem1637 = iprot.readString(); - struct.success.add(_elem1637); + _elem1647 = iprot.readString(); + struct.success.add(_elem1647); } iprot.readListEnd(); } @@ -61103,9 +61257,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 (java.lang.String _iter1639 : struct.success) + for (java.lang.String _iter1649 : struct.success) { - oprot.writeString(_iter1639); + oprot.writeString(_iter1649); } oprot.writeListEnd(); } @@ -61144,9 +61298,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_databases_resul if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (java.lang.String _iter1640 : struct.success) + for (java.lang.String _iter1650 : struct.success) { - oprot.writeString(_iter1640); + oprot.writeString(_iter1650); } } } @@ -61161,13 +61315,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_databases_result java.util.BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1641 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.success = new java.util.ArrayList(_list1641.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1642; - for (int _i1643 = 0; _i1643 < _list1641.size; ++_i1643) + org.apache.thrift.protocol.TList _list1651 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.success = new java.util.ArrayList(_list1651.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1652; + for (int _i1653 = 0; _i1653 < _list1651.size; ++_i1653) { - _elem1642 = iprot.readString(); - struct.success.add(_elem1642); + _elem1652 = iprot.readString(); + struct.success.add(_elem1652); } } struct.setSuccessIsSet(true); @@ -61830,13 +61984,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 _list1644 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list1644.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1645; - for (int _i1646 = 0; _i1646 < _list1644.size; ++_i1646) + org.apache.thrift.protocol.TList _list1654 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list1654.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1655; + for (int _i1656 = 0; _i1656 < _list1654.size; ++_i1656) { - _elem1645 = iprot.readString(); - struct.success.add(_elem1645); + _elem1655 = iprot.readString(); + struct.success.add(_elem1655); } iprot.readListEnd(); } @@ -61871,9 +62025,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 (java.lang.String _iter1647 : struct.success) + for (java.lang.String _iter1657 : struct.success) { - oprot.writeString(_iter1647); + oprot.writeString(_iter1657); } oprot.writeListEnd(); } @@ -61912,9 +62066,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_all_databases_r if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (java.lang.String _iter1648 : struct.success) + for (java.lang.String _iter1658 : struct.success) { - oprot.writeString(_iter1648); + oprot.writeString(_iter1658); } } } @@ -61929,13 +62083,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_all_databases_re java.util.BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1649 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.success = new java.util.ArrayList(_list1649.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1650; - for (int _i1651 = 0; _i1651 < _list1649.size; ++_i1651) + org.apache.thrift.protocol.TList _list1659 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.success = new java.util.ArrayList(_list1659.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1660; + for (int _i1661 = 0; _i1661 < _list1659.size; ++_i1661) { - _elem1650 = iprot.readString(); - struct.success.add(_elem1650); + _elem1660 = iprot.readString(); + struct.success.add(_elem1660); } } struct.setSuccessIsSet(true); @@ -68048,13 +68202,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_dataconnectors_ case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1652 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list1652.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1653; - for (int _i1654 = 0; _i1654 < _list1652.size; ++_i1654) + org.apache.thrift.protocol.TList _list1662 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list1662.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1663; + for (int _i1664 = 0; _i1664 < _list1662.size; ++_i1664) { - _elem1653 = iprot.readString(); - struct.success.add(_elem1653); + _elem1663 = iprot.readString(); + struct.success.add(_elem1663); } iprot.readListEnd(); } @@ -68089,9 +68243,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_dataconnectors oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (java.lang.String _iter1655 : struct.success) + for (java.lang.String _iter1665 : struct.success) { - oprot.writeString(_iter1655); + oprot.writeString(_iter1665); } oprot.writeListEnd(); } @@ -68130,9 +68284,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_dataconnectors_ if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (java.lang.String _iter1656 : struct.success) + for (java.lang.String _iter1666 : struct.success) { - oprot.writeString(_iter1656); + oprot.writeString(_iter1666); } } } @@ -68147,13 +68301,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_dataconnectors_r java.util.BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1657 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.success = new java.util.ArrayList(_list1657.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1658; - for (int _i1659 = 0; _i1659 < _list1657.size; ++_i1659) + org.apache.thrift.protocol.TList _list1667 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.success = new java.util.ArrayList(_list1667.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1668; + for (int _i1669 = 0; _i1669 < _list1667.size; ++_i1669) { - _elem1658 = iprot.readString(); - struct.success.add(_elem1658); + _elem1668 = iprot.readString(); + struct.success.add(_elem1668); } } struct.setSuccessIsSet(true); @@ -72690,16 +72844,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 _map1660 = iprot.readMapBegin(); - struct.success = new java.util.HashMap(2*_map1660.size); - @org.apache.thrift.annotation.Nullable java.lang.String _key1661; - @org.apache.thrift.annotation.Nullable Type _val1662; - for (int _i1663 = 0; _i1663 < _map1660.size; ++_i1663) + org.apache.thrift.protocol.TMap _map1670 = iprot.readMapBegin(); + struct.success = new java.util.HashMap(2*_map1670.size); + @org.apache.thrift.annotation.Nullable java.lang.String _key1671; + @org.apache.thrift.annotation.Nullable Type _val1672; + for (int _i1673 = 0; _i1673 < _map1670.size; ++_i1673) { - _key1661 = iprot.readString(); - _val1662 = new Type(); - _val1662.read(iprot); - struct.success.put(_key1661, _val1662); + _key1671 = iprot.readString(); + _val1672 = new Type(); + _val1672.read(iprot); + struct.success.put(_key1671, _val1672); } iprot.readMapEnd(); } @@ -72734,10 +72888,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 (java.util.Map.Entry _iter1664 : struct.success.entrySet()) + for (java.util.Map.Entry _iter1674 : struct.success.entrySet()) { - oprot.writeString(_iter1664.getKey()); - _iter1664.getValue().write(oprot); + oprot.writeString(_iter1674.getKey()); + _iter1674.getValue().write(oprot); } oprot.writeMapEnd(); } @@ -72776,10 +72930,10 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_type_all_result if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (java.util.Map.Entry _iter1665 : struct.success.entrySet()) + for (java.util.Map.Entry _iter1675 : struct.success.entrySet()) { - oprot.writeString(_iter1665.getKey()); - _iter1665.getValue().write(oprot); + oprot.writeString(_iter1675.getKey()); + _iter1675.getValue().write(oprot); } } } @@ -72794,16 +72948,16 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_type_all_result java.util.BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TMap _map1666 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT); - struct.success = new java.util.HashMap(2*_map1666.size); - @org.apache.thrift.annotation.Nullable java.lang.String _key1667; - @org.apache.thrift.annotation.Nullable Type _val1668; - for (int _i1669 = 0; _i1669 < _map1666.size; ++_i1669) + org.apache.thrift.protocol.TMap _map1676 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT); + struct.success = new java.util.HashMap(2*_map1676.size); + @org.apache.thrift.annotation.Nullable java.lang.String _key1677; + @org.apache.thrift.annotation.Nullable Type _val1678; + for (int _i1679 = 0; _i1679 < _map1676.size; ++_i1679) { - _key1667 = iprot.readString(); - _val1668 = new Type(); - _val1668.read(iprot); - struct.success.put(_key1667, _val1668); + _key1677 = iprot.readString(); + _val1678 = new Type(); + _val1678.read(iprot); + struct.success.put(_key1677, _val1678); } } struct.setSuccessIsSet(true); @@ -73847,14 +74001,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 _list1670 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list1670.size); - @org.apache.thrift.annotation.Nullable FieldSchema _elem1671; - for (int _i1672 = 0; _i1672 < _list1670.size; ++_i1672) + org.apache.thrift.protocol.TList _list1680 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list1680.size); + @org.apache.thrift.annotation.Nullable FieldSchema _elem1681; + for (int _i1682 = 0; _i1682 < _list1680.size; ++_i1682) { - _elem1671 = new FieldSchema(); - _elem1671.read(iprot); - struct.success.add(_elem1671); + _elem1681 = new FieldSchema(); + _elem1681.read(iprot); + struct.success.add(_elem1681); } iprot.readListEnd(); } @@ -73907,9 +74061,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 _iter1673 : struct.success) + for (FieldSchema _iter1683 : struct.success) { - _iter1673.write(oprot); + _iter1683.write(oprot); } oprot.writeListEnd(); } @@ -73964,9 +74118,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_fields_result s if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (FieldSchema _iter1674 : struct.success) + for (FieldSchema _iter1684 : struct.success) { - _iter1674.write(oprot); + _iter1684.write(oprot); } } } @@ -73987,14 +74141,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_fields_result st java.util.BitSet incoming = iprot.readBitSet(4); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1675 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.success = new java.util.ArrayList(_list1675.size); - @org.apache.thrift.annotation.Nullable FieldSchema _elem1676; - for (int _i1677 = 0; _i1677 < _list1675.size; ++_i1677) + org.apache.thrift.protocol.TList _list1685 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.success = new java.util.ArrayList(_list1685.size); + @org.apache.thrift.annotation.Nullable FieldSchema _elem1686; + for (int _i1687 = 0; _i1687 < _list1685.size; ++_i1687) { - _elem1676 = new FieldSchema(); - _elem1676.read(iprot); - struct.success.add(_elem1676); + _elem1686 = new FieldSchema(); + _elem1686.read(iprot); + struct.success.add(_elem1686); } } struct.setSuccessIsSet(true); @@ -75157,14 +75311,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 _list1678 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list1678.size); - @org.apache.thrift.annotation.Nullable FieldSchema _elem1679; - for (int _i1680 = 0; _i1680 < _list1678.size; ++_i1680) + org.apache.thrift.protocol.TList _list1688 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list1688.size); + @org.apache.thrift.annotation.Nullable FieldSchema _elem1689; + for (int _i1690 = 0; _i1690 < _list1688.size; ++_i1690) { - _elem1679 = new FieldSchema(); - _elem1679.read(iprot); - struct.success.add(_elem1679); + _elem1689 = new FieldSchema(); + _elem1689.read(iprot); + struct.success.add(_elem1689); } iprot.readListEnd(); } @@ -75217,9 +75371,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 _iter1681 : struct.success) + for (FieldSchema _iter1691 : struct.success) { - _iter1681.write(oprot); + _iter1691.write(oprot); } oprot.writeListEnd(); } @@ -75274,9 +75428,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_fields_with_env if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (FieldSchema _iter1682 : struct.success) + for (FieldSchema _iter1692 : struct.success) { - _iter1682.write(oprot); + _iter1692.write(oprot); } } } @@ -75297,14 +75451,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_fields_with_envi java.util.BitSet incoming = iprot.readBitSet(4); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1683 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.success = new java.util.ArrayList(_list1683.size); - @org.apache.thrift.annotation.Nullable FieldSchema _elem1684; - for (int _i1685 = 0; _i1685 < _list1683.size; ++_i1685) + org.apache.thrift.protocol.TList _list1693 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.success = new java.util.ArrayList(_list1693.size); + @org.apache.thrift.annotation.Nullable FieldSchema _elem1694; + for (int _i1695 = 0; _i1695 < _list1693.size; ++_i1695) { - _elem1684 = new FieldSchema(); - _elem1684.read(iprot); - struct.success.add(_elem1684); + _elem1694 = new FieldSchema(); + _elem1694.read(iprot); + struct.success.add(_elem1694); } } struct.setSuccessIsSet(true); @@ -77410,14 +77564,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 _list1686 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list1686.size); - @org.apache.thrift.annotation.Nullable FieldSchema _elem1687; - for (int _i1688 = 0; _i1688 < _list1686.size; ++_i1688) + org.apache.thrift.protocol.TList _list1696 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list1696.size); + @org.apache.thrift.annotation.Nullable FieldSchema _elem1697; + for (int _i1698 = 0; _i1698 < _list1696.size; ++_i1698) { - _elem1687 = new FieldSchema(); - _elem1687.read(iprot); - struct.success.add(_elem1687); + _elem1697 = new FieldSchema(); + _elem1697.read(iprot); + struct.success.add(_elem1697); } iprot.readListEnd(); } @@ -77470,9 +77624,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 _iter1689 : struct.success) + for (FieldSchema _iter1699 : struct.success) { - _iter1689.write(oprot); + _iter1699.write(oprot); } oprot.writeListEnd(); } @@ -77527,9 +77681,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_schema_result s if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (FieldSchema _iter1690 : struct.success) + for (FieldSchema _iter1700 : struct.success) { - _iter1690.write(oprot); + _iter1700.write(oprot); } } } @@ -77550,14 +77704,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_schema_result st java.util.BitSet incoming = iprot.readBitSet(4); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1691 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.success = new java.util.ArrayList(_list1691.size); - @org.apache.thrift.annotation.Nullable FieldSchema _elem1692; - for (int _i1693 = 0; _i1693 < _list1691.size; ++_i1693) + org.apache.thrift.protocol.TList _list1701 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.success = new java.util.ArrayList(_list1701.size); + @org.apache.thrift.annotation.Nullable FieldSchema _elem1702; + for (int _i1703 = 0; _i1703 < _list1701.size; ++_i1703) { - _elem1692 = new FieldSchema(); - _elem1692.read(iprot); - struct.success.add(_elem1692); + _elem1702 = new FieldSchema(); + _elem1702.read(iprot); + struct.success.add(_elem1702); } } struct.setSuccessIsSet(true); @@ -78720,14 +78874,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 _list1694 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list1694.size); - @org.apache.thrift.annotation.Nullable FieldSchema _elem1695; - for (int _i1696 = 0; _i1696 < _list1694.size; ++_i1696) + org.apache.thrift.protocol.TList _list1704 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list1704.size); + @org.apache.thrift.annotation.Nullable FieldSchema _elem1705; + for (int _i1706 = 0; _i1706 < _list1704.size; ++_i1706) { - _elem1695 = new FieldSchema(); - _elem1695.read(iprot); - struct.success.add(_elem1695); + _elem1705 = new FieldSchema(); + _elem1705.read(iprot); + struct.success.add(_elem1705); } iprot.readListEnd(); } @@ -78780,9 +78934,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 _iter1697 : struct.success) + for (FieldSchema _iter1707 : struct.success) { - _iter1697.write(oprot); + _iter1707.write(oprot); } oprot.writeListEnd(); } @@ -78837,9 +78991,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_schema_with_env if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (FieldSchema _iter1698 : struct.success) + for (FieldSchema _iter1708 : struct.success) { - _iter1698.write(oprot); + _iter1708.write(oprot); } } } @@ -78860,14 +79014,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_schema_with_envi java.util.BitSet incoming = iprot.readBitSet(4); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1699 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.success = new java.util.ArrayList(_list1699.size); - @org.apache.thrift.annotation.Nullable FieldSchema _elem1700; - for (int _i1701 = 0; _i1701 < _list1699.size; ++_i1701) + org.apache.thrift.protocol.TList _list1709 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.success = new java.util.ArrayList(_list1709.size); + @org.apache.thrift.annotation.Nullable FieldSchema _elem1710; + for (int _i1711 = 0; _i1711 < _list1709.size; ++_i1711) { - _elem1700 = new FieldSchema(); - _elem1700.read(iprot); - struct.success.add(_elem1700); + _elem1710 = new FieldSchema(); + _elem1710.read(iprot); + struct.success.add(_elem1710); } } struct.setSuccessIsSet(true); @@ -83074,14 +83228,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 _list1702 = iprot.readListBegin(); - struct.primaryKeys = new java.util.ArrayList(_list1702.size); - @org.apache.thrift.annotation.Nullable SQLPrimaryKey _elem1703; - for (int _i1704 = 0; _i1704 < _list1702.size; ++_i1704) + org.apache.thrift.protocol.TList _list1712 = iprot.readListBegin(); + struct.primaryKeys = new java.util.ArrayList(_list1712.size); + @org.apache.thrift.annotation.Nullable SQLPrimaryKey _elem1713; + for (int _i1714 = 0; _i1714 < _list1712.size; ++_i1714) { - _elem1703 = new SQLPrimaryKey(); - _elem1703.read(iprot); - struct.primaryKeys.add(_elem1703); + _elem1713 = new SQLPrimaryKey(); + _elem1713.read(iprot); + struct.primaryKeys.add(_elem1713); } iprot.readListEnd(); } @@ -83093,14 +83247,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 _list1705 = iprot.readListBegin(); - struct.foreignKeys = new java.util.ArrayList(_list1705.size); - @org.apache.thrift.annotation.Nullable SQLForeignKey _elem1706; - for (int _i1707 = 0; _i1707 < _list1705.size; ++_i1707) + org.apache.thrift.protocol.TList _list1715 = iprot.readListBegin(); + struct.foreignKeys = new java.util.ArrayList(_list1715.size); + @org.apache.thrift.annotation.Nullable SQLForeignKey _elem1716; + for (int _i1717 = 0; _i1717 < _list1715.size; ++_i1717) { - _elem1706 = new SQLForeignKey(); - _elem1706.read(iprot); - struct.foreignKeys.add(_elem1706); + _elem1716 = new SQLForeignKey(); + _elem1716.read(iprot); + struct.foreignKeys.add(_elem1716); } iprot.readListEnd(); } @@ -83112,14 +83266,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 _list1708 = iprot.readListBegin(); - struct.uniqueConstraints = new java.util.ArrayList(_list1708.size); - @org.apache.thrift.annotation.Nullable SQLUniqueConstraint _elem1709; - for (int _i1710 = 0; _i1710 < _list1708.size; ++_i1710) + org.apache.thrift.protocol.TList _list1718 = iprot.readListBegin(); + struct.uniqueConstraints = new java.util.ArrayList(_list1718.size); + @org.apache.thrift.annotation.Nullable SQLUniqueConstraint _elem1719; + for (int _i1720 = 0; _i1720 < _list1718.size; ++_i1720) { - _elem1709 = new SQLUniqueConstraint(); - _elem1709.read(iprot); - struct.uniqueConstraints.add(_elem1709); + _elem1719 = new SQLUniqueConstraint(); + _elem1719.read(iprot); + struct.uniqueConstraints.add(_elem1719); } iprot.readListEnd(); } @@ -83131,14 +83285,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 _list1711 = iprot.readListBegin(); - struct.notNullConstraints = new java.util.ArrayList(_list1711.size); - @org.apache.thrift.annotation.Nullable SQLNotNullConstraint _elem1712; - for (int _i1713 = 0; _i1713 < _list1711.size; ++_i1713) + org.apache.thrift.protocol.TList _list1721 = iprot.readListBegin(); + struct.notNullConstraints = new java.util.ArrayList(_list1721.size); + @org.apache.thrift.annotation.Nullable SQLNotNullConstraint _elem1722; + for (int _i1723 = 0; _i1723 < _list1721.size; ++_i1723) { - _elem1712 = new SQLNotNullConstraint(); - _elem1712.read(iprot); - struct.notNullConstraints.add(_elem1712); + _elem1722 = new SQLNotNullConstraint(); + _elem1722.read(iprot); + struct.notNullConstraints.add(_elem1722); } iprot.readListEnd(); } @@ -83150,14 +83304,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, create_table_with_c case 6: // DEFAULT_CONSTRAINTS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1714 = iprot.readListBegin(); - struct.defaultConstraints = new java.util.ArrayList(_list1714.size); - @org.apache.thrift.annotation.Nullable SQLDefaultConstraint _elem1715; - for (int _i1716 = 0; _i1716 < _list1714.size; ++_i1716) + org.apache.thrift.protocol.TList _list1724 = iprot.readListBegin(); + struct.defaultConstraints = new java.util.ArrayList(_list1724.size); + @org.apache.thrift.annotation.Nullable SQLDefaultConstraint _elem1725; + for (int _i1726 = 0; _i1726 < _list1724.size; ++_i1726) { - _elem1715 = new SQLDefaultConstraint(); - _elem1715.read(iprot); - struct.defaultConstraints.add(_elem1715); + _elem1725 = new SQLDefaultConstraint(); + _elem1725.read(iprot); + struct.defaultConstraints.add(_elem1725); } iprot.readListEnd(); } @@ -83169,14 +83323,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, create_table_with_c case 7: // CHECK_CONSTRAINTS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1717 = iprot.readListBegin(); - struct.checkConstraints = new java.util.ArrayList(_list1717.size); - @org.apache.thrift.annotation.Nullable SQLCheckConstraint _elem1718; - for (int _i1719 = 0; _i1719 < _list1717.size; ++_i1719) + org.apache.thrift.protocol.TList _list1727 = iprot.readListBegin(); + struct.checkConstraints = new java.util.ArrayList(_list1727.size); + @org.apache.thrift.annotation.Nullable SQLCheckConstraint _elem1728; + for (int _i1729 = 0; _i1729 < _list1727.size; ++_i1729) { - _elem1718 = new SQLCheckConstraint(); - _elem1718.read(iprot); - struct.checkConstraints.add(_elem1718); + _elem1728 = new SQLCheckConstraint(); + _elem1728.read(iprot); + struct.checkConstraints.add(_elem1728); } iprot.readListEnd(); } @@ -83207,9 +83361,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 _iter1720 : struct.primaryKeys) + for (SQLPrimaryKey _iter1730 : struct.primaryKeys) { - _iter1720.write(oprot); + _iter1730.write(oprot); } oprot.writeListEnd(); } @@ -83219,9 +83373,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 _iter1721 : struct.foreignKeys) + for (SQLForeignKey _iter1731 : struct.foreignKeys) { - _iter1721.write(oprot); + _iter1731.write(oprot); } oprot.writeListEnd(); } @@ -83231,9 +83385,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 _iter1722 : struct.uniqueConstraints) + for (SQLUniqueConstraint _iter1732 : struct.uniqueConstraints) { - _iter1722.write(oprot); + _iter1732.write(oprot); } oprot.writeListEnd(); } @@ -83243,9 +83397,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 _iter1723 : struct.notNullConstraints) + for (SQLNotNullConstraint _iter1733 : struct.notNullConstraints) { - _iter1723.write(oprot); + _iter1733.write(oprot); } oprot.writeListEnd(); } @@ -83255,9 +83409,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, create_table_with_ oprot.writeFieldBegin(DEFAULT_CONSTRAINTS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.defaultConstraints.size())); - for (SQLDefaultConstraint _iter1724 : struct.defaultConstraints) + for (SQLDefaultConstraint _iter1734 : struct.defaultConstraints) { - _iter1724.write(oprot); + _iter1734.write(oprot); } oprot.writeListEnd(); } @@ -83267,9 +83421,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, create_table_with_ oprot.writeFieldBegin(CHECK_CONSTRAINTS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.checkConstraints.size())); - for (SQLCheckConstraint _iter1725 : struct.checkConstraints) + for (SQLCheckConstraint _iter1735 : struct.checkConstraints) { - _iter1725.write(oprot); + _iter1735.write(oprot); } oprot.writeListEnd(); } @@ -83321,54 +83475,54 @@ public void write(org.apache.thrift.protocol.TProtocol prot, create_table_with_c if (struct.isSetPrimaryKeys()) { { oprot.writeI32(struct.primaryKeys.size()); - for (SQLPrimaryKey _iter1726 : struct.primaryKeys) + for (SQLPrimaryKey _iter1736 : struct.primaryKeys) { - _iter1726.write(oprot); + _iter1736.write(oprot); } } } if (struct.isSetForeignKeys()) { { oprot.writeI32(struct.foreignKeys.size()); - for (SQLForeignKey _iter1727 : struct.foreignKeys) + for (SQLForeignKey _iter1737 : struct.foreignKeys) { - _iter1727.write(oprot); + _iter1737.write(oprot); } } } if (struct.isSetUniqueConstraints()) { { oprot.writeI32(struct.uniqueConstraints.size()); - for (SQLUniqueConstraint _iter1728 : struct.uniqueConstraints) + for (SQLUniqueConstraint _iter1738 : struct.uniqueConstraints) { - _iter1728.write(oprot); + _iter1738.write(oprot); } } } if (struct.isSetNotNullConstraints()) { { oprot.writeI32(struct.notNullConstraints.size()); - for (SQLNotNullConstraint _iter1729 : struct.notNullConstraints) + for (SQLNotNullConstraint _iter1739 : struct.notNullConstraints) { - _iter1729.write(oprot); + _iter1739.write(oprot); } } } if (struct.isSetDefaultConstraints()) { { oprot.writeI32(struct.defaultConstraints.size()); - for (SQLDefaultConstraint _iter1730 : struct.defaultConstraints) + for (SQLDefaultConstraint _iter1740 : struct.defaultConstraints) { - _iter1730.write(oprot); + _iter1740.write(oprot); } } } if (struct.isSetCheckConstraints()) { { oprot.writeI32(struct.checkConstraints.size()); - for (SQLCheckConstraint _iter1731 : struct.checkConstraints) + for (SQLCheckConstraint _iter1741 : struct.checkConstraints) { - _iter1731.write(oprot); + _iter1741.write(oprot); } } } @@ -83385,84 +83539,84 @@ public void read(org.apache.thrift.protocol.TProtocol prot, create_table_with_co } if (incoming.get(1)) { { - org.apache.thrift.protocol.TList _list1732 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.primaryKeys = new java.util.ArrayList(_list1732.size); - @org.apache.thrift.annotation.Nullable SQLPrimaryKey _elem1733; - for (int _i1734 = 0; _i1734 < _list1732.size; ++_i1734) + org.apache.thrift.protocol.TList _list1742 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.primaryKeys = new java.util.ArrayList(_list1742.size); + @org.apache.thrift.annotation.Nullable SQLPrimaryKey _elem1743; + for (int _i1744 = 0; _i1744 < _list1742.size; ++_i1744) { - _elem1733 = new SQLPrimaryKey(); - _elem1733.read(iprot); - struct.primaryKeys.add(_elem1733); + _elem1743 = new SQLPrimaryKey(); + _elem1743.read(iprot); + struct.primaryKeys.add(_elem1743); } } struct.setPrimaryKeysIsSet(true); } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list1735 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.foreignKeys = new java.util.ArrayList(_list1735.size); - @org.apache.thrift.annotation.Nullable SQLForeignKey _elem1736; - for (int _i1737 = 0; _i1737 < _list1735.size; ++_i1737) + org.apache.thrift.protocol.TList _list1745 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.foreignKeys = new java.util.ArrayList(_list1745.size); + @org.apache.thrift.annotation.Nullable SQLForeignKey _elem1746; + for (int _i1747 = 0; _i1747 < _list1745.size; ++_i1747) { - _elem1736 = new SQLForeignKey(); - _elem1736.read(iprot); - struct.foreignKeys.add(_elem1736); + _elem1746 = new SQLForeignKey(); + _elem1746.read(iprot); + struct.foreignKeys.add(_elem1746); } } struct.setForeignKeysIsSet(true); } if (incoming.get(3)) { { - org.apache.thrift.protocol.TList _list1738 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.uniqueConstraints = new java.util.ArrayList(_list1738.size); - @org.apache.thrift.annotation.Nullable SQLUniqueConstraint _elem1739; - for (int _i1740 = 0; _i1740 < _list1738.size; ++_i1740) + org.apache.thrift.protocol.TList _list1748 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.uniqueConstraints = new java.util.ArrayList(_list1748.size); + @org.apache.thrift.annotation.Nullable SQLUniqueConstraint _elem1749; + for (int _i1750 = 0; _i1750 < _list1748.size; ++_i1750) { - _elem1739 = new SQLUniqueConstraint(); - _elem1739.read(iprot); - struct.uniqueConstraints.add(_elem1739); + _elem1749 = new SQLUniqueConstraint(); + _elem1749.read(iprot); + struct.uniqueConstraints.add(_elem1749); } } struct.setUniqueConstraintsIsSet(true); } if (incoming.get(4)) { { - org.apache.thrift.protocol.TList _list1741 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.notNullConstraints = new java.util.ArrayList(_list1741.size); - @org.apache.thrift.annotation.Nullable SQLNotNullConstraint _elem1742; - for (int _i1743 = 0; _i1743 < _list1741.size; ++_i1743) + org.apache.thrift.protocol.TList _list1751 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.notNullConstraints = new java.util.ArrayList(_list1751.size); + @org.apache.thrift.annotation.Nullable SQLNotNullConstraint _elem1752; + for (int _i1753 = 0; _i1753 < _list1751.size; ++_i1753) { - _elem1742 = new SQLNotNullConstraint(); - _elem1742.read(iprot); - struct.notNullConstraints.add(_elem1742); + _elem1752 = new SQLNotNullConstraint(); + _elem1752.read(iprot); + struct.notNullConstraints.add(_elem1752); } } struct.setNotNullConstraintsIsSet(true); } if (incoming.get(5)) { { - org.apache.thrift.protocol.TList _list1744 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.defaultConstraints = new java.util.ArrayList(_list1744.size); - @org.apache.thrift.annotation.Nullable SQLDefaultConstraint _elem1745; - for (int _i1746 = 0; _i1746 < _list1744.size; ++_i1746) + org.apache.thrift.protocol.TList _list1754 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.defaultConstraints = new java.util.ArrayList(_list1754.size); + @org.apache.thrift.annotation.Nullable SQLDefaultConstraint _elem1755; + for (int _i1756 = 0; _i1756 < _list1754.size; ++_i1756) { - _elem1745 = new SQLDefaultConstraint(); - _elem1745.read(iprot); - struct.defaultConstraints.add(_elem1745); + _elem1755 = new SQLDefaultConstraint(); + _elem1755.read(iprot); + struct.defaultConstraints.add(_elem1755); } } struct.setDefaultConstraintsIsSet(true); } if (incoming.get(6)) { { - org.apache.thrift.protocol.TList _list1747 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.checkConstraints = new java.util.ArrayList(_list1747.size); - @org.apache.thrift.annotation.Nullable SQLCheckConstraint _elem1748; - for (int _i1749 = 0; _i1749 < _list1747.size; ++_i1749) + org.apache.thrift.protocol.TList _list1757 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.checkConstraints = new java.util.ArrayList(_list1757.size); + @org.apache.thrift.annotation.Nullable SQLCheckConstraint _elem1758; + for (int _i1759 = 0; _i1759 < _list1757.size; ++_i1759) { - _elem1748 = new SQLCheckConstraint(); - _elem1748.read(iprot); - struct.checkConstraints.add(_elem1748); + _elem1758 = new SQLCheckConstraint(); + _elem1758.read(iprot); + struct.checkConstraints.add(_elem1758); } } struct.setCheckConstraintsIsSet(true); @@ -95840,13 +95994,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 _list1750 = iprot.readListBegin(); - struct.partNames = new java.util.ArrayList(_list1750.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1751; - for (int _i1752 = 0; _i1752 < _list1750.size; ++_i1752) + org.apache.thrift.protocol.TList _list1760 = iprot.readListBegin(); + struct.partNames = new java.util.ArrayList(_list1760.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1761; + for (int _i1762 = 0; _i1762 < _list1760.size; ++_i1762) { - _elem1751 = iprot.readString(); - struct.partNames.add(_elem1751); + _elem1761 = iprot.readString(); + struct.partNames.add(_elem1761); } iprot.readListEnd(); } @@ -95882,9 +96036,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 (java.lang.String _iter1753 : struct.partNames) + for (java.lang.String _iter1763 : struct.partNames) { - oprot.writeString(_iter1753); + oprot.writeString(_iter1763); } oprot.writeListEnd(); } @@ -95927,9 +96081,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, truncate_table_args if (struct.isSetPartNames()) { { oprot.writeI32(struct.partNames.size()); - for (java.lang.String _iter1754 : struct.partNames) + for (java.lang.String _iter1764 : struct.partNames) { - oprot.writeString(_iter1754); + oprot.writeString(_iter1764); } } } @@ -95949,13 +96103,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, truncate_table_args } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list1755 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.partNames = new java.util.ArrayList(_list1755.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1756; - for (int _i1757 = 0; _i1757 < _list1755.size; ++_i1757) + org.apache.thrift.protocol.TList _list1765 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.partNames = new java.util.ArrayList(_list1765.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1766; + for (int _i1767 = 0; _i1767 < _list1765.size; ++_i1767) { - _elem1756 = iprot.readString(); - struct.partNames.add(_elem1756); + _elem1766 = iprot.readString(); + struct.partNames.add(_elem1766); } } struct.setPartNamesIsSet(true); @@ -98033,13 +98187,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 _list1758 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list1758.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1759; - for (int _i1760 = 0; _i1760 < _list1758.size; ++_i1760) + org.apache.thrift.protocol.TList _list1768 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list1768.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1769; + for (int _i1770 = 0; _i1770 < _list1768.size; ++_i1770) { - _elem1759 = iprot.readString(); - struct.success.add(_elem1759); + _elem1769 = iprot.readString(); + struct.success.add(_elem1769); } iprot.readListEnd(); } @@ -98074,9 +98228,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 (java.lang.String _iter1761 : struct.success) + for (java.lang.String _iter1771 : struct.success) { - oprot.writeString(_iter1761); + oprot.writeString(_iter1771); } oprot.writeListEnd(); } @@ -98115,9 +98269,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_tables_result s if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (java.lang.String _iter1762 : struct.success) + for (java.lang.String _iter1772 : struct.success) { - oprot.writeString(_iter1762); + oprot.writeString(_iter1772); } } } @@ -98132,13 +98286,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_tables_result st java.util.BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1763 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.success = new java.util.ArrayList(_list1763.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1764; - for (int _i1765 = 0; _i1765 < _list1763.size; ++_i1765) + org.apache.thrift.protocol.TList _list1773 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.success = new java.util.ArrayList(_list1773.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1774; + for (int _i1775 = 0; _i1775 < _list1773.size; ++_i1775) { - _elem1764 = iprot.readString(); - struct.success.add(_elem1764); + _elem1774 = iprot.readString(); + struct.success.add(_elem1774); } } struct.setSuccessIsSet(true); @@ -99121,13 +99275,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 _list1766 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list1766.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1767; - for (int _i1768 = 0; _i1768 < _list1766.size; ++_i1768) + org.apache.thrift.protocol.TList _list1776 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list1776.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1777; + for (int _i1778 = 0; _i1778 < _list1776.size; ++_i1778) { - _elem1767 = iprot.readString(); - struct.success.add(_elem1767); + _elem1777 = iprot.readString(); + struct.success.add(_elem1777); } iprot.readListEnd(); } @@ -99162,9 +99316,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 (java.lang.String _iter1769 : struct.success) + for (java.lang.String _iter1779 : struct.success) { - oprot.writeString(_iter1769); + oprot.writeString(_iter1779); } oprot.writeListEnd(); } @@ -99203,9 +99357,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_tables_by_type_ if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (java.lang.String _iter1770 : struct.success) + for (java.lang.String _iter1780 : struct.success) { - oprot.writeString(_iter1770); + oprot.writeString(_iter1780); } } } @@ -99220,13 +99374,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_tables_by_type_r java.util.BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1771 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.success = new java.util.ArrayList(_list1771.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1772; - for (int _i1773 = 0; _i1773 < _list1771.size; ++_i1773) + org.apache.thrift.protocol.TList _list1781 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.success = new java.util.ArrayList(_list1781.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1782; + for (int _i1783 = 0; _i1783 < _list1781.size; ++_i1783) { - _elem1772 = iprot.readString(); - struct.success.add(_elem1772); + _elem1782 = iprot.readString(); + struct.success.add(_elem1782); } } struct.setSuccessIsSet(true); @@ -99892,14 +100046,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_all_materialize case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1774 = iprot.readListBegin(); - struct.success = new java.util.ArrayList
(_list1774.size); - @org.apache.thrift.annotation.Nullable Table _elem1775; - for (int _i1776 = 0; _i1776 < _list1774.size; ++_i1776) + org.apache.thrift.protocol.TList _list1784 = iprot.readListBegin(); + struct.success = new java.util.ArrayList
(_list1784.size); + @org.apache.thrift.annotation.Nullable Table _elem1785; + for (int _i1786 = 0; _i1786 < _list1784.size; ++_i1786) { - _elem1775 = new Table(); - _elem1775.read(iprot); - struct.success.add(_elem1775); + _elem1785 = new Table(); + _elem1785.read(iprot); + struct.success.add(_elem1785); } iprot.readListEnd(); } @@ -99934,9 +100088,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_all_materializ oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (Table _iter1777 : struct.success) + for (Table _iter1787 : struct.success) { - _iter1777.write(oprot); + _iter1787.write(oprot); } oprot.writeListEnd(); } @@ -99975,9 +100129,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_all_materialize if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Table _iter1778 : struct.success) + for (Table _iter1788 : struct.success) { - _iter1778.write(oprot); + _iter1788.write(oprot); } } } @@ -99992,14 +100146,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_all_materialized java.util.BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1779 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.success = new java.util.ArrayList
(_list1779.size); - @org.apache.thrift.annotation.Nullable Table _elem1780; - for (int _i1781 = 0; _i1781 < _list1779.size; ++_i1781) + org.apache.thrift.protocol.TList _list1789 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.success = new java.util.ArrayList
(_list1789.size); + @org.apache.thrift.annotation.Nullable Table _elem1790; + for (int _i1791 = 0; _i1791 < _list1789.size; ++_i1791) { - _elem1780 = new Table(); - _elem1780.read(iprot); - struct.success.add(_elem1780); + _elem1790 = new Table(); + _elem1790.read(iprot); + struct.success.add(_elem1790); } } struct.setSuccessIsSet(true); @@ -100774,13 +100928,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 _list1782 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list1782.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1783; - for (int _i1784 = 0; _i1784 < _list1782.size; ++_i1784) + org.apache.thrift.protocol.TList _list1792 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list1792.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1793; + for (int _i1794 = 0; _i1794 < _list1792.size; ++_i1794) { - _elem1783 = iprot.readString(); - struct.success.add(_elem1783); + _elem1793 = iprot.readString(); + struct.success.add(_elem1793); } iprot.readListEnd(); } @@ -100815,9 +100969,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 (java.lang.String _iter1785 : struct.success) + for (java.lang.String _iter1795 : struct.success) { - oprot.writeString(_iter1785); + oprot.writeString(_iter1795); } oprot.writeListEnd(); } @@ -100856,9 +101010,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_materialized_vi if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (java.lang.String _iter1786 : struct.success) + for (java.lang.String _iter1796 : struct.success) { - oprot.writeString(_iter1786); + oprot.writeString(_iter1796); } } } @@ -100873,13 +101027,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_materialized_vie java.util.BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1787 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.success = new java.util.ArrayList(_list1787.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1788; - for (int _i1789 = 0; _i1789 < _list1787.size; ++_i1789) + org.apache.thrift.protocol.TList _list1797 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.success = new java.util.ArrayList(_list1797.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1798; + for (int _i1799 = 0; _i1799 < _list1797.size; ++_i1799) { - _elem1788 = iprot.readString(); - struct.success.add(_elem1788); + _elem1798 = iprot.readString(); + struct.success.add(_elem1798); } } struct.setSuccessIsSet(true); @@ -101389,13 +101543,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 _list1790 = iprot.readListBegin(); - struct.tbl_types = new java.util.ArrayList(_list1790.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1791; - for (int _i1792 = 0; _i1792 < _list1790.size; ++_i1792) + org.apache.thrift.protocol.TList _list1800 = iprot.readListBegin(); + struct.tbl_types = new java.util.ArrayList(_list1800.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1801; + for (int _i1802 = 0; _i1802 < _list1800.size; ++_i1802) { - _elem1791 = iprot.readString(); - struct.tbl_types.add(_elem1791); + _elem1801 = iprot.readString(); + struct.tbl_types.add(_elem1801); } iprot.readListEnd(); } @@ -101431,9 +101585,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 (java.lang.String _iter1793 : struct.tbl_types) + for (java.lang.String _iter1803 : struct.tbl_types) { - oprot.writeString(_iter1793); + oprot.writeString(_iter1803); } oprot.writeListEnd(); } @@ -101476,9 +101630,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 (java.lang.String _iter1794 : struct.tbl_types) + for (java.lang.String _iter1804 : struct.tbl_types) { - oprot.writeString(_iter1794); + oprot.writeString(_iter1804); } } } @@ -101498,13 +101652,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_table_meta_args } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list1795 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.tbl_types = new java.util.ArrayList(_list1795.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1796; - for (int _i1797 = 0; _i1797 < _list1795.size; ++_i1797) + org.apache.thrift.protocol.TList _list1805 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.tbl_types = new java.util.ArrayList(_list1805.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1806; + for (int _i1807 = 0; _i1807 < _list1805.size; ++_i1807) { - _elem1796 = iprot.readString(); - struct.tbl_types.add(_elem1796); + _elem1806 = iprot.readString(); + struct.tbl_types.add(_elem1806); } } struct.setTbl_typesIsSet(true); @@ -101915,14 +102069,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 _list1798 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list1798.size); - @org.apache.thrift.annotation.Nullable TableMeta _elem1799; - for (int _i1800 = 0; _i1800 < _list1798.size; ++_i1800) + org.apache.thrift.protocol.TList _list1808 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list1808.size); + @org.apache.thrift.annotation.Nullable TableMeta _elem1809; + for (int _i1810 = 0; _i1810 < _list1808.size; ++_i1810) { - _elem1799 = new TableMeta(); - _elem1799.read(iprot); - struct.success.add(_elem1799); + _elem1809 = new TableMeta(); + _elem1809.read(iprot); + struct.success.add(_elem1809); } iprot.readListEnd(); } @@ -101957,9 +102111,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 _iter1801 : struct.success) + for (TableMeta _iter1811 : struct.success) { - _iter1801.write(oprot); + _iter1811.write(oprot); } oprot.writeListEnd(); } @@ -101998,9 +102152,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_table_meta_resu if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (TableMeta _iter1802 : struct.success) + for (TableMeta _iter1812 : struct.success) { - _iter1802.write(oprot); + _iter1812.write(oprot); } } } @@ -102015,14 +102169,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_table_meta_resul java.util.BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1803 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.success = new java.util.ArrayList(_list1803.size); - @org.apache.thrift.annotation.Nullable TableMeta _elem1804; - for (int _i1805 = 0; _i1805 < _list1803.size; ++_i1805) + org.apache.thrift.protocol.TList _list1813 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.success = new java.util.ArrayList(_list1813.size); + @org.apache.thrift.annotation.Nullable TableMeta _elem1814; + for (int _i1815 = 0; _i1815 < _list1813.size; ++_i1815) { - _elem1804 = new TableMeta(); - _elem1804.read(iprot); - struct.success.add(_elem1804); + _elem1814 = new TableMeta(); + _elem1814.read(iprot); + struct.success.add(_elem1814); } } struct.setSuccessIsSet(true); @@ -102797,13 +102951,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 _list1806 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list1806.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1807; - for (int _i1808 = 0; _i1808 < _list1806.size; ++_i1808) + org.apache.thrift.protocol.TList _list1816 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list1816.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1817; + for (int _i1818 = 0; _i1818 < _list1816.size; ++_i1818) { - _elem1807 = iprot.readString(); - struct.success.add(_elem1807); + _elem1817 = iprot.readString(); + struct.success.add(_elem1817); } iprot.readListEnd(); } @@ -102838,9 +102992,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 (java.lang.String _iter1809 : struct.success) + for (java.lang.String _iter1819 : struct.success) { - oprot.writeString(_iter1809); + oprot.writeString(_iter1819); } oprot.writeListEnd(); } @@ -102879,9 +103033,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_all_tables_resu if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (java.lang.String _iter1810 : struct.success) + for (java.lang.String _iter1820 : struct.success) { - oprot.writeString(_iter1810); + oprot.writeString(_iter1820); } } } @@ -102896,13 +103050,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_all_tables_resul java.util.BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1811 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.success = new java.util.ArrayList(_list1811.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1812; - for (int _i1813 = 0; _i1813 < _list1811.size; ++_i1813) + org.apache.thrift.protocol.TList _list1821 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.success = new java.util.ArrayList(_list1821.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1822; + for (int _i1823 = 0; _i1823 < _list1821.size; ++_i1823) { - _elem1812 = iprot.readString(); - struct.success.add(_elem1812); + _elem1822 = iprot.readString(); + struct.success.add(_elem1822); } } struct.setSuccessIsSet(true); @@ -103685,14 +103839,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_tables_ext_resu case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1814 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list1814.size); - @org.apache.thrift.annotation.Nullable ExtendedTableInfo _elem1815; - for (int _i1816 = 0; _i1816 < _list1814.size; ++_i1816) + org.apache.thrift.protocol.TList _list1824 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list1824.size); + @org.apache.thrift.annotation.Nullable ExtendedTableInfo _elem1825; + for (int _i1826 = 0; _i1826 < _list1824.size; ++_i1826) { - _elem1815 = new ExtendedTableInfo(); - _elem1815.read(iprot); - struct.success.add(_elem1815); + _elem1825 = new ExtendedTableInfo(); + _elem1825.read(iprot); + struct.success.add(_elem1825); } iprot.readListEnd(); } @@ -103727,9 +103881,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_tables_ext_res oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (ExtendedTableInfo _iter1817 : struct.success) + for (ExtendedTableInfo _iter1827 : struct.success) { - _iter1817.write(oprot); + _iter1827.write(oprot); } oprot.writeListEnd(); } @@ -103768,9 +103922,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_tables_ext_resu if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (ExtendedTableInfo _iter1818 : struct.success) + for (ExtendedTableInfo _iter1828 : struct.success) { - _iter1818.write(oprot); + _iter1828.write(oprot); } } } @@ -103785,14 +103939,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_tables_ext_resul java.util.BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1819 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.success = new java.util.ArrayList(_list1819.size); - @org.apache.thrift.annotation.Nullable ExtendedTableInfo _elem1820; - for (int _i1821 = 0; _i1821 < _list1819.size; ++_i1821) + org.apache.thrift.protocol.TList _list1829 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.success = new java.util.ArrayList(_list1829.size); + @org.apache.thrift.annotation.Nullable ExtendedTableInfo _elem1830; + for (int _i1831 = 0; _i1831 < _list1829.size; ++_i1831) { - _elem1820 = new ExtendedTableInfo(); - _elem1820.read(iprot); - struct.success.add(_elem1820); + _elem1830 = new ExtendedTableInfo(); + _elem1830.read(iprot); + struct.success.add(_elem1830); } } struct.setSuccessIsSet(true); @@ -109343,13 +109497,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 _list1822 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list1822.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1823; - for (int _i1824 = 0; _i1824 < _list1822.size; ++_i1824) + org.apache.thrift.protocol.TList _list1832 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list1832.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1833; + for (int _i1834 = 0; _i1834 < _list1832.size; ++_i1834) { - _elem1823 = iprot.readString(); - struct.success.add(_elem1823); + _elem1833 = iprot.readString(); + struct.success.add(_elem1833); } iprot.readListEnd(); } @@ -109402,9 +109556,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 (java.lang.String _iter1825 : struct.success) + for (java.lang.String _iter1835 : struct.success) { - oprot.writeString(_iter1825); + oprot.writeString(_iter1835); } oprot.writeListEnd(); } @@ -109459,9 +109613,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_table_names_by_ if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (java.lang.String _iter1826 : struct.success) + for (java.lang.String _iter1836 : struct.success) { - oprot.writeString(_iter1826); + oprot.writeString(_iter1836); } } } @@ -109482,13 +109636,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_table_names_by_f java.util.BitSet incoming = iprot.readBitSet(4); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1827 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.success = new java.util.ArrayList(_list1827.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1828; - for (int _i1829 = 0; _i1829 < _list1827.size; ++_i1829) + org.apache.thrift.protocol.TList _list1837 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.success = new java.util.ArrayList(_list1837.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1838; + for (int _i1839 = 0; _i1839 < _list1837.size; ++_i1839) { - _elem1828 = iprot.readString(); - struct.success.add(_elem1828); + _elem1838 = iprot.readString(); + struct.success.add(_elem1838); } } struct.setSuccessIsSet(true); @@ -113805,19 +113959,19 @@ private static S scheme(org.apache. } } - @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class add_partition_args 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("add_partition_args"); + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class update_table_params_args 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("update_table_params_args"); - private static final org.apache.thrift.protocol.TField NEW_PART_FIELD_DESC = new org.apache.thrift.protocol.TField("new_part", org.apache.thrift.protocol.TType.STRUCT, (short)1); + private static final org.apache.thrift.protocol.TField UPDATES_FIELD_DESC = new org.apache.thrift.protocol.TField("updates", org.apache.thrift.protocol.TType.LIST, (short)1); - private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new add_partition_argsStandardSchemeFactory(); - private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new add_partition_argsTupleSchemeFactory(); + private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new update_table_params_argsStandardSchemeFactory(); + private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new update_table_params_argsTupleSchemeFactory(); - private @org.apache.thrift.annotation.Nullable Partition new_part; // required + private @org.apache.thrift.annotation.Nullable java.util.List updates; // 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 { - NEW_PART((short)1, "new_part"); + UPDATES((short)1, "updates"); private static final java.util.Map byName = new java.util.HashMap(); @@ -113833,8 +113987,8 @@ public enum _Fields implements org.apache.thrift.TFieldIdEnum { @org.apache.thrift.annotation.Nullable public static _Fields findByThriftId(int fieldId) { switch(fieldId) { - case 1: // NEW_PART - return NEW_PART; + case 1: // UPDATES + return UPDATES; default: return null; } @@ -113879,71 +114033,92 @@ public java.lang.String getFieldName() { public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; static { java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.NEW_PART, new org.apache.thrift.meta_data.FieldMetaData("new_part", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, Partition.class))); + tmpMap.put(_Fields.UPDATES, new org.apache.thrift.meta_data.FieldMetaData("updates", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TableParamsUpdate.class)))); metaDataMap = java.util.Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(add_partition_args.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(update_table_params_args.class, metaDataMap); } - public add_partition_args() { + public update_table_params_args() { } - public add_partition_args( - Partition new_part) + public update_table_params_args( + java.util.List updates) { this(); - this.new_part = new_part; + this.updates = updates; } /** * Performs a deep copy on other. */ - public add_partition_args(add_partition_args other) { - if (other.isSetNew_part()) { - this.new_part = new Partition(other.new_part); + public update_table_params_args(update_table_params_args other) { + if (other.isSetUpdates()) { + java.util.List __this__updates = new java.util.ArrayList(other.updates.size()); + for (TableParamsUpdate other_element : other.updates) { + __this__updates.add(new TableParamsUpdate(other_element)); + } + this.updates = __this__updates; } } - public add_partition_args deepCopy() { - return new add_partition_args(this); + public update_table_params_args deepCopy() { + return new update_table_params_args(this); } @Override public void clear() { - this.new_part = null; + this.updates = null; + } + + public int getUpdatesSize() { + return (this.updates == null) ? 0 : this.updates.size(); } @org.apache.thrift.annotation.Nullable - public Partition getNew_part() { - return this.new_part; + public java.util.Iterator getUpdatesIterator() { + return (this.updates == null) ? null : this.updates.iterator(); } - public void setNew_part(@org.apache.thrift.annotation.Nullable Partition new_part) { - this.new_part = new_part; + public void addToUpdates(TableParamsUpdate elem) { + if (this.updates == null) { + this.updates = new java.util.ArrayList(); + } + this.updates.add(elem); } - public void unsetNew_part() { - this.new_part = null; + @org.apache.thrift.annotation.Nullable + public java.util.List getUpdates() { + return this.updates; } - /** Returns true if field new_part is set (has been assigned a value) and false otherwise */ - public boolean isSetNew_part() { - return this.new_part != null; + public void setUpdates(@org.apache.thrift.annotation.Nullable java.util.List updates) { + this.updates = updates; } - public void setNew_partIsSet(boolean value) { + public void unsetUpdates() { + this.updates = null; + } + + /** Returns true if field updates is set (has been assigned a value) and false otherwise */ + public boolean isSetUpdates() { + return this.updates != null; + } + + public void setUpdatesIsSet(boolean value) { if (!value) { - this.new_part = null; + this.updates = null; } } public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) { switch (field) { - case NEW_PART: + case UPDATES: if (value == null) { - unsetNew_part(); + unsetUpdates(); } else { - setNew_part((Partition)value); + setUpdates((java.util.List)value); } break; @@ -113953,8 +114128,8 @@ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable @org.apache.thrift.annotation.Nullable public java.lang.Object getFieldValue(_Fields field) { switch (field) { - case NEW_PART: - return getNew_part(); + case UPDATES: + return getUpdates(); } throw new java.lang.IllegalStateException(); @@ -113967,31 +114142,31 @@ public boolean isSet(_Fields field) { } switch (field) { - case NEW_PART: - return isSetNew_part(); + case UPDATES: + return isSetUpdates(); } throw new java.lang.IllegalStateException(); } @Override public boolean equals(java.lang.Object that) { - if (that instanceof add_partition_args) - return this.equals((add_partition_args)that); + if (that instanceof update_table_params_args) + return this.equals((update_table_params_args)that); return false; } - public boolean equals(add_partition_args that) { + public boolean equals(update_table_params_args that) { if (that == null) return false; if (this == that) return true; - boolean this_present_new_part = true && this.isSetNew_part(); - boolean that_present_new_part = true && that.isSetNew_part(); - if (this_present_new_part || that_present_new_part) { - if (!(this_present_new_part && that_present_new_part)) + boolean this_present_updates = true && this.isSetUpdates(); + boolean that_present_updates = true && that.isSetUpdates(); + if (this_present_updates || that_present_updates) { + if (!(this_present_updates && that_present_updates)) return false; - if (!this.new_part.equals(that.new_part)) + if (!this.updates.equals(that.updates)) return false; } @@ -114002,27 +114177,27 @@ public boolean equals(add_partition_args that) { public int hashCode() { int hashCode = 1; - hashCode = hashCode * 8191 + ((isSetNew_part()) ? 131071 : 524287); - if (isSetNew_part()) - hashCode = hashCode * 8191 + new_part.hashCode(); + hashCode = hashCode * 8191 + ((isSetUpdates()) ? 131071 : 524287); + if (isSetUpdates()) + hashCode = hashCode * 8191 + updates.hashCode(); return hashCode; } @Override - public int compareTo(add_partition_args other) { + public int compareTo(update_table_params_args other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } int lastComparison = 0; - lastComparison = java.lang.Boolean.compare(isSetNew_part(), other.isSetNew_part()); + lastComparison = java.lang.Boolean.compare(isSetUpdates(), other.isSetUpdates()); if (lastComparison != 0) { return lastComparison; } - if (isSetNew_part()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.new_part, other.new_part); + if (isSetUpdates()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.updates, other.updates); if (lastComparison != 0) { return lastComparison; } @@ -114045,14 +114220,14 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public java.lang.String toString() { - java.lang.StringBuilder sb = new java.lang.StringBuilder("add_partition_args("); + java.lang.StringBuilder sb = new java.lang.StringBuilder("update_table_params_args("); boolean first = true; - sb.append("new_part:"); - if (this.new_part == null) { + sb.append("updates:"); + if (this.updates == null) { sb.append("null"); } else { - sb.append(this.new_part); + sb.append(this.updates); } first = false; sb.append(")"); @@ -114062,9 +114237,6 @@ public java.lang.String toString() { public void validate() throws org.apache.thrift.TException { // check for required fields // check for sub-struct validity - if (new_part != null) { - new_part.validate(); - } } private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { @@ -114083,15 +114255,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class add_partition_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory { - public add_partition_argsStandardScheme getScheme() { - return new add_partition_argsStandardScheme(); + private static class update_table_params_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory { + public update_table_params_argsStandardScheme getScheme() { + return new update_table_params_argsStandardScheme(); } } - private static class add_partition_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme { + private static class update_table_params_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, add_partition_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, update_table_params_args struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -114101,11 +114273,21 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, add_partition_args break; } switch (schemeField.id) { - case 1: // NEW_PART - if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.new_part = new Partition(); - struct.new_part.read(iprot); - struct.setNew_partIsSet(true); + case 1: // UPDATES + if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { + { + org.apache.thrift.protocol.TList _list1840 = iprot.readListBegin(); + struct.updates = new java.util.ArrayList(_list1840.size); + @org.apache.thrift.annotation.Nullable TableParamsUpdate _elem1841; + for (int _i1842 = 0; _i1842 < _list1840.size; ++_i1842) + { + _elem1841 = new TableParamsUpdate(); + _elem1841.read(iprot); + struct.updates.add(_elem1841); + } + iprot.readListEnd(); + } + struct.setUpdatesIsSet(true); } else { org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } @@ -114119,13 +114301,20 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, add_partition_args struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, add_partition_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, update_table_params_args struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); - if (struct.new_part != null) { - oprot.writeFieldBegin(NEW_PART_FIELD_DESC); - struct.new_part.write(oprot); + if (struct.updates != null) { + oprot.writeFieldBegin(UPDATES_FIELD_DESC); + { + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.updates.size())); + for (TableParamsUpdate _iter1843 : struct.updates) + { + _iter1843.write(oprot); + } + oprot.writeListEnd(); + } oprot.writeFieldEnd(); } oprot.writeFieldStop(); @@ -114134,35 +114323,50 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, add_partition_args } - private static class add_partition_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory { - public add_partition_argsTupleScheme getScheme() { - return new add_partition_argsTupleScheme(); + private static class update_table_params_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory { + public update_table_params_argsTupleScheme getScheme() { + return new update_table_params_argsTupleScheme(); } } - private static class add_partition_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme { + private static class update_table_params_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, add_partition_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, update_table_params_args struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot; java.util.BitSet optionals = new java.util.BitSet(); - if (struct.isSetNew_part()) { + if (struct.isSetUpdates()) { optionals.set(0); } oprot.writeBitSet(optionals, 1); - if (struct.isSetNew_part()) { - struct.new_part.write(oprot); + if (struct.isSetUpdates()) { + { + oprot.writeI32(struct.updates.size()); + for (TableParamsUpdate _iter1844 : struct.updates) + { + _iter1844.write(oprot); + } + } } } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, add_partition_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, update_table_params_args struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot; java.util.BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { - struct.new_part = new Partition(); - struct.new_part.read(iprot); - struct.setNew_partIsSet(true); + { + org.apache.thrift.protocol.TList _list1845 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.updates = new java.util.ArrayList(_list1845.size); + @org.apache.thrift.annotation.Nullable TableParamsUpdate _elem1846; + for (int _i1847 = 0; _i1847 < _list1845.size; ++_i1847) + { + _elem1846 = new TableParamsUpdate(); + _elem1846.read(iprot); + struct.updates.add(_elem1846); + } + } + struct.setUpdatesIsSet(true); } } } @@ -114172,28 +114376,19 @@ private static S scheme(org.apache. } } - @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class add_partition_result 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("add_partition_result"); + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class update_table_params_result 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("update_table_params_result"); - private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0); private static final org.apache.thrift.protocol.TField O1_FIELD_DESC = new org.apache.thrift.protocol.TField("o1", org.apache.thrift.protocol.TType.STRUCT, (short)1); - private static final org.apache.thrift.protocol.TField O2_FIELD_DESC = new org.apache.thrift.protocol.TField("o2", org.apache.thrift.protocol.TType.STRUCT, (short)2); - private static final org.apache.thrift.protocol.TField O3_FIELD_DESC = new org.apache.thrift.protocol.TField("o3", org.apache.thrift.protocol.TType.STRUCT, (short)3); - private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new add_partition_resultStandardSchemeFactory(); - private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new add_partition_resultTupleSchemeFactory(); + private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new update_table_params_resultStandardSchemeFactory(); + private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new update_table_params_resultTupleSchemeFactory(); - private @org.apache.thrift.annotation.Nullable Partition success; // required - private @org.apache.thrift.annotation.Nullable InvalidObjectException o1; // required - private @org.apache.thrift.annotation.Nullable AlreadyExistsException o2; // required - private @org.apache.thrift.annotation.Nullable MetaException o3; // required + private @org.apache.thrift.annotation.Nullable MetaException o1; // 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 { - SUCCESS((short)0, "success"), - O1((short)1, "o1"), - O2((short)2, "o2"), - O3((short)3, "o3"); + O1((short)1, "o1"); private static final java.util.Map byName = new java.util.HashMap(); @@ -114209,14 +114404,754 @@ public enum _Fields implements org.apache.thrift.TFieldIdEnum { @org.apache.thrift.annotation.Nullable public static _Fields findByThriftId(int fieldId) { switch(fieldId) { - case 0: // SUCCESS - return SUCCESS; case 1: // O1 return O1; - case 2: // O2 - return O2; - case 3: // O3 - return O3; + 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 java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + @org.apache.thrift.annotation.Nullable + public static _Fields findByName(java.lang.String name) { + return byName.get(name); + } + + private final short _thriftId; + private final java.lang.String _fieldName; + + _Fields(short thriftId, java.lang.String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public java.lang.String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.O1, new org.apache.thrift.meta_data.FieldMetaData("o1", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, MetaException.class))); + metaDataMap = java.util.Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(update_table_params_result.class, metaDataMap); + } + + public update_table_params_result() { + } + + public update_table_params_result( + MetaException o1) + { + this(); + this.o1 = o1; + } + + /** + * Performs a deep copy on other. + */ + public update_table_params_result(update_table_params_result other) { + if (other.isSetO1()) { + this.o1 = new MetaException(other.o1); + } + } + + public update_table_params_result deepCopy() { + return new update_table_params_result(this); + } + + @Override + public void clear() { + this.o1 = null; + } + + @org.apache.thrift.annotation.Nullable + public MetaException getO1() { + return this.o1; + } + + public void setO1(@org.apache.thrift.annotation.Nullable MetaException o1) { + this.o1 = o1; + } + + public void unsetO1() { + this.o1 = null; + } + + /** Returns true if field o1 is set (has been assigned a value) and false otherwise */ + public boolean isSetO1() { + return this.o1 != null; + } + + public void setO1IsSet(boolean value) { + if (!value) { + this.o1 = null; + } + } + + public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) { + switch (field) { + case O1: + if (value == null) { + unsetO1(); + } else { + setO1((MetaException)value); + } + break; + + } + } + + @org.apache.thrift.annotation.Nullable + public java.lang.Object getFieldValue(_Fields field) { + switch (field) { + case O1: + return getO1(); + + } + throw new java.lang.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 java.lang.IllegalArgumentException(); + } + + switch (field) { + case O1: + return isSetO1(); + } + throw new java.lang.IllegalStateException(); + } + + @Override + public boolean equals(java.lang.Object that) { + if (that instanceof update_table_params_result) + return this.equals((update_table_params_result)that); + return false; + } + + public boolean equals(update_table_params_result that) { + if (that == null) + return false; + if (this == that) + return true; + + boolean this_present_o1 = true && this.isSetO1(); + boolean that_present_o1 = true && that.isSetO1(); + if (this_present_o1 || that_present_o1) { + if (!(this_present_o1 && that_present_o1)) + return false; + if (!this.o1.equals(that.o1)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + int hashCode = 1; + + hashCode = hashCode * 8191 + ((isSetO1()) ? 131071 : 524287); + if (isSetO1()) + hashCode = hashCode * 8191 + o1.hashCode(); + + return hashCode; + } + + @Override + public int compareTo(update_table_params_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = java.lang.Boolean.compare(isSetO1(), other.isSetO1()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetO1()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.o1, other.o1); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + @org.apache.thrift.annotation.Nullable + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + scheme(iprot).read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + scheme(oprot).write(oprot, this); + } + + @Override + public java.lang.String toString() { + java.lang.StringBuilder sb = new java.lang.StringBuilder("update_table_params_result("); + boolean first = true; + + sb.append("o1:"); + if (this.o1 == null) { + sb.append("null"); + } else { + sb.append(this.o1); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // 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, java.lang.ClassNotFoundException { + try { + 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 update_table_params_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory { + public update_table_params_resultStandardScheme getScheme() { + return new update_table_params_resultStandardScheme(); + } + } + + private static class update_table_params_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, update_table_params_result 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: // O1 + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.o1 = new MetaException(); + struct.o1.read(iprot); + struct.setO1IsSet(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, update_table_params_result struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.o1 != null) { + oprot.writeFieldBegin(O1_FIELD_DESC); + struct.o1.write(oprot); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class update_table_params_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory { + public update_table_params_resultTupleScheme getScheme() { + return new update_table_params_resultTupleScheme(); + } + } + + private static class update_table_params_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, update_table_params_result struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot; + java.util.BitSet optionals = new java.util.BitSet(); + if (struct.isSetO1()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetO1()) { + struct.o1.write(oprot); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, update_table_params_result struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot; + java.util.BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.o1 = new MetaException(); + struct.o1.read(iprot); + struct.setO1IsSet(true); + } + } + } + + private static S scheme(org.apache.thrift.protocol.TProtocol proto) { + return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme(); + } + } + + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class add_partition_args 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("add_partition_args"); + + private static final org.apache.thrift.protocol.TField NEW_PART_FIELD_DESC = new org.apache.thrift.protocol.TField("new_part", org.apache.thrift.protocol.TType.STRUCT, (short)1); + + private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new add_partition_argsStandardSchemeFactory(); + private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new add_partition_argsTupleSchemeFactory(); + + private @org.apache.thrift.annotation.Nullable Partition new_part; // 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 { + NEW_PART((short)1, "new_part"); + + private static final java.util.Map byName = new java.util.HashMap(); + + static { + for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + @org.apache.thrift.annotation.Nullable + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 1: // NEW_PART + return NEW_PART; + 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 java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + @org.apache.thrift.annotation.Nullable + public static _Fields findByName(java.lang.String name) { + return byName.get(name); + } + + private final short _thriftId; + private final java.lang.String _fieldName; + + _Fields(short thriftId, java.lang.String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public java.lang.String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.NEW_PART, new org.apache.thrift.meta_data.FieldMetaData("new_part", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, Partition.class))); + metaDataMap = java.util.Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(add_partition_args.class, metaDataMap); + } + + public add_partition_args() { + } + + public add_partition_args( + Partition new_part) + { + this(); + this.new_part = new_part; + } + + /** + * Performs a deep copy on other. + */ + public add_partition_args(add_partition_args other) { + if (other.isSetNew_part()) { + this.new_part = new Partition(other.new_part); + } + } + + public add_partition_args deepCopy() { + return new add_partition_args(this); + } + + @Override + public void clear() { + this.new_part = null; + } + + @org.apache.thrift.annotation.Nullable + public Partition getNew_part() { + return this.new_part; + } + + public void setNew_part(@org.apache.thrift.annotation.Nullable Partition new_part) { + this.new_part = new_part; + } + + public void unsetNew_part() { + this.new_part = null; + } + + /** Returns true if field new_part is set (has been assigned a value) and false otherwise */ + public boolean isSetNew_part() { + return this.new_part != null; + } + + public void setNew_partIsSet(boolean value) { + if (!value) { + this.new_part = null; + } + } + + public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) { + switch (field) { + case NEW_PART: + if (value == null) { + unsetNew_part(); + } else { + setNew_part((Partition)value); + } + break; + + } + } + + @org.apache.thrift.annotation.Nullable + public java.lang.Object getFieldValue(_Fields field) { + switch (field) { + case NEW_PART: + return getNew_part(); + + } + throw new java.lang.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 java.lang.IllegalArgumentException(); + } + + switch (field) { + case NEW_PART: + return isSetNew_part(); + } + throw new java.lang.IllegalStateException(); + } + + @Override + public boolean equals(java.lang.Object that) { + if (that instanceof add_partition_args) + return this.equals((add_partition_args)that); + return false; + } + + public boolean equals(add_partition_args that) { + if (that == null) + return false; + if (this == that) + return true; + + boolean this_present_new_part = true && this.isSetNew_part(); + boolean that_present_new_part = true && that.isSetNew_part(); + if (this_present_new_part || that_present_new_part) { + if (!(this_present_new_part && that_present_new_part)) + return false; + if (!this.new_part.equals(that.new_part)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + int hashCode = 1; + + hashCode = hashCode * 8191 + ((isSetNew_part()) ? 131071 : 524287); + if (isSetNew_part()) + hashCode = hashCode * 8191 + new_part.hashCode(); + + return hashCode; + } + + @Override + public int compareTo(add_partition_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = java.lang.Boolean.compare(isSetNew_part(), other.isSetNew_part()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetNew_part()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.new_part, other.new_part); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + @org.apache.thrift.annotation.Nullable + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + scheme(iprot).read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + scheme(oprot).write(oprot, this); + } + + @Override + public java.lang.String toString() { + java.lang.StringBuilder sb = new java.lang.StringBuilder("add_partition_args("); + boolean first = true; + + sb.append("new_part:"); + if (this.new_part == null) { + sb.append("null"); + } else { + sb.append(this.new_part); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + if (new_part != null) { + new_part.validate(); + } + } + + 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, java.lang.ClassNotFoundException { + try { + 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 add_partition_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory { + public add_partition_argsStandardScheme getScheme() { + return new add_partition_argsStandardScheme(); + } + } + + private static class add_partition_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, add_partition_args 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: // NEW_PART + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.new_part = new Partition(); + struct.new_part.read(iprot); + struct.setNew_partIsSet(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, add_partition_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.new_part != null) { + oprot.writeFieldBegin(NEW_PART_FIELD_DESC); + struct.new_part.write(oprot); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class add_partition_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory { + public add_partition_argsTupleScheme getScheme() { + return new add_partition_argsTupleScheme(); + } + } + + private static class add_partition_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, add_partition_args struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot; + java.util.BitSet optionals = new java.util.BitSet(); + if (struct.isSetNew_part()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetNew_part()) { + struct.new_part.write(oprot); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, add_partition_args struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot; + java.util.BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.new_part = new Partition(); + struct.new_part.read(iprot); + struct.setNew_partIsSet(true); + } + } + } + + private static S scheme(org.apache.thrift.protocol.TProtocol proto) { + return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme(); + } + } + + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class add_partition_result 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("add_partition_result"); + + private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0); + private static final org.apache.thrift.protocol.TField O1_FIELD_DESC = new org.apache.thrift.protocol.TField("o1", org.apache.thrift.protocol.TType.STRUCT, (short)1); + private static final org.apache.thrift.protocol.TField O2_FIELD_DESC = new org.apache.thrift.protocol.TField("o2", org.apache.thrift.protocol.TType.STRUCT, (short)2); + private static final org.apache.thrift.protocol.TField O3_FIELD_DESC = new org.apache.thrift.protocol.TField("o3", org.apache.thrift.protocol.TType.STRUCT, (short)3); + + private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new add_partition_resultStandardSchemeFactory(); + private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new add_partition_resultTupleSchemeFactory(); + + private @org.apache.thrift.annotation.Nullable Partition success; // required + private @org.apache.thrift.annotation.Nullable InvalidObjectException o1; // required + private @org.apache.thrift.annotation.Nullable AlreadyExistsException o2; // required + private @org.apache.thrift.annotation.Nullable MetaException o3; // 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 { + SUCCESS((short)0, "success"), + O1((short)1, "o1"), + O2((short)2, "o2"), + O3((short)3, "o3"); + + private static final java.util.Map byName = new java.util.HashMap(); + + static { + for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + @org.apache.thrift.annotation.Nullable + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 0: // SUCCESS + return SUCCESS; + case 1: // O1 + return O1; + case 2: // O2 + return O2; + case 3: // O3 + return O3; default: return null; } @@ -116335,14 +117270,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 _list1830 = iprot.readListBegin(); - struct.new_parts = new java.util.ArrayList(_list1830.size); - @org.apache.thrift.annotation.Nullable Partition _elem1831; - for (int _i1832 = 0; _i1832 < _list1830.size; ++_i1832) + org.apache.thrift.protocol.TList _list1848 = iprot.readListBegin(); + struct.new_parts = new java.util.ArrayList(_list1848.size); + @org.apache.thrift.annotation.Nullable Partition _elem1849; + for (int _i1850 = 0; _i1850 < _list1848.size; ++_i1850) { - _elem1831 = new Partition(); - _elem1831.read(iprot); - struct.new_parts.add(_elem1831); + _elem1849 = new Partition(); + _elem1849.read(iprot); + struct.new_parts.add(_elem1849); } iprot.readListEnd(); } @@ -116368,9 +117303,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 _iter1833 : struct.new_parts) + for (Partition _iter1851 : struct.new_parts) { - _iter1833.write(oprot); + _iter1851.write(oprot); } oprot.writeListEnd(); } @@ -116401,9 +117336,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 _iter1834 : struct.new_parts) + for (Partition _iter1852 : struct.new_parts) { - _iter1834.write(oprot); + _iter1852.write(oprot); } } } @@ -116415,14 +117350,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, add_partitions_args java.util.BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1835 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.new_parts = new java.util.ArrayList(_list1835.size); - @org.apache.thrift.annotation.Nullable Partition _elem1836; - for (int _i1837 = 0; _i1837 < _list1835.size; ++_i1837) + org.apache.thrift.protocol.TList _list1853 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.new_parts = new java.util.ArrayList(_list1853.size); + @org.apache.thrift.annotation.Nullable Partition _elem1854; + for (int _i1855 = 0; _i1855 < _list1853.size; ++_i1855) { - _elem1836 = new Partition(); - _elem1836.read(iprot); - struct.new_parts.add(_elem1836); + _elem1854 = new Partition(); + _elem1854.read(iprot); + struct.new_parts.add(_elem1854); } } struct.setNew_partsIsSet(true); @@ -117429,14 +118364,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 _list1838 = iprot.readListBegin(); - struct.new_parts = new java.util.ArrayList(_list1838.size); - @org.apache.thrift.annotation.Nullable PartitionSpec _elem1839; - for (int _i1840 = 0; _i1840 < _list1838.size; ++_i1840) + org.apache.thrift.protocol.TList _list1856 = iprot.readListBegin(); + struct.new_parts = new java.util.ArrayList(_list1856.size); + @org.apache.thrift.annotation.Nullable PartitionSpec _elem1857; + for (int _i1858 = 0; _i1858 < _list1856.size; ++_i1858) { - _elem1839 = new PartitionSpec(); - _elem1839.read(iprot); - struct.new_parts.add(_elem1839); + _elem1857 = new PartitionSpec(); + _elem1857.read(iprot); + struct.new_parts.add(_elem1857); } iprot.readListEnd(); } @@ -117462,9 +118397,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 _iter1841 : struct.new_parts) + for (PartitionSpec _iter1859 : struct.new_parts) { - _iter1841.write(oprot); + _iter1859.write(oprot); } oprot.writeListEnd(); } @@ -117495,9 +118430,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 _iter1842 : struct.new_parts) + for (PartitionSpec _iter1860 : struct.new_parts) { - _iter1842.write(oprot); + _iter1860.write(oprot); } } } @@ -117509,14 +118444,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, add_partitions_pspec java.util.BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1843 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.new_parts = new java.util.ArrayList(_list1843.size); - @org.apache.thrift.annotation.Nullable PartitionSpec _elem1844; - for (int _i1845 = 0; _i1845 < _list1843.size; ++_i1845) + org.apache.thrift.protocol.TList _list1861 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.new_parts = new java.util.ArrayList(_list1861.size); + @org.apache.thrift.annotation.Nullable PartitionSpec _elem1862; + for (int _i1863 = 0; _i1863 < _list1861.size; ++_i1863) { - _elem1844 = new PartitionSpec(); - _elem1844.read(iprot); - struct.new_parts.add(_elem1844); + _elem1862 = new PartitionSpec(); + _elem1862.read(iprot); + struct.new_parts.add(_elem1862); } } struct.setNew_partsIsSet(true); @@ -118698,13 +119633,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 _list1846 = iprot.readListBegin(); - struct.part_vals = new java.util.ArrayList(_list1846.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1847; - for (int _i1848 = 0; _i1848 < _list1846.size; ++_i1848) + org.apache.thrift.protocol.TList _list1864 = iprot.readListBegin(); + struct.part_vals = new java.util.ArrayList(_list1864.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1865; + for (int _i1866 = 0; _i1866 < _list1864.size; ++_i1866) { - _elem1847 = iprot.readString(); - struct.part_vals.add(_elem1847); + _elem1865 = iprot.readString(); + struct.part_vals.add(_elem1865); } iprot.readListEnd(); } @@ -118740,9 +119675,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 (java.lang.String _iter1849 : struct.part_vals) + for (java.lang.String _iter1867 : struct.part_vals) { - oprot.writeString(_iter1849); + oprot.writeString(_iter1867); } oprot.writeListEnd(); } @@ -118785,9 +119720,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, append_partition_ar if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (java.lang.String _iter1850 : struct.part_vals) + for (java.lang.String _iter1868 : struct.part_vals) { - oprot.writeString(_iter1850); + oprot.writeString(_iter1868); } } } @@ -118807,13 +119742,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, append_partition_arg } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list1851 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.part_vals = new java.util.ArrayList(_list1851.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1852; - for (int _i1853 = 0; _i1853 < _list1851.size; ++_i1853) + org.apache.thrift.protocol.TList _list1869 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.part_vals = new java.util.ArrayList(_list1869.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1870; + for (int _i1871 = 0; _i1871 < _list1869.size; ++_i1871) { - _elem1852 = iprot.readString(); - struct.part_vals.add(_elem1852); + _elem1870 = iprot.readString(); + struct.part_vals.add(_elem1870); } } struct.setPart_valsIsSet(true); @@ -121139,13 +122074,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 _list1854 = iprot.readListBegin(); - struct.part_vals = new java.util.ArrayList(_list1854.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1855; - for (int _i1856 = 0; _i1856 < _list1854.size; ++_i1856) + org.apache.thrift.protocol.TList _list1872 = iprot.readListBegin(); + struct.part_vals = new java.util.ArrayList(_list1872.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1873; + for (int _i1874 = 0; _i1874 < _list1872.size; ++_i1874) { - _elem1855 = iprot.readString(); - struct.part_vals.add(_elem1855); + _elem1873 = iprot.readString(); + struct.part_vals.add(_elem1873); } iprot.readListEnd(); } @@ -121190,9 +122125,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 (java.lang.String _iter1857 : struct.part_vals) + for (java.lang.String _iter1875 : struct.part_vals) { - oprot.writeString(_iter1857); + oprot.writeString(_iter1875); } oprot.writeListEnd(); } @@ -121243,9 +122178,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, append_partition_wi if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (java.lang.String _iter1858 : struct.part_vals) + for (java.lang.String _iter1876 : struct.part_vals) { - oprot.writeString(_iter1858); + oprot.writeString(_iter1876); } } } @@ -121268,13 +122203,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, append_partition_wit } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list1859 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.part_vals = new java.util.ArrayList(_list1859.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1860; - for (int _i1861 = 0; _i1861 < _list1859.size; ++_i1861) + org.apache.thrift.protocol.TList _list1877 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.part_vals = new java.util.ArrayList(_list1877.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1878; + for (int _i1879 = 0; _i1879 < _list1877.size; ++_i1879) { - _elem1860 = iprot.readString(); - struct.part_vals.add(_elem1860); + _elem1878 = iprot.readString(); + struct.part_vals.add(_elem1878); } } struct.setPart_valsIsSet(true); @@ -126218,13 +127153,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 _list1862 = iprot.readListBegin(); - struct.part_vals = new java.util.ArrayList(_list1862.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1863; - for (int _i1864 = 0; _i1864 < _list1862.size; ++_i1864) + org.apache.thrift.protocol.TList _list1880 = iprot.readListBegin(); + struct.part_vals = new java.util.ArrayList(_list1880.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1881; + for (int _i1882 = 0; _i1882 < _list1880.size; ++_i1882) { - _elem1863 = iprot.readString(); - struct.part_vals.add(_elem1863); + _elem1881 = iprot.readString(); + struct.part_vals.add(_elem1881); } iprot.readListEnd(); } @@ -126268,9 +127203,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 (java.lang.String _iter1865 : struct.part_vals) + for (java.lang.String _iter1883 : struct.part_vals) { - oprot.writeString(_iter1865); + oprot.writeString(_iter1883); } oprot.writeListEnd(); } @@ -126319,9 +127254,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, drop_partition_args if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (java.lang.String _iter1866 : struct.part_vals) + for (java.lang.String _iter1884 : struct.part_vals) { - oprot.writeString(_iter1866); + oprot.writeString(_iter1884); } } } @@ -126344,13 +127279,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, drop_partition_args } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list1867 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.part_vals = new java.util.ArrayList(_list1867.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1868; - for (int _i1869 = 0; _i1869 < _list1867.size; ++_i1869) + org.apache.thrift.protocol.TList _list1885 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.part_vals = new java.util.ArrayList(_list1885.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1886; + for (int _i1887 = 0; _i1887 < _list1885.size; ++_i1887) { - _elem1868 = iprot.readString(); - struct.part_vals.add(_elem1868); + _elem1886 = iprot.readString(); + struct.part_vals.add(_elem1886); } } struct.setPart_valsIsSet(true); @@ -127592,13 +128527,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 _list1870 = iprot.readListBegin(); - struct.part_vals = new java.util.ArrayList(_list1870.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1871; - for (int _i1872 = 0; _i1872 < _list1870.size; ++_i1872) + org.apache.thrift.protocol.TList _list1888 = iprot.readListBegin(); + struct.part_vals = new java.util.ArrayList(_list1888.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1889; + for (int _i1890 = 0; _i1890 < _list1888.size; ++_i1890) { - _elem1871 = iprot.readString(); - struct.part_vals.add(_elem1871); + _elem1889 = iprot.readString(); + struct.part_vals.add(_elem1889); } iprot.readListEnd(); } @@ -127651,9 +128586,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 (java.lang.String _iter1873 : struct.part_vals) + for (java.lang.String _iter1891 : struct.part_vals) { - oprot.writeString(_iter1873); + oprot.writeString(_iter1891); } oprot.writeListEnd(); } @@ -127710,9 +128645,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, drop_partition_with if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (java.lang.String _iter1874 : struct.part_vals) + for (java.lang.String _iter1892 : struct.part_vals) { - oprot.writeString(_iter1874); + oprot.writeString(_iter1892); } } } @@ -127738,13 +128673,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, drop_partition_with_ } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list1875 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.part_vals = new java.util.ArrayList(_list1875.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1876; - for (int _i1877 = 0; _i1877 < _list1875.size; ++_i1877) + org.apache.thrift.protocol.TList _list1893 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.part_vals = new java.util.ArrayList(_list1893.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1894; + for (int _i1895 = 0; _i1895 < _list1893.size; ++_i1895) { - _elem1876 = iprot.readString(); - struct.part_vals.add(_elem1876); + _elem1894 = iprot.readString(); + struct.part_vals.add(_elem1894); } } struct.setPart_valsIsSet(true); @@ -133302,13 +134237,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 _list1878 = iprot.readListBegin(); - struct.part_vals = new java.util.ArrayList(_list1878.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1879; - for (int _i1880 = 0; _i1880 < _list1878.size; ++_i1880) + org.apache.thrift.protocol.TList _list1896 = iprot.readListBegin(); + struct.part_vals = new java.util.ArrayList(_list1896.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1897; + for (int _i1898 = 0; _i1898 < _list1896.size; ++_i1898) { - _elem1879 = iprot.readString(); - struct.part_vals.add(_elem1879); + _elem1897 = iprot.readString(); + struct.part_vals.add(_elem1897); } iprot.readListEnd(); } @@ -133344,9 +134279,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 (java.lang.String _iter1881 : struct.part_vals) + for (java.lang.String _iter1899 : struct.part_vals) { - oprot.writeString(_iter1881); + oprot.writeString(_iter1899); } oprot.writeListEnd(); } @@ -133389,9 +134324,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partition_args if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (java.lang.String _iter1882 : struct.part_vals) + for (java.lang.String _iter1900 : struct.part_vals) { - oprot.writeString(_iter1882); + oprot.writeString(_iter1900); } } } @@ -133411,13 +134346,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partition_args s } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list1883 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.part_vals = new java.util.ArrayList(_list1883.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1884; - for (int _i1885 = 0; _i1885 < _list1883.size; ++_i1885) + org.apache.thrift.protocol.TList _list1901 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.part_vals = new java.util.ArrayList(_list1901.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1902; + for (int _i1903 = 0; _i1903 < _list1901.size; ++_i1903) { - _elem1884 = iprot.readString(); - struct.part_vals.add(_elem1884); + _elem1902 = iprot.readString(); + struct.part_vals.add(_elem1902); } } struct.setPart_valsIsSet(true); @@ -135589,15 +136524,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 _map1886 = iprot.readMapBegin(); - struct.partitionSpecs = new java.util.HashMap(2*_map1886.size); - @org.apache.thrift.annotation.Nullable java.lang.String _key1887; - @org.apache.thrift.annotation.Nullable java.lang.String _val1888; - for (int _i1889 = 0; _i1889 < _map1886.size; ++_i1889) + org.apache.thrift.protocol.TMap _map1904 = iprot.readMapBegin(); + struct.partitionSpecs = new java.util.HashMap(2*_map1904.size); + @org.apache.thrift.annotation.Nullable java.lang.String _key1905; + @org.apache.thrift.annotation.Nullable java.lang.String _val1906; + for (int _i1907 = 0; _i1907 < _map1904.size; ++_i1907) { - _key1887 = iprot.readString(); - _val1888 = iprot.readString(); - struct.partitionSpecs.put(_key1887, _val1888); + _key1905 = iprot.readString(); + _val1906 = iprot.readString(); + struct.partitionSpecs.put(_key1905, _val1906); } iprot.readMapEnd(); } @@ -135655,10 +136590,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 (java.util.Map.Entry _iter1890 : struct.partitionSpecs.entrySet()) + for (java.util.Map.Entry _iter1908 : struct.partitionSpecs.entrySet()) { - oprot.writeString(_iter1890.getKey()); - oprot.writeString(_iter1890.getValue()); + oprot.writeString(_iter1908.getKey()); + oprot.writeString(_iter1908.getValue()); } oprot.writeMapEnd(); } @@ -135721,10 +136656,10 @@ public void write(org.apache.thrift.protocol.TProtocol prot, exchange_partition_ if (struct.isSetPartitionSpecs()) { { oprot.writeI32(struct.partitionSpecs.size()); - for (java.util.Map.Entry _iter1891 : struct.partitionSpecs.entrySet()) + for (java.util.Map.Entry _iter1909 : struct.partitionSpecs.entrySet()) { - oprot.writeString(_iter1891.getKey()); - oprot.writeString(_iter1891.getValue()); + oprot.writeString(_iter1909.getKey()); + oprot.writeString(_iter1909.getValue()); } } } @@ -135748,15 +136683,15 @@ public void read(org.apache.thrift.protocol.TProtocol prot, exchange_partition_a java.util.BitSet incoming = iprot.readBitSet(5); if (incoming.get(0)) { { - org.apache.thrift.protocol.TMap _map1892 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); - struct.partitionSpecs = new java.util.HashMap(2*_map1892.size); - @org.apache.thrift.annotation.Nullable java.lang.String _key1893; - @org.apache.thrift.annotation.Nullable java.lang.String _val1894; - for (int _i1895 = 0; _i1895 < _map1892.size; ++_i1895) + org.apache.thrift.protocol.TMap _map1910 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); + struct.partitionSpecs = new java.util.HashMap(2*_map1910.size); + @org.apache.thrift.annotation.Nullable java.lang.String _key1911; + @org.apache.thrift.annotation.Nullable java.lang.String _val1912; + for (int _i1913 = 0; _i1913 < _map1910.size; ++_i1913) { - _key1893 = iprot.readString(); - _val1894 = iprot.readString(); - struct.partitionSpecs.put(_key1893, _val1894); + _key1911 = iprot.readString(); + _val1912 = iprot.readString(); + struct.partitionSpecs.put(_key1911, _val1912); } } struct.setPartitionSpecsIsSet(true); @@ -137210,15 +138145,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 _map1896 = iprot.readMapBegin(); - struct.partitionSpecs = new java.util.HashMap(2*_map1896.size); - @org.apache.thrift.annotation.Nullable java.lang.String _key1897; - @org.apache.thrift.annotation.Nullable java.lang.String _val1898; - for (int _i1899 = 0; _i1899 < _map1896.size; ++_i1899) + org.apache.thrift.protocol.TMap _map1914 = iprot.readMapBegin(); + struct.partitionSpecs = new java.util.HashMap(2*_map1914.size); + @org.apache.thrift.annotation.Nullable java.lang.String _key1915; + @org.apache.thrift.annotation.Nullable java.lang.String _val1916; + for (int _i1917 = 0; _i1917 < _map1914.size; ++_i1917) { - _key1897 = iprot.readString(); - _val1898 = iprot.readString(); - struct.partitionSpecs.put(_key1897, _val1898); + _key1915 = iprot.readString(); + _val1916 = iprot.readString(); + struct.partitionSpecs.put(_key1915, _val1916); } iprot.readMapEnd(); } @@ -137276,10 +138211,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 (java.util.Map.Entry _iter1900 : struct.partitionSpecs.entrySet()) + for (java.util.Map.Entry _iter1918 : struct.partitionSpecs.entrySet()) { - oprot.writeString(_iter1900.getKey()); - oprot.writeString(_iter1900.getValue()); + oprot.writeString(_iter1918.getKey()); + oprot.writeString(_iter1918.getValue()); } oprot.writeMapEnd(); } @@ -137342,10 +138277,10 @@ public void write(org.apache.thrift.protocol.TProtocol prot, exchange_partitions if (struct.isSetPartitionSpecs()) { { oprot.writeI32(struct.partitionSpecs.size()); - for (java.util.Map.Entry _iter1901 : struct.partitionSpecs.entrySet()) + for (java.util.Map.Entry _iter1919 : struct.partitionSpecs.entrySet()) { - oprot.writeString(_iter1901.getKey()); - oprot.writeString(_iter1901.getValue()); + oprot.writeString(_iter1919.getKey()); + oprot.writeString(_iter1919.getValue()); } } } @@ -137369,15 +138304,15 @@ public void read(org.apache.thrift.protocol.TProtocol prot, exchange_partitions_ java.util.BitSet incoming = iprot.readBitSet(5); if (incoming.get(0)) { { - org.apache.thrift.protocol.TMap _map1902 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); - struct.partitionSpecs = new java.util.HashMap(2*_map1902.size); - @org.apache.thrift.annotation.Nullable java.lang.String _key1903; - @org.apache.thrift.annotation.Nullable java.lang.String _val1904; - for (int _i1905 = 0; _i1905 < _map1902.size; ++_i1905) + org.apache.thrift.protocol.TMap _map1920 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); + struct.partitionSpecs = new java.util.HashMap(2*_map1920.size); + @org.apache.thrift.annotation.Nullable java.lang.String _key1921; + @org.apache.thrift.annotation.Nullable java.lang.String _val1922; + for (int _i1923 = 0; _i1923 < _map1920.size; ++_i1923) { - _key1903 = iprot.readString(); - _val1904 = iprot.readString(); - struct.partitionSpecs.put(_key1903, _val1904); + _key1921 = iprot.readString(); + _val1922 = iprot.readString(); + struct.partitionSpecs.put(_key1921, _val1922); } } struct.setPartitionSpecsIsSet(true); @@ -138047,14 +138982,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 _list1906 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list1906.size); - @org.apache.thrift.annotation.Nullable Partition _elem1907; - for (int _i1908 = 0; _i1908 < _list1906.size; ++_i1908) + org.apache.thrift.protocol.TList _list1924 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list1924.size); + @org.apache.thrift.annotation.Nullable Partition _elem1925; + for (int _i1926 = 0; _i1926 < _list1924.size; ++_i1926) { - _elem1907 = new Partition(); - _elem1907.read(iprot); - struct.success.add(_elem1907); + _elem1925 = new Partition(); + _elem1925.read(iprot); + struct.success.add(_elem1925); } iprot.readListEnd(); } @@ -138116,9 +139051,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 _iter1909 : struct.success) + for (Partition _iter1927 : struct.success) { - _iter1909.write(oprot); + _iter1927.write(oprot); } oprot.writeListEnd(); } @@ -138181,9 +139116,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, exchange_partitions if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Partition _iter1910 : struct.success) + for (Partition _iter1928 : struct.success) { - _iter1910.write(oprot); + _iter1928.write(oprot); } } } @@ -138207,14 +139142,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, exchange_partitions_ java.util.BitSet incoming = iprot.readBitSet(5); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1911 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.success = new java.util.ArrayList(_list1911.size); - @org.apache.thrift.annotation.Nullable Partition _elem1912; - for (int _i1913 = 0; _i1913 < _list1911.size; ++_i1913) + org.apache.thrift.protocol.TList _list1929 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.success = new java.util.ArrayList(_list1929.size); + @org.apache.thrift.annotation.Nullable Partition _elem1930; + for (int _i1931 = 0; _i1931 < _list1929.size; ++_i1931) { - _elem1912 = new Partition(); - _elem1912.read(iprot); - struct.success.add(_elem1912); + _elem1930 = new Partition(); + _elem1930.read(iprot); + struct.success.add(_elem1930); } } struct.setSuccessIsSet(true); @@ -138919,13 +139854,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 _list1914 = iprot.readListBegin(); - struct.part_vals = new java.util.ArrayList(_list1914.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1915; - for (int _i1916 = 0; _i1916 < _list1914.size; ++_i1916) + org.apache.thrift.protocol.TList _list1932 = iprot.readListBegin(); + struct.part_vals = new java.util.ArrayList(_list1932.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1933; + for (int _i1934 = 0; _i1934 < _list1932.size; ++_i1934) { - _elem1915 = iprot.readString(); - struct.part_vals.add(_elem1915); + _elem1933 = iprot.readString(); + struct.part_vals.add(_elem1933); } iprot.readListEnd(); } @@ -138945,13 +139880,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 _list1917 = iprot.readListBegin(); - struct.group_names = new java.util.ArrayList(_list1917.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1918; - for (int _i1919 = 0; _i1919 < _list1917.size; ++_i1919) + org.apache.thrift.protocol.TList _list1935 = iprot.readListBegin(); + struct.group_names = new java.util.ArrayList(_list1935.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1936; + for (int _i1937 = 0; _i1937 < _list1935.size; ++_i1937) { - _elem1918 = iprot.readString(); - struct.group_names.add(_elem1918); + _elem1936 = iprot.readString(); + struct.group_names.add(_elem1936); } iprot.readListEnd(); } @@ -138987,9 +139922,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 (java.lang.String _iter1920 : struct.part_vals) + for (java.lang.String _iter1938 : struct.part_vals) { - oprot.writeString(_iter1920); + oprot.writeString(_iter1938); } oprot.writeListEnd(); } @@ -139004,9 +139939,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 (java.lang.String _iter1921 : struct.group_names) + for (java.lang.String _iter1939 : struct.group_names) { - oprot.writeString(_iter1921); + oprot.writeString(_iter1939); } oprot.writeListEnd(); } @@ -139055,9 +139990,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partition_with_ if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (java.lang.String _iter1922 : struct.part_vals) + for (java.lang.String _iter1940 : struct.part_vals) { - oprot.writeString(_iter1922); + oprot.writeString(_iter1940); } } } @@ -139067,9 +140002,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partition_with_ if (struct.isSetGroup_names()) { { oprot.writeI32(struct.group_names.size()); - for (java.lang.String _iter1923 : struct.group_names) + for (java.lang.String _iter1941 : struct.group_names) { - oprot.writeString(_iter1923); + oprot.writeString(_iter1941); } } } @@ -139089,13 +140024,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partition_with_a } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list1924 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.part_vals = new java.util.ArrayList(_list1924.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1925; - for (int _i1926 = 0; _i1926 < _list1924.size; ++_i1926) + org.apache.thrift.protocol.TList _list1942 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.part_vals = new java.util.ArrayList(_list1942.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1943; + for (int _i1944 = 0; _i1944 < _list1942.size; ++_i1944) { - _elem1925 = iprot.readString(); - struct.part_vals.add(_elem1925); + _elem1943 = iprot.readString(); + struct.part_vals.add(_elem1943); } } struct.setPart_valsIsSet(true); @@ -139106,13 +140041,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partition_with_a } if (incoming.get(4)) { { - org.apache.thrift.protocol.TList _list1927 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.group_names = new java.util.ArrayList(_list1927.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1928; - for (int _i1929 = 0; _i1929 < _list1927.size; ++_i1929) + org.apache.thrift.protocol.TList _list1945 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.group_names = new java.util.ArrayList(_list1945.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1946; + for (int _i1947 = 0; _i1947 < _list1945.size; ++_i1947) { - _elem1928 = iprot.readString(); - struct.group_names.add(_elem1928); + _elem1946 = iprot.readString(); + struct.group_names.add(_elem1946); } } struct.setGroup_namesIsSet(true); @@ -141899,14 +142834,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 _list1930 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list1930.size); - @org.apache.thrift.annotation.Nullable Partition _elem1931; - for (int _i1932 = 0; _i1932 < _list1930.size; ++_i1932) + org.apache.thrift.protocol.TList _list1948 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list1948.size); + @org.apache.thrift.annotation.Nullable Partition _elem1949; + for (int _i1950 = 0; _i1950 < _list1948.size; ++_i1950) { - _elem1931 = new Partition(); - _elem1931.read(iprot); - struct.success.add(_elem1931); + _elem1949 = new Partition(); + _elem1949.read(iprot); + struct.success.add(_elem1949); } iprot.readListEnd(); } @@ -141950,9 +142885,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 _iter1933 : struct.success) + for (Partition _iter1951 : struct.success) { - _iter1933.write(oprot); + _iter1951.write(oprot); } oprot.writeListEnd(); } @@ -141999,9 +142934,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_resu if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Partition _iter1934 : struct.success) + for (Partition _iter1952 : struct.success) { - _iter1934.write(oprot); + _iter1952.write(oprot); } } } @@ -142019,14 +142954,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_resul java.util.BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1935 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.success = new java.util.ArrayList(_list1935.size); - @org.apache.thrift.annotation.Nullable Partition _elem1936; - for (int _i1937 = 0; _i1937 < _list1935.size; ++_i1937) + org.apache.thrift.protocol.TList _list1953 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.success = new java.util.ArrayList(_list1953.size); + @org.apache.thrift.annotation.Nullable Partition _elem1954; + for (int _i1955 = 0; _i1955 < _list1953.size; ++_i1955) { - _elem1936 = new Partition(); - _elem1936.read(iprot); - struct.success.add(_elem1936); + _elem1954 = new Partition(); + _elem1954.read(iprot); + struct.success.add(_elem1954); } } struct.setSuccessIsSet(true); @@ -143664,13 +144599,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 _list1938 = iprot.readListBegin(); - struct.group_names = new java.util.ArrayList(_list1938.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1939; - for (int _i1940 = 0; _i1940 < _list1938.size; ++_i1940) + org.apache.thrift.protocol.TList _list1956 = iprot.readListBegin(); + struct.group_names = new java.util.ArrayList(_list1956.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1957; + for (int _i1958 = 0; _i1958 < _list1956.size; ++_i1958) { - _elem1939 = iprot.readString(); - struct.group_names.add(_elem1939); + _elem1957 = iprot.readString(); + struct.group_names.add(_elem1957); } iprot.readListEnd(); } @@ -143714,9 +144649,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 (java.lang.String _iter1941 : struct.group_names) + for (java.lang.String _iter1959 : struct.group_names) { - oprot.writeString(_iter1941); + oprot.writeString(_iter1959); } oprot.writeListEnd(); } @@ -143771,9 +144706,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_with if (struct.isSetGroup_names()) { { oprot.writeI32(struct.group_names.size()); - for (java.lang.String _iter1942 : struct.group_names) + for (java.lang.String _iter1960 : struct.group_names) { - oprot.writeString(_iter1942); + oprot.writeString(_iter1960); } } } @@ -143801,13 +144736,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_with_ } if (incoming.get(4)) { { - org.apache.thrift.protocol.TList _list1943 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.group_names = new java.util.ArrayList(_list1943.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1944; - for (int _i1945 = 0; _i1945 < _list1943.size; ++_i1945) + org.apache.thrift.protocol.TList _list1961 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.group_names = new java.util.ArrayList(_list1961.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1962; + for (int _i1963 = 0; _i1963 < _list1961.size; ++_i1963) { - _elem1944 = iprot.readString(); - struct.group_names.add(_elem1944); + _elem1962 = iprot.readString(); + struct.group_names.add(_elem1962); } } struct.setGroup_namesIsSet(true); @@ -144299,14 +145234,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 _list1946 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list1946.size); - @org.apache.thrift.annotation.Nullable Partition _elem1947; - for (int _i1948 = 0; _i1948 < _list1946.size; ++_i1948) + org.apache.thrift.protocol.TList _list1964 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list1964.size); + @org.apache.thrift.annotation.Nullable Partition _elem1965; + for (int _i1966 = 0; _i1966 < _list1964.size; ++_i1966) { - _elem1947 = new Partition(); - _elem1947.read(iprot); - struct.success.add(_elem1947); + _elem1965 = new Partition(); + _elem1965.read(iprot); + struct.success.add(_elem1965); } iprot.readListEnd(); } @@ -144350,9 +145285,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 _iter1949 : struct.success) + for (Partition _iter1967 : struct.success) { - _iter1949.write(oprot); + _iter1967.write(oprot); } oprot.writeListEnd(); } @@ -144399,9 +145334,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_with if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Partition _iter1950 : struct.success) + for (Partition _iter1968 : struct.success) { - _iter1950.write(oprot); + _iter1968.write(oprot); } } } @@ -144419,14 +145354,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_with_ java.util.BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1951 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.success = new java.util.ArrayList(_list1951.size); - @org.apache.thrift.annotation.Nullable Partition _elem1952; - for (int _i1953 = 0; _i1953 < _list1951.size; ++_i1953) + org.apache.thrift.protocol.TList _list1969 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.success = new java.util.ArrayList(_list1969.size); + @org.apache.thrift.annotation.Nullable Partition _elem1970; + for (int _i1971 = 0; _i1971 < _list1969.size; ++_i1971) { - _elem1952 = new Partition(); - _elem1952.read(iprot); - struct.success.add(_elem1952); + _elem1970 = new Partition(); + _elem1970.read(iprot); + struct.success.add(_elem1970); } } struct.setSuccessIsSet(true); @@ -145495,14 +146430,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 _list1954 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list1954.size); - @org.apache.thrift.annotation.Nullable PartitionSpec _elem1955; - for (int _i1956 = 0; _i1956 < _list1954.size; ++_i1956) + org.apache.thrift.protocol.TList _list1972 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list1972.size); + @org.apache.thrift.annotation.Nullable PartitionSpec _elem1973; + for (int _i1974 = 0; _i1974 < _list1972.size; ++_i1974) { - _elem1955 = new PartitionSpec(); - _elem1955.read(iprot); - struct.success.add(_elem1955); + _elem1973 = new PartitionSpec(); + _elem1973.read(iprot); + struct.success.add(_elem1973); } iprot.readListEnd(); } @@ -145546,9 +146481,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 _iter1957 : struct.success) + for (PartitionSpec _iter1975 : struct.success) { - _iter1957.write(oprot); + _iter1975.write(oprot); } oprot.writeListEnd(); } @@ -145595,9 +146530,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_pspe if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (PartitionSpec _iter1958 : struct.success) + for (PartitionSpec _iter1976 : struct.success) { - _iter1958.write(oprot); + _iter1976.write(oprot); } } } @@ -145615,14 +146550,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_pspec java.util.BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1959 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.success = new java.util.ArrayList(_list1959.size); - @org.apache.thrift.annotation.Nullable PartitionSpec _elem1960; - for (int _i1961 = 0; _i1961 < _list1959.size; ++_i1961) + org.apache.thrift.protocol.TList _list1977 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.success = new java.util.ArrayList(_list1977.size); + @org.apache.thrift.annotation.Nullable PartitionSpec _elem1978; + for (int _i1979 = 0; _i1979 < _list1977.size; ++_i1979) { - _elem1960 = new PartitionSpec(); - _elem1960.read(iprot); - struct.success.add(_elem1960); + _elem1978 = new PartitionSpec(); + _elem1978.read(iprot); + struct.success.add(_elem1978); } } struct.setSuccessIsSet(true); @@ -146688,13 +147623,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 _list1962 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list1962.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1963; - for (int _i1964 = 0; _i1964 < _list1962.size; ++_i1964) + org.apache.thrift.protocol.TList _list1980 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list1980.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1981; + for (int _i1982 = 0; _i1982 < _list1980.size; ++_i1982) { - _elem1963 = iprot.readString(); - struct.success.add(_elem1963); + _elem1981 = iprot.readString(); + struct.success.add(_elem1981); } iprot.readListEnd(); } @@ -146738,9 +147673,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 (java.lang.String _iter1965 : struct.success) + for (java.lang.String _iter1983 : struct.success) { - oprot.writeString(_iter1965); + oprot.writeString(_iter1983); } oprot.writeListEnd(); } @@ -146787,9 +147722,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partition_names if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (java.lang.String _iter1966 : struct.success) + for (java.lang.String _iter1984 : struct.success) { - oprot.writeString(_iter1966); + oprot.writeString(_iter1984); } } } @@ -146807,13 +147742,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partition_names_ java.util.BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1967 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.success = new java.util.ArrayList(_list1967.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1968; - for (int _i1969 = 0; _i1969 < _list1967.size; ++_i1969) + org.apache.thrift.protocol.TList _list1985 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.success = new java.util.ArrayList(_list1985.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1986; + for (int _i1987 = 0; _i1987 < _list1985.size; ++_i1987) { - _elem1968 = iprot.readString(); - struct.success.add(_elem1968); + _elem1986 = iprot.readString(); + struct.success.add(_elem1986); } } struct.setSuccessIsSet(true); @@ -147679,13 +148614,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, fetch_partition_nam case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1970 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list1970.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1971; - for (int _i1972 = 0; _i1972 < _list1970.size; ++_i1972) + org.apache.thrift.protocol.TList _list1988 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list1988.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1989; + for (int _i1990 = 0; _i1990 < _list1988.size; ++_i1990) { - _elem1971 = iprot.readString(); - struct.success.add(_elem1971); + _elem1989 = iprot.readString(); + struct.success.add(_elem1989); } iprot.readListEnd(); } @@ -147729,9 +148664,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, fetch_partition_na oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (java.lang.String _iter1973 : struct.success) + for (java.lang.String _iter1991 : struct.success) { - oprot.writeString(_iter1973); + oprot.writeString(_iter1991); } oprot.writeListEnd(); } @@ -147778,9 +148713,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, fetch_partition_nam if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (java.lang.String _iter1974 : struct.success) + for (java.lang.String _iter1992 : struct.success) { - oprot.writeString(_iter1974); + oprot.writeString(_iter1992); } } } @@ -147798,13 +148733,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, fetch_partition_name java.util.BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1975 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.success = new java.util.ArrayList(_list1975.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1976; - for (int _i1977 = 0; _i1977 < _list1975.size; ++_i1977) + org.apache.thrift.protocol.TList _list1993 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.success = new java.util.ArrayList(_list1993.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1994; + for (int _i1995 = 0; _i1995 < _list1993.size; ++_i1995) { - _elem1976 = iprot.readString(); - struct.success.add(_elem1976); + _elem1994 = iprot.readString(); + struct.success.add(_elem1994); } } struct.setSuccessIsSet(true); @@ -149345,13 +150280,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 _list1978 = iprot.readListBegin(); - struct.part_vals = new java.util.ArrayList(_list1978.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1979; - for (int _i1980 = 0; _i1980 < _list1978.size; ++_i1980) + org.apache.thrift.protocol.TList _list1996 = iprot.readListBegin(); + struct.part_vals = new java.util.ArrayList(_list1996.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem1997; + for (int _i1998 = 0; _i1998 < _list1996.size; ++_i1998) { - _elem1979 = iprot.readString(); - struct.part_vals.add(_elem1979); + _elem1997 = iprot.readString(); + struct.part_vals.add(_elem1997); } iprot.readListEnd(); } @@ -149395,9 +150330,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 (java.lang.String _iter1981 : struct.part_vals) + for (java.lang.String _iter1999 : struct.part_vals) { - oprot.writeString(_iter1981); + oprot.writeString(_iter1999); } oprot.writeListEnd(); } @@ -149446,9 +150381,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 (java.lang.String _iter1982 : struct.part_vals) + for (java.lang.String _iter2000 : struct.part_vals) { - oprot.writeString(_iter1982); + oprot.writeString(_iter2000); } } } @@ -149471,13 +150406,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_ar } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list1983 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.part_vals = new java.util.ArrayList(_list1983.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1984; - for (int _i1985 = 0; _i1985 < _list1983.size; ++_i1985) + org.apache.thrift.protocol.TList _list2001 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.part_vals = new java.util.ArrayList(_list2001.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem2002; + for (int _i2003 = 0; _i2003 < _list2001.size; ++_i2003) { - _elem1984 = iprot.readString(); - struct.part_vals.add(_elem1984); + _elem2002 = iprot.readString(); + struct.part_vals.add(_elem2002); } } struct.setPart_valsIsSet(true); @@ -149973,14 +150908,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 _list1986 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list1986.size); - @org.apache.thrift.annotation.Nullable Partition _elem1987; - for (int _i1988 = 0; _i1988 < _list1986.size; ++_i1988) + org.apache.thrift.protocol.TList _list2004 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list2004.size); + @org.apache.thrift.annotation.Nullable Partition _elem2005; + for (int _i2006 = 0; _i2006 < _list2004.size; ++_i2006) { - _elem1987 = new Partition(); - _elem1987.read(iprot); - struct.success.add(_elem1987); + _elem2005 = new Partition(); + _elem2005.read(iprot); + struct.success.add(_elem2005); } iprot.readListEnd(); } @@ -150024,9 +150959,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 _iter1989 : struct.success) + for (Partition _iter2007 : struct.success) { - _iter1989.write(oprot); + _iter2007.write(oprot); } oprot.writeListEnd(); } @@ -150073,9 +151008,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_r if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Partition _iter1990 : struct.success) + for (Partition _iter2008 : struct.success) { - _iter1990.write(oprot); + _iter2008.write(oprot); } } } @@ -150093,14 +151028,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_re java.util.BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1991 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.success = new java.util.ArrayList(_list1991.size); - @org.apache.thrift.annotation.Nullable Partition _elem1992; - for (int _i1993 = 0; _i1993 < _list1991.size; ++_i1993) + org.apache.thrift.protocol.TList _list2009 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.success = new java.util.ArrayList(_list2009.size); + @org.apache.thrift.annotation.Nullable Partition _elem2010; + for (int _i2011 = 0; _i2011 < _list2009.size; ++_i2011) { - _elem1992 = new Partition(); - _elem1992.read(iprot); - struct.success.add(_elem1992); + _elem2010 = new Partition(); + _elem2010.read(iprot); + struct.success.add(_elem2010); } } struct.setSuccessIsSet(true); @@ -150875,13 +151810,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 _list1994 = iprot.readListBegin(); - struct.part_vals = new java.util.ArrayList(_list1994.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1995; - for (int _i1996 = 0; _i1996 < _list1994.size; ++_i1996) + org.apache.thrift.protocol.TList _list2012 = iprot.readListBegin(); + struct.part_vals = new java.util.ArrayList(_list2012.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem2013; + for (int _i2014 = 0; _i2014 < _list2012.size; ++_i2014) { - _elem1995 = iprot.readString(); - struct.part_vals.add(_elem1995); + _elem2013 = iprot.readString(); + struct.part_vals.add(_elem2013); } iprot.readListEnd(); } @@ -150909,13 +151844,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 _list1997 = iprot.readListBegin(); - struct.group_names = new java.util.ArrayList(_list1997.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem1998; - for (int _i1999 = 0; _i1999 < _list1997.size; ++_i1999) + org.apache.thrift.protocol.TList _list2015 = iprot.readListBegin(); + struct.group_names = new java.util.ArrayList(_list2015.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem2016; + for (int _i2017 = 0; _i2017 < _list2015.size; ++_i2017) { - _elem1998 = iprot.readString(); - struct.group_names.add(_elem1998); + _elem2016 = iprot.readString(); + struct.group_names.add(_elem2016); } iprot.readListEnd(); } @@ -150951,9 +151886,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 (java.lang.String _iter2000 : struct.part_vals) + for (java.lang.String _iter2018 : struct.part_vals) { - oprot.writeString(_iter2000); + oprot.writeString(_iter2018); } oprot.writeListEnd(); } @@ -150971,9 +151906,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 (java.lang.String _iter2001 : struct.group_names) + for (java.lang.String _iter2019 : struct.group_names) { - oprot.writeString(_iter2001); + oprot.writeString(_iter2019); } oprot.writeListEnd(); } @@ -151025,9 +151960,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 (java.lang.String _iter2002 : struct.part_vals) + for (java.lang.String _iter2020 : struct.part_vals) { - oprot.writeString(_iter2002); + oprot.writeString(_iter2020); } } } @@ -151040,9 +151975,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 (java.lang.String _iter2003 : struct.group_names) + for (java.lang.String _iter2021 : struct.group_names) { - oprot.writeString(_iter2003); + oprot.writeString(_iter2021); } } } @@ -151062,13 +151997,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_wi } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list2004 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.part_vals = new java.util.ArrayList(_list2004.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem2005; - for (int _i2006 = 0; _i2006 < _list2004.size; ++_i2006) + org.apache.thrift.protocol.TList _list2022 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.part_vals = new java.util.ArrayList(_list2022.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem2023; + for (int _i2024 = 0; _i2024 < _list2022.size; ++_i2024) { - _elem2005 = iprot.readString(); - struct.part_vals.add(_elem2005); + _elem2023 = iprot.readString(); + struct.part_vals.add(_elem2023); } } struct.setPart_valsIsSet(true); @@ -151083,13 +152018,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_wi } if (incoming.get(5)) { { - org.apache.thrift.protocol.TList _list2007 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.group_names = new java.util.ArrayList(_list2007.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem2008; - for (int _i2009 = 0; _i2009 < _list2007.size; ++_i2009) + org.apache.thrift.protocol.TList _list2025 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.group_names = new java.util.ArrayList(_list2025.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem2026; + for (int _i2027 = 0; _i2027 < _list2025.size; ++_i2027) { - _elem2008 = iprot.readString(); - struct.group_names.add(_elem2008); + _elem2026 = iprot.readString(); + struct.group_names.add(_elem2026); } } struct.setGroup_namesIsSet(true); @@ -151581,14 +152516,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 _list2010 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list2010.size); - @org.apache.thrift.annotation.Nullable Partition _elem2011; - for (int _i2012 = 0; _i2012 < _list2010.size; ++_i2012) + org.apache.thrift.protocol.TList _list2028 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list2028.size); + @org.apache.thrift.annotation.Nullable Partition _elem2029; + for (int _i2030 = 0; _i2030 < _list2028.size; ++_i2030) { - _elem2011 = new Partition(); - _elem2011.read(iprot); - struct.success.add(_elem2011); + _elem2029 = new Partition(); + _elem2029.read(iprot); + struct.success.add(_elem2029); } iprot.readListEnd(); } @@ -151632,9 +152567,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 _iter2013 : struct.success) + for (Partition _iter2031 : struct.success) { - _iter2013.write(oprot); + _iter2031.write(oprot); } oprot.writeListEnd(); } @@ -151681,9 +152616,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_w if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Partition _iter2014 : struct.success) + for (Partition _iter2032 : struct.success) { - _iter2014.write(oprot); + _iter2032.write(oprot); } } } @@ -151701,14 +152636,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_wi java.util.BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list2015 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.success = new java.util.ArrayList(_list2015.size); - @org.apache.thrift.annotation.Nullable Partition _elem2016; - for (int _i2017 = 0; _i2017 < _list2015.size; ++_i2017) + org.apache.thrift.protocol.TList _list2033 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.success = new java.util.ArrayList(_list2033.size); + @org.apache.thrift.annotation.Nullable Partition _elem2034; + for (int _i2035 = 0; _i2035 < _list2033.size; ++_i2035) { - _elem2016 = new Partition(); - _elem2016.read(iprot); - struct.success.add(_elem2016); + _elem2034 = new Partition(); + _elem2034.read(iprot); + struct.success.add(_elem2034); } } struct.setSuccessIsSet(true); @@ -153249,13 +154184,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 _list2018 = iprot.readListBegin(); - struct.part_vals = new java.util.ArrayList(_list2018.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem2019; - for (int _i2020 = 0; _i2020 < _list2018.size; ++_i2020) + org.apache.thrift.protocol.TList _list2036 = iprot.readListBegin(); + struct.part_vals = new java.util.ArrayList(_list2036.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem2037; + for (int _i2038 = 0; _i2038 < _list2036.size; ++_i2038) { - _elem2019 = iprot.readString(); - struct.part_vals.add(_elem2019); + _elem2037 = iprot.readString(); + struct.part_vals.add(_elem2037); } iprot.readListEnd(); } @@ -153299,9 +154234,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 (java.lang.String _iter2021 : struct.part_vals) + for (java.lang.String _iter2039 : struct.part_vals) { - oprot.writeString(_iter2021); + oprot.writeString(_iter2039); } oprot.writeListEnd(); } @@ -153350,9 +154285,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partition_names if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (java.lang.String _iter2022 : struct.part_vals) + for (java.lang.String _iter2040 : struct.part_vals) { - oprot.writeString(_iter2022); + oprot.writeString(_iter2040); } } } @@ -153375,13 +154310,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partition_names_ } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list2023 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.part_vals = new java.util.ArrayList(_list2023.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem2024; - for (int _i2025 = 0; _i2025 < _list2023.size; ++_i2025) + org.apache.thrift.protocol.TList _list2041 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.part_vals = new java.util.ArrayList(_list2041.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem2042; + for (int _i2043 = 0; _i2043 < _list2041.size; ++_i2043) { - _elem2024 = iprot.readString(); - struct.part_vals.add(_elem2024); + _elem2042 = iprot.readString(); + struct.part_vals.add(_elem2042); } } struct.setPart_valsIsSet(true); @@ -153874,13 +154809,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 _list2026 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list2026.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem2027; - for (int _i2028 = 0; _i2028 < _list2026.size; ++_i2028) + org.apache.thrift.protocol.TList _list2044 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list2044.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem2045; + for (int _i2046 = 0; _i2046 < _list2044.size; ++_i2046) { - _elem2027 = iprot.readString(); - struct.success.add(_elem2027); + _elem2045 = iprot.readString(); + struct.success.add(_elem2045); } iprot.readListEnd(); } @@ -153924,9 +154859,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 (java.lang.String _iter2029 : struct.success) + for (java.lang.String _iter2047 : struct.success) { - oprot.writeString(_iter2029); + oprot.writeString(_iter2047); } oprot.writeListEnd(); } @@ -153973,9 +154908,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partition_names if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (java.lang.String _iter2030 : struct.success) + for (java.lang.String _iter2048 : struct.success) { - oprot.writeString(_iter2030); + oprot.writeString(_iter2048); } } } @@ -153993,13 +154928,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partition_names_ java.util.BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list2031 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.success = new java.util.ArrayList(_list2031.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem2032; - for (int _i2033 = 0; _i2033 < _list2031.size; ++_i2033) + org.apache.thrift.protocol.TList _list2049 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.success = new java.util.ArrayList(_list2049.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem2050; + for (int _i2051 = 0; _i2051 < _list2049.size; ++_i2051) { - _elem2032 = iprot.readString(); - struct.success.add(_elem2032); + _elem2050 = iprot.readString(); + struct.success.add(_elem2050); } } struct.setSuccessIsSet(true); @@ -155811,13 +156746,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 _list2034 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list2034.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem2035; - for (int _i2036 = 0; _i2036 < _list2034.size; ++_i2036) + org.apache.thrift.protocol.TList _list2052 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list2052.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem2053; + for (int _i2054 = 0; _i2054 < _list2052.size; ++_i2054) { - _elem2035 = iprot.readString(); - struct.success.add(_elem2035); + _elem2053 = iprot.readString(); + struct.success.add(_elem2053); } iprot.readListEnd(); } @@ -155861,9 +156796,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 (java.lang.String _iter2037 : struct.success) + for (java.lang.String _iter2055 : struct.success) { - oprot.writeString(_iter2037); + oprot.writeString(_iter2055); } oprot.writeListEnd(); } @@ -155910,9 +156845,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partition_names if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (java.lang.String _iter2038 : struct.success) + for (java.lang.String _iter2056 : struct.success) { - oprot.writeString(_iter2038); + oprot.writeString(_iter2056); } } } @@ -155930,13 +156865,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partition_names_ java.util.BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list2039 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.success = new java.util.ArrayList(_list2039.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem2040; - for (int _i2041 = 0; _i2041 < _list2039.size; ++_i2041) + org.apache.thrift.protocol.TList _list2057 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.success = new java.util.ArrayList(_list2057.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem2058; + for (int _i2059 = 0; _i2059 < _list2057.size; ++_i2059) { - _elem2040 = iprot.readString(); - struct.success.add(_elem2040); + _elem2058 = iprot.readString(); + struct.success.add(_elem2058); } } struct.setSuccessIsSet(true); @@ -157109,14 +158044,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 _list2042 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list2042.size); - @org.apache.thrift.annotation.Nullable Partition _elem2043; - for (int _i2044 = 0; _i2044 < _list2042.size; ++_i2044) + org.apache.thrift.protocol.TList _list2060 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list2060.size); + @org.apache.thrift.annotation.Nullable Partition _elem2061; + for (int _i2062 = 0; _i2062 < _list2060.size; ++_i2062) { - _elem2043 = new Partition(); - _elem2043.read(iprot); - struct.success.add(_elem2043); + _elem2061 = new Partition(); + _elem2061.read(iprot); + struct.success.add(_elem2061); } iprot.readListEnd(); } @@ -157160,9 +158095,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 _iter2045 : struct.success) + for (Partition _iter2063 : struct.success) { - _iter2045.write(oprot); + _iter2063.write(oprot); } oprot.writeListEnd(); } @@ -157209,9 +158144,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_by_f if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Partition _iter2046 : struct.success) + for (Partition _iter2064 : struct.success) { - _iter2046.write(oprot); + _iter2064.write(oprot); } } } @@ -157229,14 +158164,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_by_fi java.util.BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list2047 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.success = new java.util.ArrayList(_list2047.size); - @org.apache.thrift.annotation.Nullable Partition _elem2048; - for (int _i2049 = 0; _i2049 < _list2047.size; ++_i2049) + org.apache.thrift.protocol.TList _list2065 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.success = new java.util.ArrayList(_list2065.size); + @org.apache.thrift.annotation.Nullable Partition _elem2066; + for (int _i2067 = 0; _i2067 < _list2065.size; ++_i2067) { - _elem2048 = new Partition(); - _elem2048.read(iprot); - struct.success.add(_elem2048); + _elem2066 = new Partition(); + _elem2066.read(iprot); + struct.success.add(_elem2066); } } struct.setSuccessIsSet(true); @@ -158105,14 +159040,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 _list2050 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list2050.size); - @org.apache.thrift.annotation.Nullable Partition _elem2051; - for (int _i2052 = 0; _i2052 < _list2050.size; ++_i2052) + org.apache.thrift.protocol.TList _list2068 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list2068.size); + @org.apache.thrift.annotation.Nullable Partition _elem2069; + for (int _i2070 = 0; _i2070 < _list2068.size; ++_i2070) { - _elem2051 = new Partition(); - _elem2051.read(iprot); - struct.success.add(_elem2051); + _elem2069 = new Partition(); + _elem2069.read(iprot); + struct.success.add(_elem2069); } iprot.readListEnd(); } @@ -158156,9 +159091,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 _iter2053 : struct.success) + for (Partition _iter2071 : struct.success) { - _iter2053.write(oprot); + _iter2071.write(oprot); } oprot.writeListEnd(); } @@ -158205,9 +159140,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_by_f if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Partition _iter2054 : struct.success) + for (Partition _iter2072 : struct.success) { - _iter2054.write(oprot); + _iter2072.write(oprot); } } } @@ -158225,14 +159160,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_by_fi java.util.BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list2055 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.success = new java.util.ArrayList(_list2055.size); - @org.apache.thrift.annotation.Nullable Partition _elem2056; - for (int _i2057 = 0; _i2057 < _list2055.size; ++_i2057) + org.apache.thrift.protocol.TList _list2073 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.success = new java.util.ArrayList(_list2073.size); + @org.apache.thrift.annotation.Nullable Partition _elem2074; + for (int _i2075 = 0; _i2075 < _list2073.size; ++_i2075) { - _elem2056 = new Partition(); - _elem2056.read(iprot); - struct.success.add(_elem2056); + _elem2074 = new Partition(); + _elem2074.read(iprot); + struct.success.add(_elem2074); } } struct.setSuccessIsSet(true); @@ -159405,14 +160340,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 _list2058 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list2058.size); - @org.apache.thrift.annotation.Nullable PartitionSpec _elem2059; - for (int _i2060 = 0; _i2060 < _list2058.size; ++_i2060) + org.apache.thrift.protocol.TList _list2076 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list2076.size); + @org.apache.thrift.annotation.Nullable PartitionSpec _elem2077; + for (int _i2078 = 0; _i2078 < _list2076.size; ++_i2078) { - _elem2059 = new PartitionSpec(); - _elem2059.read(iprot); - struct.success.add(_elem2059); + _elem2077 = new PartitionSpec(); + _elem2077.read(iprot); + struct.success.add(_elem2077); } iprot.readListEnd(); } @@ -159456,9 +160391,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 _iter2061 : struct.success) + for (PartitionSpec _iter2079 : struct.success) { - _iter2061.write(oprot); + _iter2079.write(oprot); } oprot.writeListEnd(); } @@ -159505,9 +160440,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 _iter2062 : struct.success) + for (PartitionSpec _iter2080 : struct.success) { - _iter2062.write(oprot); + _iter2080.write(oprot); } } } @@ -159525,14 +160460,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_part_specs_by_fi java.util.BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list2063 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.success = new java.util.ArrayList(_list2063.size); - @org.apache.thrift.annotation.Nullable PartitionSpec _elem2064; - for (int _i2065 = 0; _i2065 < _list2063.size; ++_i2065) + org.apache.thrift.protocol.TList _list2081 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.success = new java.util.ArrayList(_list2081.size); + @org.apache.thrift.annotation.Nullable PartitionSpec _elem2082; + for (int _i2083 = 0; _i2083 < _list2081.size; ++_i2083) { - _elem2064 = new PartitionSpec(); - _elem2064.read(iprot); - struct.success.add(_elem2064); + _elem2082 = new PartitionSpec(); + _elem2082.read(iprot); + struct.success.add(_elem2082); } } struct.setSuccessIsSet(true); @@ -163080,13 +164015,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 _list2066 = iprot.readListBegin(); - struct.names = new java.util.ArrayList(_list2066.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem2067; - for (int _i2068 = 0; _i2068 < _list2066.size; ++_i2068) + org.apache.thrift.protocol.TList _list2084 = iprot.readListBegin(); + struct.names = new java.util.ArrayList(_list2084.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem2085; + for (int _i2086 = 0; _i2086 < _list2084.size; ++_i2086) { - _elem2067 = iprot.readString(); - struct.names.add(_elem2067); + _elem2085 = iprot.readString(); + struct.names.add(_elem2085); } iprot.readListEnd(); } @@ -163122,9 +164057,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 (java.lang.String _iter2069 : struct.names) + for (java.lang.String _iter2087 : struct.names) { - oprot.writeString(_iter2069); + oprot.writeString(_iter2087); } oprot.writeListEnd(); } @@ -163167,9 +164102,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_by_n if (struct.isSetNames()) { { oprot.writeI32(struct.names.size()); - for (java.lang.String _iter2070 : struct.names) + for (java.lang.String _iter2088 : struct.names) { - oprot.writeString(_iter2070); + oprot.writeString(_iter2088); } } } @@ -163189,13 +164124,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_by_na } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list2071 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.names = new java.util.ArrayList(_list2071.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem2072; - for (int _i2073 = 0; _i2073 < _list2071.size; ++_i2073) + org.apache.thrift.protocol.TList _list2089 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.names = new java.util.ArrayList(_list2089.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem2090; + for (int _i2091 = 0; _i2091 < _list2089.size; ++_i2091) { - _elem2072 = iprot.readString(); - struct.names.add(_elem2072); + _elem2090 = iprot.readString(); + struct.names.add(_elem2090); } } struct.setNamesIsSet(true); @@ -163768,14 +164703,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 _list2074 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list2074.size); - @org.apache.thrift.annotation.Nullable Partition _elem2075; - for (int _i2076 = 0; _i2076 < _list2074.size; ++_i2076) + org.apache.thrift.protocol.TList _list2092 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list2092.size); + @org.apache.thrift.annotation.Nullable Partition _elem2093; + for (int _i2094 = 0; _i2094 < _list2092.size; ++_i2094) { - _elem2075 = new Partition(); - _elem2075.read(iprot); - struct.success.add(_elem2075); + _elem2093 = new Partition(); + _elem2093.read(iprot); + struct.success.add(_elem2093); } iprot.readListEnd(); } @@ -163828,9 +164763,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 _iter2077 : struct.success) + for (Partition _iter2095 : struct.success) { - _iter2077.write(oprot); + _iter2095.write(oprot); } oprot.writeListEnd(); } @@ -163885,9 +164820,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_by_n if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Partition _iter2078 : struct.success) + for (Partition _iter2096 : struct.success) { - _iter2078.write(oprot); + _iter2096.write(oprot); } } } @@ -163908,14 +164843,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_by_na java.util.BitSet incoming = iprot.readBitSet(4); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list2079 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.success = new java.util.ArrayList(_list2079.size); - @org.apache.thrift.annotation.Nullable Partition _elem2080; - for (int _i2081 = 0; _i2081 < _list2079.size; ++_i2081) + org.apache.thrift.protocol.TList _list2097 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.success = new java.util.ArrayList(_list2097.size); + @org.apache.thrift.annotation.Nullable Partition _elem2098; + for (int _i2099 = 0; _i2099 < _list2097.size; ++_i2099) { - _elem2080 = new Partition(); - _elem2080.read(iprot); - struct.success.add(_elem2080); + _elem2098 = new Partition(); + _elem2098.read(iprot); + struct.success.add(_elem2098); } } struct.setSuccessIsSet(true); @@ -168419,14 +169354,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 _list2082 = iprot.readListBegin(); - struct.new_parts = new java.util.ArrayList(_list2082.size); - @org.apache.thrift.annotation.Nullable Partition _elem2083; - for (int _i2084 = 0; _i2084 < _list2082.size; ++_i2084) + org.apache.thrift.protocol.TList _list2100 = iprot.readListBegin(); + struct.new_parts = new java.util.ArrayList(_list2100.size); + @org.apache.thrift.annotation.Nullable Partition _elem2101; + for (int _i2102 = 0; _i2102 < _list2100.size; ++_i2102) { - _elem2083 = new Partition(); - _elem2083.read(iprot); - struct.new_parts.add(_elem2083); + _elem2101 = new Partition(); + _elem2101.read(iprot); + struct.new_parts.add(_elem2101); } iprot.readListEnd(); } @@ -168462,9 +169397,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 _iter2085 : struct.new_parts) + for (Partition _iter2103 : struct.new_parts) { - _iter2085.write(oprot); + _iter2103.write(oprot); } oprot.writeListEnd(); } @@ -168507,9 +169442,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 _iter2086 : struct.new_parts) + for (Partition _iter2104 : struct.new_parts) { - _iter2086.write(oprot); + _iter2104.write(oprot); } } } @@ -168529,14 +169464,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, alter_partitions_arg } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list2087 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.new_parts = new java.util.ArrayList(_list2087.size); - @org.apache.thrift.annotation.Nullable Partition _elem2088; - for (int _i2089 = 0; _i2089 < _list2087.size; ++_i2089) + org.apache.thrift.protocol.TList _list2105 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.new_parts = new java.util.ArrayList(_list2105.size); + @org.apache.thrift.annotation.Nullable Partition _elem2106; + for (int _i2107 = 0; _i2107 < _list2105.size; ++_i2107) { - _elem2088 = new Partition(); - _elem2088.read(iprot); - struct.new_parts.add(_elem2088); + _elem2106 = new Partition(); + _elem2106.read(iprot); + struct.new_parts.add(_elem2106); } } struct.setNew_partsIsSet(true); @@ -169598,14 +170533,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 _list2090 = iprot.readListBegin(); - struct.new_parts = new java.util.ArrayList(_list2090.size); - @org.apache.thrift.annotation.Nullable Partition _elem2091; - for (int _i2092 = 0; _i2092 < _list2090.size; ++_i2092) + org.apache.thrift.protocol.TList _list2108 = iprot.readListBegin(); + struct.new_parts = new java.util.ArrayList(_list2108.size); + @org.apache.thrift.annotation.Nullable Partition _elem2109; + for (int _i2110 = 0; _i2110 < _list2108.size; ++_i2110) { - _elem2091 = new Partition(); - _elem2091.read(iprot); - struct.new_parts.add(_elem2091); + _elem2109 = new Partition(); + _elem2109.read(iprot); + struct.new_parts.add(_elem2109); } iprot.readListEnd(); } @@ -169650,9 +170585,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 _iter2093 : struct.new_parts) + for (Partition _iter2111 : struct.new_parts) { - _iter2093.write(oprot); + _iter2111.write(oprot); } oprot.writeListEnd(); } @@ -169703,9 +170638,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 _iter2094 : struct.new_parts) + for (Partition _iter2112 : struct.new_parts) { - _iter2094.write(oprot); + _iter2112.write(oprot); } } } @@ -169728,14 +170663,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, alter_partitions_wit } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list2095 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.new_parts = new java.util.ArrayList(_list2095.size); - @org.apache.thrift.annotation.Nullable Partition _elem2096; - for (int _i2097 = 0; _i2097 < _list2095.size; ++_i2097) + org.apache.thrift.protocol.TList _list2113 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.new_parts = new java.util.ArrayList(_list2113.size); + @org.apache.thrift.annotation.Nullable Partition _elem2114; + for (int _i2115 = 0; _i2115 < _list2113.size; ++_i2115) { - _elem2096 = new Partition(); - _elem2096.read(iprot); - struct.new_parts.add(_elem2096); + _elem2114 = new Partition(); + _elem2114.read(iprot); + struct.new_parts.add(_elem2114); } } struct.setNew_partsIsSet(true); @@ -172899,13 +173834,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 _list2098 = iprot.readListBegin(); - struct.part_vals = new java.util.ArrayList(_list2098.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem2099; - for (int _i2100 = 0; _i2100 < _list2098.size; ++_i2100) + org.apache.thrift.protocol.TList _list2116 = iprot.readListBegin(); + struct.part_vals = new java.util.ArrayList(_list2116.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem2117; + for (int _i2118 = 0; _i2118 < _list2116.size; ++_i2118) { - _elem2099 = iprot.readString(); - struct.part_vals.add(_elem2099); + _elem2117 = iprot.readString(); + struct.part_vals.add(_elem2117); } iprot.readListEnd(); } @@ -172950,9 +173885,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 (java.lang.String _iter2101 : struct.part_vals) + for (java.lang.String _iter2119 : struct.part_vals) { - oprot.writeString(_iter2101); + oprot.writeString(_iter2119); } oprot.writeListEnd(); } @@ -173003,9 +173938,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, rename_partition_ar if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (java.lang.String _iter2102 : struct.part_vals) + for (java.lang.String _iter2120 : struct.part_vals) { - oprot.writeString(_iter2102); + oprot.writeString(_iter2120); } } } @@ -173028,13 +173963,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, rename_partition_arg } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list2103 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.part_vals = new java.util.ArrayList(_list2103.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem2104; - for (int _i2105 = 0; _i2105 < _list2103.size; ++_i2105) + org.apache.thrift.protocol.TList _list2121 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.part_vals = new java.util.ArrayList(_list2121.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem2122; + for (int _i2123 = 0; _i2123 < _list2121.size; ++_i2123) { - _elem2104 = iprot.readString(); - struct.part_vals.add(_elem2104); + _elem2122 = iprot.readString(); + struct.part_vals.add(_elem2122); } } struct.setPart_valsIsSet(true); @@ -174860,13 +175795,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 _list2106 = iprot.readListBegin(); - struct.part_vals = new java.util.ArrayList(_list2106.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem2107; - for (int _i2108 = 0; _i2108 < _list2106.size; ++_i2108) + org.apache.thrift.protocol.TList _list2124 = iprot.readListBegin(); + struct.part_vals = new java.util.ArrayList(_list2124.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem2125; + for (int _i2126 = 0; _i2126 < _list2124.size; ++_i2126) { - _elem2107 = iprot.readString(); - struct.part_vals.add(_elem2107); + _elem2125 = iprot.readString(); + struct.part_vals.add(_elem2125); } iprot.readListEnd(); } @@ -174900,9 +175835,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 (java.lang.String _iter2109 : struct.part_vals) + for (java.lang.String _iter2127 : struct.part_vals) { - oprot.writeString(_iter2109); + oprot.writeString(_iter2127); } oprot.writeListEnd(); } @@ -174939,9 +175874,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, partition_name_has_ if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (java.lang.String _iter2110 : struct.part_vals) + for (java.lang.String _iter2128 : struct.part_vals) { - oprot.writeString(_iter2110); + oprot.writeString(_iter2128); } } } @@ -174956,13 +175891,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, partition_name_has_v java.util.BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list2111 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.part_vals = new java.util.ArrayList(_list2111.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem2112; - for (int _i2113 = 0; _i2113 < _list2111.size; ++_i2113) + org.apache.thrift.protocol.TList _list2129 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.part_vals = new java.util.ArrayList(_list2129.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem2130; + for (int _i2131 = 0; _i2131 < _list2129.size; ++_i2131) { - _elem2112 = iprot.readString(); - struct.part_vals.add(_elem2112); + _elem2130 = iprot.readString(); + struct.part_vals.add(_elem2130); } } struct.setPart_valsIsSet(true); @@ -177135,13 +178070,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 _list2114 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list2114.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem2115; - for (int _i2116 = 0; _i2116 < _list2114.size; ++_i2116) + org.apache.thrift.protocol.TList _list2132 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list2132.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem2133; + for (int _i2134 = 0; _i2134 < _list2132.size; ++_i2134) { - _elem2115 = iprot.readString(); - struct.success.add(_elem2115); + _elem2133 = iprot.readString(); + struct.success.add(_elem2133); } iprot.readListEnd(); } @@ -177176,9 +178111,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 (java.lang.String _iter2117 : struct.success) + for (java.lang.String _iter2135 : struct.success) { - oprot.writeString(_iter2117); + oprot.writeString(_iter2135); } oprot.writeListEnd(); } @@ -177217,9 +178152,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, partition_name_to_v if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (java.lang.String _iter2118 : struct.success) + for (java.lang.String _iter2136 : struct.success) { - oprot.writeString(_iter2118); + oprot.writeString(_iter2136); } } } @@ -177234,13 +178169,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, partition_name_to_va java.util.BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list2119 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.success = new java.util.ArrayList(_list2119.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem2120; - for (int _i2121 = 0; _i2121 < _list2119.size; ++_i2121) + org.apache.thrift.protocol.TList _list2137 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.success = new java.util.ArrayList(_list2137.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem2138; + for (int _i2139 = 0; _i2139 < _list2137.size; ++_i2139) { - _elem2120 = iprot.readString(); - struct.success.add(_elem2120); + _elem2138 = iprot.readString(); + struct.success.add(_elem2138); } } struct.setSuccessIsSet(true); @@ -178011,15 +178946,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 _map2122 = iprot.readMapBegin(); - struct.success = new java.util.HashMap(2*_map2122.size); - @org.apache.thrift.annotation.Nullable java.lang.String _key2123; - @org.apache.thrift.annotation.Nullable java.lang.String _val2124; - for (int _i2125 = 0; _i2125 < _map2122.size; ++_i2125) + org.apache.thrift.protocol.TMap _map2140 = iprot.readMapBegin(); + struct.success = new java.util.HashMap(2*_map2140.size); + @org.apache.thrift.annotation.Nullable java.lang.String _key2141; + @org.apache.thrift.annotation.Nullable java.lang.String _val2142; + for (int _i2143 = 0; _i2143 < _map2140.size; ++_i2143) { - _key2123 = iprot.readString(); - _val2124 = iprot.readString(); - struct.success.put(_key2123, _val2124); + _key2141 = iprot.readString(); + _val2142 = iprot.readString(); + struct.success.put(_key2141, _val2142); } iprot.readMapEnd(); } @@ -178054,10 +178989,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 (java.util.Map.Entry _iter2126 : struct.success.entrySet()) + for (java.util.Map.Entry _iter2144 : struct.success.entrySet()) { - oprot.writeString(_iter2126.getKey()); - oprot.writeString(_iter2126.getValue()); + oprot.writeString(_iter2144.getKey()); + oprot.writeString(_iter2144.getValue()); } oprot.writeMapEnd(); } @@ -178096,10 +179031,10 @@ public void write(org.apache.thrift.protocol.TProtocol prot, partition_name_to_s if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (java.util.Map.Entry _iter2127 : struct.success.entrySet()) + for (java.util.Map.Entry _iter2145 : struct.success.entrySet()) { - oprot.writeString(_iter2127.getKey()); - oprot.writeString(_iter2127.getValue()); + oprot.writeString(_iter2145.getKey()); + oprot.writeString(_iter2145.getValue()); } } } @@ -178114,15 +179049,15 @@ public void read(org.apache.thrift.protocol.TProtocol prot, partition_name_to_sp java.util.BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TMap _map2128 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); - struct.success = new java.util.HashMap(2*_map2128.size); - @org.apache.thrift.annotation.Nullable java.lang.String _key2129; - @org.apache.thrift.annotation.Nullable java.lang.String _val2130; - for (int _i2131 = 0; _i2131 < _map2128.size; ++_i2131) + org.apache.thrift.protocol.TMap _map2146 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); + struct.success = new java.util.HashMap(2*_map2146.size); + @org.apache.thrift.annotation.Nullable java.lang.String _key2147; + @org.apache.thrift.annotation.Nullable java.lang.String _val2148; + for (int _i2149 = 0; _i2149 < _map2146.size; ++_i2149) { - _key2129 = iprot.readString(); - _val2130 = iprot.readString(); - struct.success.put(_key2129, _val2130); + _key2147 = iprot.readString(); + _val2148 = iprot.readString(); + struct.success.put(_key2147, _val2148); } } struct.setSuccessIsSet(true); @@ -178721,15 +179656,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 _map2132 = iprot.readMapBegin(); - struct.part_vals = new java.util.HashMap(2*_map2132.size); - @org.apache.thrift.annotation.Nullable java.lang.String _key2133; - @org.apache.thrift.annotation.Nullable java.lang.String _val2134; - for (int _i2135 = 0; _i2135 < _map2132.size; ++_i2135) + org.apache.thrift.protocol.TMap _map2150 = iprot.readMapBegin(); + struct.part_vals = new java.util.HashMap(2*_map2150.size); + @org.apache.thrift.annotation.Nullable java.lang.String _key2151; + @org.apache.thrift.annotation.Nullable java.lang.String _val2152; + for (int _i2153 = 0; _i2153 < _map2150.size; ++_i2153) { - _key2133 = iprot.readString(); - _val2134 = iprot.readString(); - struct.part_vals.put(_key2133, _val2134); + _key2151 = iprot.readString(); + _val2152 = iprot.readString(); + struct.part_vals.put(_key2151, _val2152); } iprot.readMapEnd(); } @@ -178773,10 +179708,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 (java.util.Map.Entry _iter2136 : struct.part_vals.entrySet()) + for (java.util.Map.Entry _iter2154 : struct.part_vals.entrySet()) { - oprot.writeString(_iter2136.getKey()); - oprot.writeString(_iter2136.getValue()); + oprot.writeString(_iter2154.getKey()); + oprot.writeString(_iter2154.getValue()); } oprot.writeMapEnd(); } @@ -178827,10 +179762,10 @@ public void write(org.apache.thrift.protocol.TProtocol prot, markPartitionForEve if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (java.util.Map.Entry _iter2137 : struct.part_vals.entrySet()) + for (java.util.Map.Entry _iter2155 : struct.part_vals.entrySet()) { - oprot.writeString(_iter2137.getKey()); - oprot.writeString(_iter2137.getValue()); + oprot.writeString(_iter2155.getKey()); + oprot.writeString(_iter2155.getValue()); } } } @@ -178853,15 +179788,15 @@ public void read(org.apache.thrift.protocol.TProtocol prot, markPartitionForEven } if (incoming.get(2)) { { - org.apache.thrift.protocol.TMap _map2138 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); - struct.part_vals = new java.util.HashMap(2*_map2138.size); - @org.apache.thrift.annotation.Nullable java.lang.String _key2139; - @org.apache.thrift.annotation.Nullable java.lang.String _val2140; - for (int _i2141 = 0; _i2141 < _map2138.size; ++_i2141) + org.apache.thrift.protocol.TMap _map2156 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); + struct.part_vals = new java.util.HashMap(2*_map2156.size); + @org.apache.thrift.annotation.Nullable java.lang.String _key2157; + @org.apache.thrift.annotation.Nullable java.lang.String _val2158; + for (int _i2159 = 0; _i2159 < _map2156.size; ++_i2159) { - _key2139 = iprot.readString(); - _val2140 = iprot.readString(); - struct.part_vals.put(_key2139, _val2140); + _key2157 = iprot.readString(); + _val2158 = iprot.readString(); + struct.part_vals.put(_key2157, _val2158); } } struct.setPart_valsIsSet(true); @@ -180353,15 +181288,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 _map2142 = iprot.readMapBegin(); - struct.part_vals = new java.util.HashMap(2*_map2142.size); - @org.apache.thrift.annotation.Nullable java.lang.String _key2143; - @org.apache.thrift.annotation.Nullable java.lang.String _val2144; - for (int _i2145 = 0; _i2145 < _map2142.size; ++_i2145) + org.apache.thrift.protocol.TMap _map2160 = iprot.readMapBegin(); + struct.part_vals = new java.util.HashMap(2*_map2160.size); + @org.apache.thrift.annotation.Nullable java.lang.String _key2161; + @org.apache.thrift.annotation.Nullable java.lang.String _val2162; + for (int _i2163 = 0; _i2163 < _map2160.size; ++_i2163) { - _key2143 = iprot.readString(); - _val2144 = iprot.readString(); - struct.part_vals.put(_key2143, _val2144); + _key2161 = iprot.readString(); + _val2162 = iprot.readString(); + struct.part_vals.put(_key2161, _val2162); } iprot.readMapEnd(); } @@ -180405,10 +181340,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 (java.util.Map.Entry _iter2146 : struct.part_vals.entrySet()) + for (java.util.Map.Entry _iter2164 : struct.part_vals.entrySet()) { - oprot.writeString(_iter2146.getKey()); - oprot.writeString(_iter2146.getValue()); + oprot.writeString(_iter2164.getKey()); + oprot.writeString(_iter2164.getValue()); } oprot.writeMapEnd(); } @@ -180459,10 +181394,10 @@ public void write(org.apache.thrift.protocol.TProtocol prot, isPartitionMarkedFo if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (java.util.Map.Entry _iter2147 : struct.part_vals.entrySet()) + for (java.util.Map.Entry _iter2165 : struct.part_vals.entrySet()) { - oprot.writeString(_iter2147.getKey()); - oprot.writeString(_iter2147.getValue()); + oprot.writeString(_iter2165.getKey()); + oprot.writeString(_iter2165.getValue()); } } } @@ -180485,15 +181420,15 @@ public void read(org.apache.thrift.protocol.TProtocol prot, isPartitionMarkedFor } if (incoming.get(2)) { { - org.apache.thrift.protocol.TMap _map2148 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); - struct.part_vals = new java.util.HashMap(2*_map2148.size); - @org.apache.thrift.annotation.Nullable java.lang.String _key2149; - @org.apache.thrift.annotation.Nullable java.lang.String _val2150; - for (int _i2151 = 0; _i2151 < _map2148.size; ++_i2151) + org.apache.thrift.protocol.TMap _map2166 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING); + struct.part_vals = new java.util.HashMap(2*_map2166.size); + @org.apache.thrift.annotation.Nullable java.lang.String _key2167; + @org.apache.thrift.annotation.Nullable java.lang.String _val2168; + for (int _i2169 = 0; _i2169 < _map2166.size; ++_i2169) { - _key2149 = iprot.readString(); - _val2150 = iprot.readString(); - struct.part_vals.put(_key2149, _val2150); + _key2167 = iprot.readString(); + _val2168 = iprot.readString(); + struct.part_vals.put(_key2167, _val2168); } } struct.setPart_valsIsSet(true); @@ -208347,13 +209282,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 _list2152 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list2152.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem2153; - for (int _i2154 = 0; _i2154 < _list2152.size; ++_i2154) + org.apache.thrift.protocol.TList _list2170 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list2170.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem2171; + for (int _i2172 = 0; _i2172 < _list2170.size; ++_i2172) { - _elem2153 = iprot.readString(); - struct.success.add(_elem2153); + _elem2171 = iprot.readString(); + struct.success.add(_elem2171); } iprot.readListEnd(); } @@ -208388,9 +209323,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 (java.lang.String _iter2155 : struct.success) + for (java.lang.String _iter2173 : struct.success) { - oprot.writeString(_iter2155); + oprot.writeString(_iter2173); } oprot.writeListEnd(); } @@ -208429,9 +209364,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_functions_resul if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (java.lang.String _iter2156 : struct.success) + for (java.lang.String _iter2174 : struct.success) { - oprot.writeString(_iter2156); + oprot.writeString(_iter2174); } } } @@ -208446,13 +209381,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_functions_result java.util.BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list2157 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.success = new java.util.ArrayList(_list2157.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem2158; - for (int _i2159 = 0; _i2159 < _list2157.size; ++_i2159) + org.apache.thrift.protocol.TList _list2175 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.success = new java.util.ArrayList(_list2175.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem2176; + for (int _i2177 = 0; _i2177 < _list2175.size; ++_i2177) { - _elem2158 = iprot.readString(); - struct.success.add(_elem2158); + _elem2176 = iprot.readString(); + struct.success.add(_elem2176); } } struct.setSuccessIsSet(true); @@ -213382,13 +214317,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 _list2160 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list2160.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem2161; - for (int _i2162 = 0; _i2162 < _list2160.size; ++_i2162) + org.apache.thrift.protocol.TList _list2178 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list2178.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem2179; + for (int _i2180 = 0; _i2180 < _list2178.size; ++_i2180) { - _elem2161 = iprot.readString(); - struct.success.add(_elem2161); + _elem2179 = iprot.readString(); + struct.success.add(_elem2179); } iprot.readListEnd(); } @@ -213423,9 +214358,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 (java.lang.String _iter2163 : struct.success) + for (java.lang.String _iter2181 : struct.success) { - oprot.writeString(_iter2163); + oprot.writeString(_iter2181); } oprot.writeListEnd(); } @@ -213464,9 +214399,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_role_names_resu if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (java.lang.String _iter2164 : struct.success) + for (java.lang.String _iter2182 : struct.success) { - oprot.writeString(_iter2164); + oprot.writeString(_iter2182); } } } @@ -213481,13 +214416,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_role_names_resul java.util.BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list2165 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.success = new java.util.ArrayList(_list2165.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem2166; - for (int _i2167 = 0; _i2167 < _list2165.size; ++_i2167) + org.apache.thrift.protocol.TList _list2183 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.success = new java.util.ArrayList(_list2183.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem2184; + for (int _i2185 = 0; _i2185 < _list2183.size; ++_i2185) { - _elem2166 = iprot.readString(); - struct.success.add(_elem2166); + _elem2184 = iprot.readString(); + struct.success.add(_elem2184); } } struct.setSuccessIsSet(true); @@ -216794,14 +217729,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 _list2168 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list2168.size); - @org.apache.thrift.annotation.Nullable Role _elem2169; - for (int _i2170 = 0; _i2170 < _list2168.size; ++_i2170) + org.apache.thrift.protocol.TList _list2186 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list2186.size); + @org.apache.thrift.annotation.Nullable Role _elem2187; + for (int _i2188 = 0; _i2188 < _list2186.size; ++_i2188) { - _elem2169 = new Role(); - _elem2169.read(iprot); - struct.success.add(_elem2169); + _elem2187 = new Role(); + _elem2187.read(iprot); + struct.success.add(_elem2187); } iprot.readListEnd(); } @@ -216836,9 +217771,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 _iter2171 : struct.success) + for (Role _iter2189 : struct.success) { - _iter2171.write(oprot); + _iter2189.write(oprot); } oprot.writeListEnd(); } @@ -216877,9 +217812,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, list_roles_result s if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Role _iter2172 : struct.success) + for (Role _iter2190 : struct.success) { - _iter2172.write(oprot); + _iter2190.write(oprot); } } } @@ -216894,14 +217829,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, list_roles_result st java.util.BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list2173 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.success = new java.util.ArrayList(_list2173.size); - @org.apache.thrift.annotation.Nullable Role _elem2174; - for (int _i2175 = 0; _i2175 < _list2173.size; ++_i2175) + org.apache.thrift.protocol.TList _list2191 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.success = new java.util.ArrayList(_list2191.size); + @org.apache.thrift.annotation.Nullable Role _elem2192; + for (int _i2193 = 0; _i2193 < _list2191.size; ++_i2193) { - _elem2174 = new Role(); - _elem2174.read(iprot); - struct.success.add(_elem2174); + _elem2192 = new Role(); + _elem2192.read(iprot); + struct.success.add(_elem2192); } } struct.setSuccessIsSet(true); @@ -219935,13 +220870,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 _list2176 = iprot.readListBegin(); - struct.group_names = new java.util.ArrayList(_list2176.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem2177; - for (int _i2178 = 0; _i2178 < _list2176.size; ++_i2178) + org.apache.thrift.protocol.TList _list2194 = iprot.readListBegin(); + struct.group_names = new java.util.ArrayList(_list2194.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem2195; + for (int _i2196 = 0; _i2196 < _list2194.size; ++_i2196) { - _elem2177 = iprot.readString(); - struct.group_names.add(_elem2177); + _elem2195 = iprot.readString(); + struct.group_names.add(_elem2195); } iprot.readListEnd(); } @@ -219977,9 +220912,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 (java.lang.String _iter2179 : struct.group_names) + for (java.lang.String _iter2197 : struct.group_names) { - oprot.writeString(_iter2179); + oprot.writeString(_iter2197); } oprot.writeListEnd(); } @@ -220022,9 +220957,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 (java.lang.String _iter2180 : struct.group_names) + for (java.lang.String _iter2198 : struct.group_names) { - oprot.writeString(_iter2180); + oprot.writeString(_iter2198); } } } @@ -220045,13 +220980,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_privilege_set_ar } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list2181 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.group_names = new java.util.ArrayList(_list2181.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem2182; - for (int _i2183 = 0; _i2183 < _list2181.size; ++_i2183) + org.apache.thrift.protocol.TList _list2199 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.group_names = new java.util.ArrayList(_list2199.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem2200; + for (int _i2201 = 0; _i2201 < _list2199.size; ++_i2201) { - _elem2182 = iprot.readString(); - struct.group_names.add(_elem2182); + _elem2200 = iprot.readString(); + struct.group_names.add(_elem2200); } } struct.setGroup_namesIsSet(true); @@ -221522,14 +222457,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 _list2184 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list2184.size); - @org.apache.thrift.annotation.Nullable HiveObjectPrivilege _elem2185; - for (int _i2186 = 0; _i2186 < _list2184.size; ++_i2186) + org.apache.thrift.protocol.TList _list2202 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list2202.size); + @org.apache.thrift.annotation.Nullable HiveObjectPrivilege _elem2203; + for (int _i2204 = 0; _i2204 < _list2202.size; ++_i2204) { - _elem2185 = new HiveObjectPrivilege(); - _elem2185.read(iprot); - struct.success.add(_elem2185); + _elem2203 = new HiveObjectPrivilege(); + _elem2203.read(iprot); + struct.success.add(_elem2203); } iprot.readListEnd(); } @@ -221564,9 +222499,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 _iter2187 : struct.success) + for (HiveObjectPrivilege _iter2205 : struct.success) { - _iter2187.write(oprot); + _iter2205.write(oprot); } oprot.writeListEnd(); } @@ -221605,9 +222540,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, list_privileges_res if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (HiveObjectPrivilege _iter2188 : struct.success) + for (HiveObjectPrivilege _iter2206 : struct.success) { - _iter2188.write(oprot); + _iter2206.write(oprot); } } } @@ -221622,14 +222557,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, list_privileges_resu java.util.BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list2189 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.success = new java.util.ArrayList(_list2189.size); - @org.apache.thrift.annotation.Nullable HiveObjectPrivilege _elem2190; - for (int _i2191 = 0; _i2191 < _list2189.size; ++_i2191) + org.apache.thrift.protocol.TList _list2207 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.success = new java.util.ArrayList(_list2207.size); + @org.apache.thrift.annotation.Nullable HiveObjectPrivilege _elem2208; + for (int _i2209 = 0; _i2209 < _list2207.size; ++_i2209) { - _elem2190 = new HiveObjectPrivilege(); - _elem2190.read(iprot); - struct.success.add(_elem2190); + _elem2208 = new HiveObjectPrivilege(); + _elem2208.read(iprot); + struct.success.add(_elem2208); } } struct.setSuccessIsSet(true); @@ -225607,13 +226542,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 _list2192 = iprot.readListBegin(); - struct.group_names = new java.util.ArrayList(_list2192.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem2193; - for (int _i2194 = 0; _i2194 < _list2192.size; ++_i2194) + org.apache.thrift.protocol.TList _list2210 = iprot.readListBegin(); + struct.group_names = new java.util.ArrayList(_list2210.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem2211; + for (int _i2212 = 0; _i2212 < _list2210.size; ++_i2212) { - _elem2193 = iprot.readString(); - struct.group_names.add(_elem2193); + _elem2211 = iprot.readString(); + struct.group_names.add(_elem2211); } iprot.readListEnd(); } @@ -225644,9 +226579,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 (java.lang.String _iter2195 : struct.group_names) + for (java.lang.String _iter2213 : struct.group_names) { - oprot.writeString(_iter2195); + oprot.writeString(_iter2213); } oprot.writeListEnd(); } @@ -225683,9 +226618,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 (java.lang.String _iter2196 : struct.group_names) + for (java.lang.String _iter2214 : struct.group_names) { - oprot.writeString(_iter2196); + oprot.writeString(_iter2214); } } } @@ -225701,13 +226636,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, set_ugi_args struct) } if (incoming.get(1)) { { - org.apache.thrift.protocol.TList _list2197 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.group_names = new java.util.ArrayList(_list2197.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem2198; - for (int _i2199 = 0; _i2199 < _list2197.size; ++_i2199) + org.apache.thrift.protocol.TList _list2215 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.group_names = new java.util.ArrayList(_list2215.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem2216; + for (int _i2217 = 0; _i2217 < _list2215.size; ++_i2217) { - _elem2198 = iprot.readString(); - struct.group_names.add(_elem2198); + _elem2216 = iprot.readString(); + struct.group_names.add(_elem2216); } } struct.setGroup_namesIsSet(true); @@ -226115,13 +227050,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 _list2200 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list2200.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem2201; - for (int _i2202 = 0; _i2202 < _list2200.size; ++_i2202) + org.apache.thrift.protocol.TList _list2218 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list2218.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem2219; + for (int _i2220 = 0; _i2220 < _list2218.size; ++_i2220) { - _elem2201 = iprot.readString(); - struct.success.add(_elem2201); + _elem2219 = iprot.readString(); + struct.success.add(_elem2219); } iprot.readListEnd(); } @@ -226156,9 +227091,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 (java.lang.String _iter2203 : struct.success) + for (java.lang.String _iter2221 : struct.success) { - oprot.writeString(_iter2203); + oprot.writeString(_iter2221); } oprot.writeListEnd(); } @@ -226197,9 +227132,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, set_ugi_result stru if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (java.lang.String _iter2204 : struct.success) + for (java.lang.String _iter2222 : struct.success) { - oprot.writeString(_iter2204); + oprot.writeString(_iter2222); } } } @@ -226214,13 +227149,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, set_ugi_result struc java.util.BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list2205 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.success = new java.util.ArrayList(_list2205.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem2206; - for (int _i2207 = 0; _i2207 < _list2205.size; ++_i2207) + org.apache.thrift.protocol.TList _list2223 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.success = new java.util.ArrayList(_list2223.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem2224; + for (int _i2225 = 0; _i2225 < _list2223.size; ++_i2225) { - _elem2206 = iprot.readString(); - struct.success.add(_elem2206); + _elem2224 = iprot.readString(); + struct.success.add(_elem2224); } } struct.setSuccessIsSet(true); @@ -231559,13 +232494,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 _list2208 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list2208.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem2209; - for (int _i2210 = 0; _i2210 < _list2208.size; ++_i2210) + org.apache.thrift.protocol.TList _list2226 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list2226.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem2227; + for (int _i2228 = 0; _i2228 < _list2226.size; ++_i2228) { - _elem2209 = iprot.readString(); - struct.success.add(_elem2209); + _elem2227 = iprot.readString(); + struct.success.add(_elem2227); } iprot.readListEnd(); } @@ -231591,9 +232526,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 (java.lang.String _iter2211 : struct.success) + for (java.lang.String _iter2229 : struct.success) { - oprot.writeString(_iter2211); + oprot.writeString(_iter2229); } oprot.writeListEnd(); } @@ -231624,9 +232559,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_all_token_ident if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (java.lang.String _iter2212 : struct.success) + for (java.lang.String _iter2230 : struct.success) { - oprot.writeString(_iter2212); + oprot.writeString(_iter2230); } } } @@ -231638,13 +232573,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_all_token_identi java.util.BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list2213 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.success = new java.util.ArrayList(_list2213.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem2214; - for (int _i2215 = 0; _i2215 < _list2213.size; ++_i2215) + org.apache.thrift.protocol.TList _list2231 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.success = new java.util.ArrayList(_list2231.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem2232; + for (int _i2233 = 0; _i2233 < _list2231.size; ++_i2233) { - _elem2214 = iprot.readString(); - struct.success.add(_elem2214); + _elem2232 = iprot.readString(); + struct.success.add(_elem2232); } } struct.setSuccessIsSet(true); @@ -234695,13 +235630,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 _list2216 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list2216.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem2217; - for (int _i2218 = 0; _i2218 < _list2216.size; ++_i2218) + org.apache.thrift.protocol.TList _list2234 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list2234.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem2235; + for (int _i2236 = 0; _i2236 < _list2234.size; ++_i2236) { - _elem2217 = iprot.readString(); - struct.success.add(_elem2217); + _elem2235 = iprot.readString(); + struct.success.add(_elem2235); } iprot.readListEnd(); } @@ -234727,9 +235662,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 (java.lang.String _iter2219 : struct.success) + for (java.lang.String _iter2237 : struct.success) { - oprot.writeString(_iter2219); + oprot.writeString(_iter2237); } oprot.writeListEnd(); } @@ -234760,9 +235695,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_master_keys_res if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (java.lang.String _iter2220 : struct.success) + for (java.lang.String _iter2238 : struct.success) { - oprot.writeString(_iter2220); + oprot.writeString(_iter2238); } } } @@ -234774,13 +235709,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_master_keys_resu java.util.BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list2221 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.success = new java.util.ArrayList(_list2221.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem2222; - for (int _i2223 = 0; _i2223 < _list2221.size; ++_i2223) + org.apache.thrift.protocol.TList _list2239 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.success = new java.util.ArrayList(_list2239.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem2240; + for (int _i2241 = 0; _i2241 < _list2239.size; ++_i2241) { - _elem2222 = iprot.readString(); - struct.success.add(_elem2222); + _elem2240 = iprot.readString(); + struct.success.add(_elem2240); } } struct.setSuccessIsSet(true); @@ -241841,15 +242776,15 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, add_write_ids_to_mi case 2: // WRITE_IDS if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map2224 = iprot.readMapBegin(); - struct.writeIds = new java.util.HashMap(2*_map2224.size); - @org.apache.thrift.annotation.Nullable java.lang.String _key2225; - long _val2226; - for (int _i2227 = 0; _i2227 < _map2224.size; ++_i2227) + org.apache.thrift.protocol.TMap _map2242 = iprot.readMapBegin(); + struct.writeIds = new java.util.HashMap(2*_map2242.size); + @org.apache.thrift.annotation.Nullable java.lang.String _key2243; + long _val2244; + for (int _i2245 = 0; _i2245 < _map2242.size; ++_i2245) { - _key2225 = iprot.readString(); - _val2226 = iprot.readI64(); - struct.writeIds.put(_key2225, _val2226); + _key2243 = iprot.readString(); + _val2244 = iprot.readI64(); + struct.writeIds.put(_key2243, _val2244); } iprot.readMapEnd(); } @@ -241878,10 +242813,10 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, add_write_ids_to_m oprot.writeFieldBegin(WRITE_IDS_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.I64, struct.writeIds.size())); - for (java.util.Map.Entry _iter2228 : struct.writeIds.entrySet()) + for (java.util.Map.Entry _iter2246 : struct.writeIds.entrySet()) { - oprot.writeString(_iter2228.getKey()); - oprot.writeI64(_iter2228.getValue()); + oprot.writeString(_iter2246.getKey()); + oprot.writeI64(_iter2246.getValue()); } oprot.writeMapEnd(); } @@ -241918,10 +242853,10 @@ public void write(org.apache.thrift.protocol.TProtocol prot, add_write_ids_to_mi if (struct.isSetWriteIds()) { { oprot.writeI32(struct.writeIds.size()); - for (java.util.Map.Entry _iter2229 : struct.writeIds.entrySet()) + for (java.util.Map.Entry _iter2247 : struct.writeIds.entrySet()) { - oprot.writeString(_iter2229.getKey()); - oprot.writeI64(_iter2229.getValue()); + oprot.writeString(_iter2247.getKey()); + oprot.writeI64(_iter2247.getValue()); } } } @@ -241937,15 +242872,15 @@ public void read(org.apache.thrift.protocol.TProtocol prot, add_write_ids_to_min } if (incoming.get(1)) { { - org.apache.thrift.protocol.TMap _map2230 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.I64); - struct.writeIds = new java.util.HashMap(2*_map2230.size); - @org.apache.thrift.annotation.Nullable java.lang.String _key2231; - long _val2232; - for (int _i2233 = 0; _i2233 < _map2230.size; ++_i2233) + org.apache.thrift.protocol.TMap _map2248 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.I64); + struct.writeIds = new java.util.HashMap(2*_map2248.size); + @org.apache.thrift.annotation.Nullable java.lang.String _key2249; + long _val2250; + for (int _i2251 = 0; _i2251 < _map2248.size; ++_i2251) { - _key2231 = iprot.readString(); - _val2232 = iprot.readI64(); - struct.writeIds.put(_key2231, _val2232); + _key2249 = iprot.readString(); + _val2250 = iprot.readI64(); + struct.writeIds.put(_key2249, _val2250); } } struct.setWriteIdsIsSet(true); @@ -257942,13 +258877,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, find_columns_with_s case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list2234 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list2234.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem2235; - for (int _i2236 = 0; _i2236 < _list2234.size; ++_i2236) + org.apache.thrift.protocol.TList _list2252 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list2252.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem2253; + for (int _i2254 = 0; _i2254 < _list2252.size; ++_i2254) { - _elem2235 = iprot.readString(); - struct.success.add(_elem2235); + _elem2253 = iprot.readString(); + struct.success.add(_elem2253); } iprot.readListEnd(); } @@ -257974,9 +258909,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, find_columns_with_ oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (java.lang.String _iter2237 : struct.success) + for (java.lang.String _iter2255 : struct.success) { - oprot.writeString(_iter2237); + oprot.writeString(_iter2255); } oprot.writeListEnd(); } @@ -258007,9 +258942,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, find_columns_with_s if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (java.lang.String _iter2238 : struct.success) + for (java.lang.String _iter2256 : struct.success) { - oprot.writeString(_iter2238); + oprot.writeString(_iter2256); } } } @@ -258021,13 +258956,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, find_columns_with_st java.util.BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list2239 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.success = new java.util.ArrayList(_list2239.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem2240; - for (int _i2241 = 0; _i2241 < _list2239.size; ++_i2241) + org.apache.thrift.protocol.TList _list2257 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.success = new java.util.ArrayList(_list2257.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem2258; + for (int _i2259 = 0; _i2259 < _list2257.size; ++_i2259) { - _elem2240 = iprot.readString(); - struct.success.add(_elem2240); + _elem2258 = iprot.readString(); + struct.success.add(_elem2258); } } struct.setSuccessIsSet(true); @@ -299009,14 +299944,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_schema_all_vers case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list2242 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list2242.size); - @org.apache.thrift.annotation.Nullable SchemaVersion _elem2243; - for (int _i2244 = 0; _i2244 < _list2242.size; ++_i2244) + org.apache.thrift.protocol.TList _list2260 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list2260.size); + @org.apache.thrift.annotation.Nullable SchemaVersion _elem2261; + for (int _i2262 = 0; _i2262 < _list2260.size; ++_i2262) { - _elem2243 = new SchemaVersion(); - _elem2243.read(iprot); - struct.success.add(_elem2243); + _elem2261 = new SchemaVersion(); + _elem2261.read(iprot); + struct.success.add(_elem2261); } iprot.readListEnd(); } @@ -299060,9 +299995,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_schema_all_ver oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (SchemaVersion _iter2245 : struct.success) + for (SchemaVersion _iter2263 : struct.success) { - _iter2245.write(oprot); + _iter2263.write(oprot); } oprot.writeListEnd(); } @@ -299109,9 +300044,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_schema_all_vers if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (SchemaVersion _iter2246 : struct.success) + for (SchemaVersion _iter2264 : struct.success) { - _iter2246.write(oprot); + _iter2264.write(oprot); } } } @@ -299129,14 +300064,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_schema_all_versi java.util.BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list2247 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.success = new java.util.ArrayList(_list2247.size); - @org.apache.thrift.annotation.Nullable SchemaVersion _elem2248; - for (int _i2249 = 0; _i2249 < _list2247.size; ++_i2249) + org.apache.thrift.protocol.TList _list2265 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.success = new java.util.ArrayList(_list2265.size); + @org.apache.thrift.annotation.Nullable SchemaVersion _elem2266; + for (int _i2267 = 0; _i2267 < _list2265.size; ++_i2267) { - _elem2248 = new SchemaVersion(); - _elem2248.read(iprot); - struct.success.add(_elem2248); + _elem2266 = new SchemaVersion(); + _elem2266.read(iprot); + struct.success.add(_elem2266); } } struct.setSuccessIsSet(true); @@ -307751,14 +308686,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_runtime_stats_r case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list2250 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list2250.size); - @org.apache.thrift.annotation.Nullable RuntimeStat _elem2251; - for (int _i2252 = 0; _i2252 < _list2250.size; ++_i2252) + org.apache.thrift.protocol.TList _list2268 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list2268.size); + @org.apache.thrift.annotation.Nullable RuntimeStat _elem2269; + for (int _i2270 = 0; _i2270 < _list2268.size; ++_i2270) { - _elem2251 = new RuntimeStat(); - _elem2251.read(iprot); - struct.success.add(_elem2251); + _elem2269 = new RuntimeStat(); + _elem2269.read(iprot); + struct.success.add(_elem2269); } iprot.readListEnd(); } @@ -307793,9 +308728,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_runtime_stats_ oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (RuntimeStat _iter2253 : struct.success) + for (RuntimeStat _iter2271 : struct.success) { - _iter2253.write(oprot); + _iter2271.write(oprot); } oprot.writeListEnd(); } @@ -307834,9 +308769,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_runtime_stats_r if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (RuntimeStat _iter2254 : struct.success) + for (RuntimeStat _iter2272 : struct.success) { - _iter2254.write(oprot); + _iter2272.write(oprot); } } } @@ -307851,14 +308786,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_runtime_stats_re java.util.BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list2255 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.success = new java.util.ArrayList(_list2255.size); - @org.apache.thrift.annotation.Nullable RuntimeStat _elem2256; - for (int _i2257 = 0; _i2257 < _list2255.size; ++_i2257) + org.apache.thrift.protocol.TList _list2273 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.success = new java.util.ArrayList(_list2273.size); + @org.apache.thrift.annotation.Nullable RuntimeStat _elem2274; + for (int _i2275 = 0; _i2275 < _list2273.size; ++_i2275) { - _elem2256 = new RuntimeStat(); - _elem2256.read(iprot); - struct.success.add(_elem2256); + _elem2274 = new RuntimeStat(); + _elem2274.read(iprot); + struct.success.add(_elem2274); } } struct.setSuccessIsSet(true); @@ -317969,13 +318904,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_all_stored_proc case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list2258 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list2258.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem2259; - for (int _i2260 = 0; _i2260 < _list2258.size; ++_i2260) + org.apache.thrift.protocol.TList _list2276 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list2276.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem2277; + for (int _i2278 = 0; _i2278 < _list2276.size; ++_i2278) { - _elem2259 = iprot.readString(); - struct.success.add(_elem2259); + _elem2277 = iprot.readString(); + struct.success.add(_elem2277); } iprot.readListEnd(); } @@ -318010,9 +318945,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_all_stored_pro oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (java.lang.String _iter2261 : struct.success) + for (java.lang.String _iter2279 : struct.success) { - oprot.writeString(_iter2261); + oprot.writeString(_iter2279); } oprot.writeListEnd(); } @@ -318051,9 +318986,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_all_stored_proc if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (java.lang.String _iter2262 : struct.success) + for (java.lang.String _iter2280 : struct.success) { - oprot.writeString(_iter2262); + oprot.writeString(_iter2280); } } } @@ -318068,13 +319003,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_all_stored_proce java.util.BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list2263 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.success = new java.util.ArrayList(_list2263.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem2264; - for (int _i2265 = 0; _i2265 < _list2263.size; ++_i2265) + org.apache.thrift.protocol.TList _list2281 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.success = new java.util.ArrayList(_list2281.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem2282; + for (int _i2283 = 0; _i2283 < _list2281.size; ++_i2283) { - _elem2264 = iprot.readString(); - struct.success.add(_elem2264); + _elem2282 = iprot.readString(); + struct.success.add(_elem2282); } } struct.setSuccessIsSet(true); @@ -320531,13 +321466,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_all_packages_re case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list2266 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list2266.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem2267; - for (int _i2268 = 0; _i2268 < _list2266.size; ++_i2268) + org.apache.thrift.protocol.TList _list2284 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list2284.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem2285; + for (int _i2286 = 0; _i2286 < _list2284.size; ++_i2286) { - _elem2267 = iprot.readString(); - struct.success.add(_elem2267); + _elem2285 = iprot.readString(); + struct.success.add(_elem2285); } iprot.readListEnd(); } @@ -320572,9 +321507,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_all_packages_r oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (java.lang.String _iter2269 : struct.success) + for (java.lang.String _iter2287 : struct.success) { - oprot.writeString(_iter2269); + oprot.writeString(_iter2287); } oprot.writeListEnd(); } @@ -320613,9 +321548,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_all_packages_re if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (java.lang.String _iter2270 : struct.success) + for (java.lang.String _iter2288 : struct.success) { - oprot.writeString(_iter2270); + oprot.writeString(_iter2288); } } } @@ -320630,13 +321565,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_all_packages_res java.util.BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list2271 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); - struct.success = new java.util.ArrayList(_list2271.size); - @org.apache.thrift.annotation.Nullable java.lang.String _elem2272; - for (int _i2273 = 0; _i2273 < _list2271.size; ++_i2273) + org.apache.thrift.protocol.TList _list2289 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING); + struct.success = new java.util.ArrayList(_list2289.size); + @org.apache.thrift.annotation.Nullable java.lang.String _elem2290; + for (int _i2291 = 0; _i2291 < _list2289.size; ++_i2291) { - _elem2272 = iprot.readString(); - struct.success.add(_elem2272); + _elem2290 = iprot.readString(); + struct.success.add(_elem2290); } } struct.setSuccessIsSet(true); @@ -322150,14 +323085,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_all_write_event case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list2274 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list2274.size); - @org.apache.thrift.annotation.Nullable WriteEventInfo _elem2275; - for (int _i2276 = 0; _i2276 < _list2274.size; ++_i2276) + org.apache.thrift.protocol.TList _list2292 = iprot.readListBegin(); + struct.success = new java.util.ArrayList(_list2292.size); + @org.apache.thrift.annotation.Nullable WriteEventInfo _elem2293; + for (int _i2294 = 0; _i2294 < _list2292.size; ++_i2294) { - _elem2275 = new WriteEventInfo(); - _elem2275.read(iprot); - struct.success.add(_elem2275); + _elem2293 = new WriteEventInfo(); + _elem2293.read(iprot); + struct.success.add(_elem2293); } iprot.readListEnd(); } @@ -322192,9 +323127,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_all_write_even oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (WriteEventInfo _iter2277 : struct.success) + for (WriteEventInfo _iter2295 : struct.success) { - _iter2277.write(oprot); + _iter2295.write(oprot); } oprot.writeListEnd(); } @@ -322233,9 +323168,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_all_write_event if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (WriteEventInfo _iter2278 : struct.success) + for (WriteEventInfo _iter2296 : struct.success) { - _iter2278.write(oprot); + _iter2296.write(oprot); } } } @@ -322250,14 +323185,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_all_write_event_ java.util.BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list2279 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); - struct.success = new java.util.ArrayList(_list2279.size); - @org.apache.thrift.annotation.Nullable WriteEventInfo _elem2280; - for (int _i2281 = 0; _i2281 < _list2279.size; ++_i2281) + org.apache.thrift.protocol.TList _list2297 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRUCT); + struct.success = new java.util.ArrayList(_list2297.size); + @org.apache.thrift.annotation.Nullable WriteEventInfo _elem2298; + for (int _i2299 = 0; _i2299 < _list2297.size; ++_i2299) { - _elem2280 = new WriteEventInfo(); - _elem2280.read(iprot); - struct.success.add(_elem2280); + _elem2298 = new WriteEventInfo(); + _elem2298.read(iprot); + struct.success.add(_elem2298); } } struct.setSuccessIsSet(true); diff --git a/standalone-metastore/metastore-common/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote b/standalone-metastore/metastore-common/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote index e34e8cfb926f..a527f243537d 100755 --- a/standalone-metastore/metastore-common/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote +++ b/standalone-metastore/metastore-common/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote @@ -91,6 +91,7 @@ if len(sys.argv) <= 1 or sys.argv[1] == '--help': print(' void alter_table_with_environment_context(string dbname, string tbl_name, Table new_tbl, EnvironmentContext environment_context)') print(' void alter_table_with_cascade(string dbname, string tbl_name, Table new_tbl, bool cascade)') print(' AlterTableResponse alter_table_req(AlterTableRequest req)') + print(' void update_table_params( updates)') print(' Partition add_partition(Partition new_part)') print(' Partition add_partition_with_environment_context(Partition new_part, EnvironmentContext environment_context)') print(' i32 add_partitions( new_parts)') @@ -802,6 +803,12 @@ elif cmd == 'alter_table_req': sys.exit(1) pp.pprint(client.alter_table_req(eval(args[0]),)) +elif cmd == 'update_table_params': + if len(args) != 1: + print('update_table_params requires 1 args') + sys.exit(1) + pp.pprint(client.update_table_params(eval(args[0]),)) + elif cmd == 'add_partition': if len(args) != 1: print('add_partition requires 1 args') diff --git a/standalone-metastore/metastore-common/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py b/standalone-metastore/metastore-common/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py index de630a9e8f6b..2c57d8ef0d1a 100644 --- a/standalone-metastore/metastore-common/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py +++ b/standalone-metastore/metastore-common/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py @@ -583,6 +583,14 @@ def alter_table_req(self, req): """ pass + def update_table_params(self, updates): + """ + Parameters: + - updates + + """ + pass + def add_partition(self, new_part): """ Parameters: @@ -4856,6 +4864,38 @@ def recv_alter_table_req(self): raise result.o2 raise TApplicationException(TApplicationException.MISSING_RESULT, "alter_table_req failed: unknown result") + def update_table_params(self, updates): + """ + Parameters: + - updates + + """ + self.send_update_table_params(updates) + self.recv_update_table_params() + + def send_update_table_params(self, updates): + self._oprot.writeMessageBegin('update_table_params', TMessageType.CALL, self._seqid) + args = update_table_params_args() + args.updates = updates + args.write(self._oprot) + self._oprot.writeMessageEnd() + self._oprot.trans.flush() + + def recv_update_table_params(self): + iprot = self._iprot + (fname, mtype, rseqid) = iprot.readMessageBegin() + if mtype == TMessageType.EXCEPTION: + x = TApplicationException() + x.read(iprot) + iprot.readMessageEnd() + raise x + result = update_table_params_result() + result.read(iprot) + iprot.readMessageEnd() + if result.o1 is not None: + raise result.o1 + return + def add_partition(self, new_part): """ Parameters: @@ -12749,6 +12789,7 @@ def __init__(self, handler): self._processMap["alter_table_with_environment_context"] = Processor.process_alter_table_with_environment_context self._processMap["alter_table_with_cascade"] = Processor.process_alter_table_with_cascade self._processMap["alter_table_req"] = Processor.process_alter_table_req + self._processMap["update_table_params"] = Processor.process_update_table_params self._processMap["add_partition"] = Processor.process_add_partition self._processMap["add_partition_with_environment_context"] = Processor.process_add_partition_with_environment_context self._processMap["add_partitions"] = Processor.process_add_partitions @@ -14964,6 +15005,32 @@ def process_alter_table_req(self, seqid, iprot, oprot): oprot.writeMessageEnd() oprot.trans.flush() + def process_update_table_params(self, seqid, iprot, oprot): + args = update_table_params_args() + args.read(iprot) + iprot.readMessageEnd() + result = update_table_params_result() + try: + self._handler.update_table_params(args.updates) + msg_type = TMessageType.REPLY + except TTransport.TTransportException: + raise + except MetaException as o1: + msg_type = TMessageType.REPLY + result.o1 = o1 + except TApplicationException as ex: + logging.exception('TApplication exception in handler') + msg_type = TMessageType.EXCEPTION + result = ex + except Exception: + logging.exception('Unexpected exception in handler') + msg_type = TMessageType.EXCEPTION + result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') + oprot.writeMessageBegin("update_table_params", msg_type, seqid) + result.write(oprot) + oprot.writeMessageEnd() + oprot.trans.flush() + def process_add_partition(self, seqid, iprot, oprot): args = add_partition_args() args.read(iprot) @@ -23210,10 +23277,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1441, _size1438) = iprot.readListBegin() - for _i1442 in range(_size1438): - _elem1443 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.success.append(_elem1443) + (_etype1450, _size1447) = iprot.readListBegin() + for _i1451 in range(_size1447): + _elem1452 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.success.append(_elem1452) iprot.readListEnd() else: iprot.skip(ftype) @@ -23235,8 +23302,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 iter1444 in self.success: - oprot.writeString(iter1444.encode('utf-8') if sys.version_info[0] == 2 else iter1444) + for iter1453 in self.success: + oprot.writeString(iter1453.encode('utf-8') if sys.version_info[0] == 2 else iter1453) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -23334,10 +23401,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1448, _size1445) = iprot.readListBegin() - for _i1449 in range(_size1445): - _elem1450 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.success.append(_elem1450) + (_etype1457, _size1454) = iprot.readListBegin() + for _i1458 in range(_size1454): + _elem1459 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.success.append(_elem1459) iprot.readListEnd() else: iprot.skip(ftype) @@ -23359,8 +23426,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 iter1451 in self.success: - oprot.writeString(iter1451.encode('utf-8') if sys.version_info[0] == 2 else iter1451) + for iter1460 in self.success: + oprot.writeString(iter1460.encode('utf-8') if sys.version_info[0] == 2 else iter1460) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -24328,10 +24395,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1455, _size1452) = iprot.readListBegin() - for _i1456 in range(_size1452): - _elem1457 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.success.append(_elem1457) + (_etype1464, _size1461) = iprot.readListBegin() + for _i1465 in range(_size1461): + _elem1466 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.success.append(_elem1466) iprot.readListEnd() else: iprot.skip(ftype) @@ -24353,8 +24420,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 iter1458 in self.success: - oprot.writeString(iter1458.encode('utf-8') if sys.version_info[0] == 2 else iter1458) + for iter1467 in self.success: + oprot.writeString(iter1467.encode('utf-8') if sys.version_info[0] == 2 else iter1467) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -25063,12 +25130,12 @@ def read(self, iprot): if fid == 0: if ftype == TType.MAP: self.success = {} - (_ktype1460, _vtype1461, _size1459) = iprot.readMapBegin() - for _i1463 in range(_size1459): - _key1464 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - _val1465 = Type() - _val1465.read(iprot) - self.success[_key1464] = _val1465 + (_ktype1469, _vtype1470, _size1468) = iprot.readMapBegin() + for _i1472 in range(_size1468): + _key1473 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + _val1474 = Type() + _val1474.read(iprot) + self.success[_key1473] = _val1474 iprot.readMapEnd() else: iprot.skip(ftype) @@ -25090,9 +25157,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 kiter1466, viter1467 in self.success.items(): - oprot.writeString(kiter1466.encode('utf-8') if sys.version_info[0] == 2 else kiter1466) - viter1467.write(oprot) + for kiter1475, viter1476 in self.success.items(): + oprot.writeString(kiter1475.encode('utf-8') if sys.version_info[0] == 2 else kiter1475) + viter1476.write(oprot) oprot.writeMapEnd() oprot.writeFieldEnd() if self.o2 is not None: @@ -25225,11 +25292,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1471, _size1468) = iprot.readListBegin() - for _i1472 in range(_size1468): - _elem1473 = FieldSchema() - _elem1473.read(iprot) - self.success.append(_elem1473) + (_etype1480, _size1477) = iprot.readListBegin() + for _i1481 in range(_size1477): + _elem1482 = FieldSchema() + _elem1482.read(iprot) + self.success.append(_elem1482) iprot.readListEnd() else: iprot.skip(ftype) @@ -25261,8 +25328,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 iter1474 in self.success: - iter1474.write(oprot) + for iter1483 in self.success: + iter1483.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -25418,11 +25485,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1478, _size1475) = iprot.readListBegin() - for _i1479 in range(_size1475): - _elem1480 = FieldSchema() - _elem1480.read(iprot) - self.success.append(_elem1480) + (_etype1487, _size1484) = iprot.readListBegin() + for _i1488 in range(_size1484): + _elem1489 = FieldSchema() + _elem1489.read(iprot) + self.success.append(_elem1489) iprot.readListEnd() else: iprot.skip(ftype) @@ -25454,8 +25521,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 iter1481 in self.success: - iter1481.write(oprot) + for iter1490 in self.success: + iter1490.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -25759,11 +25826,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1485, _size1482) = iprot.readListBegin() - for _i1486 in range(_size1482): - _elem1487 = FieldSchema() - _elem1487.read(iprot) - self.success.append(_elem1487) + (_etype1494, _size1491) = iprot.readListBegin() + for _i1495 in range(_size1491): + _elem1496 = FieldSchema() + _elem1496.read(iprot) + self.success.append(_elem1496) iprot.readListEnd() else: iprot.skip(ftype) @@ -25795,8 +25862,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 iter1488 in self.success: - iter1488.write(oprot) + for iter1497 in self.success: + iter1497.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -25952,11 +26019,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1492, _size1489) = iprot.readListBegin() - for _i1493 in range(_size1489): - _elem1494 = FieldSchema() - _elem1494.read(iprot) - self.success.append(_elem1494) + (_etype1501, _size1498) = iprot.readListBegin() + for _i1502 in range(_size1498): + _elem1503 = FieldSchema() + _elem1503.read(iprot) + self.success.append(_elem1503) iprot.readListEnd() else: iprot.skip(ftype) @@ -25988,8 +26055,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 iter1495 in self.success: - iter1495.write(oprot) + for iter1504 in self.success: + iter1504.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -26566,66 +26633,66 @@ def read(self, iprot): elif fid == 2: if ftype == TType.LIST: self.primaryKeys = [] - (_etype1499, _size1496) = iprot.readListBegin() - for _i1500 in range(_size1496): - _elem1501 = SQLPrimaryKey() - _elem1501.read(iprot) - self.primaryKeys.append(_elem1501) + (_etype1508, _size1505) = iprot.readListBegin() + for _i1509 in range(_size1505): + _elem1510 = SQLPrimaryKey() + _elem1510.read(iprot) + self.primaryKeys.append(_elem1510) iprot.readListEnd() else: iprot.skip(ftype) elif fid == 3: if ftype == TType.LIST: self.foreignKeys = [] - (_etype1505, _size1502) = iprot.readListBegin() - for _i1506 in range(_size1502): - _elem1507 = SQLForeignKey() - _elem1507.read(iprot) - self.foreignKeys.append(_elem1507) + (_etype1514, _size1511) = iprot.readListBegin() + for _i1515 in range(_size1511): + _elem1516 = SQLForeignKey() + _elem1516.read(iprot) + self.foreignKeys.append(_elem1516) iprot.readListEnd() else: iprot.skip(ftype) elif fid == 4: if ftype == TType.LIST: self.uniqueConstraints = [] - (_etype1511, _size1508) = iprot.readListBegin() - for _i1512 in range(_size1508): - _elem1513 = SQLUniqueConstraint() - _elem1513.read(iprot) - self.uniqueConstraints.append(_elem1513) + (_etype1520, _size1517) = iprot.readListBegin() + for _i1521 in range(_size1517): + _elem1522 = SQLUniqueConstraint() + _elem1522.read(iprot) + self.uniqueConstraints.append(_elem1522) iprot.readListEnd() else: iprot.skip(ftype) elif fid == 5: if ftype == TType.LIST: self.notNullConstraints = [] - (_etype1517, _size1514) = iprot.readListBegin() - for _i1518 in range(_size1514): - _elem1519 = SQLNotNullConstraint() - _elem1519.read(iprot) - self.notNullConstraints.append(_elem1519) + (_etype1526, _size1523) = iprot.readListBegin() + for _i1527 in range(_size1523): + _elem1528 = SQLNotNullConstraint() + _elem1528.read(iprot) + self.notNullConstraints.append(_elem1528) iprot.readListEnd() else: iprot.skip(ftype) elif fid == 6: if ftype == TType.LIST: self.defaultConstraints = [] - (_etype1523, _size1520) = iprot.readListBegin() - for _i1524 in range(_size1520): - _elem1525 = SQLDefaultConstraint() - _elem1525.read(iprot) - self.defaultConstraints.append(_elem1525) + (_etype1532, _size1529) = iprot.readListBegin() + for _i1533 in range(_size1529): + _elem1534 = SQLDefaultConstraint() + _elem1534.read(iprot) + self.defaultConstraints.append(_elem1534) iprot.readListEnd() else: iprot.skip(ftype) elif fid == 7: if ftype == TType.LIST: self.checkConstraints = [] - (_etype1529, _size1526) = iprot.readListBegin() - for _i1530 in range(_size1526): - _elem1531 = SQLCheckConstraint() - _elem1531.read(iprot) - self.checkConstraints.append(_elem1531) + (_etype1538, _size1535) = iprot.readListBegin() + for _i1539 in range(_size1535): + _elem1540 = SQLCheckConstraint() + _elem1540.read(iprot) + self.checkConstraints.append(_elem1540) iprot.readListEnd() else: iprot.skip(ftype) @@ -26646,43 +26713,43 @@ def write(self, oprot): if self.primaryKeys is not None: oprot.writeFieldBegin('primaryKeys', TType.LIST, 2) oprot.writeListBegin(TType.STRUCT, len(self.primaryKeys)) - for iter1532 in self.primaryKeys: - iter1532.write(oprot) + for iter1541 in self.primaryKeys: + iter1541.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 iter1533 in self.foreignKeys: - iter1533.write(oprot) + for iter1542 in self.foreignKeys: + iter1542.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 iter1534 in self.uniqueConstraints: - iter1534.write(oprot) + for iter1543 in self.uniqueConstraints: + iter1543.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 iter1535 in self.notNullConstraints: - iter1535.write(oprot) + for iter1544 in self.notNullConstraints: + iter1544.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.defaultConstraints is not None: oprot.writeFieldBegin('defaultConstraints', TType.LIST, 6) oprot.writeListBegin(TType.STRUCT, len(self.defaultConstraints)) - for iter1536 in self.defaultConstraints: - iter1536.write(oprot) + for iter1545 in self.defaultConstraints: + iter1545.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.checkConstraints is not None: oprot.writeFieldBegin('checkConstraints', TType.LIST, 7) oprot.writeListBegin(TType.STRUCT, len(self.checkConstraints)) - for iter1537 in self.checkConstraints: - iter1537.write(oprot) + for iter1546 in self.checkConstraints: + iter1546.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -28624,10 +28691,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.partNames = [] - (_etype1541, _size1538) = iprot.readListBegin() - for _i1542 in range(_size1538): - _elem1543 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.partNames.append(_elem1543) + (_etype1550, _size1547) = iprot.readListBegin() + for _i1551 in range(_size1547): + _elem1552 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.partNames.append(_elem1552) iprot.readListEnd() else: iprot.skip(ftype) @@ -28652,8 +28719,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 iter1544 in self.partNames: - oprot.writeString(iter1544.encode('utf-8') if sys.version_info[0] == 2 else iter1544) + for iter1553 in self.partNames: + oprot.writeString(iter1553.encode('utf-8') if sys.version_info[0] == 2 else iter1553) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -28979,10 +29046,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1548, _size1545) = iprot.readListBegin() - for _i1549 in range(_size1545): - _elem1550 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.success.append(_elem1550) + (_etype1557, _size1554) = iprot.readListBegin() + for _i1558 in range(_size1554): + _elem1559 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.success.append(_elem1559) iprot.readListEnd() else: iprot.skip(ftype) @@ -29004,8 +29071,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 iter1551 in self.success: - oprot.writeString(iter1551.encode('utf-8') if sys.version_info[0] == 2 else iter1551) + for iter1560 in self.success: + oprot.writeString(iter1560.encode('utf-8') if sys.version_info[0] == 2 else iter1560) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -29146,10 +29213,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1555, _size1552) = iprot.readListBegin() - for _i1556 in range(_size1552): - _elem1557 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.success.append(_elem1557) + (_etype1564, _size1561) = iprot.readListBegin() + for _i1565 in range(_size1561): + _elem1566 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.success.append(_elem1566) iprot.readListEnd() else: iprot.skip(ftype) @@ -29171,8 +29238,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 iter1558 in self.success: - oprot.writeString(iter1558.encode('utf-8') if sys.version_info[0] == 2 else iter1558) + for iter1567 in self.success: + oprot.writeString(iter1567.encode('utf-8') if sys.version_info[0] == 2 else iter1567) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -29270,11 +29337,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1562, _size1559) = iprot.readListBegin() - for _i1563 in range(_size1559): - _elem1564 = Table() - _elem1564.read(iprot) - self.success.append(_elem1564) + (_etype1571, _size1568) = iprot.readListBegin() + for _i1572 in range(_size1568): + _elem1573 = Table() + _elem1573.read(iprot) + self.success.append(_elem1573) iprot.readListEnd() else: iprot.skip(ftype) @@ -29296,8 +29363,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 iter1565 in self.success: - iter1565.write(oprot) + for iter1574 in self.success: + iter1574.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -29414,10 +29481,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1569, _size1566) = iprot.readListBegin() - for _i1570 in range(_size1566): - _elem1571 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.success.append(_elem1571) + (_etype1578, _size1575) = iprot.readListBegin() + for _i1579 in range(_size1575): + _elem1580 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.success.append(_elem1580) iprot.readListEnd() else: iprot.skip(ftype) @@ -29439,8 +29506,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 iter1572 in self.success: - oprot.writeString(iter1572.encode('utf-8') if sys.version_info[0] == 2 else iter1572) + for iter1581 in self.success: + oprot.writeString(iter1581.encode('utf-8') if sys.version_info[0] == 2 else iter1581) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -29507,10 +29574,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.tbl_types = [] - (_etype1576, _size1573) = iprot.readListBegin() - for _i1577 in range(_size1573): - _elem1578 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.tbl_types.append(_elem1578) + (_etype1585, _size1582) = iprot.readListBegin() + for _i1586 in range(_size1582): + _elem1587 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.tbl_types.append(_elem1587) iprot.readListEnd() else: iprot.skip(ftype) @@ -29535,8 +29602,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 iter1579 in self.tbl_types: - oprot.writeString(iter1579.encode('utf-8') if sys.version_info[0] == 2 else iter1579) + for iter1588 in self.tbl_types: + oprot.writeString(iter1588.encode('utf-8') if sys.version_info[0] == 2 else iter1588) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -29589,11 +29656,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1583, _size1580) = iprot.readListBegin() - for _i1584 in range(_size1580): - _elem1585 = TableMeta() - _elem1585.read(iprot) - self.success.append(_elem1585) + (_etype1592, _size1589) = iprot.readListBegin() + for _i1593 in range(_size1589): + _elem1594 = TableMeta() + _elem1594.read(iprot) + self.success.append(_elem1594) iprot.readListEnd() else: iprot.skip(ftype) @@ -29615,8 +29682,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 iter1586 in self.success: - iter1586.write(oprot) + for iter1595 in self.success: + iter1595.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -29733,10 +29800,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1590, _size1587) = iprot.readListBegin() - for _i1591 in range(_size1587): - _elem1592 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.success.append(_elem1592) + (_etype1599, _size1596) = iprot.readListBegin() + for _i1600 in range(_size1596): + _elem1601 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.success.append(_elem1601) iprot.readListEnd() else: iprot.skip(ftype) @@ -29758,8 +29825,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 iter1593 in self.success: - oprot.writeString(iter1593.encode('utf-8') if sys.version_info[0] == 2 else iter1593) + for iter1602 in self.success: + oprot.writeString(iter1602.encode('utf-8') if sys.version_info[0] == 2 else iter1602) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -29877,11 +29944,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1597, _size1594) = iprot.readListBegin() - for _i1598 in range(_size1594): - _elem1599 = ExtendedTableInfo() - _elem1599.read(iprot) - self.success.append(_elem1599) + (_etype1606, _size1603) = iprot.readListBegin() + for _i1607 in range(_size1603): + _elem1608 = ExtendedTableInfo() + _elem1608.read(iprot) + self.success.append(_elem1608) iprot.readListEnd() else: iprot.skip(ftype) @@ -29903,8 +29970,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 iter1600 in self.success: - iter1600.write(oprot) + for iter1609 in self.success: + iter1609.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -30717,10 +30784,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1604, _size1601) = iprot.readListBegin() - for _i1605 in range(_size1601): - _elem1606 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.success.append(_elem1606) + (_etype1613, _size1610) = iprot.readListBegin() + for _i1614 in range(_size1610): + _elem1615 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.success.append(_elem1615) iprot.readListEnd() else: iprot.skip(ftype) @@ -30752,8 +30819,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 iter1607 in self.success: - oprot.writeString(iter1607.encode('utf-8') if sys.version_info[0] == 2 else iter1607) + for iter1616 in self.success: + oprot.writeString(iter1616.encode('utf-8') if sys.version_info[0] == 2 else iter1616) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -31450,6 +31517,139 @@ def __ne__(self, other): ) +class update_table_params_args(object): + """ + Attributes: + - updates + + """ + + + def __init__(self, updates=None,): + self.updates = updates + + def read(self, iprot): + if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: + iprot._fast_decode(self, iprot, [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.LIST: + self.updates = [] + (_etype1620, _size1617) = iprot.readListBegin() + for _i1621 in range(_size1617): + _elem1622 = TableParamsUpdate() + _elem1622.read(iprot) + self.updates.append(_elem1622) + iprot.readListEnd() + else: + iprot.skip(ftype) + else: + iprot.skip(ftype) + iprot.readFieldEnd() + iprot.readStructEnd() + + def write(self, oprot): + if oprot._fast_encode is not None and self.thrift_spec is not None: + oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec])) + return + oprot.writeStructBegin('update_table_params_args') + if self.updates is not None: + oprot.writeFieldBegin('updates', TType.LIST, 1) + oprot.writeListBegin(TType.STRUCT, len(self.updates)) + for iter1623 in self.updates: + iter1623.write(oprot) + oprot.writeListEnd() + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.items()] + 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) +all_structs.append(update_table_params_args) +update_table_params_args.thrift_spec = ( + None, # 0 + (1, TType.LIST, 'updates', (TType.STRUCT, [TableParamsUpdate, None], False), None, ), # 1 +) + + +class update_table_params_result(object): + """ + Attributes: + - o1 + + """ + + + def __init__(self, o1=None,): + self.o1 = o1 + + def read(self, iprot): + if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: + iprot._fast_decode(self, iprot, [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.STRUCT: + self.o1 = MetaException.read(iprot) + else: + iprot.skip(ftype) + else: + iprot.skip(ftype) + iprot.readFieldEnd() + iprot.readStructEnd() + + def write(self, oprot): + if oprot._fast_encode is not None and self.thrift_spec is not None: + oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec])) + return + oprot.writeStructBegin('update_table_params_result') + if self.o1 is not None: + oprot.writeFieldBegin('o1', TType.STRUCT, 1) + self.o1.write(oprot) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.items()] + 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) +all_structs.append(update_table_params_result) +update_table_params_result.thrift_spec = ( + None, # 0 + (1, TType.STRUCT, 'o1', [MetaException, None], None, ), # 1 +) + + class add_partition_args(object): """ Attributes: @@ -31808,11 +32008,11 @@ def read(self, iprot): if fid == 1: if ftype == TType.LIST: self.new_parts = [] - (_etype1611, _size1608) = iprot.readListBegin() - for _i1612 in range(_size1608): - _elem1613 = Partition() - _elem1613.read(iprot) - self.new_parts.append(_elem1613) + (_etype1627, _size1624) = iprot.readListBegin() + for _i1628 in range(_size1624): + _elem1629 = Partition() + _elem1629.read(iprot) + self.new_parts.append(_elem1629) iprot.readListEnd() else: iprot.skip(ftype) @@ -31829,8 +32029,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 iter1614 in self.new_parts: - iter1614.write(oprot) + for iter1630 in self.new_parts: + iter1630.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -31976,11 +32176,11 @@ def read(self, iprot): if fid == 1: if ftype == TType.LIST: self.new_parts = [] - (_etype1618, _size1615) = iprot.readListBegin() - for _i1619 in range(_size1615): - _elem1620 = PartitionSpec() - _elem1620.read(iprot) - self.new_parts.append(_elem1620) + (_etype1634, _size1631) = iprot.readListBegin() + for _i1635 in range(_size1631): + _elem1636 = PartitionSpec() + _elem1636.read(iprot) + self.new_parts.append(_elem1636) iprot.readListEnd() else: iprot.skip(ftype) @@ -31997,8 +32197,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 iter1621 in self.new_parts: - iter1621.write(oprot) + for iter1637 in self.new_parts: + iter1637.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -32158,10 +32358,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype1625, _size1622) = iprot.readListBegin() - for _i1626 in range(_size1622): - _elem1627 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.part_vals.append(_elem1627) + (_etype1641, _size1638) = iprot.readListBegin() + for _i1642 in range(_size1638): + _elem1643 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.part_vals.append(_elem1643) iprot.readListEnd() else: iprot.skip(ftype) @@ -32186,8 +32386,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 iter1628 in self.part_vals: - oprot.writeString(iter1628.encode('utf-8') if sys.version_info[0] == 2 else iter1628) + for iter1644 in self.part_vals: + oprot.writeString(iter1644.encode('utf-8') if sys.version_info[0] == 2 else iter1644) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -32513,10 +32713,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype1632, _size1629) = iprot.readListBegin() - for _i1633 in range(_size1629): - _elem1634 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.part_vals.append(_elem1634) + (_etype1648, _size1645) = iprot.readListBegin() + for _i1649 in range(_size1645): + _elem1650 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.part_vals.append(_elem1650) iprot.readListEnd() else: iprot.skip(ftype) @@ -32547,8 +32747,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 iter1635 in self.part_vals: - oprot.writeString(iter1635.encode('utf-8') if sys.version_info[0] == 2 else iter1635) + for iter1651 in self.part_vals: + oprot.writeString(iter1651.encode('utf-8') if sys.version_info[0] == 2 else iter1651) oprot.writeListEnd() oprot.writeFieldEnd() if self.environment_context is not None: @@ -33260,10 +33460,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype1639, _size1636) = iprot.readListBegin() - for _i1640 in range(_size1636): - _elem1641 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.part_vals.append(_elem1641) + (_etype1655, _size1652) = iprot.readListBegin() + for _i1656 in range(_size1652): + _elem1657 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.part_vals.append(_elem1657) iprot.readListEnd() else: iprot.skip(ftype) @@ -33293,8 +33493,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 iter1642 in self.part_vals: - oprot.writeString(iter1642.encode('utf-8') if sys.version_info[0] == 2 else iter1642) + for iter1658 in self.part_vals: + oprot.writeString(iter1658.encode('utf-8') if sys.version_info[0] == 2 else iter1658) oprot.writeListEnd() oprot.writeFieldEnd() if self.deleteData is not None: @@ -33453,10 +33653,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype1646, _size1643) = iprot.readListBegin() - for _i1647 in range(_size1643): - _elem1648 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.part_vals.append(_elem1648) + (_etype1662, _size1659) = iprot.readListBegin() + for _i1663 in range(_size1659): + _elem1664 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.part_vals.append(_elem1664) iprot.readListEnd() else: iprot.skip(ftype) @@ -33492,8 +33692,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 iter1649 in self.part_vals: - oprot.writeString(iter1649.encode('utf-8') if sys.version_info[0] == 2 else iter1649) + for iter1665 in self.part_vals: + oprot.writeString(iter1665.encode('utf-8') if sys.version_info[0] == 2 else iter1665) oprot.writeListEnd() oprot.writeFieldEnd() if self.deleteData is not None: @@ -34329,10 +34529,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype1653, _size1650) = iprot.readListBegin() - for _i1654 in range(_size1650): - _elem1655 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.part_vals.append(_elem1655) + (_etype1669, _size1666) = iprot.readListBegin() + for _i1670 in range(_size1666): + _elem1671 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.part_vals.append(_elem1671) iprot.readListEnd() else: iprot.skip(ftype) @@ -34357,8 +34557,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 iter1656 in self.part_vals: - oprot.writeString(iter1656.encode('utf-8') if sys.version_info[0] == 2 else iter1656) + for iter1672 in self.part_vals: + oprot.writeString(iter1672.encode('utf-8') if sys.version_info[0] == 2 else iter1672) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -34652,11 +34852,11 @@ def read(self, iprot): if fid == 1: if ftype == TType.MAP: self.partitionSpecs = {} - (_ktype1658, _vtype1659, _size1657) = iprot.readMapBegin() - for _i1661 in range(_size1657): - _key1662 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - _val1663 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.partitionSpecs[_key1662] = _val1663 + (_ktype1674, _vtype1675, _size1673) = iprot.readMapBegin() + for _i1677 in range(_size1673): + _key1678 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + _val1679 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.partitionSpecs[_key1678] = _val1679 iprot.readMapEnd() else: iprot.skip(ftype) @@ -34693,9 +34893,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 kiter1664, viter1665 in self.partitionSpecs.items(): - oprot.writeString(kiter1664.encode('utf-8') if sys.version_info[0] == 2 else kiter1664) - oprot.writeString(viter1665.encode('utf-8') if sys.version_info[0] == 2 else viter1665) + for kiter1680, viter1681 in self.partitionSpecs.items(): + oprot.writeString(kiter1680.encode('utf-8') if sys.version_info[0] == 2 else kiter1680) + oprot.writeString(viter1681.encode('utf-8') if sys.version_info[0] == 2 else viter1681) oprot.writeMapEnd() oprot.writeFieldEnd() if self.source_db is not None: @@ -34882,11 +35082,11 @@ def read(self, iprot): if fid == 1: if ftype == TType.MAP: self.partitionSpecs = {} - (_ktype1667, _vtype1668, _size1666) = iprot.readMapBegin() - for _i1670 in range(_size1666): - _key1671 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - _val1672 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.partitionSpecs[_key1671] = _val1672 + (_ktype1683, _vtype1684, _size1682) = iprot.readMapBegin() + for _i1686 in range(_size1682): + _key1687 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + _val1688 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.partitionSpecs[_key1687] = _val1688 iprot.readMapEnd() else: iprot.skip(ftype) @@ -34923,9 +35123,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 kiter1673, viter1674 in self.partitionSpecs.items(): - oprot.writeString(kiter1673.encode('utf-8') if sys.version_info[0] == 2 else kiter1673) - oprot.writeString(viter1674.encode('utf-8') if sys.version_info[0] == 2 else viter1674) + for kiter1689, viter1690 in self.partitionSpecs.items(): + oprot.writeString(kiter1689.encode('utf-8') if sys.version_info[0] == 2 else kiter1689) + oprot.writeString(viter1690.encode('utf-8') if sys.version_info[0] == 2 else viter1690) oprot.writeMapEnd() oprot.writeFieldEnd() if self.source_db is not None: @@ -35002,11 +35202,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1678, _size1675) = iprot.readListBegin() - for _i1679 in range(_size1675): - _elem1680 = Partition() - _elem1680.read(iprot) - self.success.append(_elem1680) + (_etype1694, _size1691) = iprot.readListBegin() + for _i1695 in range(_size1691): + _elem1696 = Partition() + _elem1696.read(iprot) + self.success.append(_elem1696) iprot.readListEnd() else: iprot.skip(ftype) @@ -35043,8 +35243,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 iter1681 in self.success: - iter1681.write(oprot) + for iter1697 in self.success: + iter1697.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -35130,10 +35330,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype1685, _size1682) = iprot.readListBegin() - for _i1686 in range(_size1682): - _elem1687 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.part_vals.append(_elem1687) + (_etype1701, _size1698) = iprot.readListBegin() + for _i1702 in range(_size1698): + _elem1703 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.part_vals.append(_elem1703) iprot.readListEnd() else: iprot.skip(ftype) @@ -35145,10 +35345,10 @@ def read(self, iprot): elif fid == 5: if ftype == TType.LIST: self.group_names = [] - (_etype1691, _size1688) = iprot.readListBegin() - for _i1692 in range(_size1688): - _elem1693 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.group_names.append(_elem1693) + (_etype1707, _size1704) = iprot.readListBegin() + for _i1708 in range(_size1704): + _elem1709 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.group_names.append(_elem1709) iprot.readListEnd() else: iprot.skip(ftype) @@ -35173,8 +35373,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 iter1694 in self.part_vals: - oprot.writeString(iter1694.encode('utf-8') if sys.version_info[0] == 2 else iter1694) + for iter1710 in self.part_vals: + oprot.writeString(iter1710.encode('utf-8') if sys.version_info[0] == 2 else iter1710) oprot.writeListEnd() oprot.writeFieldEnd() if self.user_name is not None: @@ -35184,8 +35384,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 iter1695 in self.group_names: - oprot.writeString(iter1695.encode('utf-8') if sys.version_info[0] == 2 else iter1695) + for iter1711 in self.group_names: + oprot.writeString(iter1711.encode('utf-8') if sys.version_info[0] == 2 else iter1711) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -35586,11 +35786,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1699, _size1696) = iprot.readListBegin() - for _i1700 in range(_size1696): - _elem1701 = Partition() - _elem1701.read(iprot) - self.success.append(_elem1701) + (_etype1715, _size1712) = iprot.readListBegin() + for _i1716 in range(_size1712): + _elem1717 = Partition() + _elem1717.read(iprot) + self.success.append(_elem1717) iprot.readListEnd() else: iprot.skip(ftype) @@ -35617,8 +35817,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 iter1702 in self.success: - iter1702.write(oprot) + for iter1718 in self.success: + iter1718.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -35853,10 +36053,10 @@ def read(self, iprot): elif fid == 5: if ftype == TType.LIST: self.group_names = [] - (_etype1706, _size1703) = iprot.readListBegin() - for _i1707 in range(_size1703): - _elem1708 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.group_names.append(_elem1708) + (_etype1722, _size1719) = iprot.readListBegin() + for _i1723 in range(_size1719): + _elem1724 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.group_names.append(_elem1724) iprot.readListEnd() else: iprot.skip(ftype) @@ -35889,8 +36089,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 iter1709 in self.group_names: - oprot.writeString(iter1709.encode('utf-8') if sys.version_info[0] == 2 else iter1709) + for iter1725 in self.group_names: + oprot.writeString(iter1725.encode('utf-8') if sys.version_info[0] == 2 else iter1725) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -35947,11 +36147,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1713, _size1710) = iprot.readListBegin() - for _i1714 in range(_size1710): - _elem1715 = Partition() - _elem1715.read(iprot) - self.success.append(_elem1715) + (_etype1729, _size1726) = iprot.readListBegin() + for _i1730 in range(_size1726): + _elem1731 = Partition() + _elem1731.read(iprot) + self.success.append(_elem1731) iprot.readListEnd() else: iprot.skip(ftype) @@ -35978,8 +36178,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 iter1716 in self.success: - iter1716.write(oprot) + for iter1732 in self.success: + iter1732.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -36127,11 +36327,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1720, _size1717) = iprot.readListBegin() - for _i1721 in range(_size1717): - _elem1722 = PartitionSpec() - _elem1722.read(iprot) - self.success.append(_elem1722) + (_etype1736, _size1733) = iprot.readListBegin() + for _i1737 in range(_size1733): + _elem1738 = PartitionSpec() + _elem1738.read(iprot) + self.success.append(_elem1738) iprot.readListEnd() else: iprot.skip(ftype) @@ -36158,8 +36358,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 iter1723 in self.success: - iter1723.write(oprot) + for iter1739 in self.success: + iter1739.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -36307,10 +36507,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1727, _size1724) = iprot.readListBegin() - for _i1728 in range(_size1724): - _elem1729 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.success.append(_elem1729) + (_etype1743, _size1740) = iprot.readListBegin() + for _i1744 in range(_size1740): + _elem1745 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.success.append(_elem1745) iprot.readListEnd() else: iprot.skip(ftype) @@ -36337,8 +36537,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 iter1730 in self.success: - oprot.writeString(iter1730.encode('utf-8') if sys.version_info[0] == 2 else iter1730) + for iter1746 in self.success: + oprot.writeString(iter1746.encode('utf-8') if sys.version_info[0] == 2 else iter1746) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -36463,10 +36663,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1734, _size1731) = iprot.readListBegin() - for _i1735 in range(_size1731): - _elem1736 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.success.append(_elem1736) + (_etype1750, _size1747) = iprot.readListBegin() + for _i1751 in range(_size1747): + _elem1752 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.success.append(_elem1752) iprot.readListEnd() else: iprot.skip(ftype) @@ -36493,8 +36693,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 iter1737 in self.success: - oprot.writeString(iter1737.encode('utf-8') if sys.version_info[0] == 2 else iter1737) + for iter1753 in self.success: + oprot.writeString(iter1753.encode('utf-8') if sys.version_info[0] == 2 else iter1753) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -36717,10 +36917,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype1741, _size1738) = iprot.readListBegin() - for _i1742 in range(_size1738): - _elem1743 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.part_vals.append(_elem1743) + (_etype1757, _size1754) = iprot.readListBegin() + for _i1758 in range(_size1754): + _elem1759 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.part_vals.append(_elem1759) iprot.readListEnd() else: iprot.skip(ftype) @@ -36750,8 +36950,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 iter1744 in self.part_vals: - oprot.writeString(iter1744.encode('utf-8') if sys.version_info[0] == 2 else iter1744) + for iter1760 in self.part_vals: + oprot.writeString(iter1760.encode('utf-8') if sys.version_info[0] == 2 else iter1760) oprot.writeListEnd() oprot.writeFieldEnd() if self.max_parts is not None: @@ -36811,11 +37011,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1748, _size1745) = iprot.readListBegin() - for _i1749 in range(_size1745): - _elem1750 = Partition() - _elem1750.read(iprot) - self.success.append(_elem1750) + (_etype1764, _size1761) = iprot.readListBegin() + for _i1765 in range(_size1761): + _elem1766 = Partition() + _elem1766.read(iprot) + self.success.append(_elem1766) iprot.readListEnd() else: iprot.skip(ftype) @@ -36842,8 +37042,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 iter1751 in self.success: - iter1751.write(oprot) + for iter1767 in self.success: + iter1767.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -36921,10 +37121,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype1755, _size1752) = iprot.readListBegin() - for _i1756 in range(_size1752): - _elem1757 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.part_vals.append(_elem1757) + (_etype1771, _size1768) = iprot.readListBegin() + for _i1772 in range(_size1768): + _elem1773 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.part_vals.append(_elem1773) iprot.readListEnd() else: iprot.skip(ftype) @@ -36941,10 +37141,10 @@ def read(self, iprot): elif fid == 6: if ftype == TType.LIST: self.group_names = [] - (_etype1761, _size1758) = iprot.readListBegin() - for _i1762 in range(_size1758): - _elem1763 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.group_names.append(_elem1763) + (_etype1777, _size1774) = iprot.readListBegin() + for _i1778 in range(_size1774): + _elem1779 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.group_names.append(_elem1779) iprot.readListEnd() else: iprot.skip(ftype) @@ -36969,8 +37169,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 iter1764 in self.part_vals: - oprot.writeString(iter1764.encode('utf-8') if sys.version_info[0] == 2 else iter1764) + for iter1780 in self.part_vals: + oprot.writeString(iter1780.encode('utf-8') if sys.version_info[0] == 2 else iter1780) oprot.writeListEnd() oprot.writeFieldEnd() if self.max_parts is not None: @@ -36984,8 +37184,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 iter1765 in self.group_names: - oprot.writeString(iter1765.encode('utf-8') if sys.version_info[0] == 2 else iter1765) + for iter1781 in self.group_names: + oprot.writeString(iter1781.encode('utf-8') if sys.version_info[0] == 2 else iter1781) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -37043,11 +37243,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1769, _size1766) = iprot.readListBegin() - for _i1770 in range(_size1766): - _elem1771 = Partition() - _elem1771.read(iprot) - self.success.append(_elem1771) + (_etype1785, _size1782) = iprot.readListBegin() + for _i1786 in range(_size1782): + _elem1787 = Partition() + _elem1787.read(iprot) + self.success.append(_elem1787) iprot.readListEnd() else: iprot.skip(ftype) @@ -37074,8 +37274,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 iter1772 in self.success: - iter1772.write(oprot) + for iter1788 in self.success: + iter1788.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -37298,10 +37498,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype1776, _size1773) = iprot.readListBegin() - for _i1777 in range(_size1773): - _elem1778 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.part_vals.append(_elem1778) + (_etype1792, _size1789) = iprot.readListBegin() + for _i1793 in range(_size1789): + _elem1794 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.part_vals.append(_elem1794) iprot.readListEnd() else: iprot.skip(ftype) @@ -37331,8 +37531,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 iter1779 in self.part_vals: - oprot.writeString(iter1779.encode('utf-8') if sys.version_info[0] == 2 else iter1779) + for iter1795 in self.part_vals: + oprot.writeString(iter1795.encode('utf-8') if sys.version_info[0] == 2 else iter1795) oprot.writeListEnd() oprot.writeFieldEnd() if self.max_parts is not None: @@ -37392,10 +37592,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1783, _size1780) = iprot.readListBegin() - for _i1784 in range(_size1780): - _elem1785 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.success.append(_elem1785) + (_etype1799, _size1796) = iprot.readListBegin() + for _i1800 in range(_size1796): + _elem1801 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.success.append(_elem1801) iprot.readListEnd() else: iprot.skip(ftype) @@ -37422,8 +37622,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 iter1786 in self.success: - oprot.writeString(iter1786.encode('utf-8') if sys.version_info[0] == 2 else iter1786) + for iter1802 in self.success: + oprot.writeString(iter1802.encode('utf-8') if sys.version_info[0] == 2 else iter1802) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -37697,10 +37897,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1790, _size1787) = iprot.readListBegin() - for _i1791 in range(_size1787): - _elem1792 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.success.append(_elem1792) + (_etype1806, _size1803) = iprot.readListBegin() + for _i1807 in range(_size1803): + _elem1808 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.success.append(_elem1808) iprot.readListEnd() else: iprot.skip(ftype) @@ -37727,8 +37927,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 iter1793 in self.success: - oprot.writeString(iter1793.encode('utf-8') if sys.version_info[0] == 2 else iter1793) + for iter1809 in self.success: + oprot.writeString(iter1809.encode('utf-8') if sys.version_info[0] == 2 else iter1809) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -37888,11 +38088,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1797, _size1794) = iprot.readListBegin() - for _i1798 in range(_size1794): - _elem1799 = Partition() - _elem1799.read(iprot) - self.success.append(_elem1799) + (_etype1813, _size1810) = iprot.readListBegin() + for _i1814 in range(_size1810): + _elem1815 = Partition() + _elem1815.read(iprot) + self.success.append(_elem1815) iprot.readListEnd() else: iprot.skip(ftype) @@ -37919,8 +38119,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 iter1800 in self.success: - iter1800.write(oprot) + for iter1816 in self.success: + iter1816.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -38045,11 +38245,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1804, _size1801) = iprot.readListBegin() - for _i1805 in range(_size1801): - _elem1806 = Partition() - _elem1806.read(iprot) - self.success.append(_elem1806) + (_etype1820, _size1817) = iprot.readListBegin() + for _i1821 in range(_size1817): + _elem1822 = Partition() + _elem1822.read(iprot) + self.success.append(_elem1822) iprot.readListEnd() else: iprot.skip(ftype) @@ -38076,8 +38276,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 iter1807 in self.success: - iter1807.write(oprot) + for iter1823 in self.success: + iter1823.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -38237,11 +38437,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1811, _size1808) = iprot.readListBegin() - for _i1812 in range(_size1808): - _elem1813 = PartitionSpec() - _elem1813.read(iprot) - self.success.append(_elem1813) + (_etype1827, _size1824) = iprot.readListBegin() + for _i1828 in range(_size1824): + _elem1829 = PartitionSpec() + _elem1829.read(iprot) + self.success.append(_elem1829) iprot.readListEnd() else: iprot.skip(ftype) @@ -38268,8 +38468,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 iter1814 in self.success: - iter1814.write(oprot) + for iter1830 in self.success: + iter1830.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -38810,10 +39010,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.names = [] - (_etype1818, _size1815) = iprot.readListBegin() - for _i1819 in range(_size1815): - _elem1820 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.names.append(_elem1820) + (_etype1834, _size1831) = iprot.readListBegin() + for _i1835 in range(_size1831): + _elem1836 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.names.append(_elem1836) iprot.readListEnd() else: iprot.skip(ftype) @@ -38838,8 +39038,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 iter1821 in self.names: - oprot.writeString(iter1821.encode('utf-8') if sys.version_info[0] == 2 else iter1821) + for iter1837 in self.names: + oprot.writeString(iter1837.encode('utf-8') if sys.version_info[0] == 2 else iter1837) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -38896,11 +39096,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1825, _size1822) = iprot.readListBegin() - for _i1826 in range(_size1822): - _elem1827 = Partition() - _elem1827.read(iprot) - self.success.append(_elem1827) + (_etype1841, _size1838) = iprot.readListBegin() + for _i1842 in range(_size1838): + _elem1843 = Partition() + _elem1843.read(iprot) + self.success.append(_elem1843) iprot.readListEnd() else: iprot.skip(ftype) @@ -38932,8 +39132,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 iter1828 in self.success: - iter1828.write(oprot) + for iter1844 in self.success: + iter1844.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -39629,11 +39829,11 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.new_parts = [] - (_etype1832, _size1829) = iprot.readListBegin() - for _i1833 in range(_size1829): - _elem1834 = Partition() - _elem1834.read(iprot) - self.new_parts.append(_elem1834) + (_etype1848, _size1845) = iprot.readListBegin() + for _i1849 in range(_size1845): + _elem1850 = Partition() + _elem1850.read(iprot) + self.new_parts.append(_elem1850) iprot.readListEnd() else: iprot.skip(ftype) @@ -39658,8 +39858,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 iter1835 in self.new_parts: - iter1835.write(oprot) + for iter1851 in self.new_parts: + iter1851.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -39800,11 +40000,11 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.new_parts = [] - (_etype1839, _size1836) = iprot.readListBegin() - for _i1840 in range(_size1836): - _elem1841 = Partition() - _elem1841.read(iprot) - self.new_parts.append(_elem1841) + (_etype1855, _size1852) = iprot.readListBegin() + for _i1856 in range(_size1852): + _elem1857 = Partition() + _elem1857.read(iprot) + self.new_parts.append(_elem1857) iprot.readListEnd() else: iprot.skip(ftype) @@ -39835,8 +40035,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 iter1842 in self.new_parts: - iter1842.write(oprot) + for iter1858 in self.new_parts: + iter1858.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.environment_context is not None: @@ -40305,10 +40505,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype1846, _size1843) = iprot.readListBegin() - for _i1847 in range(_size1843): - _elem1848 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.part_vals.append(_elem1848) + (_etype1862, _size1859) = iprot.readListBegin() + for _i1863 in range(_size1859): + _elem1864 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.part_vals.append(_elem1864) iprot.readListEnd() else: iprot.skip(ftype) @@ -40339,8 +40539,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 iter1849 in self.part_vals: - oprot.writeString(iter1849.encode('utf-8') if sys.version_info[0] == 2 else iter1849) + for iter1865 in self.part_vals: + oprot.writeString(iter1865.encode('utf-8') if sys.version_info[0] == 2 else iter1865) oprot.writeListEnd() oprot.writeFieldEnd() if self.new_part is not None: @@ -40621,10 +40821,10 @@ def read(self, iprot): if fid == 1: if ftype == TType.LIST: self.part_vals = [] - (_etype1853, _size1850) = iprot.readListBegin() - for _i1854 in range(_size1850): - _elem1855 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.part_vals.append(_elem1855) + (_etype1869, _size1866) = iprot.readListBegin() + for _i1870 in range(_size1866): + _elem1871 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.part_vals.append(_elem1871) iprot.readListEnd() else: iprot.skip(ftype) @@ -40646,8 +40846,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 iter1856 in self.part_vals: - oprot.writeString(iter1856.encode('utf-8') if sys.version_info[0] == 2 else iter1856) + for iter1872 in self.part_vals: + oprot.writeString(iter1872.encode('utf-8') if sys.version_info[0] == 2 else iter1872) oprot.writeListEnd() oprot.writeFieldEnd() if self.throw_exception is not None: @@ -40985,10 +41185,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1860, _size1857) = iprot.readListBegin() - for _i1861 in range(_size1857): - _elem1862 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.success.append(_elem1862) + (_etype1876, _size1873) = iprot.readListBegin() + for _i1877 in range(_size1873): + _elem1878 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.success.append(_elem1878) iprot.readListEnd() else: iprot.skip(ftype) @@ -41010,8 +41210,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 iter1863 in self.success: - oprot.writeString(iter1863.encode('utf-8') if sys.version_info[0] == 2 else iter1863) + for iter1879 in self.success: + oprot.writeString(iter1879.encode('utf-8') if sys.version_info[0] == 2 else iter1879) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -41128,11 +41328,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.MAP: self.success = {} - (_ktype1865, _vtype1866, _size1864) = iprot.readMapBegin() - for _i1868 in range(_size1864): - _key1869 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - _val1870 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.success[_key1869] = _val1870 + (_ktype1881, _vtype1882, _size1880) = iprot.readMapBegin() + for _i1884 in range(_size1880): + _key1885 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + _val1886 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.success[_key1885] = _val1886 iprot.readMapEnd() else: iprot.skip(ftype) @@ -41154,9 +41354,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 kiter1871, viter1872 in self.success.items(): - oprot.writeString(kiter1871.encode('utf-8') if sys.version_info[0] == 2 else kiter1871) - oprot.writeString(viter1872.encode('utf-8') if sys.version_info[0] == 2 else viter1872) + for kiter1887, viter1888 in self.success.items(): + oprot.writeString(kiter1887.encode('utf-8') if sys.version_info[0] == 2 else kiter1887) + oprot.writeString(viter1888.encode('utf-8') if sys.version_info[0] == 2 else viter1888) oprot.writeMapEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -41225,11 +41425,11 @@ def read(self, iprot): elif fid == 3: if ftype == TType.MAP: self.part_vals = {} - (_ktype1874, _vtype1875, _size1873) = iprot.readMapBegin() - for _i1877 in range(_size1873): - _key1878 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - _val1879 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.part_vals[_key1878] = _val1879 + (_ktype1890, _vtype1891, _size1889) = iprot.readMapBegin() + for _i1893 in range(_size1889): + _key1894 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + _val1895 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.part_vals[_key1894] = _val1895 iprot.readMapEnd() else: iprot.skip(ftype) @@ -41259,9 +41459,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 kiter1880, viter1881 in self.part_vals.items(): - oprot.writeString(kiter1880.encode('utf-8') if sys.version_info[0] == 2 else kiter1880) - oprot.writeString(viter1881.encode('utf-8') if sys.version_info[0] == 2 else viter1881) + for kiter1896, viter1897 in self.part_vals.items(): + oprot.writeString(kiter1896.encode('utf-8') if sys.version_info[0] == 2 else kiter1896) + oprot.writeString(viter1897.encode('utf-8') if sys.version_info[0] == 2 else viter1897) oprot.writeMapEnd() oprot.writeFieldEnd() if self.eventType is not None: @@ -41455,11 +41655,11 @@ def read(self, iprot): elif fid == 3: if ftype == TType.MAP: self.part_vals = {} - (_ktype1883, _vtype1884, _size1882) = iprot.readMapBegin() - for _i1886 in range(_size1882): - _key1887 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - _val1888 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.part_vals[_key1887] = _val1888 + (_ktype1899, _vtype1900, _size1898) = iprot.readMapBegin() + for _i1902 in range(_size1898): + _key1903 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + _val1904 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.part_vals[_key1903] = _val1904 iprot.readMapEnd() else: iprot.skip(ftype) @@ -41489,9 +41689,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 kiter1889, viter1890 in self.part_vals.items(): - oprot.writeString(kiter1889.encode('utf-8') if sys.version_info[0] == 2 else kiter1889) - oprot.writeString(viter1890.encode('utf-8') if sys.version_info[0] == 2 else viter1890) + for kiter1905, viter1906 in self.part_vals.items(): + oprot.writeString(kiter1905.encode('utf-8') if sys.version_info[0] == 2 else kiter1905) + oprot.writeString(viter1906.encode('utf-8') if sys.version_info[0] == 2 else viter1906) oprot.writeMapEnd() oprot.writeFieldEnd() if self.eventType is not None: @@ -45705,10 +45905,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1894, _size1891) = iprot.readListBegin() - for _i1895 in range(_size1891): - _elem1896 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.success.append(_elem1896) + (_etype1910, _size1907) = iprot.readListBegin() + for _i1911 in range(_size1907): + _elem1912 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.success.append(_elem1912) iprot.readListEnd() else: iprot.skip(ftype) @@ -45730,8 +45930,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 iter1897 in self.success: - oprot.writeString(iter1897.encode('utf-8') if sys.version_info[0] == 2 else iter1897) + for iter1913 in self.success: + oprot.writeString(iter1913.encode('utf-8') if sys.version_info[0] == 2 else iter1913) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -46514,10 +46714,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1901, _size1898) = iprot.readListBegin() - for _i1902 in range(_size1898): - _elem1903 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.success.append(_elem1903) + (_etype1917, _size1914) = iprot.readListBegin() + for _i1918 in range(_size1914): + _elem1919 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.success.append(_elem1919) iprot.readListEnd() else: iprot.skip(ftype) @@ -46539,8 +46739,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 iter1904 in self.success: - oprot.writeString(iter1904.encode('utf-8') if sys.version_info[0] == 2 else iter1904) + for iter1920 in self.success: + oprot.writeString(iter1920.encode('utf-8') if sys.version_info[0] == 2 else iter1920) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -47023,11 +47223,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1908, _size1905) = iprot.readListBegin() - for _i1909 in range(_size1905): - _elem1910 = Role() - _elem1910.read(iprot) - self.success.append(_elem1910) + (_etype1924, _size1921) = iprot.readListBegin() + for _i1925 in range(_size1921): + _elem1926 = Role() + _elem1926.read(iprot) + self.success.append(_elem1926) iprot.readListEnd() else: iprot.skip(ftype) @@ -47049,8 +47249,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 iter1911 in self.success: - iter1911.write(oprot) + for iter1927 in self.success: + iter1927.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -47529,10 +47729,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.group_names = [] - (_etype1915, _size1912) = iprot.readListBegin() - for _i1916 in range(_size1912): - _elem1917 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.group_names.append(_elem1917) + (_etype1931, _size1928) = iprot.readListBegin() + for _i1932 in range(_size1928): + _elem1933 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.group_names.append(_elem1933) iprot.readListEnd() else: iprot.skip(ftype) @@ -47557,8 +47757,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 iter1918 in self.group_names: - oprot.writeString(iter1918.encode('utf-8') if sys.version_info[0] == 2 else iter1918) + for iter1934 in self.group_names: + oprot.writeString(iter1934.encode('utf-8') if sys.version_info[0] == 2 else iter1934) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -47772,11 +47972,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1922, _size1919) = iprot.readListBegin() - for _i1923 in range(_size1919): - _elem1924 = HiveObjectPrivilege() - _elem1924.read(iprot) - self.success.append(_elem1924) + (_etype1938, _size1935) = iprot.readListBegin() + for _i1939 in range(_size1935): + _elem1940 = HiveObjectPrivilege() + _elem1940.read(iprot) + self.success.append(_elem1940) iprot.readListEnd() else: iprot.skip(ftype) @@ -47798,8 +47998,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 iter1925 in self.success: - iter1925.write(oprot) + for iter1941 in self.success: + iter1941.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -48430,10 +48630,10 @@ def read(self, iprot): elif fid == 2: if ftype == TType.LIST: self.group_names = [] - (_etype1929, _size1926) = iprot.readListBegin() - for _i1930 in range(_size1926): - _elem1931 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.group_names.append(_elem1931) + (_etype1945, _size1942) = iprot.readListBegin() + for _i1946 in range(_size1942): + _elem1947 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.group_names.append(_elem1947) iprot.readListEnd() else: iprot.skip(ftype) @@ -48454,8 +48654,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 iter1932 in self.group_names: - oprot.writeString(iter1932.encode('utf-8') if sys.version_info[0] == 2 else iter1932) + for iter1948 in self.group_names: + oprot.writeString(iter1948.encode('utf-8') if sys.version_info[0] == 2 else iter1948) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -48507,10 +48707,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1936, _size1933) = iprot.readListBegin() - for _i1937 in range(_size1933): - _elem1938 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.success.append(_elem1938) + (_etype1952, _size1949) = iprot.readListBegin() + for _i1953 in range(_size1949): + _elem1954 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.success.append(_elem1954) iprot.readListEnd() else: iprot.skip(ftype) @@ -48532,8 +48732,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 iter1939 in self.success: - oprot.writeString(iter1939.encode('utf-8') if sys.version_info[0] == 2 else iter1939) + for iter1955 in self.success: + oprot.writeString(iter1955.encode('utf-8') if sys.version_info[0] == 2 else iter1955) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -49416,10 +49616,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1943, _size1940) = iprot.readListBegin() - for _i1944 in range(_size1940): - _elem1945 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.success.append(_elem1945) + (_etype1959, _size1956) = iprot.readListBegin() + for _i1960 in range(_size1956): + _elem1961 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.success.append(_elem1961) iprot.readListEnd() else: iprot.skip(ftype) @@ -49436,8 +49636,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 iter1946 in self.success: - oprot.writeString(iter1946.encode('utf-8') if sys.version_info[0] == 2 else iter1946) + for iter1962 in self.success: + oprot.writeString(iter1962.encode('utf-8') if sys.version_info[0] == 2 else iter1962) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -49934,10 +50134,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1950, _size1947) = iprot.readListBegin() - for _i1951 in range(_size1947): - _elem1952 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.success.append(_elem1952) + (_etype1966, _size1963) = iprot.readListBegin() + for _i1967 in range(_size1963): + _elem1968 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.success.append(_elem1968) iprot.readListEnd() else: iprot.skip(ftype) @@ -49954,8 +50154,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 iter1953 in self.success: - oprot.writeString(iter1953.encode('utf-8') if sys.version_info[0] == 2 else iter1953) + for iter1969 in self.success: + oprot.writeString(iter1969.encode('utf-8') if sys.version_info[0] == 2 else iter1969) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -51122,11 +51322,11 @@ def read(self, iprot): elif fid == 2: if ftype == TType.MAP: self.writeIds = {} - (_ktype1955, _vtype1956, _size1954) = iprot.readMapBegin() - for _i1958 in range(_size1954): - _key1959 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - _val1960 = iprot.readI64() - self.writeIds[_key1959] = _val1960 + (_ktype1971, _vtype1972, _size1970) = iprot.readMapBegin() + for _i1974 in range(_size1970): + _key1975 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + _val1976 = iprot.readI64() + self.writeIds[_key1975] = _val1976 iprot.readMapEnd() else: iprot.skip(ftype) @@ -51147,9 +51347,9 @@ def write(self, oprot): if self.writeIds is not None: oprot.writeFieldBegin('writeIds', TType.MAP, 2) oprot.writeMapBegin(TType.STRING, TType.I64, len(self.writeIds)) - for kiter1961, viter1962 in self.writeIds.items(): - oprot.writeString(kiter1961.encode('utf-8') if sys.version_info[0] == 2 else kiter1961) - oprot.writeI64(viter1962) + for kiter1977, viter1978 in self.writeIds.items(): + oprot.writeString(kiter1977.encode('utf-8') if sys.version_info[0] == 2 else kiter1977) + oprot.writeI64(viter1978) oprot.writeMapEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -53762,10 +53962,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1966, _size1963) = iprot.readListBegin() - for _i1967 in range(_size1963): - _elem1968 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.success.append(_elem1968) + (_etype1982, _size1979) = iprot.readListBegin() + for _i1983 in range(_size1979): + _elem1984 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.success.append(_elem1984) iprot.readListEnd() else: iprot.skip(ftype) @@ -53782,8 +53982,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 iter1969 in self.success: - oprot.writeString(iter1969.encode('utf-8') if sys.version_info[0] == 2 else iter1969) + for iter1985 in self.success: + oprot.writeString(iter1985.encode('utf-8') if sys.version_info[0] == 2 else iter1985) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -60339,11 +60539,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1973, _size1970) = iprot.readListBegin() - for _i1974 in range(_size1970): - _elem1975 = SchemaVersion() - _elem1975.read(iprot) - self.success.append(_elem1975) + (_etype1989, _size1986) = iprot.readListBegin() + for _i1990 in range(_size1986): + _elem1991 = SchemaVersion() + _elem1991.read(iprot) + self.success.append(_elem1991) iprot.readListEnd() else: iprot.skip(ftype) @@ -60370,8 +60570,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 iter1976 in self.success: - iter1976.write(oprot) + for iter1992 in self.success: + iter1992.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -61760,11 +61960,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1980, _size1977) = iprot.readListBegin() - for _i1981 in range(_size1977): - _elem1982 = RuntimeStat() - _elem1982.read(iprot) - self.success.append(_elem1982) + (_etype1996, _size1993) = iprot.readListBegin() + for _i1997 in range(_size1993): + _elem1998 = RuntimeStat() + _elem1998.read(iprot) + self.success.append(_elem1998) iprot.readListEnd() else: iprot.skip(ftype) @@ -61786,8 +61986,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 iter1983 in self.success: - iter1983.write(oprot) + for iter1999 in self.success: + iter1999.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -63424,10 +63624,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1987, _size1984) = iprot.readListBegin() - for _i1988 in range(_size1984): - _elem1989 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.success.append(_elem1989) + (_etype2003, _size2000) = iprot.readListBegin() + for _i2004 in range(_size2000): + _elem2005 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.success.append(_elem2005) iprot.readListEnd() else: iprot.skip(ftype) @@ -63449,8 +63649,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 iter1990 in self.success: - oprot.writeString(iter1990.encode('utf-8') if sys.version_info[0] == 2 else iter1990) + for iter2006 in self.success: + oprot.writeString(iter2006.encode('utf-8') if sys.version_info[0] == 2 else iter2006) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -63842,10 +64042,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1994, _size1991) = iprot.readListBegin() - for _i1995 in range(_size1991): - _elem1996 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.success.append(_elem1996) + (_etype2010, _size2007) = iprot.readListBegin() + for _i2011 in range(_size2007): + _elem2012 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.success.append(_elem2012) iprot.readListEnd() else: iprot.skip(ftype) @@ -63867,8 +64067,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 iter1997 in self.success: - oprot.writeString(iter1997.encode('utf-8') if sys.version_info[0] == 2 else iter1997) + for iter2013 in self.success: + oprot.writeString(iter2013.encode('utf-8') if sys.version_info[0] == 2 else iter2013) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -64111,11 +64311,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype2001, _size1998) = iprot.readListBegin() - for _i2002 in range(_size1998): - _elem2003 = WriteEventInfo() - _elem2003.read(iprot) - self.success.append(_elem2003) + (_etype2017, _size2014) = iprot.readListBegin() + for _i2018 in range(_size2014): + _elem2019 = WriteEventInfo() + _elem2019.read(iprot) + self.success.append(_elem2019) iprot.readListEnd() else: iprot.skip(ftype) @@ -64137,8 +64337,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 iter2004 in self.success: - iter2004.write(oprot) + for iter2020 in self.success: + iter2020.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: diff --git a/standalone-metastore/metastore-common/src/gen/thrift/gen-py/hive_metastore/ttypes.py b/standalone-metastore/metastore-common/src/gen/thrift/gen-py/hive_metastore/ttypes.py index d44f3eb7f41c..567d94de2fd9 100644 --- a/standalone-metastore/metastore-common/src/gen/thrift/gen-py/hive_metastore/ttypes.py +++ b/standalone-metastore/metastore-common/src/gen/thrift/gen-py/hive_metastore/ttypes.py @@ -28155,6 +28155,134 @@ def __ne__(self, other): return not (self == other) +class TableParamsUpdate(object): + """ + Attributes: + - cat_name + - db_name + - table_name + - params + - expected_param_key + - expected_param_value + + """ + + + def __init__(self, cat_name=None, db_name=None, table_name=None, params=None, expected_param_key=None, expected_param_value=None,): + self.cat_name = cat_name + self.db_name = db_name + self.table_name = table_name + self.params = params + self.expected_param_key = expected_param_key + self.expected_param_value = expected_param_value + + def read(self, iprot): + if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: + iprot._fast_decode(self, iprot, [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.STRING: + self.cat_name = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + else: + iprot.skip(ftype) + elif fid == 2: + if ftype == TType.STRING: + self.db_name = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + else: + iprot.skip(ftype) + elif fid == 3: + if ftype == TType.STRING: + self.table_name = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + else: + iprot.skip(ftype) + elif fid == 4: + if ftype == TType.MAP: + self.params = {} + (_ktype1304, _vtype1305, _size1303) = iprot.readMapBegin() + for _i1307 in range(_size1303): + _key1308 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + _val1309 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.params[_key1308] = _val1309 + iprot.readMapEnd() + else: + iprot.skip(ftype) + elif fid == 5: + if ftype == TType.STRING: + self.expected_param_key = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + else: + iprot.skip(ftype) + elif fid == 6: + if ftype == TType.STRING: + self.expected_param_value = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + else: + iprot.skip(ftype) + else: + iprot.skip(ftype) + iprot.readFieldEnd() + iprot.readStructEnd() + + def write(self, oprot): + if oprot._fast_encode is not None and self.thrift_spec is not None: + oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec])) + return + oprot.writeStructBegin('TableParamsUpdate') + if self.cat_name is not None: + oprot.writeFieldBegin('cat_name', TType.STRING, 1) + oprot.writeString(self.cat_name.encode('utf-8') if sys.version_info[0] == 2 else self.cat_name) + oprot.writeFieldEnd() + if self.db_name is not None: + oprot.writeFieldBegin('db_name', TType.STRING, 2) + oprot.writeString(self.db_name.encode('utf-8') if sys.version_info[0] == 2 else self.db_name) + oprot.writeFieldEnd() + if self.table_name is not None: + oprot.writeFieldBegin('table_name', TType.STRING, 3) + oprot.writeString(self.table_name.encode('utf-8') if sys.version_info[0] == 2 else self.table_name) + oprot.writeFieldEnd() + if self.params is not None: + oprot.writeFieldBegin('params', TType.MAP, 4) + oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.params)) + for kiter1310, viter1311 in self.params.items(): + oprot.writeString(kiter1310.encode('utf-8') if sys.version_info[0] == 2 else kiter1310) + oprot.writeString(viter1311.encode('utf-8') if sys.version_info[0] == 2 else viter1311) + oprot.writeMapEnd() + oprot.writeFieldEnd() + if self.expected_param_key is not None: + oprot.writeFieldBegin('expected_param_key', TType.STRING, 5) + oprot.writeString(self.expected_param_key.encode('utf-8') if sys.version_info[0] == 2 else self.expected_param_key) + oprot.writeFieldEnd() + if self.expected_param_value is not None: + oprot.writeFieldBegin('expected_param_value', TType.STRING, 6) + oprot.writeString(self.expected_param_value.encode('utf-8') if sys.version_info[0] == 2 else self.expected_param_value) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + if self.db_name is None: + raise TProtocolException(message='Required field db_name is unset!') + if self.table_name is None: + raise TProtocolException(message='Required field table_name is unset!') + if self.params is None: + raise TProtocolException(message='Required field params is unset!') + return + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.items()] + 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 GetPartitionsFilterSpec(object): """ Attributes: @@ -28185,10 +28313,10 @@ def read(self, iprot): elif fid == 8: if ftype == TType.LIST: self.filters = [] - (_etype1306, _size1303) = iprot.readListBegin() - for _i1307 in range(_size1303): - _elem1308 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.filters.append(_elem1308) + (_etype1315, _size1312) = iprot.readListBegin() + for _i1316 in range(_size1312): + _elem1317 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.filters.append(_elem1317) iprot.readListEnd() else: iprot.skip(ftype) @@ -28209,8 +28337,8 @@ def write(self, oprot): if self.filters is not None: oprot.writeFieldBegin('filters', TType.LIST, 8) oprot.writeListBegin(TType.STRING, len(self.filters)) - for iter1309 in self.filters: - oprot.writeString(iter1309.encode('utf-8') if sys.version_info[0] == 2 else iter1309) + for iter1318 in self.filters: + oprot.writeString(iter1318.encode('utf-8') if sys.version_info[0] == 2 else iter1318) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -28254,11 +28382,11 @@ def read(self, iprot): if fid == 1: if ftype == TType.LIST: self.partitionSpec = [] - (_etype1313, _size1310) = iprot.readListBegin() - for _i1314 in range(_size1310): - _elem1315 = PartitionSpec() - _elem1315.read(iprot) - self.partitionSpec.append(_elem1315) + (_etype1322, _size1319) = iprot.readListBegin() + for _i1323 in range(_size1319): + _elem1324 = PartitionSpec() + _elem1324.read(iprot) + self.partitionSpec.append(_elem1324) iprot.readListEnd() else: iprot.skip(ftype) @@ -28275,8 +28403,8 @@ def write(self, oprot): if self.partitionSpec is not None: oprot.writeFieldBegin('partitionSpec', TType.LIST, 1) oprot.writeListBegin(TType.STRUCT, len(self.partitionSpec)) - for iter1316 in self.partitionSpec: - iter1316.write(oprot) + for iter1325 in self.partitionSpec: + iter1325.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -28365,10 +28493,10 @@ def read(self, iprot): elif fid == 6: if ftype == TType.LIST: self.groupNames = [] - (_etype1320, _size1317) = iprot.readListBegin() - for _i1321 in range(_size1317): - _elem1322 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.groupNames.append(_elem1322) + (_etype1329, _size1326) = iprot.readListBegin() + for _i1330 in range(_size1326): + _elem1331 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.groupNames.append(_elem1331) iprot.readListEnd() else: iprot.skip(ftype) @@ -28387,10 +28515,10 @@ def read(self, iprot): elif fid == 9: if ftype == TType.LIST: self.processorCapabilities = [] - (_etype1326, _size1323) = iprot.readListBegin() - for _i1327 in range(_size1323): - _elem1328 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.processorCapabilities.append(_elem1328) + (_etype1335, _size1332) = iprot.readListBegin() + for _i1336 in range(_size1332): + _elem1337 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.processorCapabilities.append(_elem1337) iprot.readListEnd() else: iprot.skip(ftype) @@ -28437,8 +28565,8 @@ def write(self, oprot): if self.groupNames is not None: oprot.writeFieldBegin('groupNames', TType.LIST, 6) oprot.writeListBegin(TType.STRING, len(self.groupNames)) - for iter1329 in self.groupNames: - oprot.writeString(iter1329.encode('utf-8') if sys.version_info[0] == 2 else iter1329) + for iter1338 in self.groupNames: + oprot.writeString(iter1338.encode('utf-8') if sys.version_info[0] == 2 else iter1338) oprot.writeListEnd() oprot.writeFieldEnd() if self.projectionSpec is not None: @@ -28452,8 +28580,8 @@ def write(self, oprot): if self.processorCapabilities is not None: oprot.writeFieldBegin('processorCapabilities', TType.LIST, 9) oprot.writeListBegin(TType.STRING, len(self.processorCapabilities)) - for iter1330 in self.processorCapabilities: - oprot.writeString(iter1330.encode('utf-8') if sys.version_info[0] == 2 else iter1330) + for iter1339 in self.processorCapabilities: + oprot.writeString(iter1339.encode('utf-8') if sys.version_info[0] == 2 else iter1339) oprot.writeListEnd() oprot.writeFieldEnd() if self.processorIdentifier is not None: @@ -28622,11 +28750,11 @@ def read(self, iprot): if fid == 1: if ftype == TType.LIST: self.fields = [] - (_etype1334, _size1331) = iprot.readListBegin() - for _i1335 in range(_size1331): - _elem1336 = FieldSchema() - _elem1336.read(iprot) - self.fields.append(_elem1336) + (_etype1343, _size1340) = iprot.readListBegin() + for _i1344 in range(_size1340): + _elem1345 = FieldSchema() + _elem1345.read(iprot) + self.fields.append(_elem1345) iprot.readListEnd() else: iprot.skip(ftype) @@ -28643,8 +28771,8 @@ def write(self, oprot): if self.fields is not None: oprot.writeFieldBegin('fields', TType.LIST, 1) oprot.writeListBegin(TType.STRUCT, len(self.fields)) - for iter1337 in self.fields: - iter1337.write(oprot) + for iter1346 in self.fields: + iter1346.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -28807,11 +28935,11 @@ def read(self, iprot): if fid == 1: if ftype == TType.LIST: self.fields = [] - (_etype1341, _size1338) = iprot.readListBegin() - for _i1342 in range(_size1338): - _elem1343 = FieldSchema() - _elem1343.read(iprot) - self.fields.append(_elem1343) + (_etype1350, _size1347) = iprot.readListBegin() + for _i1351 in range(_size1347): + _elem1352 = FieldSchema() + _elem1352.read(iprot) + self.fields.append(_elem1352) iprot.readListEnd() else: iprot.skip(ftype) @@ -28828,8 +28956,8 @@ def write(self, oprot): if self.fields is not None: oprot.writeFieldBegin('fields', TType.LIST, 1) oprot.writeListBegin(TType.STRUCT, len(self.fields)) - for iter1344 in self.fields: - iter1344.write(oprot) + for iter1353 in self.fields: + iter1353.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -28900,10 +29028,10 @@ def read(self, iprot): elif fid == 4: if ftype == TType.LIST: self.partVals = [] - (_etype1348, _size1345) = iprot.readListBegin() - for _i1349 in range(_size1345): - _elem1350 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.partVals.append(_elem1350) + (_etype1357, _size1354) = iprot.readListBegin() + for _i1358 in range(_size1354): + _elem1359 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.partVals.append(_elem1359) iprot.readListEnd() else: iprot.skip(ftype) @@ -28942,8 +29070,8 @@ def write(self, oprot): if self.partVals is not None: oprot.writeFieldBegin('partVals', TType.LIST, 4) oprot.writeListBegin(TType.STRING, len(self.partVals)) - for iter1351 in self.partVals: - oprot.writeString(iter1351.encode('utf-8') if sys.version_info[0] == 2 else iter1351) + for iter1360 in self.partVals: + oprot.writeString(iter1360.encode('utf-8') if sys.version_info[0] == 2 else iter1360) oprot.writeListEnd() oprot.writeFieldEnd() if self.validWriteIdList is not None: @@ -29210,11 +29338,11 @@ def read(self, iprot): if fid == 1: if ftype == TType.LIST: self.partitions = [] - (_etype1355, _size1352) = iprot.readListBegin() - for _i1356 in range(_size1352): - _elem1357 = Partition() - _elem1357.read(iprot) - self.partitions.append(_elem1357) + (_etype1364, _size1361) = iprot.readListBegin() + for _i1365 in range(_size1361): + _elem1366 = Partition() + _elem1366.read(iprot) + self.partitions.append(_elem1366) iprot.readListEnd() else: iprot.skip(ftype) @@ -29231,8 +29359,8 @@ def write(self, oprot): if self.partitions is not None: oprot.writeFieldBegin('partitions', TType.LIST, 1) oprot.writeListBegin(TType.STRUCT, len(self.partitions)) - for iter1358 in self.partitions: - iter1358.write(oprot) + for iter1367 in self.partitions: + iter1367.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -29439,10 +29567,10 @@ def read(self, iprot): elif fid == 4: if ftype == TType.LIST: self.partValues = [] - (_etype1362, _size1359) = iprot.readListBegin() - for _i1363 in range(_size1359): - _elem1364 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.partValues.append(_elem1364) + (_etype1371, _size1368) = iprot.readListBegin() + for _i1372 in range(_size1368): + _elem1373 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.partValues.append(_elem1373) iprot.readListEnd() else: iprot.skip(ftype) @@ -29486,8 +29614,8 @@ def write(self, oprot): if self.partValues is not None: oprot.writeFieldBegin('partValues', TType.LIST, 4) oprot.writeListBegin(TType.STRING, len(self.partValues)) - for iter1365 in self.partValues: - oprot.writeString(iter1365.encode('utf-8') if sys.version_info[0] == 2 else iter1365) + for iter1374 in self.partValues: + oprot.writeString(iter1374.encode('utf-8') if sys.version_info[0] == 2 else iter1374) oprot.writeListEnd() oprot.writeFieldEnd() if self.maxParts is not None: @@ -29547,10 +29675,10 @@ def read(self, iprot): if fid == 1: if ftype == TType.LIST: self.names = [] - (_etype1369, _size1366) = iprot.readListBegin() - for _i1370 in range(_size1366): - _elem1371 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.names.append(_elem1371) + (_etype1378, _size1375) = iprot.readListBegin() + for _i1379 in range(_size1375): + _elem1380 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.names.append(_elem1380) iprot.readListEnd() else: iprot.skip(ftype) @@ -29567,8 +29695,8 @@ def write(self, oprot): if self.names is not None: oprot.writeFieldBegin('names', TType.LIST, 1) oprot.writeListBegin(TType.STRING, len(self.names)) - for iter1372 in self.names: - oprot.writeString(iter1372.encode('utf-8') if sys.version_info[0] == 2 else iter1372) + for iter1381 in self.names: + oprot.writeString(iter1381.encode('utf-8') if sys.version_info[0] == 2 else iter1381) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -29653,10 +29781,10 @@ def read(self, iprot): elif fid == 4: if ftype == TType.LIST: self.partVals = [] - (_etype1376, _size1373) = iprot.readListBegin() - for _i1377 in range(_size1373): - _elem1378 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.partVals.append(_elem1378) + (_etype1385, _size1382) = iprot.readListBegin() + for _i1386 in range(_size1382): + _elem1387 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.partVals.append(_elem1387) iprot.readListEnd() else: iprot.skip(ftype) @@ -29673,10 +29801,10 @@ def read(self, iprot): elif fid == 7: if ftype == TType.LIST: self.groupNames = [] - (_etype1382, _size1379) = iprot.readListBegin() - for _i1383 in range(_size1379): - _elem1384 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.groupNames.append(_elem1384) + (_etype1391, _size1388) = iprot.readListBegin() + for _i1392 in range(_size1388): + _elem1393 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.groupNames.append(_elem1393) iprot.readListEnd() else: iprot.skip(ftype) @@ -29708,10 +29836,10 @@ def read(self, iprot): elif fid == 13: if ftype == TType.LIST: self.partNames = [] - (_etype1388, _size1385) = iprot.readListBegin() - for _i1389 in range(_size1385): - _elem1390 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.partNames.append(_elem1390) + (_etype1397, _size1394) = iprot.readListBegin() + for _i1398 in range(_size1394): + _elem1399 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.partNames.append(_elem1399) iprot.readListEnd() else: iprot.skip(ftype) @@ -29740,8 +29868,8 @@ def write(self, oprot): if self.partVals is not None: oprot.writeFieldBegin('partVals', TType.LIST, 4) oprot.writeListBegin(TType.STRING, len(self.partVals)) - for iter1391 in self.partVals: - oprot.writeString(iter1391.encode('utf-8') if sys.version_info[0] == 2 else iter1391) + for iter1400 in self.partVals: + oprot.writeString(iter1400.encode('utf-8') if sys.version_info[0] == 2 else iter1400) oprot.writeListEnd() oprot.writeFieldEnd() if self.maxParts is not None: @@ -29755,8 +29883,8 @@ def write(self, oprot): if self.groupNames is not None: oprot.writeFieldBegin('groupNames', TType.LIST, 7) oprot.writeListBegin(TType.STRING, len(self.groupNames)) - for iter1392 in self.groupNames: - oprot.writeString(iter1392.encode('utf-8') if sys.version_info[0] == 2 else iter1392) + for iter1401 in self.groupNames: + oprot.writeString(iter1401.encode('utf-8') if sys.version_info[0] == 2 else iter1401) oprot.writeListEnd() oprot.writeFieldEnd() if self.validWriteIdList is not None: @@ -29782,8 +29910,8 @@ def write(self, oprot): if self.partNames is not None: oprot.writeFieldBegin('partNames', TType.LIST, 13) oprot.writeListBegin(TType.STRING, len(self.partNames)) - for iter1393 in self.partNames: - oprot.writeString(iter1393.encode('utf-8') if sys.version_info[0] == 2 else iter1393) + for iter1402 in self.partNames: + oprot.writeString(iter1402.encode('utf-8') if sys.version_info[0] == 2 else iter1402) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -29831,11 +29959,11 @@ def read(self, iprot): if fid == 1: if ftype == TType.LIST: self.partitions = [] - (_etype1397, _size1394) = iprot.readListBegin() - for _i1398 in range(_size1394): - _elem1399 = Partition() - _elem1399.read(iprot) - self.partitions.append(_elem1399) + (_etype1406, _size1403) = iprot.readListBegin() + for _i1407 in range(_size1403): + _elem1408 = Partition() + _elem1408.read(iprot) + self.partitions.append(_elem1408) iprot.readListEnd() else: iprot.skip(ftype) @@ -29852,8 +29980,8 @@ def write(self, oprot): if self.partitions is not None: oprot.writeFieldBegin('partitions', TType.LIST, 1) oprot.writeListBegin(TType.STRUCT, len(self.partitions)) - for iter1400 in self.partitions: - iter1400.write(oprot) + for iter1409 in self.partitions: + iter1409.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -30017,11 +30145,11 @@ def read(self, iprot): if fid == 1: if ftype == TType.LIST: self.replicationMetricList = [] - (_etype1404, _size1401) = iprot.readListBegin() - for _i1405 in range(_size1401): - _elem1406 = ReplicationMetrics() - _elem1406.read(iprot) - self.replicationMetricList.append(_elem1406) + (_etype1413, _size1410) = iprot.readListBegin() + for _i1414 in range(_size1410): + _elem1415 = ReplicationMetrics() + _elem1415.read(iprot) + self.replicationMetricList.append(_elem1415) iprot.readListEnd() else: iprot.skip(ftype) @@ -30038,8 +30166,8 @@ def write(self, oprot): if self.replicationMetricList is not None: oprot.writeFieldBegin('replicationMetricList', TType.LIST, 1) oprot.writeListBegin(TType.STRUCT, len(self.replicationMetricList)) - for iter1407 in self.replicationMetricList: - iter1407.write(oprot) + for iter1416 in self.replicationMetricList: + iter1416.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -30164,10 +30292,10 @@ def read(self, iprot): if fid == 1: if ftype == TType.LIST: self.excludeTxnTypes = [] - (_etype1411, _size1408) = iprot.readListBegin() - for _i1412 in range(_size1408): - _elem1413 = iprot.readI32() - self.excludeTxnTypes.append(_elem1413) + (_etype1420, _size1417) = iprot.readListBegin() + for _i1421 in range(_size1417): + _elem1422 = iprot.readI32() + self.excludeTxnTypes.append(_elem1422) iprot.readListEnd() else: iprot.skip(ftype) @@ -30184,8 +30312,8 @@ def write(self, oprot): if self.excludeTxnTypes is not None: oprot.writeFieldBegin('excludeTxnTypes', TType.LIST, 1) oprot.writeListBegin(TType.I32, len(self.excludeTxnTypes)) - for iter1414 in self.excludeTxnTypes: - oprot.writeI32(iter1414) + for iter1423 in self.excludeTxnTypes: + oprot.writeI32(iter1423) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -31057,20 +31185,20 @@ def read(self, iprot): elif fid == 4: if ftype == TType.LIST: self.part_names = [] - (_etype1418, _size1415) = iprot.readListBegin() - for _i1419 in range(_size1415): - _elem1420 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.part_names.append(_elem1420) + (_etype1427, _size1424) = iprot.readListBegin() + for _i1428 in range(_size1424): + _elem1429 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.part_names.append(_elem1429) iprot.readListEnd() else: iprot.skip(ftype) elif fid == 5: if ftype == TType.LIST: self.col_names = [] - (_etype1424, _size1421) = iprot.readListBegin() - for _i1425 in range(_size1421): - _elem1426 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.col_names.append(_elem1426) + (_etype1433, _size1430) = iprot.readListBegin() + for _i1434 in range(_size1430): + _elem1435 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.col_names.append(_elem1435) iprot.readListEnd() else: iprot.skip(ftype) @@ -31109,15 +31237,15 @@ def write(self, oprot): if self.part_names is not None: oprot.writeFieldBegin('part_names', TType.LIST, 4) oprot.writeListBegin(TType.STRING, len(self.part_names)) - for iter1427 in self.part_names: - oprot.writeString(iter1427.encode('utf-8') if sys.version_info[0] == 2 else iter1427) + for iter1436 in self.part_names: + oprot.writeString(iter1436.encode('utf-8') if sys.version_info[0] == 2 else iter1436) oprot.writeListEnd() oprot.writeFieldEnd() if self.col_names is not None: oprot.writeFieldBegin('col_names', TType.LIST, 5) oprot.writeListBegin(TType.STRING, len(self.col_names)) - for iter1428 in self.col_names: - oprot.writeString(iter1428.encode('utf-8') if sys.version_info[0] == 2 else iter1428) + for iter1437 in self.col_names: + oprot.writeString(iter1437.encode('utf-8') if sys.version_info[0] == 2 else iter1437) oprot.writeListEnd() oprot.writeFieldEnd() if self.engine is not None: @@ -31173,11 +31301,11 @@ def read(self, iprot): if fid == 1: if ftype == TType.MAP: self.replTxnMapEntry = {} - (_ktype1430, _vtype1431, _size1429) = iprot.readMapBegin() - for _i1433 in range(_size1429): - _key1434 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - _val1435 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() - self.replTxnMapEntry[_key1434] = _val1435 + (_ktype1439, _vtype1440, _size1438) = iprot.readMapBegin() + for _i1442 in range(_size1438): + _key1443 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + _val1444 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() + self.replTxnMapEntry[_key1443] = _val1444 iprot.readMapEnd() else: iprot.skip(ftype) @@ -31194,9 +31322,9 @@ def write(self, oprot): if self.replTxnMapEntry is not None: oprot.writeFieldBegin('replTxnMapEntry', TType.MAP, 1) oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.replTxnMapEntry)) - for kiter1436, viter1437 in self.replTxnMapEntry.items(): - oprot.writeString(kiter1436.encode('utf-8') if sys.version_info[0] == 2 else kiter1436) - oprot.writeString(viter1437.encode('utf-8') if sys.version_info[0] == 2 else viter1437) + for kiter1445, viter1446 in self.replTxnMapEntry.items(): + oprot.writeString(kiter1445.encode('utf-8') if sys.version_info[0] == 2 else kiter1445) + oprot.writeString(viter1446.encode('utf-8') if sys.version_info[0] == 2 else viter1446) oprot.writeMapEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -34695,6 +34823,16 @@ def __ne__(self, other): all_structs.append(AlterTableResponse) AlterTableResponse.thrift_spec = ( ) +all_structs.append(TableParamsUpdate) +TableParamsUpdate.thrift_spec = ( + None, # 0 + (1, TType.STRING, 'cat_name', 'UTF8', None, ), # 1 + (2, TType.STRING, 'db_name', 'UTF8', None, ), # 2 + (3, TType.STRING, 'table_name', 'UTF8', None, ), # 3 + (4, TType.MAP, 'params', (TType.STRING, 'UTF8', TType.STRING, 'UTF8', False), None, ), # 4 + (5, TType.STRING, 'expected_param_key', 'UTF8', None, ), # 5 + (6, TType.STRING, 'expected_param_value', 'UTF8', None, ), # 6 +) all_structs.append(GetPartitionsFilterSpec) GetPartitionsFilterSpec.thrift_spec = ( None, # 0 diff --git a/standalone-metastore/metastore-common/src/gen/thrift/gen-rb/hive_metastore_types.rb b/standalone-metastore/metastore-common/src/gen/thrift/gen-rb/hive_metastore_types.rb index 3026b7d1f183..e3ff4fefcf26 100644 --- a/standalone-metastore/metastore-common/src/gen/thrift/gen-rb/hive_metastore_types.rb +++ b/standalone-metastore/metastore-common/src/gen/thrift/gen-rb/hive_metastore_types.rb @@ -824,6 +824,8 @@ class AlterTableRequest; end class AlterTableResponse; end +class TableParamsUpdate; end + class GetPartitionsFilterSpec; end class GetPartitionsResponse; end @@ -7718,6 +7720,35 @@ def validate ::Thrift::Struct.generate_accessors self end +class TableParamsUpdate + include ::Thrift::Struct, ::Thrift::Struct_Union + CAT_NAME = 1 + DB_NAME = 2 + TABLE_NAME = 3 + PARAMS = 4 + EXPECTED_PARAM_KEY = 5 + EXPECTED_PARAM_VALUE = 6 + + FIELDS = { + CAT_NAME => {:type => ::Thrift::Types::STRING, :name => 'cat_name', :optional => true}, + DB_NAME => {:type => ::Thrift::Types::STRING, :name => 'db_name'}, + TABLE_NAME => {:type => ::Thrift::Types::STRING, :name => 'table_name'}, + PARAMS => {:type => ::Thrift::Types::MAP, :name => 'params', :key => {:type => ::Thrift::Types::STRING}, :value => {:type => ::Thrift::Types::STRING}}, + EXPECTED_PARAM_KEY => {:type => ::Thrift::Types::STRING, :name => 'expected_param_key', :optional => true}, + EXPECTED_PARAM_VALUE => {:type => ::Thrift::Types::STRING, :name => 'expected_param_value', :optional => true} + } + + def struct_fields; FIELDS; end + + def validate + raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Required field db_name is unset!') unless @db_name + raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Required field table_name is unset!') unless @table_name + raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Required field params is unset!') unless @params + end + + ::Thrift::Struct.generate_accessors self +end + class GetPartitionsFilterSpec include ::Thrift::Struct, ::Thrift::Struct_Union FILTERMODE = 7 diff --git a/standalone-metastore/metastore-common/src/gen/thrift/gen-rb/thrift_hive_metastore.rb b/standalone-metastore/metastore-common/src/gen/thrift/gen-rb/thrift_hive_metastore.rb index 1c33e538c7d6..e92e13da9762 100644 --- a/standalone-metastore/metastore-common/src/gen/thrift/gen-rb/thrift_hive_metastore.rb +++ b/standalone-metastore/metastore-common/src/gen/thrift/gen-rb/thrift_hive_metastore.rb @@ -1132,6 +1132,21 @@ def recv_alter_table_req() raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'alter_table_req failed: unknown result') end + def update_table_params(updates) + send_update_table_params(updates) + recv_update_table_params() + end + + def send_update_table_params(updates) + send_message('update_table_params', Update_table_params_args, :updates => updates) + end + + def recv_update_table_params() + result = receive_message(Update_table_params_result) + raise result.o1 unless result.o1.nil? + return + end + def add_partition(new_part) send_add_partition(new_part) return recv_add_partition() @@ -5612,6 +5627,17 @@ def process_alter_table_req(seqid, iprot, oprot) write_result(result, oprot, 'alter_table_req', seqid) end + def process_update_table_params(seqid, iprot, oprot) + args = read_args(iprot, Update_table_params_args) + result = Update_table_params_result.new() + begin + @handler.update_table_params(args.updates) + rescue ::MetaException => o1 + result.o1 = o1 + end + write_result(result, oprot, 'update_table_params', seqid) + end + def process_add_partition(seqid, iprot, oprot) args = read_args(iprot, Add_partition_args) result = Add_partition_result.new() @@ -10709,6 +10735,38 @@ def validate ::Thrift::Struct.generate_accessors self end + class Update_table_params_args + include ::Thrift::Struct, ::Thrift::Struct_Union + UPDATES = 1 + + FIELDS = { + UPDATES => {:type => ::Thrift::Types::LIST, :name => 'updates', :element => {:type => ::Thrift::Types::STRUCT, :class => ::TableParamsUpdate}} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Update_table_params_result + include ::Thrift::Struct, ::Thrift::Struct_Union + O1 = 1 + + FIELDS = { + O1 => {:type => ::Thrift::Types::STRUCT, :name => 'o1', :class => ::MetaException} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + class Add_partition_args include ::Thrift::Struct, ::Thrift::Struct_Union NEW_PART = 1 diff --git a/standalone-metastore/metastore-common/src/main/java/org/apache/hadoop/hive/TxnCoordinator.java b/standalone-metastore/metastore-common/src/main/java/org/apache/hadoop/hive/TxnCoordinator.java new file mode 100644 index 000000000000..be8b11e1678d --- /dev/null +++ b/standalone-metastore/metastore-common/src/main/java/org/apache/hadoop/hive/TxnCoordinator.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; + +import org.apache.thrift.TException; + +/** + * Transaction-level coordinator hook. + */ +public interface TxnCoordinator { + /** + * Perform commit work for the given transaction. + */ + void commit() throws TException; + + /** + * Roll back any state for the given transaction. + */ + void rollback() throws TException; + + /** + * Whether this coordinator has pending work that should be treated as open. + */ + boolean hasPendingWork(); + +} diff --git a/standalone-metastore/metastore-common/src/main/thrift/hive_metastore.thrift b/standalone-metastore/metastore-common/src/main/thrift/hive_metastore.thrift index 962adb5fd3df..68c7b8bbfe60 100644 --- a/standalone-metastore/metastore-common/src/main/thrift/hive_metastore.thrift +++ b/standalone-metastore/metastore-common/src/main/thrift/hive_metastore.thrift @@ -2310,6 +2310,15 @@ struct AlterTableRequest { struct AlterTableResponse { } +struct TableParamsUpdate { + 1: optional string cat_name + 2: required string db_name + 3: required string table_name + 4: required map params + 5: optional string expected_param_key + 6: optional string expected_param_value +} + enum PartitionFilterMode { BY_NAMES, // filter by names BY_VALUES, // filter by values @@ -2779,6 +2788,9 @@ service ThriftHiveMetastore extends fb303.FacebookService AlterTableResponse alter_table_req(1:AlterTableRequest req) throws (1:InvalidOperationException o1, 2:MetaException o2) + // multi-table table-parameter update + void update_table_params(1:list updates) throws (1:MetaException o1) + // the following applies to only tables that have partitions diff --git a/standalone-metastore/metastore-server/src/main/java/org/apache/hadoop/hive/metastore/DirectSqlBase.java b/standalone-metastore/metastore-server/src/main/java/org/apache/hadoop/hive/metastore/DirectSqlBase.java new file mode 100644 index 000000000000..e15083f95020 --- /dev/null +++ b/standalone-metastore/metastore-server/src/main/java/org/apache/hadoop/hive/metastore/DirectSqlBase.java @@ -0,0 +1,75 @@ +/* + * 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; + +import org.apache.hadoop.hive.metastore.api.MetaException; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import javax.jdo.PersistenceManager; +import javax.jdo.datastore.JDOConnection; +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.SQLException; + +class DirectSqlBase { + + private static final Logger LOG = LoggerFactory.getLogger(DirectSqlBase.class.getName()); + + protected final PersistenceManager pm; + protected final DatabaseProduct dbType; + protected final int maxBatchSize; + + DirectSqlBase(PersistenceManager pm, DatabaseProduct dbType, int batchSize) { + this.pm = pm; + this.dbType = dbType; + this.maxBatchSize = batchSize; + } + + protected void updateWithStatement(ThrowableConsumer consumer, String query) + throws MetaException { + JDOConnection jdoConn = pm.getDataStoreConnection(); + boolean doTrace = LOG.isDebugEnabled(); + long start = doTrace ? System.nanoTime() : 0; + try (PreparedStatement statement = + ((Connection) jdoConn.getNativeConnection()).prepareStatement(query)) { + consumer.accept(statement); + MetastoreDirectSqlUtils.timingTrace(doTrace, query, start, doTrace ? System.nanoTime() : 0); + } catch (SQLException e) { + LOG.error("Failed to execute update query: " + query, e); + throw new MetaException("Unable to execute update due to: " + e.getMessage()); + } finally { + closeDbConn(jdoConn); + } + } + + protected interface ThrowableConsumer { + void accept(T t) throws SQLException, MetaException; + } + + protected void closeDbConn(JDOConnection jdoConn) { + try { + if (jdoConn != null) { + jdoConn.close(); + } + } catch (Exception e) { + LOG.warn("Failed to close db connection", e); + } + } +} diff --git a/standalone-metastore/metastore-server/src/main/java/org/apache/hadoop/hive/metastore/DirectSqlUpdateParams.java b/standalone-metastore/metastore-server/src/main/java/org/apache/hadoop/hive/metastore/DirectSqlUpdateParams.java new file mode 100644 index 000000000000..0d40ef87501c --- /dev/null +++ b/standalone-metastore/metastore-server/src/main/java/org/apache/hadoop/hive/metastore/DirectSqlUpdateParams.java @@ -0,0 +1,168 @@ +/* + * 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; + +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import javax.jdo.PersistenceManager; + +import org.apache.commons.lang3.tuple.Pair; +import org.apache.hadoop.hive.metastore.api.MetaException; +import org.apache.hadoop.hive.metastore.txn.TxnUtils; + +import static org.apache.hadoop.hive.metastore.MetastoreDirectSqlUtils.executeWithArray; +import static org.apache.hadoop.hive.metastore.MetastoreDirectSqlUtils.extractSqlClob; +import static org.apache.hadoop.hive.metastore.MetastoreDirectSqlUtils.extractSqlLong; + +/** + * Shared helper to diff and apply parameter table changes (delete/update/insert) in batches. + */ +class DirectSqlUpdateParams extends DirectSqlBase { + + DirectSqlUpdateParams(PersistenceManager pm, DatabaseProduct dbType, int batchSize) { + super(pm, dbType, batchSize); + } + + void run(String paramTable, String idColumn, List ids, Map>> newParamsOpt) + throws MetaException { + Map> oldParams = getParams(paramTable, idColumn, ids); + + List> toDelete = new ArrayList<>(); + List>> toUpdate = new ArrayList<>(); + List>> toInsert = new ArrayList<>(); + + for (Long id : ids) { + Map oldParam = oldParams.getOrDefault(id, new HashMap<>()); + Map newParam = newParamsOpt.get(id).orElseGet(HashMap::new); + + for (Map.Entry entry : oldParam.entrySet()) { + String key = entry.getKey(); + String oldValue = entry.getValue(); + if (!newParam.containsKey(key)) { + toDelete.add(Pair.of(id, key)); + } else if (!oldValue.equals(newParam.get(key))) { + toUpdate.add(Pair.of(id, Pair.of(key, newParam.get(key)))); + } + } + for (Map.Entry entry : newParam.entrySet()) { + if (!oldParam.containsKey(entry.getKey())) { + toInsert.add(Pair.of(id, Pair.of(entry.getKey(), entry.getValue()))); + } + } + } + + deleteParams(paramTable, idColumn, toDelete); + updateParams(paramTable, idColumn, toUpdate); + insertParams(paramTable, idColumn, toInsert); + } + + private Map> getParams(String paramTable, String idName, List ids) + throws MetaException { + Map> idToParams = new HashMap<>(); + Batchable.runBatched(maxBatchSize, ids, new Batchable<>() { + @Override + public List run(List input) throws MetaException { + String idList = MetaStoreDirectSql.getIdListForIn(input); + String queryText = "select " + idName + ", \"PARAM_KEY\", \"PARAM_VALUE\" from " + paramTable + + " where " + idName + " in (" + idList + ")"; + try (QueryWrapper query = new QueryWrapper(pm.newQuery("javax.jdo.query.SQL", queryText))) { + List sqlResult = executeWithArray(query.getInnerQuery(), null, queryText); + for (Object[] row : sqlResult) { + Long id = extractSqlLong(row[0]); + String paramKey = extractSqlClob(row[1]); + String paramVal = extractSqlClob(row[2]); + idToParams.computeIfAbsent(id, key -> new HashMap<>()).put(paramKey, paramVal); + } + } + return null; + } + }); + return idToParams; + } + + private void deleteParams(String paramTable, String idColumn, List> deleteIdKeys) + throws MetaException { + String deleteStmt = "delete from " + paramTable + " where " + idColumn + "=? and \"PARAM_KEY\"=?"; + int maxRows = dbType.getMaxRows(maxBatchSize, 2); + updateWithStatement(statement -> Batchable.runBatched(maxRows, deleteIdKeys, + new Batchable, Void>() { + @Override + public List run(List> input) throws SQLException { + for (Pair pair : input) { + statement.setLong(1, pair.getLeft()); + statement.setString(2, pair.getRight()); + statement.addBatch(); + } + statement.executeBatch(); + return null; + } + } + ), deleteStmt); + } + + private void updateParams(String paramTable, String idColumn, + List>> updateIdAndParams) throws MetaException { + List columns = List.of("\"PARAM_VALUE\""); + List conditionKeys = Arrays.asList(idColumn, "\"PARAM_KEY\""); + String stmt = TxnUtils.createUpdatePreparedStmt(paramTable, columns, conditionKeys); + int maxRows = dbType.getMaxRows(maxBatchSize, 3); + updateWithStatement(statement -> Batchable.runBatched(maxRows, updateIdAndParams, + new Batchable<>() { + @Override + public List run(List>> input) throws SQLException { + for (Pair> pair : input) { + statement.setString(1, pair.getRight().getRight()); + statement.setLong(2, pair.getLeft()); + statement.setString(3, pair.getRight().getLeft()); + statement.addBatch(); + } + statement.executeBatch(); + return null; + } + } + ), stmt); + } + + private void insertParams(String paramTable, String idColumn, + List>> addIdAndParams) throws MetaException { + List columns = Arrays.asList(idColumn, "\"PARAM_KEY\"", "\"PARAM_VALUE\""); + String query = TxnUtils.createInsertPreparedStmt(paramTable, columns); + int maxRows = dbType.getMaxRows(maxBatchSize, 3); + updateWithStatement(statement -> Batchable.runBatched(maxRows, addIdAndParams, + new Batchable>, Void>() { + @Override + public List run(List>> input) throws SQLException { + for (Pair> pair : input) { + statement.setLong(1, pair.getLeft()); + statement.setString(2, pair.getRight().getLeft()); + statement.setString(3, pair.getRight().getRight()); + statement.addBatch(); + } + statement.executeBatch(); + return null; + } + } + ), query); + } + +} diff --git a/standalone-metastore/metastore-server/src/main/java/org/apache/hadoop/hive/metastore/DirectSqlUpdatePart.java b/standalone-metastore/metastore-server/src/main/java/org/apache/hadoop/hive/metastore/DirectSqlUpdatePart.java index 4473067ad099..a2b1bf2ebd35 100644 --- a/standalone-metastore/metastore-server/src/main/java/org/apache/hadoop/hive/metastore/DirectSqlUpdatePart.java +++ b/standalone-metastore/metastore-server/src/main/java/org/apache/hadoop/hive/metastore/DirectSqlUpdatePart.java @@ -80,34 +80,18 @@ * * This class separates out the update part from MetaStoreDirectSql class. */ -class DirectSqlUpdatePart { +class DirectSqlUpdatePart extends DirectSqlBase{ private static final Logger LOG = LoggerFactory.getLogger(DirectSqlUpdatePart.class.getName()); - private final PersistenceManager pm; private final Configuration conf; - private final DatabaseProduct dbType; - private final int maxBatchSize; private final SQLGenerator sqlGenerator; - DirectSqlUpdatePart(PersistenceManager pm, Configuration conf, - DatabaseProduct dbType, int batchSize) { - this.pm = pm; + DirectSqlUpdatePart(PersistenceManager pm, Configuration conf, DatabaseProduct dbType, int batchSize) { + super(pm, dbType, batchSize); this.conf = conf; - this.dbType = dbType; - this.maxBatchSize = batchSize; sqlGenerator = new SQLGenerator(dbType, conf); } - void closeDbConn(JDOConnection jdoConn) { - try { - if (jdoConn != null) { - jdoConn.close(); - } - } catch (Exception e) { - LOG.warn("Failed to close db connection", e); - } - } - static String quoteString(String input) { return "'" + input + "'"; } @@ -546,31 +530,10 @@ public void alterPartitions(Map, Long> partValuesToId, Map { - void accept(T t) throws SQLException, MetaException; - } - private List filterIdsByNonNullValue(List ids, Map map) { return ids.stream().filter(id -> map.get(id) != null).collect(Collectors.toList()); } - private void updateWithStatement(ThrowableConsumer consumer, String query) - throws MetaException { - JDOConnection jdoConn = pm.getDataStoreConnection(); - boolean doTrace = LOG.isDebugEnabled(); - long start = doTrace ? System.nanoTime() : 0; - try (PreparedStatement statement = - ((Connection) jdoConn.getNativeConnection()).prepareStatement(query)) { - consumer.accept(statement); - MetastoreDirectSqlUtils.timingTrace(doTrace, query, start, doTrace ? System.nanoTime() : 0); - } catch (SQLException e) { - LOG.error("Failed to execute update query: " + query, e); - throw new MetaException("Unable to execute update due to: " + e.getMessage()); - } finally { - closeDbConn(jdoConn); - } - } - private void updatePartitionsInBatch(Map, Long> partValuesToId, List newParts) throws MetaException { List columns = Arrays.asList("\"CREATE_TIME\"", "\"LAST_ACCESS_TIME\"", "\"WRITE_ID\""); @@ -620,124 +583,9 @@ public List run(List input) throws Exception { } private void updateParamTableInBatch(String paramTable, String idColumn, List ids, - Map>> newParamsOpt) throws MetaException { - Map> oldParams = getParams(paramTable, idColumn, ids); - - List> paramsToDelete = new ArrayList<>(); - List>> paramsToUpdate = new ArrayList<>(); - List>> paramsToAdd = new ArrayList<>(); - - for (Long id : ids) { - Map oldParam = oldParams.getOrDefault(id, new HashMap<>()); - Map newParam = newParamsOpt.get(id).orElseGet(HashMap::new); - for (Map.Entry entry : oldParam.entrySet()) { - String key = entry.getKey(); - String oldValue = entry.getValue(); - if (!newParam.containsKey(key)) { - paramsToDelete.add(Pair.of(id, key)); - } else if (!oldValue.equals(newParam.get(key))) { - paramsToUpdate.add(Pair.of(id, Pair.of(key, newParam.get(key)))); - } - } - List>> newlyParams = newParam.entrySet().stream() - .filter(entry -> !oldParam.containsKey(entry.getKey())) - .map(entry -> Pair.of(id, Pair.of(entry.getKey(), entry.getValue()))) - .collect(Collectors.toList()); - paramsToAdd.addAll(newlyParams); - } - - deleteParams(paramTable, idColumn, paramsToDelete); - updateParams(paramTable, idColumn, paramsToUpdate); - insertParams(paramTable, idColumn, paramsToAdd); - } - - private Map> getParams(String paramTable, String idName, - List ids) throws MetaException { - Map> idToParams = new HashMap<>(); - Batchable.runBatched(maxBatchSize, ids, new Batchable() { - @Override - public List run(List input) throws MetaException { - String idLists = MetaStoreDirectSql.getIdListForIn(input); - String queryText = "select " + idName + ", \"PARAM_KEY\", \"PARAM_VALUE\" from " + - paramTable + " where " + idName + " in (" + idLists + ")"; - try (QueryWrapper query = new QueryWrapper(pm.newQuery("javax.jdo.query.SQL", queryText))) { - List sqlResult = executeWithArray(query.getInnerQuery(), null, queryText); - for (Object[] row : sqlResult) { - Long id = extractSqlLong(row[0]); - String paramKey = extractSqlClob(row[1]); - String paramVal = extractSqlClob(row[2]); - idToParams.computeIfAbsent(id, key -> new HashMap<>()).put(paramKey, paramVal); - } - } - return null; - } - }); - return idToParams; - } - - private void deleteParams(String paramTable, String idColumn, - List> deleteIdKeys) throws MetaException { - String deleteStmt = "delete from " + paramTable + " where " + idColumn + "=? and \"PARAM_KEY\"=?"; - int maxRows = dbType.getMaxRows(maxBatchSize, 2); - updateWithStatement(statement -> Batchable.runBatched(maxRows, deleteIdKeys, - new Batchable, Void>() { - @Override - public List run(List> input) throws SQLException { - for (Pair pair : input) { - statement.setLong(1, pair.getLeft()); - statement.setString(2, pair.getRight()); - statement.addBatch(); - } - statement.executeBatch(); - return null; - } - } - ), deleteStmt); - } - - private void updateParams(String paramTable, String idColumn, - List>> updateIdAndParams) throws MetaException { - List columns = Arrays.asList("\"PARAM_VALUE\""); - List conditionKeys = Arrays.asList(idColumn, "\"PARAM_KEY\""); - String stmt = TxnUtils.createUpdatePreparedStmt(paramTable, columns, conditionKeys); - int maxRows = dbType.getMaxRows(maxBatchSize, 3); - updateWithStatement(statement -> Batchable.runBatched(maxRows, updateIdAndParams, - new Batchable>, Object>() { - @Override - public List run(List>> input) throws SQLException { - for (Pair> pair : input) { - statement.setString(1, pair.getRight().getRight()); - statement.setLong(2, pair.getLeft()); - statement.setString(3, pair.getRight().getLeft()); - statement.addBatch(); - } - statement.executeBatch(); - return null; - } - } - ), stmt); - } - - private void insertParams(String paramTable, String idColumn, - List>> addIdAndParams) throws MetaException { - List columns = Arrays.asList(idColumn, "\"PARAM_KEY\"", "\"PARAM_VALUE\""); - String query = TxnUtils.createInsertPreparedStmt(paramTable, columns); - int maxRows = dbType.getMaxRows(maxBatchSize, 3); - updateWithStatement(statement -> Batchable.runBatched(maxRows, addIdAndParams, - new Batchable>, Void>() { - @Override - public List run(List>> input) throws SQLException { - for (Pair> pair : input) { - statement.setLong(1, pair.getLeft()); - statement.setString(2, pair.getRight().getLeft()); - statement.setString(3, pair.getRight().getRight()); - statement.addBatch(); - } - statement.executeBatch(); - return null; - } - } - ), query); + Map>> newParamsOpt) throws MetaException { + new DirectSqlUpdateParams(pm, dbType, maxBatchSize) + .run(paramTable, idColumn, ids, newParamsOpt); } private void updateStorageDescriptorInBatch(Map idToSd) diff --git a/standalone-metastore/metastore-server/src/main/java/org/apache/hadoop/hive/metastore/HMSHandler.java b/standalone-metastore/metastore-server/src/main/java/org/apache/hadoop/hive/metastore/HMSHandler.java index 6065574d9690..048285eba888 100644 --- a/standalone-metastore/metastore-server/src/main/java/org/apache/hadoop/hive/metastore/HMSHandler.java +++ b/standalone-metastore/metastore-server/src/main/java/org/apache/hadoop/hive/metastore/HMSHandler.java @@ -6717,6 +6717,11 @@ public void commit_txn(CommitTxnRequest rqst) throws TException { } } + @Override + public void update_table_params(List updates) throws TException { + getMS().updateTableParams(updates); + } + @Override public void repl_tbl_writeid_state(ReplTblWriteIdStateRequest rqst) throws TException { getTxnHandler().replTableWriteIdState(rqst); diff --git a/standalone-metastore/metastore-server/src/main/java/org/apache/hadoop/hive/metastore/MetaStoreDirectSql.java b/standalone-metastore/metastore-server/src/main/java/org/apache/hadoop/hive/metastore/MetaStoreDirectSql.java index 49d187505dc3..403355100c26 100644 --- a/standalone-metastore/metastore-server/src/main/java/org/apache/hadoop/hive/metastore/MetaStoreDirectSql.java +++ b/standalone-metastore/metastore-server/src/main/java/org/apache/hadoop/hive/metastore/MetaStoreDirectSql.java @@ -46,6 +46,7 @@ import java.util.LinkedList; import java.util.List; import java.util.Map; +import java.util.Optional; import java.util.Set; import java.util.TreeMap; import java.util.concurrent.atomic.AtomicLong; @@ -90,6 +91,7 @@ import org.apache.hadoop.hive.metastore.api.SkewedInfo; import org.apache.hadoop.hive.metastore.api.StorageDescriptor; import org.apache.hadoop.hive.metastore.api.Table; +import org.apache.hadoop.hive.metastore.api.TableParamsUpdate; import org.apache.hadoop.hive.metastore.client.builder.GetPartitionsArgs; import org.apache.hadoop.hive.metastore.conf.MetastoreConf; import org.apache.hadoop.hive.metastore.conf.MetastoreConf.ConfVars; @@ -2880,4 +2882,59 @@ long updateTableParam(Table table, String key, String expectedValue, String newV Query query = pm.newQuery("javax.jdo.query.SQL", statement); return (long) query.executeWithArray(newValue, table.getId(), key, expectedValue); } + + /** + * Update parameters for multiple tables. For each table: + * - enforce CAS on the provided expected key/value (default metadata_location) + * - diff desired params vs current and delete/update/insert accordingly + * Table resolution happens per update via the provided resolver. + */ + public void updateTableParams(List updates, TableResolver resolver) + throws MetaException { + if (!pm.currentTransaction().isActive()) { + throw new MetaException("Direct SQL batch update requires an active transaction"); + } + if (updates == null || updates.isEmpty()) { + return; + } + + List tableIds = new ArrayList<>(updates.size()); + Map>> tableParamsOpt = new HashMap<>(); + + for (TableParamsUpdate item : updates) { + String dbName = item.getDb_name(); + String tableName = item.getTable_name(); + Table tbl = resolver.resolve(item.getCat_name(), dbName, tableName); + + Map newParams = item.getParams(); + if (newParams == null || newParams.isEmpty()) { + continue; + } + + String expectedKey = item.getExpected_param_key(); + String expectedVal = item.getExpected_param_value(); + + if (expectedKey != null) { + if (!newParams.containsKey(expectedKey)) { + throw new MetaException("Expected key must be present in params for " + + dbName + "." + tableName); + } + long affected = updateTableParam(tbl, expectedKey, expectedVal, newParams.get(expectedKey)); + if (affected != 1) { + throw new MetaException("The table has been modified. The parameter value for key '" + + expectedKey + "' is different"); + } + } + tableIds.add(tbl.getId()); + tableParamsOpt.put(tbl.getId(), Optional.of(newParams)); + } + + new DirectSqlUpdateParams(pm, dbType, batchSize) + .run("\"TABLE_PARAMS\"", "\"TBL_ID\"", tableIds, tableParamsOpt); + } + + @FunctionalInterface + public interface TableResolver { + Table resolve(String catName, String dbName, String tableName) throws MetaException; + } } diff --git a/standalone-metastore/metastore-server/src/main/java/org/apache/hadoop/hive/metastore/ObjectStore.java b/standalone-metastore/metastore-server/src/main/java/org/apache/hadoop/hive/metastore/ObjectStore.java index 8a2c94a6443d..340c5c35b13e 100644 --- a/standalone-metastore/metastore-server/src/main/java/org/apache/hadoop/hive/metastore/ObjectStore.java +++ b/standalone-metastore/metastore-server/src/main/java/org/apache/hadoop/hive/metastore/ObjectStore.java @@ -75,6 +75,7 @@ import org.apache.commons.collections4.CollectionUtils; import org.apache.commons.lang3.ArrayUtils; +import org.apache.commons.lang3.ObjectUtils; import org.apache.commons.lang3.StringUtils; import org.apache.commons.lang3.exception.ExceptionUtils; import org.apache.commons.lang3.tuple.Pair; @@ -178,6 +179,7 @@ import org.apache.hadoop.hive.metastore.api.StoredProcedure; import org.apache.hadoop.hive.metastore.api.Table; import org.apache.hadoop.hive.metastore.api.TableMeta; +import org.apache.hadoop.hive.metastore.api.TableParamsUpdate; import org.apache.hadoop.hive.metastore.api.Type; import org.apache.hadoop.hive.metastore.api.UniqueConstraintsRequest; import org.apache.hadoop.hive.metastore.api.UnknownDBException; @@ -575,6 +577,33 @@ protected Long getJdoResult(GetHelper ctx) throws MetaException, NoSuchObj }.run(false); } + @Override + public void updateTableParams(List updates) throws MetaException, NoSuchObjectException { + if (updates == null || updates.isEmpty()) { + return; + } + + new GetListHelper(null, null, null, true, false) { + @Override + protected List getSqlResult(GetHelper> ctx) throws MetaException { + boolean success = false; + try { + openTransaction(); + directSql.updateTableParams(updates, ObjectStore.this::getTable); + success = commitTransaction(); + } finally { + rollbackAndCleanup(success, null); + } + return null; + } + + @Override + protected List getJdoResult(GetHelper> ctx) { + throw new UnsupportedOperationException("UnsupportedOperationException"); + } + }.run(false); + } + /** * if this is the commit of the first open call then an actual commit is * called. @@ -1608,10 +1637,13 @@ private List listAllTableConstraintsWithOptionalConstraintName( } @Override - public Table - getTable(String catName, String dbName, String tableName) + public Table getTable(String catName, String dbName, String tableName) throws MetaException { - return getTable(catName, dbName, tableName, null); + return getTable( + ObjectUtils.defaultIfNull(catName, getDefaultCatalog(conf)), + dbName, tableName, + null + ); } @Override diff --git a/standalone-metastore/metastore-server/src/main/java/org/apache/hadoop/hive/metastore/RawStore.java b/standalone-metastore/metastore-server/src/main/java/org/apache/hadoop/hive/metastore/RawStore.java index e75ca54ceeb7..9ac7f921e077 100644 --- a/standalone-metastore/metastore-server/src/main/java/org/apache/hadoop/hive/metastore/RawStore.java +++ b/standalone-metastore/metastore-server/src/main/java/org/apache/hadoop/hive/metastore/RawStore.java @@ -105,6 +105,7 @@ import org.apache.hadoop.hive.metastore.api.UnknownDBException; import org.apache.hadoop.hive.metastore.api.UnknownPartitionException; import org.apache.hadoop.hive.metastore.api.UnknownTableException; +import org.apache.hadoop.hive.metastore.api.TableParamsUpdate; import org.apache.hadoop.hive.metastore.api.WMFullResourcePlan; import org.apache.hadoop.hive.metastore.api.WMMapping; import org.apache.hadoop.hive.metastore.api.WMNullablePool; @@ -591,6 +592,13 @@ List getTableMeta(String catName, String dbNames, String tableNames, List
getTableObjectsByName(String catName, String dbname, List tableNames) throws MetaException, UnknownDBException; + /** + * Multi-table table-parameter update. + * @param updates updates to apply. + */ + void updateTableParams(List updates) throws MetaException, NoSuchObjectException; + + /** * @param catName catalog name * @param dbname diff --git a/standalone-metastore/metastore-server/src/main/java/org/apache/hadoop/hive/metastore/cache/CachedStore.java b/standalone-metastore/metastore-server/src/main/java/org/apache/hadoop/hive/metastore/cache/CachedStore.java index 49baf6d1fb9d..ea3523051fab 100644 --- a/standalone-metastore/metastore-server/src/main/java/org/apache/hadoop/hive/metastore/cache/CachedStore.java +++ b/standalone-metastore/metastore-server/src/main/java/org/apache/hadoop/hive/metastore/cache/CachedStore.java @@ -1531,6 +1531,10 @@ public Table getTable(String catName, String dbName, String tblName, String vali return newTable; } + @Override public void updateTableParams(List updates) throws MetaException, NoSuchObjectException { + rawStore.updateTableParams(updates); + } + @Override public void updateCreationMetadata(String catName, String dbname, String tablename, CreationMetadata cm) throws MetaException { rawStore.updateCreationMetadata(catName, dbname, tablename, cm); From f0d11a281a1b26cd988d544335216741f92615f4 Mon Sep 17 00:00:00 2001 From: Denys Kuzmenko Date: Fri, 13 Feb 2026 20:50:31 +0200 Subject: [PATCH 2/4] phase2: added retry --- .../org/apache/iceberg/HiveTransaction.java | 97 +++++ .../iceberg/hive/HiveTxnCoordinator.java | 245 +++++++++---- .../iceberg/hive/StagingTableOperations.java | 25 +- .../mr/hive/HiveIcebergOutputCommitter.java | 51 ++- .../mr/hive/HiveIcebergStorageHandler.java | 2 +- .../iceberg/mr/hive/IcebergAcidUtil.java | 8 + .../iceberg/mr/hive/IcebergTableUtil.java | 2 +- ...veIcebergStorageHandlerWithEngineBase.java | 99 +++-- .../mr/hive/TestConflictingDataFiles.java | 95 ++--- .../hive/TestHiveIcebergOutputCommitter.java | 2 +- .../iceberg/mr/hive/TestOptimisticRetry.java | 61 ++-- .../mr/hive/TestXAConflictingDataFiles.java | 341 ++++++++++++++++++ .../HiveIcebergStorageHandlerStub.java | 91 +---- .../concurrent/PhaserCommitDecorator.java | 131 +++++++ .../XAHiveIcebergStorageHandlerStub.java | 40 ++ .../concurrent/XAHiveTxnCoordinatorStub.java | 37 ++ .../org/apache/hadoop/hive/ql/Driver.java | 6 +- .../apache/hadoop/hive/ql/DriverContext.java | 4 + .../hadoop/hive/ql/DriverTxnHandler.java | 67 ++-- .../hive/ql/lockmgr/AcidTxnCoordinator.java | 28 +- .../hadoop/hive/ql/lockmgr/DbTxnManager.java | 57 +-- .../hive/ql/session/SessionStateUtil.java | 10 + 22 files changed, 1123 insertions(+), 376 deletions(-) create mode 100644 iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/TestXAConflictingDataFiles.java create mode 100644 iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/test/concurrent/PhaserCommitDecorator.java create mode 100644 iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/test/concurrent/XAHiveIcebergStorageHandlerStub.java create mode 100644 iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/test/concurrent/XAHiveTxnCoordinatorStub.java diff --git a/iceberg/iceberg-catalog/src/main/java/org/apache/iceberg/HiveTransaction.java b/iceberg/iceberg-catalog/src/main/java/org/apache/iceberg/HiveTransaction.java index 21a918d35ce9..bf8041120b5a 100644 --- a/iceberg/iceberg-catalog/src/main/java/org/apache/iceberg/HiveTransaction.java +++ b/iceberg/iceberg-catalog/src/main/java/org/apache/iceberg/HiveTransaction.java @@ -19,8 +19,15 @@ package org.apache.iceberg; +import java.util.Set; +import java.util.stream.Collectors; import org.apache.iceberg.hive.HiveTableOperations; import org.apache.iceberg.hive.StagingTableOperations; +import org.apache.iceberg.io.FileIO; +import org.apache.iceberg.relocated.com.google.common.collect.Sets; +import org.apache.iceberg.util.Tasks; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; /** * Transaction implementation that stages metadata changes for atomic batch HMS updates across @@ -31,6 +38,8 @@ */ public class HiveTransaction extends BaseTransaction { + private static final Logger LOG = LoggerFactory.getLogger(HiveTransaction.class); + private final HiveTableOperations hiveOps; private final StagingTableOperations stagingOps; @@ -51,4 +60,92 @@ public HiveTableOperations ops() { public StagingTableOperations stagingOps() { return stagingOps; } + + /** + * Cleans up all artifacts produced by the staged commit: new manifests, manifest lists, + * the metadata JSON file, and uncommitted files. + * + *

Called by the coordinator when the batch HMS update fails after staging succeeded. + */ + public void cleanUpOnCommitFailure() { + // clean up manifests and manifest lists from new snapshots + cleanAllUpdates(); + + // delete the staged metadata JSON file + deleteMetadataFile(); + + // delete uncommitted files tracked by the base transaction + deleteUncommittedFiles(); + } + + /** + * Deletes manifest files and manifest lists produced by new snapshots in this transaction. + * Uses metadata diff (current vs start) to identify new snapshots and their artifacts. + */ + private void cleanAllUpdates() { + FileIO io = stagingOps.io(); + + // Collect all manifest paths from the base metadata — these must NOT be deleted + Set baseManifestPaths = Sets.newHashSet(); + for (Snapshot snapshot : startMetadata().snapshots()) { + try { + snapshot.allManifests(io).forEach(m -> baseManifestPaths.add(m.path())); + } catch (RuntimeException e) { + LOG.warn("Failed to read base manifests for cleanup", e); + } + } + + // Find new snapshots added by this transaction and clean their artifacts + Set baseSnapshotIds = startMetadata().snapshots().stream() + .map(Snapshot::snapshotId) + .collect(Collectors.toSet()); + + for (Snapshot snapshot : currentMetadata().snapshots()) { + if (baseSnapshotIds.contains(snapshot.snapshotId())) { + continue; + } + + // Delete new manifest files (not from base) + try { + for (ManifestFile manifest : snapshot.allManifests(io)) { + if (!baseManifestPaths.contains(manifest.path())) { + io.deleteFile(manifest.path()); + } + } + } catch (RuntimeException e) { + LOG.warn("Failed to clean manifests for snapshot {}", snapshot.snapshotId(), e); + } + + // Delete the manifest list + try { + io.deleteFile(snapshot.manifestListLocation()); + } catch (RuntimeException e) { + LOG.warn("Failed to clean manifest list {}", snapshot.manifestListLocation(), e); + } + } + } + + /** + * Deletes the staged metadata JSON file written by StagingTableOperations.doCommit(). + */ + private void deleteMetadataFile() { + String metadataLocation = stagingOps.metadataLocation(); + if (metadataLocation != null) { + try { + stagingOps.io().deleteFile(metadataLocation); + } catch (RuntimeException e) { + LOG.warn("Failed to clean metadata file {}", metadataLocation, e); + } + } + } + + /** + * Deletes uncommitted files tracked during the transaction (e.g. replaced data files). + */ + private void deleteUncommittedFiles() { + Tasks.foreach(deletedFiles()) + .suppressFailureWhenFinished() + .onFailure((file, exc) -> LOG.warn("Failed to delete uncommitted file: {}", file, exc)) + .run(stagingOps.io()::deleteFile); + } } diff --git a/iceberg/iceberg-catalog/src/main/java/org/apache/iceberg/hive/HiveTxnCoordinator.java b/iceberg/iceberg-catalog/src/main/java/org/apache/iceberg/hive/HiveTxnCoordinator.java index 360043c899d1..423e5b483d6d 100644 --- a/iceberg/iceberg-catalog/src/main/java/org/apache/iceberg/hive/HiveTxnCoordinator.java +++ b/iceberg/iceberg-catalog/src/main/java/org/apache/iceberg/hive/HiveTxnCoordinator.java @@ -21,43 +21,57 @@ import java.util.List; import java.util.Map; +import java.util.Objects; import java.util.Set; import java.util.stream.Collectors; +import java.util.stream.Stream; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hive.TxnCoordinator; +import org.apache.hadoop.hive.common.StatsSetupConst; import org.apache.hadoop.hive.metastore.IMetaStoreClient; +import org.apache.hadoop.hive.metastore.api.ColumnStatisticsObj; import org.apache.hadoop.hive.metastore.api.Table; import org.apache.hadoop.hive.metastore.api.TableParamsUpdate; -import org.apache.iceberg.BaseMetastoreOperations; +import org.apache.hadoop.hive.metastore.utils.MetaStoreUtils; import org.apache.iceberg.BaseTable; +import org.apache.iceberg.BlobMetadata; import org.apache.iceberg.HiveTransaction; import org.apache.iceberg.TableMetadata; import org.apache.iceberg.Transaction; +import org.apache.iceberg.exceptions.CleanableFailure; +import org.apache.iceberg.exceptions.CommitFailedException; +import org.apache.iceberg.exceptions.CommitStateUnknownException; +import org.apache.iceberg.exceptions.ValidationException; import org.apache.iceberg.relocated.com.google.common.collect.Lists; import org.apache.iceberg.relocated.com.google.common.collect.Maps; +import org.apache.iceberg.util.Tasks; import org.apache.thrift.TException; +import static org.apache.iceberg.TableProperties.COMMIT_MAX_RETRY_WAIT_MS; +import static org.apache.iceberg.TableProperties.COMMIT_MAX_RETRY_WAIT_MS_DEFAULT; +import static org.apache.iceberg.TableProperties.COMMIT_MIN_RETRY_WAIT_MS; +import static org.apache.iceberg.TableProperties.COMMIT_MIN_RETRY_WAIT_MS_DEFAULT; +import static org.apache.iceberg.TableProperties.COMMIT_NUM_RETRIES; +import static org.apache.iceberg.TableProperties.COMMIT_NUM_RETRIES_DEFAULT; +import static org.apache.iceberg.TableProperties.COMMIT_TOTAL_RETRY_TIME_MS; +import static org.apache.iceberg.TableProperties.COMMIT_TOTAL_RETRY_TIME_MS_DEFAULT; + /** * Transaction coordinator that aggregates Iceberg table commits and performs atomic HMS updates * across multiple tables using {@code updateTableParams}. */ -public final class HiveTxnCoordinator implements TxnCoordinator { +public class HiveTxnCoordinator implements TxnCoordinator { private final Configuration conf; private final IMetaStoreClient msClient; - private final Map stagedCommits = Maps.newConcurrentMap(); + private final Map stagedUpdates = Maps.newConcurrentMap(); public HiveTxnCoordinator(Configuration conf, IMetaStoreClient msClient) { this.conf = conf; this.msClient = msClient; } - @Override - public boolean hasPendingWork() { - return !stagedCommits.isEmpty(); - } - public Transaction getOrCreateTransaction(org.apache.iceberg.Table table) { Transaction txn = getTransaction(table); if (txn != null) { @@ -67,25 +81,52 @@ public Transaction getOrCreateTransaction(org.apache.iceberg.Table table) { baseTable.operations() instanceof HiveTableOperations ops)) { return table.newTransaction(); } - return stagedCommits.computeIfAbsent( + return stagedUpdates.computeIfAbsent( table.name(), ignored -> new HiveTransaction(table, ops)); } public Transaction getTransaction(org.apache.iceberg.Table table) { - return stagedCommits.get(table.name()); + return stagedUpdates.get(table.name()); } @Override public synchronized void commit() throws TException { - if (stagedCommits.isEmpty()) { + if (stagedUpdates.isEmpty()) { return; } - // Sort commits by table name for deterministic ordering - List> updates = Lists.newArrayList(stagedCommits.entrySet()); + List> updates = Lists.newArrayList(stagedUpdates.entrySet()); updates.sort(Map.Entry.comparingByKey()); - attemptCommit(updates); + TableMetadata base = updates.getFirst().getValue() + .startMetadata(); + + try { + Tasks.foreach(1) + .retry(base.propertyAsInt(COMMIT_NUM_RETRIES, COMMIT_NUM_RETRIES_DEFAULT)) + .exponentialBackoff( + base.propertyAsInt(COMMIT_MIN_RETRY_WAIT_MS, COMMIT_MIN_RETRY_WAIT_MS_DEFAULT), + base.propertyAsInt(COMMIT_MAX_RETRY_WAIT_MS, COMMIT_MAX_RETRY_WAIT_MS_DEFAULT), + base.propertyAsInt(COMMIT_TOTAL_RETRY_TIME_MS, COMMIT_TOTAL_RETRY_TIME_MS_DEFAULT), + 2.0 /* exponential */) + .onlyRetryOn(CommitFailedException.class) + .run(i -> doCommit(updates)); + + } catch (CommitStateUnknownException e) { + throw MetaStoreUtils.newMetaException(e); + + } catch (ValidationException | CommitFailedException e) { + // All retries exhausted — clean up manifests, metadata files, and uncommitted files + cleanUpOnCommitFailure(e); + throw MetaStoreUtils.newMetaException(e); + + } catch (RuntimeException e) { + cleanUpOnCommitFailure(e); + throw e; + + } finally { + clearState(); + } } @Override @@ -93,8 +134,88 @@ public synchronized void rollback() { clearState(); } - private void clearState() { - stagedCommits.clear(); + @Override + public boolean hasPendingWork() { + return !stagedUpdates.isEmpty(); + } + + private void doCommit(List> updates) { + List payload = Lists.newArrayList(); + List locks = Lists.newArrayList(); + + try { + for (Map.Entry entry : updates) { + HiveTransaction hiveTxn = entry.getValue(); + + // 1. WRITE: stage transaction (writes metadata file only) + hiveTxn.commitTransaction(); + + TableMetadata base = hiveTxn.startMetadata(); + HiveTableOperations ops = hiveTxn.ops(); + + // 2. LOCK + HiveLock lock = ops.lockObject(base); + lock.lock(); + locks.add(lock); + + // 3. VERIFY under lock: refresh from HMS via original ops + TableMetadata current = ops.refresh(); + + if (!Objects.equals(base.metadataFileLocation(), current.metadataFileLocation())) { + throw new CommitFailedException( + "Base metadata location '%s' is not same as the current table metadata location '%s' for %s", + base.metadataFileLocation(), current.metadataFileLocation(), entry.getKey()); + } + + // 4. Build payload using staged metadata + TableParamsUpdate paramsUpdate = buildTableParamsUpdate( + base, hiveTxn.currentMetadata(), ops, hiveTxn.stagingOps().metadataLocation()); + payload.add(paramsUpdate); + } + + // 5. PERSIST: batch commit (CAS guaranteed to pass — verified under lock) + locks.forEach(HiveLock::ensureActive); + msClient.updateTableParams(payload); + + // Verify locks still active after persist — if lost, commit state is unknown + try { + locks.forEach(HiveLock::ensureActive); + } catch (LockException le) { + throw new CommitStateUnknownException( + "Failed to heartbeat for hive lock while committing changes. " + + "This can lead to a concurrent commit attempt be able to overwrite this commit. " + + "Please check the commit history. If you are running into this issue, try reducing " + + "iceberg.hive.lock-heartbeat-interval-ms.", + le); + } + + releaseLocks(locks); + + } catch (CommitStateUnknownException e) { + // Commit may have succeeded — do NOT clean up metadata/manifests, only release locks + releaseLocks(locks); + throw e; + + } catch (LockException e) { + // Lock acquisition or pre-persist ensureActive failed — safe to retry + releaseLocks(locks); + throw new CommitFailedException(e); + + } catch (TException e) { + if (isCasFailure(e)) { + releaseLocks(locks); + throw new CommitFailedException(e, + "The table %s.%s has been modified concurrently", + payload.getLast().getDb_name(), payload.getLast().getTable_name()); + } + // Non-CAS TException from updateTableParams — we can't tell if the batch update was applied + releaseLocks(locks); + throw new CommitStateUnknownException(e); + + } catch (RuntimeException e) { + releaseLocks(locks); + throw e; + } } private TableParamsUpdate buildTableParamsUpdate( @@ -120,6 +241,11 @@ private TableParamsUpdate buildTableParamsUpdate( maxPropSize, base.metadataFileLocation()); + List colNames = getStatsColumnNames(newMetadata); + if (!colNames.isEmpty()) { + StatsSetupConst.setColumnStatsState(tbl.getParameters(), colNames); + } + TableParamsUpdate newParams = new TableParamsUpdate(); newParams.setDb_name(ops.database()); newParams.setTable_name(ops.table()); @@ -132,70 +258,49 @@ private TableParamsUpdate buildTableParamsUpdate( return newParams; } - private void attemptCommit(List> updates) throws TException { - List payload = Lists.newArrayList(); - List txns = Lists.newArrayList(); - List locks = Lists.newArrayList(); - - try { - for (Map.Entry entry : updates) { - HiveTransaction hiveTxn = entry.getValue(); - - // Stage the transaction and track it for potential reset on retry - hiveTxn.commitTransaction(); - txns.add(hiveTxn); - - TableMetadata base = hiveTxn.startMetadata(); - TableMetadata newMetadata = hiveTxn.currentMetadata(); - HiveTableOperations ops = hiveTxn.ops(); - - String newMetadataFileLocation = hiveTxn.stagingOps().metadataLocation(); - - // Acquire lock - if this fails, txn is already in list for cleanup - HiveLock lock = ops.lockObject(base); - lock.lock(); - locks.add(lock); - - // Build and add the HMS update payload - TableParamsUpdate paramsUpdate = buildTableParamsUpdate(base, newMetadata, ops, newMetadataFileLocation); - payload.add(paramsUpdate); - } - - // Ensure all locks are active - locks.forEach(HiveLock::ensureActive); - - msClient.updateTableParams(payload); + private static List getStatsColumnNames(TableMetadata metadata) { + Stream colStatsBlobs = metadata.statisticsFiles().stream() + .flatMap(sf -> sf.blobMetadata().stream()) + .filter(blob -> ColumnStatisticsObj.class.getSimpleName().equals(blob.type())); + + if (metadata.spec().isUnpartitioned()) { + // For unpartitioned tables: each blob is a column + return colStatsBlobs + .flatMap(blob -> blob.fields().stream()) + .map(fieldId -> metadata.schema().findColumnName(fieldId)) + .toList(); + } - // Success - release locks and clear state - releaseLocks(locks); - clearState(); + // For partitioned tables: each blob is a partition containing all columns, + // take the first blob and fetch all columns from its fields list + return colStatsBlobs.findFirst() + .map(blob -> blob.fields().stream() + .map(fieldId -> metadata.schema().findColumnName(fieldId)) + .toList()) + .orElse(List.of()); + } - } catch (Exception e) { - cleanupFailedCommit(txns, locks); - throw e; - } + private static boolean isCasFailure(TException ex) { + return ex.getMessage() != null && + ex.getMessage().contains("The table has been modified. The parameter value for key '" + + HiveTableOperations.METADATA_LOCATION_PROP + + "' is"); } - private void cleanupFailedCommit(List txns, List locks) { - cleanupMetadata(txns); - releaseLocks(locks); - clearState(); + private void releaseLocks(List locks) { + locks.forEach(HiveLock::unlock); } - private void cleanupMetadata(List txns) { - txns.forEach(txn -> { - String metadataLocation = txn.stagingOps().metadataLocation(); - if (metadataLocation != null) { - HiveOperationsBase.cleanupMetadata( - txn.ops().io(), - BaseMetastoreOperations.CommitStatus.FAILURE.name(), - metadataLocation); + private void cleanUpOnCommitFailure(Exception ex) { + stagedUpdates.values().forEach(txn -> { + if (!txn.ops().requireStrictCleanup() || ex instanceof CleanableFailure) { + txn.cleanUpOnCommitFailure(); } }); } - private void releaseLocks(List locks) { - locks.forEach(HiveLock::unlock); + private void clearState() { + stagedUpdates.clear(); } } diff --git a/iceberg/iceberg-catalog/src/main/java/org/apache/iceberg/hive/StagingTableOperations.java b/iceberg/iceberg-catalog/src/main/java/org/apache/iceberg/hive/StagingTableOperations.java index beee3df417a1..c61bde44d654 100644 --- a/iceberg/iceberg-catalog/src/main/java/org/apache/iceberg/hive/StagingTableOperations.java +++ b/iceberg/iceberg-catalog/src/main/java/org/apache/iceberg/hive/StagingTableOperations.java @@ -21,18 +21,14 @@ import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hive.metastore.IMetaStoreClient; -import org.apache.hadoop.hive.metastore.api.Table; import org.apache.iceberg.ClientPool; import org.apache.iceberg.TableMetadata; import org.apache.iceberg.io.FileIO; import org.apache.thrift.TException; /** - * TableOperations that skips HMS updates and locking during staging. - * Extends HiveTableOperations and overrides: - * 1. lockObject() to return NoLock (coordinator handles locking) - * 2. persistTable() to be no-op (coordinator handles HMS batch update) - * 3. Captures the staged metadata location for cleanup + * TableOperations that only writes metadata files during commit. + * Skips HMS reads, locking, and persistence — all handled by the coordinator. */ public class StagingTableOperations extends HiveTableOperations { @@ -49,21 +45,8 @@ public StagingTableOperations( } @Override - protected String writeNewMetadataIfRequired(boolean newTable, TableMetadata metadata) { - String location = super.writeNewMetadataIfRequired(newTable, metadata); - this.newMetadataLocation = location; - return location; - } - - @Override - HiveLock lockObject(TableMetadata metadata) { - // No lock needed during staging - coordinator will acquire locks before HMS batch update - return new NoLock(); - } - - @Override - public void persistTable(Table hmsTable, boolean updateHiveTable, String metadataLocation) { - // No-op - skip HMS update, metadata files already written by doCommit() + protected void doCommit(TableMetadata base, TableMetadata metadata) { + newMetadataLocation = writeNewMetadataIfRequired(base == null, metadata); } public String metadataLocation() { diff --git a/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/HiveIcebergOutputCommitter.java b/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/HiveIcebergOutputCommitter.java index 549bdc1b4152..d7929c3850ca 100644 --- a/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/HiveIcebergOutputCommitter.java +++ b/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/HiveIcebergOutputCommitter.java @@ -41,7 +41,6 @@ import org.apache.hadoop.fs.FileStatus; import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.fs.Path; -import org.apache.hadoop.hive.conf.HiveConf; import org.apache.hadoop.hive.conf.HiveConf.ConfVars; import org.apache.hadoop.hive.ql.Context.Operation; import org.apache.hadoop.hive.ql.Context.RewritePolicy; @@ -109,15 +108,7 @@ public class HiveIcebergOutputCommitter extends OutputCommitter { private static final String CONFLICT_DETECTION_FILTER = "Conflict detection Filter Expression: {}"; private ExecutorService workerPool; - private final Configuration conf; - - public HiveIcebergOutputCommitter() { - this(new HiveConf()); - } - - public HiveIcebergOutputCommitter(Configuration conf) { - this.conf = conf; - } + private JobConf jobConf; @Override public void setupJob(JobContext jobContext) { @@ -146,8 +137,8 @@ public void commitTask(TaskAttemptContext originalContext) throws IOException { TaskAttemptContext context = TezUtil.enrichContextWithAttemptWrapper(originalContext); TaskAttemptID attemptID = context.getTaskAttemptID(); - JobConf jobConf = context.getJobConf(); - Set mergedPaths = getCombinedLocations(jobConf); + JobConf conf = context.getJobConf(); + Set mergedPaths = getCombinedLocations(conf); Set outputs = outputTables(context.getJobConf()); Map> writers = Optional.ofNullable(WriterRegistry.writers(attemptID)) @@ -156,7 +147,7 @@ public void commitTask(TaskAttemptContext originalContext) throws IOException { return ImmutableMap.of(); }); - ExecutorService tableExecutor = tableExecutor(jobConf, outputs.size()); + ExecutorService tableExecutor = tableExecutor(conf, outputs.size()); try { // Generates commit files for the target tables in parallel Tasks.foreach(outputs) @@ -167,7 +158,7 @@ public void commitTask(TaskAttemptContext originalContext) throws IOException { .run(output -> { Table table = HiveTableUtil.deserializeTable(context.getJobConf(), output); if (table != null) { - String fileForCommitLocation = HiveTableUtil.fileForCommitLocation(table.location(), jobConf, + String fileForCommitLocation = HiveTableUtil.fileForCommitLocation(table.location(), conf, attemptID.getJobID(), attemptID.getTaskID().getId()); if (writers.get(output) != null) { List dataFiles = Lists.newArrayList(); @@ -277,7 +268,7 @@ public void commitJobs(List originalContextList, Operation operation .map(TezUtil::enrichContextWithVertexId) .collect(Collectors.toList()); Multimap outputs = collectOutputs(jobContextList); - JobConf jobConf = jobContextList.getFirst().getJobConf(); + jobConf = jobContextList.getFirst().getJobConf(); long startTime = System.currentTimeMillis(); String ids = jobContextList.stream() @@ -348,7 +339,7 @@ public void abortJobs(List originalContextList) throws IOException { .map(TezUtil::enrichContextWithVertexId) .collect(Collectors.toList()); Multimap outputs = collectOutputs(jobContextList); - JobConf jobConf = jobContextList.getFirst().getJobConf(); + jobConf = jobContextList.getFirst().getJobConf(); String ids = jobContextList.stream() .map(jobContext -> jobContext.getJobID().toString()).collect(Collectors.joining(",")); @@ -447,22 +438,22 @@ private void commitTable(FileIO io, ExecutorService executor, OutputTable output Expression filterExpr = null; for (JobContext jobContext : jobContexts) { - JobConf jobConf = jobContext.getJobConf(); + JobConf conf = jobContext.getJobConf(); - table = Optional.ofNullable(table).orElseGet(() -> Catalogs.loadTable(jobConf, catalogProperties)); - branchName = jobConf.get(InputFormatConfig.OUTPUT_TABLE_SNAPSHOT_REF); + table = Optional.ofNullable(table).orElseGet(() -> Catalogs.loadTable(conf, catalogProperties)); + branchName = conf.get(InputFormatConfig.OUTPUT_TABLE_SNAPSHOT_REF); snapshotId = getSnapshotId(outputTable.table, branchName); if (filterExpr == null) { - filterExpr = SessionStateUtil.getConflictDetectionFilter(jobConf, catalogProperties.get(Catalogs.NAME)) - .map(expr -> HiveIcebergInputFormat.getFilterExpr(jobConf, expr)) + filterExpr = SessionStateUtil.getConflictDetectionFilter(conf, catalogProperties.get(Catalogs.NAME)) + .map(expr -> HiveIcebergInputFormat.getFilterExpr(conf, expr)) .orElse(null); } LOG.info("Committing job has started for table: {}, using location: {}", - table, HiveTableUtil.jobLocation(outputTable.table.location(), jobConf, jobContext.getJobID())); + table, HiveTableUtil.jobLocation(outputTable.table.location(), conf, jobContext.getJobID())); - int numTasks = SessionStateUtil.getCommitInfo(jobConf, name) + int numTasks = SessionStateUtil.getCommitInfo(conf, name) .map(info -> info.get(jobContext.getJobID().toString())) .map(SessionStateUtil.CommitInfo::getTaskNum).orElseGet(() -> { // Fallback logic, if number of tasks are not available in the config @@ -470,7 +461,7 @@ private void commitTable(FileIO io, ExecutorService executor, OutputTable output // If this is a map only task, then every mapper will generate a result file. LOG.info("Number of tasks not available in session state for jobID: {}, table: {}. " + "Falling back to jobConf numReduceTasks/numMapTasks", jobContext.getJobID(), name); - return jobConf.getNumReduceTasks() > 0 ? jobConf.getNumReduceTasks() : jobConf.getNumMapTasks(); + return conf.getNumReduceTasks() > 0 ? conf.getNumReduceTasks() : conf.getNumMapTasks(); }); FilesForCommit writeResults = collectResults( @@ -543,7 +534,7 @@ private Long getSnapshotId(Table table, String branchName) { private void commitWrite(Table table, String branchName, Long snapshotId, long startTime, FilesForCommit results, Operation operation, Expression filterExpr) { - Transaction txn = IcebergAcidUtil.getOrCreateTransaction(table, conf); + Transaction txn = IcebergAcidUtil.getOrCreateTransaction(table, jobConf); if (!results.replacedDataFiles().isEmpty()) { OverwriteFiles write = txn.newOverwrite(); @@ -635,7 +626,7 @@ private void commitCompaction(Table table, Long snapshotId, long startTime, File List existingDeleteFiles = fileSizeThreshold == -1 ? IcebergCompactionUtil.getDeleteFiles(table, snapshotId, partitionPath) : Collections.emptyList(); - Transaction txn = IcebergAcidUtil.getOrCreateTransaction(table, conf); + Transaction txn = IcebergAcidUtil.getOrCreateTransaction(table, jobConf); RewriteFiles rewriteFiles = txn.newRewrite(); existingDataFiles.forEach(rewriteFiles::deleteFile); @@ -667,7 +658,7 @@ private void commitOverwrite(Table table, String branchName, Long snapshotId, lo FilesForCommit results) { Preconditions.checkArgument(results.deleteFiles().isEmpty(), "Can not handle deletes with overwrite"); - Transaction txn = IcebergAcidUtil.getOrCreateTransaction(table, conf); + Transaction txn = IcebergAcidUtil.getOrCreateTransaction(table, jobConf); if (!results.dataFiles().isEmpty()) { ReplacePartitions overwrite = txn.newReplacePartitions(); @@ -706,7 +697,7 @@ private void commitOverwrite(Table table, String branchName, Long snapshotId, lo * @throws IOException if there is a failure deleting the files */ private void cleanup(JobContext jobContext, Collection jobLocations) throws IOException { - JobConf jobConf = jobContext.getJobConf(); + JobConf conf = jobContext.getJobConf(); LOG.info("Cleaning for job {} started", jobContext.getJobID()); @@ -718,7 +709,7 @@ private void cleanup(JobContext jobContext, Collection jobLocations) thr .run(jobLocation -> { LOG.info("Cleaning location: {}", jobLocation); Path toDelete = new Path(jobLocation); - FileSystem fs = Util.getFs(toDelete, jobConf); + FileSystem fs = Util.getFs(toDelete, conf); fs.delete(toDelete, true); }, IOException.class); @@ -916,7 +907,7 @@ private void cleanMergeTaskInputFiles(List jobContexts, ExecutorServ // At this stage the file is written and task-committed, but the old files are still present. Stream mergedPaths = jobContexts.stream() .map(JobContext::getJobConf) - .filter(jobConf -> jobConf.getInputFormat().getClass().isAssignableFrom(CombineHiveInputFormat.class)) + .filter(conf -> conf.getInputFormat().getClass().isAssignableFrom(CombineHiveInputFormat.class)) .map(Utilities::getMapWork).filter(Objects::nonNull) .map(MapWork::getInputPaths).filter(Objects::nonNull) .flatMap(List::stream); diff --git a/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/HiveIcebergStorageHandler.java b/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/HiveIcebergStorageHandler.java index c6be28c60240..8c61dcb98d15 100644 --- a/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/HiveIcebergStorageHandler.java +++ b/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/HiveIcebergStorageHandler.java @@ -1103,7 +1103,7 @@ public void storageHandlerCommit(Properties commitProperties, Operation operatio @Override public HiveIcebergOutputCommitter getOutputCommitter() { - return new HiveIcebergOutputCommitter(conf); + return new HiveIcebergOutputCommitter(); } @Override diff --git a/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/IcebergAcidUtil.java b/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/IcebergAcidUtil.java index 6f7db342c5ba..33954d106eb3 100644 --- a/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/IcebergAcidUtil.java +++ b/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/IcebergAcidUtil.java @@ -32,6 +32,7 @@ import org.apache.hadoop.hive.ql.lockmgr.HiveTxnManager; import org.apache.hadoop.hive.ql.metadata.VirtualColumn; import org.apache.hadoop.hive.ql.session.SessionState; +import org.apache.hadoop.hive.ql.session.SessionStateUtil; import org.apache.iceberg.ContentFile; import org.apache.iceberg.MetadataColumns; import org.apache.iceberg.PartitionKey; @@ -229,6 +230,13 @@ public static Transaction getOrCreateTransaction(Table table, Configuration conf if (txnManager == null) { return table.newTransaction(); } + boolean isExplicitTxnOpen = txnManager.isTxnOpen() && !txnManager.isImplicitTransactionOpen(null); + int outputCount = SessionStateUtil.getOutputTableCount(conf) + .orElse(1); + + if (!isExplicitTxnOpen && outputCount < 2) { + return table.newTransaction(); + } HiveTxnCoordinator txnCoordinator = txnManager.getOrSetTxnCoordinator( HiveTxnCoordinator.class, msClient -> new HiveTxnCoordinator(conf, msClient)); return txnCoordinator != null ? diff --git a/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/IcebergTableUtil.java b/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/IcebergTableUtil.java index 9157a875d5a4..86adf0ffcd2a 100644 --- a/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/IcebergTableUtil.java +++ b/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/IcebergTableUtil.java @@ -187,7 +187,7 @@ static Table getTable(Configuration configuration, Properties properties, boolea return tableLoadFunc.apply(null); } else { return SessionStateUtil.getResource(configuration, tableIdentifier) - .filter(Table.class::isInstance) // cleaner than instanceof lambda + .filter(Table.class::isInstance) .map(Table.class::cast) .map(tbl -> Optional.ofNullable(IcebergAcidUtil.getTransaction(tbl)) .map(Transaction::table) diff --git a/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/HiveIcebergStorageHandlerWithEngineBase.java b/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/HiveIcebergStorageHandlerWithEngineBase.java index 31cd880d4df5..ea6cd82d20e1 100644 --- a/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/HiveIcebergStorageHandlerWithEngineBase.java +++ b/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/HiveIcebergStorageHandlerWithEngineBase.java @@ -25,10 +25,12 @@ import java.util.Map; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; +import java.util.concurrent.Phaser; import java.util.concurrent.TimeUnit; import java.util.function.Predicate; import org.apache.hadoop.hive.common.StatsSetupConst; import org.apache.hadoop.hive.conf.HiveConf; +import org.apache.hadoop.hive.conf.HiveConf.ConfVars; import org.apache.hadoop.hive.ql.exec.mr.ExecMapper; import org.apache.iceberg.FileFormat; import org.apache.iceberg.Schema; @@ -40,7 +42,6 @@ import org.apache.iceberg.mr.hive.test.TestHiveShell; import org.apache.iceberg.mr.hive.test.TestTables; import org.apache.iceberg.mr.hive.test.TestTables.TestTableType; -import org.apache.iceberg.mr.hive.test.concurrent.HiveIcebergStorageHandlerStub; import org.apache.iceberg.mr.hive.test.concurrent.TestUtilPhaser; import org.apache.iceberg.mr.hive.test.concurrent.WithMockedStorageHandler; import org.apache.iceberg.mr.hive.test.utils.HiveIcebergStorageHandlerTestUtils; @@ -243,10 +244,10 @@ public static void afterClass() throws Exception { public void before() throws IOException { testTables = HiveIcebergStorageHandlerTestUtils.testTables(shell, testTableType, temp); HiveIcebergStorageHandlerTestUtils.init(shell, testTables, temp); - HiveConf.setBoolVar(shell.getHiveConf(), HiveConf.ConfVars.HIVE_VECTORIZATION_ENABLED, isVectorized); + HiveConf.setBoolVar(shell.getHiveConf(), ConfVars.HIVE_VECTORIZATION_ENABLED, isVectorized); // Fetch task conversion might kick in for certain queries preventing vectorization code path to be used, so // we turn it off explicitly to achieve better coverage. - HiveConf.setVar(shell.getHiveConf(), HiveConf.ConfVars.HIVE_FETCH_TASK_CONVERSION, + HiveConf.setVar(shell.getHiveConf(), ConfVars.HIVE_FETCH_TASK_CONVERSION, isVectorized ? "none" : "more"); } @@ -277,33 +278,50 @@ protected void validateBasicStats(Table icebergTable, String dbName, String tabl } } + protected void executeConcurrentlyWithExtLocking(String[]... stmts) throws Exception { + executeConcurrently(true, RETRY_STRATEGIES_WITHOUT_WRITE_CONFLICT, stmts); + } + + protected void executeConcurrentlyNoRetry(String[]... stmts) throws Exception { + executeConcurrently(false, RETRY_STRATEGIES_WITHOUT_WRITE_CONFLICT, stmts); + } + + protected void executeConcurrentlyWithRetry(String[]... stmts) throws Exception { + executeConcurrently(false, RETRY_STRATEGIES, stmts); + } + /** - * Executes multiple SQL queries concurrently with controlled synchronization for testing. + * Executes multiple statement groups concurrently with controlled synchronization for testing. + * + *

Each {@code String[]} element represents a group of SQL statements executed sequentially + * by one thread. If a single group is provided, it is duplicated to run on two threads. * *

This method supports two synchronization modes: *

    - *
  • Ext-locking mode ({@code useExtLocking=true}): Queries execute in strict sequential - * order (sql[0], then sql[1], then sql[2], ...) to verify that external table locking prevents - * concurrent execution. Each query waits for its turn before starting.
    • - *
  • Barrier synchronization mode ({@code useExtLocking=false}): Queries execute concurrently, - * then commit in order to test optimistic concurrency control and retry on write conflicts.
    • + *
  • Ext-locking mode ({@code useExtLocking=true}): Groups execute in strict sequential + * order to verify that external table locking prevents concurrent execution.
    • + *
  • Barrier synchronization mode ({@code useExtLocking=false}): All statements except + * the last in each group execute concurrently without phaser synchronization. Then all threads + * sync at a barrier, initialize the phaser, and execute their last statement with ordered + * commits via {@link PhaserCommitDecorator}.
    • *
* - *

Uses {@link TestUtilPhaser} and {@link HiveIcebergStorageHandlerStub} to coordinate thread - * execution order deterministically. - * * @param useExtLocking if true, enables external locking mode with sequential execution; * if false, enables concurrent execution with ordered commits * @param retryStrategies comma-separated list of Hive query retry strategies to enable - * @param sql array of SQL queries to execute. If single query provided, it's executed by all threads. - * If multiple queries provided, each thread executes sql[i] where i is the thread index. + * @param sql array of statement groups. Each group is executed by one thread. + * If a single group is provided, it is duplicated to two threads. * @throws Exception if any query execution fails */ protected void executeConcurrently( - boolean useExtLocking, String retryStrategies, String... sql) throws Exception { + boolean useExtLocking, String retryStrategies, String[]... sql) throws Exception { + + String[][] stmts = (sql.length == 1) ? + new String[][] { sql[0], sql[0] } : sql; + int nThreads = stmts.length; - int nThreads = sql.length > 1 ? sql.length : 2; - TestUtilPhaser testUtilPhaser = TestUtilPhaser.getInstance(); + TestUtilPhaser testUtilPhaser = useExtLocking ? TestUtilPhaser.getInstance() : null; + Phaser barrier = useExtLocking ? null : new Phaser(nThreads); try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) { @@ -314,32 +332,49 @@ protected void executeConcurrently( TestUtilPhaser.ThreadContext.setQueryIndex(i); - if (useExtLocking) { - TestUtilPhaser.ThreadContext.setUseExtLocking(true); - } else { - testUtilPhaser.register(); - } - HiveIcebergStorageHandlerTestUtils.init(shell, testTables, temp); - HiveConf.setBoolVar(shell.getHiveConf(), HiveConf.ConfVars.HIVE_VECTORIZATION_ENABLED, isVectorized); - HiveConf.setVar(shell.getHiveConf(), HiveConf.ConfVars.HIVE_FETCH_TASK_CONVERSION, "none"); - HiveConf.setBoolVar(shell.getHiveConf(), HiveConf.ConfVars.HIVE_OPTIMIZE_METADATA_DELETE, false); - HiveConf.setVar(shell.getHiveConf(), HiveConf.ConfVars.HIVE_QUERY_REEXECUTION_STRATEGIES, - retryStrategies); + + HiveConf.setBoolVar(shell.getHiveConf(), ConfVars.HIVE_VECTORIZATION_ENABLED, isVectorized); + HiveConf.setBoolVar(shell.getHiveConf(), ConfVars.HIVE_IN_TEST, true); + HiveConf.setVar(shell.getHiveConf(), ConfVars.HIVE_FETCH_TASK_CONVERSION, "none"); + HiveConf.setBoolVar(shell.getHiveConf(), ConfVars.HIVE_OPTIMIZE_METADATA_DELETE, false); + HiveConf.setVar(shell.getHiveConf(), ConfVars.HIVE_QUERY_REEXECUTION_STRATEGIES, retryStrategies); if (useExtLocking) { - HiveConf.setBoolVar(shell.getHiveConf(), HiveConf.ConfVars.HIVE_TXN_EXT_LOCKING_ENABLED, true); + HiveConf.setBoolVar(shell.getHiveConf(), ConfVars.HIVE_TXN_EXT_LOCKING_ENABLED, true); shell.getHiveConf().setBoolean(ConfigProperties.LOCK_HIVE_ENABLED, false); - // Wait for turn: sql[0] waits for phase 0 -> 1, sql[1] for 1 -> 2, etc. - // Phase advances when previous query validates snapshot. LOG.debug("Thread {} (queryIndex={}) waiting for turn", Thread.currentThread().getName(), i); + TestUtilPhaser.ThreadContext.setUseExtLocking(true); testUtilPhaser.awaitTurn(); } try { - shell.executeStatement(sql.length > 1 ? sql[i] : sql[0]); + if (useExtLocking) { + for (String stmt : stmts[i]) { + shell.executeStatement(stmt); + } + + } else { + // Execute all statements except the last (phaser not instantiated → PhaserCommitDecorator no-ops) + for (int j = 0; j < stmts[i].length - 1; j++) { + shell.executeStatement(stmts[i][j]); + } + + // Wait for all threads to finish preceding statements + barrier.arriveAndAwaitAdvance(); + + // Instantiate phaser and register + TestUtilPhaser.getInstance().register(); + + // Wait for all threads to register + barrier.arriveAndAwaitAdvance(); + + // Execute last statement — PhaserCommitDecorator handles commit ordering + shell.executeStatement(stmts[i][stmts[i].length - 1]); + } + LOG.debug("Thread {} (queryIndex={}) completed statement execution", Thread.currentThread().getName(), i); } finally { diff --git a/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/TestConflictingDataFiles.java b/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/TestConflictingDataFiles.java index 288ab402daca..cf2ca787ab53 100644 --- a/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/TestConflictingDataFiles.java +++ b/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/TestConflictingDataFiles.java @@ -77,11 +77,13 @@ public void setUpTables() { public void testSingleFilterUpdate() throws Exception { Assume.assumeTrue(formatVersion >= 2); - String[] sql = new String[] { - "UPDATE customers SET first_name='Changed' WHERE last_name='Taylor'", - "UPDATE customers SET first_name='Changed' WHERE last_name='Donnel'" - }; - executeConcurrently(false, RETRY_STRATEGIES_WITHOUT_WRITE_CONFLICT, sql); + String[][] sql = new String[][]{ + { + "UPDATE customers SET first_name='Changed' WHERE last_name='Taylor'" + }, { + "UPDATE customers SET first_name='Changed' WHERE last_name='Donnel'" + }}; + executeConcurrentlyNoRetry(sql); List objects = shell.executeStatement("SELECT * FROM customers ORDER BY customer_id, last_name, first_name"); @@ -107,11 +109,13 @@ public void testSingleFilterUpdate() throws Exception { public void testMultiFiltersUpdate() throws Exception { Assume.assumeTrue(formatVersion >= 2); - String[] sql = new String[] { - "UPDATE customers SET first_name='Changed' WHERE last_name='Henderson' OR last_name='Johnson'", - "UPDATE customers SET first_name='Changed' WHERE last_name='Taylor' AND customer_id=1" - }; - executeConcurrently(false, RETRY_STRATEGIES_WITHOUT_WRITE_CONFLICT, sql); + String[][] sql = new String[][]{ + { + "UPDATE customers SET first_name='Changed' WHERE last_name='Henderson' OR last_name='Johnson'" + }, { + "UPDATE customers SET first_name='Changed' WHERE last_name='Taylor' AND customer_id=1" + }}; + executeConcurrentlyNoRetry(sql); List objects = shell.executeStatement("SELECT * FROM customers ORDER BY customer_id, last_name, first_name"); @@ -136,12 +140,15 @@ public void testMultiFiltersUpdate() throws Exception { @Test public void testDeleteFilters() throws Exception { - String[] sql = new String[] { - "DELETE FROM customers WHERE last_name='Taylor'", - "DELETE FROM customers WHERE last_name='Donnel'", - "DELETE FROM customers WHERE last_name='Henderson' OR last_name='Johnson'" - }; - executeConcurrently(false, RETRY_STRATEGIES_WITHOUT_WRITE_CONFLICT, sql); + String[][] sql = new String[][] { + { + "DELETE FROM customers WHERE last_name='Taylor'" + }, { + "DELETE FROM customers WHERE last_name='Donnel'" + }, { + "DELETE FROM customers WHERE last_name='Henderson' OR last_name='Johnson'" + }}; + executeConcurrentlyNoRetry(sql); List objects = shell.executeStatement("SELECT * FROM customers ORDER BY customer_id, last_name, first_name"); @@ -162,13 +169,15 @@ public void testDeleteFilters() throws Exception { @Test public void testConflictingDeletes() throws Exception { - String[] sql = new String[]{ - "DELETE FROM customers WHERE customer_id=3 or first_name='Joanna'", - "DELETE FROM customers WHERE last_name='Johnson'" - }; + String[][] sql = new String[][]{ + { + "DELETE FROM customers WHERE customer_id=3 or first_name='Joanna'" + }, { + "DELETE FROM customers WHERE last_name='Johnson'" + }}; try { - executeConcurrently(false, RETRY_STRATEGIES_WITHOUT_WRITE_CONFLICT, sql); + executeConcurrentlyNoRetry(sql); } catch (ValidationException ex) { if (formatVersion == 2) { Assert.fail("Unexpected ValidationException for format version 2"); @@ -194,11 +203,11 @@ public void testConflictingDeletes() throws Exception { @Test public void testConflictingUpdates() { - String sql = "UPDATE customers SET first_name='Changed' " + - "WHERE last_name='Taylor'"; + String[][] sql = new String[][] {{ + "UPDATE customers SET first_name='Changed' WHERE last_name='Taylor'" + }}; - Throwable ex = Assert.assertThrows(ValidationException.class, - () -> executeConcurrently(false, RETRY_STRATEGIES_WITHOUT_WRITE_CONFLICT, sql)); + Throwable ex = Assert.assertThrows(ValidationException.class, () -> executeConcurrentlyNoRetry(sql)); Assert.assertTrue(ex.getMessage().startsWith("Found conflicting files")); List objects = @@ -226,13 +235,14 @@ public void testConflictingUpdates() { public void testConflictingUpdateAndDelete() { Assume.assumeTrue(formatVersion >= 2); - String[] sql = new String[]{ - "DELETE FROM customers WHERE customer_id=3 or first_name='Joanna'", - "UPDATE customers SET last_name='Changed' WHERE customer_id=3 or first_name='Joanna'" - }; + String[][] sql = new String[][]{ + { + "DELETE FROM customers WHERE customer_id=3 or first_name='Joanna'" + }, { + "UPDATE customers SET last_name='Changed' WHERE customer_id=3 or first_name='Joanna'" + }}; - Throwable ex = Assert.assertThrows(ValidationException.class, - () -> executeConcurrently(false, RETRY_STRATEGIES_WITHOUT_WRITE_CONFLICT, sql)); + Throwable ex = Assert.assertThrows(ValidationException.class, () -> executeConcurrentlyNoRetry(sql)); Assert.assertTrue(ex.getMessage().startsWith("Found new conflicting delete files")); List res = shell.executeStatement("SELECT count(*) FROM customers " + @@ -249,12 +259,13 @@ public void testConflictingMergeInserts() { PartitionSpec.unpartitioned(), fileFormat, HiveIcebergStorageHandlerTestUtils.CUSTOMER_RECORDS, formatVersion, Collections.emptyMap(), STORAGE_HANDLER_STUB); - String sql = "MERGE INTO target t USING source src ON t.customer_id = src.customer_id " + - "WHEN NOT MATCHED THEN " + - "INSERT values (src.customer_id, src.first_name, src.last_name)"; + String[][] sql = {{ + "MERGE INTO target t USING source src ON t.customer_id = src.customer_id " + + "WHEN NOT MATCHED THEN " + + "INSERT values (src.customer_id, src.first_name, src.last_name)" + }}; - Throwable ex = Assert.assertThrows(ValidationException.class, - () -> executeConcurrently(false, RETRY_STRATEGIES_WITHOUT_WRITE_CONFLICT, sql)); + Throwable ex = Assert.assertThrows(ValidationException.class, () -> executeConcurrentlyNoRetry(sql)); Assert.assertTrue(ex.getMessage().startsWith("Found conflicting files")); List res = shell.executeStatement("SELECT count(*) FROM target"); @@ -283,11 +294,13 @@ public void testConcurrentInsertAndOverwrite() throws Exception { .build(), formatVersion, Collections.emptyMap(), STORAGE_HANDLER_STUB); - String[] sql = new String[] { - "INSERT INTO ice_t SELECT i*100, p*100 FROM ice_t", - "INSERT OVERWRITE TABLE ice_t SELECT i+1, p+1 FROM ice_t" - }; - executeConcurrently(true, RETRY_STRATEGIES_WITHOUT_WRITE_CONFLICT, sql); + String[][] sql = new String[][] { + { + "INSERT INTO ice_t SELECT i*100, p*100 FROM ice_t" + }, { + "INSERT OVERWRITE TABLE ice_t SELECT i+1, p+1 FROM ice_t" + }}; + executeConcurrentlyWithExtLocking(sql); List objects = shell.executeStatement("SELECT * FROM ice_t"); diff --git a/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/TestHiveIcebergOutputCommitter.java b/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/TestHiveIcebergOutputCommitter.java index e60c21a0e69f..b5f5eb31587b 100644 --- a/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/TestHiveIcebergOutputCommitter.java +++ b/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/TestHiveIcebergOutputCommitter.java @@ -302,6 +302,6 @@ private List writeRecords( String name, int taskNum, int attemptNum, boolean commitTasks, boolean abortTasks, JobConf conf) throws IOException { return writeRecords(name, taskNum, attemptNum, commitTasks, abortTasks, conf, - new HiveIcebergOutputCommitter(conf)); + new HiveIcebergOutputCommitter()); } } diff --git a/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/TestOptimisticRetry.java b/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/TestOptimisticRetry.java index d9249af73c91..299cceb90949 100644 --- a/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/TestOptimisticRetry.java +++ b/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/TestOptimisticRetry.java @@ -51,8 +51,10 @@ public void testConcurrentOverlappingUpdates() throws Exception { PartitionSpec.unpartitioned(), fileFormat, HiveIcebergStorageHandlerTestUtils.OTHER_CUSTOMER_RECORDS_2, formatVersion, Collections.emptyMap(), STORAGE_HANDLER_STUB); - String sql = "UPDATE customers SET last_name='Changed' WHERE customer_id=3 or first_name='Joanna'"; - executeConcurrently(false, RETRY_STRATEGIES, sql); + String[][] sql = new String[][]{{ + "UPDATE customers SET last_name='Changed' WHERE customer_id=3 or first_name='Joanna'" + }}; + executeConcurrentlyWithRetry(sql); List res = shell.executeStatement("SELECT count(*) FROM customers WHERE last_name='Changed'"); Assert.assertEquals(5L, res.getFirst()[0]); @@ -64,11 +66,13 @@ public void testConcurrentOverwriteAndUpdate() throws Exception { PartitionSpec.unpartitioned(), fileFormat, HiveIcebergStorageHandlerTestUtils.OTHER_CUSTOMER_RECORDS_2, formatVersion, Collections.emptyMap(), STORAGE_HANDLER_STUB); - String[] sql = new String[] { - "INSERT OVERWRITE table customers SELECT * FROM customers WHERE last_name='Taylor'", - "UPDATE customers SET first_name='Changed' WHERE last_name='Taylor'" - }; - executeConcurrently(false, RETRY_STRATEGIES, sql); + String[][] sql = new String[][] { + { + "INSERT OVERWRITE table customers SELECT * FROM customers WHERE last_name='Taylor'" + }, { + "UPDATE customers SET first_name='Changed' WHERE last_name='Taylor'" + }}; + executeConcurrentlyWithRetry(sql); List res = shell.executeStatement("SELECT count(*) FROM customers"); Assert.assertEquals(1L, res.getFirst()[0]); @@ -83,11 +87,13 @@ public void testNonOverlappingConcurrent2Updates() throws Exception { PartitionSpec.unpartitioned(), fileFormat, HiveIcebergStorageHandlerTestUtils.OTHER_CUSTOMER_RECORDS_2, formatVersion, Collections.emptyMap(), STORAGE_HANDLER_STUB); - String[] sql = new String[]{ - "UPDATE customers SET last_name='Changed' WHERE customer_id=3 or first_name='Joanna'", - "UPDATE customers SET last_name='Changed2' WHERE customer_id=2 and first_name='Jake'" - }; - executeConcurrently(false, RETRY_STRATEGIES, sql); + String[][] sql = new String[][]{ + { + "UPDATE customers SET last_name='Changed' WHERE customer_id=3 or first_name='Joanna'" + }, { + "UPDATE customers SET last_name='Changed2' WHERE customer_id=2 and first_name='Jake'" + }}; + executeConcurrentlyWithRetry(sql); List res = shell.executeStatement("SELECT count(*) FROM customers WHERE last_name='Changed'"); Assert.assertEquals(5L, res.getFirst()[0]); @@ -105,10 +111,12 @@ public void testConcurrent2MergeInserts() throws Exception { PartitionSpec.unpartitioned(), fileFormat, HiveIcebergStorageHandlerTestUtils.CUSTOMER_RECORDS, formatVersion, Collections.emptyMap(), STORAGE_HANDLER_STUB); - String sql = "MERGE INTO target t USING source s on t.customer_id = s.customer_id " + - "WHEN NOT MATCHED THEN " + - "INSERT VALUES (s.customer_id, s.first_name, s.last_name)"; - executeConcurrently(false, RETRY_STRATEGIES, sql); + String[][] sql = new String[][]{{ + "MERGE INTO target t USING source s on t.customer_id = s.customer_id " + + "WHEN NOT MATCHED THEN " + + "INSERT VALUES (s.customer_id, s.first_name, s.last_name)" + }}; + executeConcurrentlyWithRetry(sql); List res = shell.executeStatement("SELECT count(*) FROM target"); Assert.assertEquals(6L, res.getFirst()[0]); @@ -126,16 +134,17 @@ public void testConcurrent2MergeUpdates() throws Exception { fileFormat, HiveIcebergStorageHandlerTestUtils.USER_CLICKS_RECORDS_2, formatVersion, Collections.emptyMap(), STORAGE_HANDLER_STUB); - String query1 = "MERGE INTO target t USING source src ON t.name = src.name " + - "WHEN MATCHED THEN " + - "UPDATE SET age=15"; - - String query2 = "MERGE INTO target t USING source src ON t.age = src.age " + - "WHEN MATCHED THEN " + - "UPDATE SET age=15"; - - String[] sql = new String[] {query1, query2}; - executeConcurrently(false, RETRY_STRATEGIES, sql); + String[][] sql = new String[][] { + { + "MERGE INTO target t USING source src ON t.name = src.name " + + "WHEN MATCHED THEN " + + "UPDATE SET age=15" + }, { + "MERGE INTO target t USING source src ON t.age = src.age " + + "WHEN MATCHED THEN " + + "UPDATE SET age=15" + }}; + executeConcurrentlyWithRetry(sql); List res = shell.executeStatement("SELECT count(*) FROM target where age = 15"); Assert.assertEquals(2L, res.getFirst()[0]); diff --git a/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/TestXAConflictingDataFiles.java b/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/TestXAConflictingDataFiles.java new file mode 100644 index 000000000000..a91200de4d72 --- /dev/null +++ b/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/TestXAConflictingDataFiles.java @@ -0,0 +1,341 @@ +/* + * 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.iceberg.mr.hive; + +import java.util.Collection; +import java.util.Collections; +import java.util.List; +import org.apache.iceberg.FileFormat; +import org.apache.iceberg.PartitionSpec; +import org.apache.iceberg.catalog.TableIdentifier; +import org.apache.iceberg.data.Record; +import org.apache.iceberg.mr.TestHelper; +import org.apache.iceberg.mr.hive.test.TestTables.TestTableType; +import org.apache.iceberg.mr.hive.test.concurrent.WithMockedStorageHandler; +import org.apache.iceberg.mr.hive.test.utils.HiveIcebergStorageHandlerTestUtils; +import org.apache.iceberg.mr.hive.test.utils.HiveIcebergTestUtils; +import org.junit.Assert; +import org.junit.Assume; +import org.junit.Before; +import org.junit.Test; +import org.junit.runners.Parameterized.Parameters; + +@WithMockedStorageHandler +public class TestXAConflictingDataFiles extends HiveIcebergStorageHandlerWithEngineBase { + + public static final String XA_STORAGE_HANDLER_STUB = + "'org.apache.iceberg.mr.hive.test.concurrent.XAHiveIcebergStorageHandlerStub'"; + + @Parameters(name = "fileFormat={0}, catalog={1}, isVectorized={2}, formatVersion={3}") + public static Collection parameters() { + return HiveIcebergStorageHandlerWithEngineBase.getParameters(p -> + p.fileFormat() == FileFormat.PARQUET && + p.testTableType() == TestTableType.HIVE_CATALOG && + p.isVectorized()); + } + + @Before + public void setUpTables() { + PartitionSpec spec = + PartitionSpec.builderFor(HiveIcebergStorageHandlerTestUtils.CUSTOMER_SCHEMA) + .identity("last_name").bucket("customer_id", 16).build(); + + testTables.createTable(shell, "t1", HiveIcebergStorageHandlerTestUtils.CUSTOMER_SCHEMA, + spec, fileFormat, HiveIcebergStorageHandlerTestUtils.OTHER_CUSTOMER_RECORDS_2, + formatVersion, Collections.emptyMap(), XA_STORAGE_HANDLER_STUB); + shell.executeStatement(testTables.getInsertQuery( + HiveIcebergStorageHandlerTestUtils.OTHER_CUSTOMER_RECORDS_1, + TableIdentifier.of("default", "t1"), false)); + + testTables.createTable(shell, "t2", HiveIcebergStorageHandlerTestUtils.CUSTOMER_SCHEMA, + spec, fileFormat, HiveIcebergStorageHandlerTestUtils.OTHER_CUSTOMER_RECORDS_2, + formatVersion, Collections.emptyMap(), XA_STORAGE_HANDLER_STUB); + shell.executeStatement(testTables.getInsertQuery( + HiveIcebergStorageHandlerTestUtils.OTHER_CUSTOMER_RECORDS_1, + TableIdentifier.of("default", "t2"), false)); + } + + // ===== Multi-table Insert Tests ===== + + @Test + public void testConcurrentMultiTableInserts() throws Exception { + String[][] sql = new String[][]{ + { + "FROM (SELECT 100 as customer_id, 'NewA' as first_name, 'PartA' as last_name) s " + + "INSERT INTO t1 SELECT * " + + "INSERT INTO t2 SELECT *" + }, { + "FROM (SELECT 200 as customer_id, 'NewB' as first_name, 'PartB' as last_name) s " + + "INSERT INTO t1 SELECT * " + + "INSERT INTO t2 SELECT *" + }}; + executeConcurrentlyNoRetry(sql); + + List expected = TestHelper.RecordsBuilder + .newInstance(HiveIcebergStorageHandlerTestUtils.CUSTOMER_SCHEMA) + .add(1L, "Joanna", "Pierce") + .add(1L, "Sharon", "Taylor") + .add(2L, "Bob", "Silver") + .add(2L, "Jake", "Donnel") + .add(2L, "Joanna", "Silver") + .add(2L, "Susan", "Morrison") + .add(3L, "Blake", "Burr") + .add(3L, "Marci", "Barna") + .add(3L, "Trudy", "Henderson") + .add(3L, "Trudy", "Johnson") + .add(4L, "Laci", "Zold") + .add(5L, "Peti", "Rozsaszin") + .add(100L, "NewA", "PartA") + .add(200L, "NewB", "PartB") + .build(); + + List t1Rows = shell.executeStatement( + "SELECT * FROM t1 ORDER BY customer_id, first_name, last_name"); + Assert.assertEquals(14, t1Rows.size()); + HiveIcebergTestUtils.validateData(expected, + HiveIcebergTestUtils.valueForRow(HiveIcebergStorageHandlerTestUtils.CUSTOMER_SCHEMA, t1Rows), 0); + + List t2Rows = shell.executeStatement( + "SELECT * FROM t2 ORDER BY customer_id, first_name, last_name"); + Assert.assertEquals(14, t2Rows.size()); + HiveIcebergTestUtils.validateData(expected, + HiveIcebergTestUtils.valueForRow(HiveIcebergStorageHandlerTestUtils.CUSTOMER_SCHEMA, t2Rows), 0); + } + + @Test + public void testMultiTableInsertWithUpdate() throws Exception { + Assume.assumeTrue(formatVersion >= 2); + + String[][] sql = new String[][]{ + { + "FROM (SELECT 100 as customer_id, 'NewA' as first_name, 'PartA' as last_name) s " + + "INSERT INTO t1 SELECT * " + + "INSERT INTO t2 SELECT *" + }, { + "UPDATE t1 SET first_name='Changed' WHERE last_name='Taylor'" + }}; + executeConcurrentlyNoRetry(sql); + + List t1Rows = shell.executeStatement( + "SELECT * FROM t1 ORDER BY customer_id, first_name, last_name"); + Assert.assertEquals(13, t1Rows.size()); + List expectedT1 = TestHelper.RecordsBuilder + .newInstance(HiveIcebergStorageHandlerTestUtils.CUSTOMER_SCHEMA) + .add(1L, "Changed", "Taylor") + .add(1L, "Joanna", "Pierce") + .add(2L, "Bob", "Silver") + .add(2L, "Jake", "Donnel") + .add(2L, "Joanna", "Silver") + .add(2L, "Susan", "Morrison") + .add(3L, "Blake", "Burr") + .add(3L, "Marci", "Barna") + .add(3L, "Trudy", "Henderson") + .add(3L, "Trudy", "Johnson") + .add(4L, "Laci", "Zold") + .add(5L, "Peti", "Rozsaszin") + .add(100L, "NewA", "PartA") + .build(); + HiveIcebergTestUtils.validateData(expectedT1, + HiveIcebergTestUtils.valueForRow(HiveIcebergStorageHandlerTestUtils.CUSTOMER_SCHEMA, t1Rows), 0); + + List t2Rows = shell.executeStatement( + "SELECT * FROM t2 ORDER BY customer_id, first_name, last_name"); + Assert.assertEquals(13, t2Rows.size()); + } + + // ===== Multi-statement Transaction Tests ===== + + @Test + public void testMultiStatementSingleFilterUpdate() throws Exception { + Assume.assumeTrue(formatVersion >= 2); + + String[][] stmts = new String[][]{ + { + "START TRANSACTION", + "UPDATE t1 SET first_name='Changed' WHERE last_name='Taylor'", + "UPDATE t2 SET first_name='Changed' WHERE last_name='Donnel'", + "COMMIT" + }, + { + "START TRANSACTION", + "UPDATE t1 SET first_name='Changed' WHERE last_name='Henderson'", + "UPDATE t2 SET first_name='Changed' WHERE last_name='Morrison'", + "COMMIT" + } + }; + executeConcurrentlyNoRetry(stmts); + + List t1Rows = shell.executeStatement( + "SELECT * FROM t1 ORDER BY customer_id, first_name, last_name"); + Assert.assertEquals(12, t1Rows.size()); + List expectedT1 = TestHelper.RecordsBuilder + .newInstance(HiveIcebergStorageHandlerTestUtils.CUSTOMER_SCHEMA) + .add(1L, "Changed", "Taylor") + .add(1L, "Joanna", "Pierce") + .add(2L, "Bob", "Silver") + .add(2L, "Jake", "Donnel") + .add(2L, "Joanna", "Silver") + .add(2L, "Susan", "Morrison") + .add(3L, "Blake", "Burr") + .add(3L, "Changed", "Henderson") + .add(3L, "Marci", "Barna") + .add(3L, "Trudy", "Johnson") + .add(4L, "Laci", "Zold") + .add(5L, "Peti", "Rozsaszin") + .build(); + HiveIcebergTestUtils.validateData(expectedT1, + HiveIcebergTestUtils.valueForRow(HiveIcebergStorageHandlerTestUtils.CUSTOMER_SCHEMA, t1Rows), 0); + + List t2Rows = shell.executeStatement( + "SELECT * FROM t2 ORDER BY customer_id, first_name, last_name"); + Assert.assertEquals(12, t2Rows.size()); + List expectedT2 = TestHelper.RecordsBuilder + .newInstance(HiveIcebergStorageHandlerTestUtils.CUSTOMER_SCHEMA) + .add(1L, "Joanna", "Pierce") + .add(1L, "Sharon", "Taylor") + .add(2L, "Bob", "Silver") + .add(2L, "Changed", "Donnel") + .add(2L, "Changed", "Morrison") + .add(2L, "Joanna", "Silver") + .add(3L, "Blake", "Burr") + .add(3L, "Marci", "Barna") + .add(3L, "Trudy", "Henderson") + .add(3L, "Trudy", "Johnson") + .add(4L, "Laci", "Zold") + .add(5L, "Peti", "Rozsaszin") + .build(); + HiveIcebergTestUtils.validateData(expectedT2, + HiveIcebergTestUtils.valueForRow(HiveIcebergStorageHandlerTestUtils.CUSTOMER_SCHEMA, t2Rows), 0); + } + + @Test + public void testConflictingMultiStatementUpdates() { + Assume.assumeTrue(formatVersion >= 2); + + String[][] stmts = new String[][]{ + { + "START TRANSACTION", + "UPDATE t1 SET first_name='Changed' WHERE last_name='Taylor'", + "UPDATE t2 SET first_name='Changed' WHERE last_name='Taylor'", + "COMMIT" + }, + { + "START TRANSACTION", + "UPDATE t1 SET first_name='Changed' WHERE last_name='Taylor'", + "UPDATE t2 SET first_name='Changed' WHERE last_name='Taylor'", + "COMMIT" + } + }; + + Assert.assertThrows(Exception.class, () -> executeConcurrentlyNoRetry(stmts)); + + // First transaction succeeded + List t1Rows = shell.executeStatement( + "SELECT * FROM t1 ORDER BY customer_id, first_name, last_name"); + Assert.assertEquals(12, t1Rows.size()); + + List t1Taylor = shell.executeStatement( + "SELECT first_name FROM t1 WHERE last_name='Taylor'"); + Assert.assertEquals(1, t1Taylor.size()); + Assert.assertEquals("Changed", t1Taylor.getFirst()[0]); + + List t2Taylor = shell.executeStatement( + "SELECT first_name FROM t2 WHERE last_name='Taylor'"); + Assert.assertEquals(1, t2Taylor.size()); + Assert.assertEquals("Changed", t2Taylor.getFirst()[0]); + } + + @Test + public void testMultiStatementInsertAndUpdate() throws Exception { + Assume.assumeTrue(formatVersion >= 2); + + String[][] stmts = new String[][]{ + { + "START TRANSACTION", + "INSERT INTO t1 VALUES (100, 'NewA', 'PartA')", + "UPDATE t2 SET first_name='Changed' WHERE last_name='Taylor'", + "COMMIT" + }, + { + "START TRANSACTION", + "INSERT INTO t1 VALUES (200, 'NewB', 'PartB')", + "UPDATE t2 SET first_name='Changed' WHERE last_name='Donnel'", + "COMMIT" + } + }; + executeConcurrentlyNoRetry(stmts); + + // t1: 12 original + 2 inserts = 14 + List t1Count = shell.executeStatement("SELECT count(*) FROM t1"); + Assert.assertEquals(14L, t1Count.getFirst()[0]); + + List newRows = shell.executeStatement( + "SELECT customer_id FROM t1 WHERE last_name IN ('PartA', 'PartB') ORDER BY customer_id"); + Assert.assertEquals(2, newRows.size()); + Assert.assertEquals(100L, newRows.get(0)[0]); + Assert.assertEquals(200L, newRows.get(1)[0]); + + // t2: 12 rows with updates + Assert.assertEquals(12L, + shell.executeStatement("SELECT count(*) FROM t2").getFirst()[0]); + Assert.assertEquals("Changed", + shell.executeStatement("SELECT first_name FROM t2 WHERE last_name='Taylor'").getFirst()[0]); + Assert.assertEquals("Changed", + shell.executeStatement("SELECT first_name FROM t2 WHERE last_name='Donnel'").getFirst()[0]); + } + + @Test + public void testMultiStatementDeleteAndUpdate() throws Exception { + Assume.assumeTrue(formatVersion >= 2); + + String[][] stmts = new String[][]{ + { + "START TRANSACTION", + "DELETE FROM t1 WHERE last_name='Taylor'", + "UPDATE t2 SET first_name='Changed' WHERE last_name='Taylor'", + "COMMIT" + }, + { + "START TRANSACTION", + "DELETE FROM t1 WHERE last_name='Donnel'", + "UPDATE t2 SET first_name='Changed' WHERE last_name='Donnel'", + "COMMIT" + } + }; + executeConcurrently(false, RETRY_STRATEGIES_WITHOUT_WRITE_CONFLICT, stmts); + + // t1: 12 - 1 (Taylor) - 1 (Donnel) = 10 + Assert.assertEquals(10L, + shell.executeStatement("SELECT count(*) FROM t1").getFirst()[0]); + Assert.assertEquals(0, + shell.executeStatement("SELECT * FROM t1 WHERE last_name='Taylor'").size()); + Assert.assertEquals(0, + shell.executeStatement("SELECT * FROM t1 WHERE last_name='Donnel'").size()); + + // t2: 12 rows with updates + Assert.assertEquals(12L, + shell.executeStatement("SELECT count(*) FROM t2").getFirst()[0]); + Assert.assertEquals("Changed", + shell.executeStatement("SELECT first_name FROM t2 WHERE last_name='Taylor'").getFirst()[0]); + Assert.assertEquals("Changed", + shell.executeStatement("SELECT first_name FROM t2 WHERE last_name='Donnel'").getFirst()[0]); + } + +} diff --git a/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/test/concurrent/HiveIcebergStorageHandlerStub.java b/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/test/concurrent/HiveIcebergStorageHandlerStub.java index dd9ea4a6112e..05b70edc1d38 100644 --- a/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/test/concurrent/HiveIcebergStorageHandlerStub.java +++ b/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/test/concurrent/HiveIcebergStorageHandlerStub.java @@ -20,91 +20,24 @@ package org.apache.iceberg.mr.hive.test.concurrent; import java.io.IOException; -import java.time.Duration; import java.util.List; -import org.apache.commons.lang3.ThreadUtils; import org.apache.hadoop.hive.ql.Context; import org.apache.hadoop.hive.ql.plan.TableDesc; import org.apache.hadoop.mapred.JobContext; import org.apache.iceberg.mr.hive.HiveIcebergOutputCommitter; import org.apache.iceberg.mr.hive.HiveIcebergStorageHandler; -import org.apache.iceberg.mr.hive.test.concurrent.TestUtilPhaser.ThreadContext; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; -/** - * Test stub for HiveIcebergStorageHandler that coordinates concurrent write testing. - * - *

Supports two synchronization modes: - *

    - *
  • Ext-locking mode: Tests external table locking. Counter ensures queries start sequentially, - * next query starts when current reaches validateCurrentSnapshot. Phaser verifies lock prevents - * concurrent execution.
    • - *
  • Barrier mode: Tests optimistic concurrency. All queries start concurrently, sync at barrier - * in commitJobs, then commit sequentially by index. Supports retry on conflict.
    • - *
- */ public class HiveIcebergStorageHandlerStub extends HiveIcebergStorageHandler { - private static final Logger LOG = LoggerFactory.getLogger(HiveIcebergStorageHandlerStub.class); - @Override public HiveIcebergOutputCommitter getOutputCommitter() { - return new HiveIcebergOutputCommitter(conf) { - @Override - public void commitJobs(List originalContextList, Context.Operation operation) throws IOException { - int queryIndex = ThreadContext.getQueryIndex(); - LOG.debug("Thread {} (queryIndex={}) entered commitJobs", Thread.currentThread(), queryIndex); - - waitForAllWritesToComplete(); - LOG.debug("Thread {} (queryIndex={}) starting commitJobs", Thread.currentThread(), queryIndex); - - super.commitJobs(originalContextList, operation); - - // Barrier Mode: If the commit succeeded, release the turn so the next thread can proceed. - // If commit failed (exception thrown), turn is NOT released, allowing retry logic to - // reuse the current turn. - if (TestUtilPhaser.isInstantiated() && !ThreadContext.useExtLocking()) { - TestUtilPhaser.getInstance().completeTurn(); - LOG.debug("Thread {} (queryIndex={}) committed and released turn", - Thread.currentThread(), queryIndex); - } - } + return new HiveIcebergOutputCommitter() { - private static void waitForAllWritesToComplete() { - if (!TestUtilPhaser.isInstantiated()) { - return; - } - - int queryIndex = ThreadContext.getQueryIndex(); - boolean useExtLocking = ThreadContext.useExtLocking(); - - if (useExtLocking) { - // Ext-locking mode: Table lock should have prevented this query from starting concurrently. - // Sleep briefly to ensure that if the lock is broken, the concurrent query has time - // to incorrectly advance the phase. - ThreadUtils.sleepQuietly(Duration.ofMillis(500)); - int phase = TestUtilPhaser.getInstance().getBarrier().getPhase(); - - if (phase != queryIndex + 1) { - throw new IllegalStateException( - String.format("External locking violation: query sql[%d] expected phase %d, got %d", - queryIndex, queryIndex + 1, phase)); - } - } else { - // Barrier mode: Optimistic concurrency. - // 1. Barrier: Wait for ALL queries to reach commit stage to maximize conflict potential. - // 2. Sequential Commit: Execute commits one-by-one to control ordering. - if (!ThreadContext.isSynced()) { - LOG.debug("Thread {} (queryIndex={}) waiting at barrier", Thread.currentThread(), queryIndex); - TestUtilPhaser.getInstance().getBarrier().arriveAndAwaitAdvance(); - ThreadContext.markSynced(); - } - - LOG.debug("Thread {} (queryIndex={}) waiting for commit turn", Thread.currentThread(), queryIndex); - TestUtilPhaser.getInstance().awaitTurn(); - } + @Override + public void commitJobs(List contexts, Context.Operation operation) throws IOException { + PhaserCommitDecorator.execute( + () -> super.commitJobs(contexts, operation)); } }; } @@ -112,17 +45,7 @@ private static void waitForAllWritesToComplete() { @Override public void validateCurrentSnapshot(TableDesc tableDesc) { super.validateCurrentSnapshot(tableDesc); - - if (!TestUtilPhaser.isInstantiated()) { - return; - } - - if (ThreadContext.useExtLocking()) { - // Ext-locking mode: Release the turn so the next sequential query can proceed - // from 'awaitTurn' to start its own execution. - TestUtilPhaser.getInstance().completeTurn(); - LOG.debug("Thread {} (queryIndex={}) validated snapshot and released turn", - Thread.currentThread(), ThreadContext.getQueryIndex()); - } + // Notify the phaser that the snapshot validation has completed, allowing waiting threads to proceed + PhaserCommitDecorator.onSnapshotValidated(); } } diff --git a/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/test/concurrent/PhaserCommitDecorator.java b/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/test/concurrent/PhaserCommitDecorator.java new file mode 100644 index 000000000000..231f1b0b48b1 --- /dev/null +++ b/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/test/concurrent/PhaserCommitDecorator.java @@ -0,0 +1,131 @@ +/* + * 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.iceberg.mr.hive.test.concurrent; + +import java.time.Duration; +import org.apache.commons.lang3.ThreadUtils; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * TestUtil that coordinates concurrent write testing. + * + *

Supports two synchronization modes: + *

    + *
  • Ext-locking mode: Tests external table locking. Counter ensures queries start sequentially, + * next query starts when current reaches validateCurrentSnapshot. Phaser verifies lock prevents + * concurrent execution.
    • + *
  • Barrier mode: Tests optimistic concurrency. All queries start concurrently, sync at barrier + * in commitJobs, then commit sequentially by index. Supports retry on conflict.
    • + *
+ */ +public class PhaserCommitDecorator { + + private static final Logger LOG = + LoggerFactory.getLogger(PhaserCommitDecorator.class); + + private PhaserCommitDecorator() { + } + + @FunctionalInterface + public interface CommitAction { + void run() throws E; + } + + public static void execute(CommitAction action) throws E { + int queryIndex = TestUtilPhaser.ThreadContext.getQueryIndex(); + LOG.debug("Thread {} (queryIndex={}) entered commit", Thread.currentThread(), queryIndex); + + waitForAllWritesToComplete(); + + LOG.debug("Thread {} (queryIndex={}) starting commit", Thread.currentThread(), queryIndex); + action.run(); // delegate call + + // Barrier Mode: If the commit succeeded, release the turn so the next thread can proceed. + // If commit failed (exception thrown), turn is NOT released, allowing retry logic to + // reuse the current turn. + if (TestUtilPhaser.isInstantiated() && + !TestUtilPhaser.ThreadContext.useExtLocking()) { + + TestUtilPhaser.getInstance().completeTurn(); + + LOG.debug("Thread {} (queryIndex={}) committed and released turn", + Thread.currentThread(), queryIndex); + } + } + + public static void onSnapshotValidated() { + if (TestUtilPhaser.isInstantiated() && + TestUtilPhaser.ThreadContext.useExtLocking()) { + + // Ext-locking mode: Release the turn so the next sequential query can proceed + // from 'awaitTurn' to start its own execution. + TestUtilPhaser.getInstance().completeTurn(); + + LOG.debug("Thread {} (queryIndex={}) validated snapshot and released turn", + Thread.currentThread(), + TestUtilPhaser.ThreadContext.getQueryIndex()); + } + } + + private static void waitForAllWritesToComplete() { + if (!TestUtilPhaser.isInstantiated()) { + return; + } + + int queryIndex = TestUtilPhaser.ThreadContext.getQueryIndex(); + boolean useExtLocking = + TestUtilPhaser.ThreadContext.useExtLocking(); + + if (useExtLocking) { + // Ext-locking mode: Table lock should have prevented this query from starting concurrently. + // Sleep briefly to ensure that if the lock is broken, the concurrent query has time + // to incorrectly advance the phase. + ThreadUtils.sleepQuietly(Duration.ofMillis(500)); + int phase = TestUtilPhaser.getInstance().getBarrier().getPhase(); + + if (phase != queryIndex + 1) { + throw new IllegalStateException( + "External locking violation: query sql[%d] expected phase %d, got %d".formatted( + queryIndex, queryIndex + 1, phase)); + } + + } else { + // Barrier mode: Optimistic concurrency. + // 1. Barrier: Wait for ALL queries to reach commit stage to maximize conflict potential. + // 2. Sequential Commit: Execute commits one-by-one to control ordering. + if (!TestUtilPhaser.ThreadContext.isSynced()) { + LOG.debug("Thread {} (queryIndex={}) waiting at barrier", Thread.currentThread(), queryIndex); + + TestUtilPhaser.getInstance() + .getBarrier() + .arriveAndAwaitAdvance(); + + TestUtilPhaser.ThreadContext.markSynced(); + } + + LOG.debug("Thread {} (queryIndex={}) waiting for commit turn", + Thread.currentThread(), queryIndex); + + TestUtilPhaser.getInstance().awaitTurn(); + } + } + +} diff --git a/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/test/concurrent/XAHiveIcebergStorageHandlerStub.java b/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/test/concurrent/XAHiveIcebergStorageHandlerStub.java new file mode 100644 index 000000000000..caf7681c927f --- /dev/null +++ b/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/test/concurrent/XAHiveIcebergStorageHandlerStub.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.iceberg.mr.hive.test.concurrent; + +import org.apache.hadoop.hive.ql.lockmgr.HiveTxnManager; +import org.apache.hadoop.hive.ql.session.SessionState; +import org.apache.iceberg.hive.HiveTxnCoordinator; +import org.apache.iceberg.mr.hive.HiveIcebergOutputCommitter; + +public class XAHiveIcebergStorageHandlerStub extends HiveIcebergStorageHandlerStub { + + @Override + public HiveIcebergOutputCommitter getOutputCommitter() { + HiveTxnManager txnManager = SessionState.get().getTxnMgr(); + + txnManager.getOrSetTxnCoordinator( + HiveTxnCoordinator.class, + msClient -> new XAHiveTxnCoordinatorStub(conf, msClient)); + + return super.getOutputCommitter(); + } + +} diff --git a/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/test/concurrent/XAHiveTxnCoordinatorStub.java b/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/test/concurrent/XAHiveTxnCoordinatorStub.java new file mode 100644 index 000000000000..fa3c2c531f3d --- /dev/null +++ b/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/test/concurrent/XAHiveTxnCoordinatorStub.java @@ -0,0 +1,37 @@ +/* + * 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.iceberg.mr.hive.test.concurrent; + +import org.apache.hadoop.conf.Configuration; +import org.apache.hadoop.hive.metastore.IMetaStoreClient; +import org.apache.iceberg.hive.HiveTxnCoordinator; +import org.apache.thrift.TException; + +public class XAHiveTxnCoordinatorStub extends HiveTxnCoordinator { + + public XAHiveTxnCoordinatorStub(Configuration conf, IMetaStoreClient msClient) { + super(conf, msClient); + } + + @Override + public void commit() throws TException { + PhaserCommitDecorator.execute(super::commit); + } +} diff --git a/ql/src/java/org/apache/hadoop/hive/ql/Driver.java b/ql/src/java/org/apache/hadoop/hive/ql/Driver.java index 4ad2c82c5686..e504410f5155 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/Driver.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/Driver.java @@ -57,6 +57,7 @@ import org.apache.hadoop.hive.ql.session.LineageState; import org.apache.hadoop.hive.ql.session.SessionState; import org.apache.hadoop.hive.ql.session.SessionState.LogHelper; +import org.apache.hadoop.hive.ql.session.SessionStateUtil; import org.apache.hadoop.hive.ql.wm.WmContext; import org.apache.hadoop.hive.serde2.ByteStream; import org.apache.hadoop.util.StringUtils; @@ -170,7 +171,7 @@ private void runInternal(String command, boolean alreadyCompiled) throws Command if (!alreadyCompiled) { compileInternal(command, true); } else { - driverContext.getPlan().setQueryStartTime(driverContext.getQueryDisplay().getQueryStartTime()); + driverContext.recordQueryStartTime(); } DriverUtils.checkInterrupted(driverState, driverContext, "at acquiring the lock.", null, null); @@ -178,6 +179,9 @@ private void runInternal(String command, boolean alreadyCompiled) throws Command lockAndRespond(); validateCurrentSnapshot(); + SessionStateUtil.setOutputTableCount(driverContext.getConf(), + context.getLoadTableOutputMap().size()); + // Reset the PerfLogger so that it doesn't retain any previous values. // Any value from compilation phase can be obtained through the map set in queryDisplay during compilation. PerfLogger perfLogger = SessionState.getPerfLogger(true); diff --git a/ql/src/java/org/apache/hadoop/hive/ql/DriverContext.java b/ql/src/java/org/apache/hadoop/hive/ql/DriverContext.java index b02161c0ca93..fd2dfc2e9e3f 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/DriverContext.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/DriverContext.java @@ -275,4 +275,8 @@ public void setExplainPlan(String explainPlan) { public String getExplainPlan() { return explainPlan; } + + public void recordQueryStartTime() { + plan.setQueryStartTime(queryDisplay.getQueryStartTime()); + } } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/DriverTxnHandler.java b/ql/src/java/org/apache/hadoop/hive/ql/DriverTxnHandler.java index 544cb2cf3db5..134ab2d2d63a 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/DriverTxnHandler.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/DriverTxnHandler.java @@ -51,6 +51,7 @@ import org.apache.hadoop.hive.ql.exec.TableScanOperator; import org.apache.hadoop.hive.ql.exec.Task; import org.apache.hadoop.hive.ql.hooks.Entity; +import org.apache.hadoop.hive.ql.hooks.PrivateHookContext; import org.apache.hadoop.hive.ql.io.AcidUtils; import org.apache.hadoop.hive.ql.lockmgr.DbTxnManager; import org.apache.hadoop.hive.ql.lockmgr.HiveLock; @@ -174,7 +175,7 @@ private boolean requiresLock() { return true; } - Queue> tasks = new LinkedList>(); + Queue> tasks = new LinkedList<>(); tasks.addAll(driverContext.getPlan().getRootTasks()); while (tasks.peek() != null) { Task task = tasks.remove(); @@ -198,15 +199,10 @@ private boolean requiresLock() { private boolean isExplicitLockOperation() { HiveOperation currentOpt = driverContext.getPlan().getOperation(); if (currentOpt != null) { - switch (currentOpt) { - case LOCKDB: - case UNLOCKDB: - case LOCKTABLE: - case UNLOCKTABLE: - return true; - default: - return false; - } + return switch (currentOpt) { + case LOCKDB, UNLOCKDB, LOCKTABLE, UNLOCKTABLE -> true; + default -> false; + }; } return false; } @@ -367,7 +363,7 @@ void recordValidWriteIds() throws LockException { && !SessionState.get().isCompaction()) { driverContext.getTxnManager().addWriteIdsToMinHistory(driverContext.getPlan(), txnWriteIds); } - LOG.debug("Encoding valid txn write ids info {}, txnid: {}", txnWriteIds.toString(), + LOG.debug("Encoding valid txn write ids info {}, txnid: {}", txnWriteIds, driverContext.getTxnManager().getCurrentTxnId()); } @@ -402,14 +398,13 @@ private void setValidWriteIds(ValidTxnWriteIdList txnWriteIds) { // in FetchOperator before recordValidTxns() but this has to be done after locks are acquired to avoid race // conditions in ACID. This case is supported only for single source query. Operator source = driverContext.getPlan().getFetchTask().getWork().getSource(); - if (source instanceof TableScanOperator) { - TableScanOperator tsOp = (TableScanOperator)source; + if (source instanceof TableScanOperator tsOp) { String fullTableName = AcidUtils.getFullTableName(tsOp.getConf().getDatabaseName(), tsOp.getConf().getTableName()); ValidWriteIdList writeIdList = txnWriteIds.getTableValidWriteIdList(fullTableName); if (tsOp.getConf().isTranscationalTable() && (writeIdList == null)) { throw new IllegalStateException(String.format( - "ACID table: %s is missing from the ValidWriteIdList config: %s", fullTableName, txnWriteIds.toString())); + "ACID table: %s is missing from the ValidWriteIdList config: %s", fullTableName, txnWriteIds)); } if (writeIdList != null) { driverContext.getPlan().getFetchTask().setValidWriteIdList(writeIdList.toString()); @@ -532,22 +527,30 @@ void rollback(CommandProcessorException cpe) throws CommandProcessorException { } void handleTransactionAfterExecution() throws CommandProcessorException { + boolean isImplicitTxnOpen = driverContext.getTxnManager().isImplicitTransactionOpen(context); + HiveOperation hiveOp = driverContext.getQueryState().getHiveOperation(); + + boolean isTxnOpen = driverContext.getTxnManager().isTxnOpen(); + boolean isCompaction = SessionState.get().isCompaction(); + try { - //since set autocommit starts an implicit txn, close it - if (driverContext.getTxnManager().isImplicitTransactionOpen(context) - || driverContext.getPlan().getOperation() == HiveOperation.COMMIT) { + if (isImplicitTxnOpen || hiveOp == HiveOperation.COMMIT) { + // since set autocommit starts an implicit txn, close it endTransactionAndCleanup(true); - } else if (driverContext.getPlan().getOperation() == HiveOperation.ROLLBACK) { - endTransactionAndCleanup(false); - } else if (!driverContext.getTxnManager().isTxnOpen() - && (driverContext.getQueryState().getHiveOperation() == HiveOperation.REPLLOAD - || !SessionState.get().isCompaction())) { - // repl load during migration, commits the explicit txn and start some internal txns. Call - // releaseLocksAndCommitOrRollback to do the clean up. + } else if (hiveOp == HiveOperation.ROLLBACK + // repl load during migration commits the explicit txn and starts internal txns + || (!isTxnOpen && (hiveOp == HiveOperation.REPLLOAD || !isCompaction))) { endTransactionAndCleanup(false); - } + } // if none of the above is true, then txn (if there is one started) is not finished } catch (LockException e) { + try { + DriverUtils.invokeFailureHooks( + driverContext, null, new PrivateHookContext(driverContext, context), + e.getMessage(), e); + } catch (Exception t) { + LOG.warn("Failed to invoke the transaction commit failure hook.", e); + } DriverUtils.handleHiveException(driverContext, e, 12, null); } } @@ -575,13 +578,13 @@ void destroy(String queryIdFromDriver) { .map(DriverContext::getTxnManager) .orElse(null); - HiveOperation op = Optional.ofNullable(driverContext) + HiveOperation hiveOp = Optional.ofNullable(driverContext) .map(DriverContext::getQueryState).map(QueryState::getHiveOperation) .orElse(null); boolean isTxnOpen = txnManager != null && txnManager.isTxnOpen() && - (txnManager.isImplicitTransactionOpen(context) || COMMIT_OR_ROLLBACK.contains(op)) && + (txnManager.isImplicitTransactionOpen(context) || COMMIT_OR_ROLLBACK.contains(hiveOp)) && org.apache.commons.lang3.StringUtils.equals(queryIdFromDriver, txnManager.getQueryid()); release(!hiveLocks.isEmpty() || isTxnOpen); @@ -617,12 +620,9 @@ synchronized void endTransactionAndCleanup(boolean commit, HiveTxnManager txnMan if (!DriverUtils.checkConcurrency(driverContext)) { return; } + commitOrRollback(commit, txnManager); + releaseLocks(txnManager, hiveLocks); - if (txnManager.isTxnOpen()) { - commitOrRollback(commit, txnManager); - } else { - releaseLocks(txnManager, hiveLocks); - } hiveLocks.clear(); if (context != null) { context.setHiveLocks(null); @@ -632,6 +632,9 @@ synchronized void endTransactionAndCleanup(boolean commit, HiveTxnManager txnMan } private void commitOrRollback(boolean commit, HiveTxnManager txnManager) throws LockException { + if (!txnManager.isTxnOpen()) { + return; + } if (commit) { if (driverContext.getConf().getBoolVar(ConfVars.HIVE_IN_TEST) && driverContext.getConf().getBoolVar(ConfVars.HIVE_TEST_MODE_ROLLBACK_TXN)) { diff --git a/ql/src/java/org/apache/hadoop/hive/ql/lockmgr/AcidTxnCoordinator.java b/ql/src/java/org/apache/hadoop/hive/ql/lockmgr/AcidTxnCoordinator.java index dba1a7ac10be..5fa06d786164 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/lockmgr/AcidTxnCoordinator.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/lockmgr/AcidTxnCoordinator.java @@ -43,7 +43,7 @@ public class AcidTxnCoordinator implements TxnCoordinator { private final HiveConf conf; private final IMetaStoreClient msClient; private final String replPolicy; - private final long txnId; + private long txnId; public AcidTxnCoordinator( HiveConf conf, IMetaStoreClient msClient, String replPolicy, long txnId) { @@ -62,18 +62,26 @@ public void commit() throws TException { commitTxnRequest.setReplPolicy(replPolicy); commitTxnRequest.setTxn_type(TxnType.DEFAULT); } - msClient.commitTxn(commitTxnRequest); + try { + msClient.commitTxn(commitTxnRequest); + } finally { + resetTxnInfo(); + } } @Override public void rollback() throws TException { LOG.debug("Rolling back {}", JavaUtils.txnIdToString(txnId)); - if (replPolicy != null) { - msClient.replRollbackTxn(txnId, replPolicy, TxnType.DEFAULT); - } else { - AbortTxnRequest abortTxnRequest = new AbortTxnRequest(txnId); - abortTxnRequest.setErrorCode(TxnErrorMsg.ABORT_ROLLBACK.getErrorCode()); - msClient.rollbackTxn(abortTxnRequest); + try { + if (replPolicy != null) { + msClient.replRollbackTxn(txnId, replPolicy, TxnType.DEFAULT); + } else { + AbortTxnRequest abortTxnRequest = new AbortTxnRequest(txnId); + abortTxnRequest.setErrorCode(TxnErrorMsg.ABORT_ROLLBACK.getErrorCode()); + msClient.rollbackTxn(abortTxnRequest); + } + } finally { + resetTxnInfo(); } } @@ -81,6 +89,10 @@ private boolean isTxnOpen() { return txnId > 0; } + private void resetTxnInfo() { + txnId = 0; + } + @Override public boolean hasPendingWork() { return isTxnOpen(); 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 4316af69ac6c..9a113bad0764 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 @@ -99,11 +99,12 @@ @NotThreadSafe public final class DbTxnManager extends HiveTxnManagerImpl { - static final private String CLASS_NAME = DbTxnManager.class.getName(); - static final private Logger LOG = LoggerFactory.getLogger(CLASS_NAME); + private static final String CLASS_NAME = DbTxnManager.class.getName(); + private static final Logger LOG = LoggerFactory.getLogger(CLASS_NAME); public static final String GLOBAL_LOCKS = "__GLOBAL_LOCKS"; - private volatile DbLockManager lockMgr = null; + private volatile TxnCoordinator txnCoordinator; + private volatile DbLockManager lockMgr; /** * The Metastore TXNS sequence is initialized to 1. * Thus is 1 is first transaction id. @@ -113,7 +114,7 @@ public final class DbTxnManager extends HiveTxnManagerImpl { /** * The local cache of table write IDs allocated/created by the current transaction */ - private Map tableWriteIds = new HashMap<>(); + private final Map tableWriteIds = new HashMap<>(); private boolean shouldReallocateWriteIds = false; /** @@ -177,8 +178,6 @@ public final class DbTxnManager extends HiveTxnManagerImpl { private static final int SHUTDOWN_HOOK_PRIORITY = 0; //Contains database under replication name for hive replication transactions (dump and load operation) private String replPolicy; - - private TxnCoordinator txnCoordinator; /** * We do this on every call to make sure TM uses same MS connection as is used by the caller (Driver, @@ -199,7 +198,7 @@ IMetaStoreClient getMS() throws LockException { try { return Hive.get(conf).getMSC(); } - catch(HiveException|MetaException e) { + catch (HiveException|MetaException e) { String msg = "Unable to reach Hive Metastore: " + e.getMessage(); LOG.error(msg, e); throw new LockException(e); @@ -258,11 +257,10 @@ long openTxn(Context ctx, String user, TxnType txnType, long delay) throws LockE try { replPolicy = ctx.getReplPolicy(); if (replPolicy != null) { - txnId = getMS().replOpenTxn(replPolicy, null, user, txnType).get(0); + txnId = getMS().replOpenTxn(replPolicy, null, user, txnType).getFirst(); } else { txnId = getMS().openTxn(user, txnType); } - txnCoordinator = null; stmtId = 0; numStatements = 0; tableWriteIds.clear(); @@ -379,17 +377,17 @@ private boolean allowOperationInATransaction(QueryPlan queryPlan) { if (queryPlan.getOperation() == HiveOperation.LOAD && queryPlan.getOutputs() != null && queryPlan.getOutputs().size() == 1) { WriteEntity writeEntity = queryPlan.getOutputs().iterator().next(); if (AcidUtils.isTransactionalTable(writeEntity.getTable())) { - switch (writeEntity.getWriteType()) { - case INSERT: + return switch (writeEntity.getWriteType()) { + case INSERT -> //allow operation in a txn - return true; - case INSERT_OVERWRITE: + true; + case INSERT_OVERWRITE -> //see HIVE-18154 - return false; - default: + false; + default -> //not relevant for LOAD - return false; - } + false; + }; } } //todo: handle Insert Overwrite as well: HIVE-18154 @@ -474,7 +472,7 @@ private Collection getGlobalLocks(Configuration conf) { if (StringUtils.isEmpty(lockNames)) { return Collections.emptyList(); } - List globalLocks = new ArrayList(); + List globalLocks = new ArrayList<>(); for (String lockName : lockNames.split(",")) { lockName = lockName.trim(); if (StringUtils.isEmpty(lockName)) { @@ -521,6 +519,9 @@ private void clearLocksAndHB() { } private void resetTxnInfo() { + if (txnId > 0) { + lockMgr = null; + } txnId = 0; txnCoordinator = null; stmtId = -1; @@ -531,12 +532,11 @@ private void resetTxnInfo() { replPolicy = null; } - public T getOrSetTxnCoordinator( + public synchronized T getOrSetTxnCoordinator( Class clazz, Function creator) { if (txnCoordinator == null && creator != null) { try { txnCoordinator = creator.apply(getMS()); - numStatements = 1; } catch (LockException e) { throw new RuntimeException(e); } @@ -711,7 +711,7 @@ public void heartbeat() throws LockException { } catch (TException e) { throw new LockException( ErrorMsg.METASTORE_COMMUNICATION_FAILED.getMsg() + "(" + JavaUtils.txnIdToString(txnId) - + "," + lock.toString() + ")", e); + + "," + lock + ")", e); } } } @@ -889,7 +889,7 @@ public boolean recordSnapshot(QueryPlan queryPlan) { else if (!isExplicitTransaction) { assert numStatements == 1 : "numStatements=" + numStatements + " in implicit txn"; if (queryPlan.hasAcidResourcesInQuery()) { - //1st and only stmt in implicit txn and uses acid resource + // 1st and only stmt in implicit txn and uses acid resource return true; } } @@ -909,7 +909,7 @@ public boolean isImplicitTransactionOpen(Context ctx) { } if (!isExplicitTransaction) { if (ctx == null || !ctx.isExplainSkipExecution()) { - assert numStatements == 1 : "numStatements=" + numStatements; + assert numStatements <= 1 : "numStatements=" + numStatements; } return true; } @@ -937,7 +937,8 @@ private void init() { if (conf == null) { throw new RuntimeException("Must call setHiveConf before any other methods."); } - initHeartbeatExecutorService(conf.getIntVar(HiveConf.ConfVars.HIVE_TXN_HEARTBEAT_THREADPOOL_SIZE)); + initHeartbeatExecutorService( + conf.getIntVar(HiveConf.ConfVars.HIVE_TXN_HEARTBEAT_THREADPOOL_SIZE)); } private synchronized static void initHeartbeatExecutorService(int corePoolSize) { @@ -1100,7 +1101,7 @@ public static long getHeartbeatInterval(Configuration conf) throws LockException long interval = HiveConf.getTimeVar(conf, HiveConf.ConfVars.HIVE_TXN_TIMEOUT, TimeUnit.MILLISECONDS) / 2; if (interval == 0) { - throw new LockException(HiveConf.ConfVars.HIVE_TXN_TIMEOUT.toString() + " not set," + + throw new LockException(HiveConf.ConfVars.HIVE_TXN_TIMEOUT + " not set," + " heartbeats won't be sent"); } return interval; @@ -1110,9 +1111,9 @@ public static long getHeartbeatInterval(Configuration conf) throws LockException * Heartbeater thread */ public static class Heartbeater implements Runnable { - private HiveTxnManager txnMgr; - private HiveConf conf; - private UserGroupInformation currentUser; + private final HiveTxnManager txnMgr; + private final HiveConf conf; + private final UserGroupInformation currentUser; LockException lockException; private final String queryId; diff --git a/ql/src/java/org/apache/hadoop/hive/ql/session/SessionStateUtil.java b/ql/src/java/org/apache/hadoop/hive/ql/session/SessionStateUtil.java index c70f7fd18c96..831a950627b0 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/session/SessionStateUtil.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/session/SessionStateUtil.java @@ -41,6 +41,7 @@ public class SessionStateUtil { public static final String MISSING_COLUMNS = "missingColumns"; public static final String COLUMN_DEFAULTS = "columnDefaults"; public static final String ROW_LINEAGE = "rowLineage"; + public static final String OUTPUT_TABLE_COUNT = "outputTablesCount"; private SessionStateUtil() { } @@ -145,6 +146,15 @@ public static Optional getQueryState(Configuration conf) { .map(ss -> ss.getQueryState(HiveConf.getQueryId(conf))); } + public static void setOutputTableCount(Configuration conf, int outputTableCount) { + SessionStateUtil.addResource(conf, OUTPUT_TABLE_COUNT, outputTableCount); + } + + public static Optional getOutputTableCount(Configuration conf) { + return getResource(conf, OUTPUT_TABLE_COUNT) + .map(Integer.class::cast); + } + /** * Container class for job commit information. */ From ee0974c240ba4d13cd9a5f57e58088e562a3cdb9 Mon Sep 17 00:00:00 2001 From: Denys Kuzmenko Date: Tue, 17 Feb 2026 20:56:29 +0200 Subject: [PATCH 3/4] txn stats fixes --- .../org/apache/iceberg/HiveTransaction.java | 93 ++---- .../iceberg/hive/HiveTxnCoordinator.java | 53 +-- .../iceberg/mr/hive/HiveIcebergMetaHook.java | 2 +- .../mr/hive/HiveIcebergStorageHandler.java | 170 ++++++---- .../apache/iceberg/mr/hive/HiveTableUtil.java | 3 +- .../iceberg/mr/hive/IcebergTableUtil.java | 314 +++++++++++------- ...major_compaction_partition_evolution.q.out | 14 +- .../org/apache/hadoop/hive/ql/QueryState.java | 6 + .../table/info/desc/DescTableOperation.java | 6 +- .../hadoop/hive/ql/stats/StatsUtils.java | 4 + .../info/desc/TestDescTableOperation.java | 4 +- 11 files changed, 371 insertions(+), 298 deletions(-) diff --git a/iceberg/iceberg-catalog/src/main/java/org/apache/iceberg/HiveTransaction.java b/iceberg/iceberg-catalog/src/main/java/org/apache/iceberg/HiveTransaction.java index bf8041120b5a..6fb51abf0069 100644 --- a/iceberg/iceberg-catalog/src/main/java/org/apache/iceberg/HiveTransaction.java +++ b/iceberg/iceberg-catalog/src/main/java/org/apache/iceberg/HiveTransaction.java @@ -19,13 +19,11 @@ package org.apache.iceberg; -import java.util.Set; -import java.util.stream.Collectors; +import java.lang.invoke.MethodHandle; +import java.lang.invoke.MethodHandles; +import java.lang.invoke.MethodType; import org.apache.iceberg.hive.HiveTableOperations; import org.apache.iceberg.hive.StagingTableOperations; -import org.apache.iceberg.io.FileIO; -import org.apache.iceberg.relocated.com.google.common.collect.Sets; -import org.apache.iceberg.util.Tasks; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -33,13 +31,15 @@ * Transaction implementation that stages metadata changes for atomic batch HMS updates across * multiple tables. * - *

Extends BaseTransaction to leverage Iceberg's retry and conflict resolution logic while + *

Extends BaseTransaction to reuse its update tracking and commit machinery while * capturing metadata locations instead of publishing directly to HMS. */ public class HiveTransaction extends BaseTransaction { private static final Logger LOG = LoggerFactory.getLogger(HiveTransaction.class); + private static final MethodHandle CLEANUP_HANDLE = initCleanupHandle(); + private final HiveTableOperations hiveOps; private final StagingTableOperations stagingOps; @@ -53,6 +53,7 @@ private HiveTransaction(Table table, HiveTableOperations ops, StagingTableOperat this.stagingOps = stagingOps; } + @Override public HiveTableOperations ops() { return hiveOps; } @@ -68,61 +69,13 @@ public StagingTableOperations stagingOps() { *

Called by the coordinator when the batch HMS update fails after staging succeeded. */ public void cleanUpOnCommitFailure() { - // clean up manifests and manifest lists from new snapshots - cleanAllUpdates(); - + try { + CLEANUP_HANDLE.invoke(this); + } catch (Throwable t) { + throw new IllegalStateException("Failed to invoke cleanUpOnCommitFailure", t); + } // delete the staged metadata JSON file deleteMetadataFile(); - - // delete uncommitted files tracked by the base transaction - deleteUncommittedFiles(); - } - - /** - * Deletes manifest files and manifest lists produced by new snapshots in this transaction. - * Uses metadata diff (current vs start) to identify new snapshots and their artifacts. - */ - private void cleanAllUpdates() { - FileIO io = stagingOps.io(); - - // Collect all manifest paths from the base metadata — these must NOT be deleted - Set baseManifestPaths = Sets.newHashSet(); - for (Snapshot snapshot : startMetadata().snapshots()) { - try { - snapshot.allManifests(io).forEach(m -> baseManifestPaths.add(m.path())); - } catch (RuntimeException e) { - LOG.warn("Failed to read base manifests for cleanup", e); - } - } - - // Find new snapshots added by this transaction and clean their artifacts - Set baseSnapshotIds = startMetadata().snapshots().stream() - .map(Snapshot::snapshotId) - .collect(Collectors.toSet()); - - for (Snapshot snapshot : currentMetadata().snapshots()) { - if (baseSnapshotIds.contains(snapshot.snapshotId())) { - continue; - } - - // Delete new manifest files (not from base) - try { - for (ManifestFile manifest : snapshot.allManifests(io)) { - if (!baseManifestPaths.contains(manifest.path())) { - io.deleteFile(manifest.path()); - } - } - } catch (RuntimeException e) { - LOG.warn("Failed to clean manifests for snapshot {}", snapshot.snapshotId(), e); - } - - // Delete the manifest list - try { - io.deleteFile(snapshot.manifestListLocation()); - } catch (RuntimeException e) { - LOG.warn("Failed to clean manifest list {}", snapshot.manifestListLocation(), e); - } - } } /** @@ -139,13 +92,19 @@ private void deleteMetadataFile() { } } - /** - * Deletes uncommitted files tracked during the transaction (e.g. replaced data files). - */ - private void deleteUncommittedFiles() { - Tasks.foreach(deletedFiles()) - .suppressFailureWhenFinished() - .onFailure((file, exc) -> LOG.warn("Failed to delete uncommitted file: {}", file, exc)) - .run(stagingOps.io()::deleteFile); + private static MethodHandle initCleanupHandle() { + try { + MethodHandles.Lookup lookup = + MethodHandles.privateLookupIn(BaseTransaction.class, MethodHandles.lookup()); + return lookup.findSpecial( + BaseTransaction.class, + "cleanUpOnCommitFailure", + MethodType.methodType(void.class), + BaseTransaction.class + ); + } catch (Exception e) { + throw new ExceptionInInitializerError(e); + } } + } diff --git a/iceberg/iceberg-catalog/src/main/java/org/apache/iceberg/hive/HiveTxnCoordinator.java b/iceberg/iceberg-catalog/src/main/java/org/apache/iceberg/hive/HiveTxnCoordinator.java index 423e5b483d6d..da3048096792 100644 --- a/iceberg/iceberg-catalog/src/main/java/org/apache/iceberg/hive/HiveTxnCoordinator.java +++ b/iceberg/iceberg-catalog/src/main/java/org/apache/iceberg/hive/HiveTxnCoordinator.java @@ -24,7 +24,6 @@ import java.util.Objects; import java.util.Set; import java.util.stream.Collectors; -import java.util.stream.Stream; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hive.TxnCoordinator; import org.apache.hadoop.hive.common.StatsSetupConst; @@ -34,7 +33,6 @@ import org.apache.hadoop.hive.metastore.api.TableParamsUpdate; import org.apache.hadoop.hive.metastore.utils.MetaStoreUtils; import org.apache.iceberg.BaseTable; -import org.apache.iceberg.BlobMetadata; import org.apache.iceberg.HiveTransaction; import org.apache.iceberg.TableMetadata; import org.apache.iceberg.Transaction; @@ -177,7 +175,7 @@ private void doCommit(List> updates) { locks.forEach(HiveLock::ensureActive); msClient.updateTableParams(payload); - // Verify locks still active after persist — if lost, commit state is unknown + // 6. Verify locks still active after persist — if lost, commit state is unknown try { locks.forEach(HiveLock::ensureActive); } catch (LockException le) { @@ -241,10 +239,7 @@ private TableParamsUpdate buildTableParamsUpdate( maxPropSize, base.metadataFileLocation()); - List colNames = getStatsColumnNames(newMetadata); - if (!colNames.isEmpty()) { - StatsSetupConst.setColumnStatsState(tbl.getParameters(), colNames); - } + populateStatsState(newMetadata, tbl); TableParamsUpdate newParams = new TableParamsUpdate(); newParams.setDb_name(ops.database()); @@ -258,25 +253,35 @@ private TableParamsUpdate buildTableParamsUpdate( return newParams; } - private static List getStatsColumnNames(TableMetadata metadata) { - Stream colStatsBlobs = metadata.statisticsFiles().stream() - .flatMap(sf -> sf.blobMetadata().stream()) - .filter(blob -> ColumnStatisticsObj.class.getSimpleName().equals(blob.type())); - - if (metadata.spec().isUnpartitioned()) { - // For unpartitioned tables: each blob is a column - return colStatsBlobs - .flatMap(blob -> blob.fields().stream()) - .map(fieldId -> metadata.schema().findColumnName(fieldId)) - .toList(); + private static void populateStatsState(TableMetadata metadata, Table tbl) { + if (metadata.spec().isUnpartitioned() || !metadata.partitionStatisticsFiles().isEmpty()) { + StatsSetupConst.setBasicStatsState(tbl.getParameters(), StatsSetupConst.TRUE); } + List colNames = getStatsColumnNames(metadata); + if (!colNames.isEmpty()) { + StatsSetupConst.setColumnStatsState(tbl.getParameters(), colNames); + } + } - // For partitioned tables: each blob is a partition containing all columns, - // take the first blob and fetch all columns from its fields list - return colStatsBlobs.findFirst() - .map(blob -> blob.fields().stream() - .map(fieldId -> metadata.schema().findColumnName(fieldId)) - .toList()) + private static List getStatsColumnNames(TableMetadata metadata) { + // Find the first statistics file that contains ColumnStatisticsObj blobs. + return metadata.statisticsFiles().stream() + .filter(sf -> sf.blobMetadata().stream() + .anyMatch(blob -> ColumnStatisticsObj.class.getSimpleName().equals(blob.type()))) + .findFirst() + .map(sf -> { + // Unpartitioned: each blob = one column, need all blobs' fields. + // Partitioned: first blob has ALL column field IDs. + if (metadata.spec().isUnpartitioned()) { + return sf.blobMetadata().stream() + .flatMap(blob -> blob.fields().stream()) + .map(fieldId -> metadata.schema().findColumnName(fieldId)) + .toList(); + } + return sf.blobMetadata().getFirst().fields().stream() + .map(fieldId -> metadata.schema().findColumnName(fieldId)) + .toList(); + }) .orElse(List.of()); } diff --git a/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/HiveIcebergMetaHook.java b/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/HiveIcebergMetaHook.java index 865116414459..8944e8619dba 100644 --- a/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/HiveIcebergMetaHook.java +++ b/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/HiveIcebergMetaHook.java @@ -600,7 +600,7 @@ private Expression generateExprFromPartitionNames(List partNames) throws for (String partName : partNames) { try { Map partitionSpec = Warehouse.makeSpecFromName(partName); - Expression partitionExpr = IcebergTableUtil.generateExprForIdentityPartition( + Expression partitionExpr = IcebergTableUtil.buildPartitionExpr( icebergTable, partitionSpec, partitionFields); predicate = Expressions.or(predicate, partitionExpr); diff --git a/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/HiveIcebergStorageHandler.java b/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/HiveIcebergStorageHandler.java index 8c61dcb98d15..49e58b875c17 100644 --- a/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/HiveIcebergStorageHandler.java +++ b/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/HiveIcebergStorageHandler.java @@ -75,7 +75,6 @@ import org.apache.hadoop.hive.ql.Context.Operation; import org.apache.hadoop.hive.ql.Context.RewritePolicy; import org.apache.hadoop.hive.ql.ErrorMsg; -import org.apache.hadoop.hive.ql.QueryState; import org.apache.hadoop.hive.ql.ddl.table.AbstractAlterTableDesc; import org.apache.hadoop.hive.ql.ddl.table.AlterTableType; import org.apache.hadoop.hive.ql.ddl.table.create.CreateTableDesc; @@ -133,7 +132,6 @@ import org.apache.hadoop.mapred.OutputFormat; import org.apache.iceberg.BaseMetastoreTableOperations; import org.apache.iceberg.BaseTable; -import org.apache.iceberg.BaseTransaction; import org.apache.iceberg.CatalogUtil; import org.apache.iceberg.DataFile; import org.apache.iceberg.DataOperations; @@ -197,7 +195,6 @@ import org.apache.iceberg.relocated.com.google.common.base.Preconditions; import org.apache.iceberg.relocated.com.google.common.collect.FluentIterable; import org.apache.iceberg.relocated.com.google.common.collect.ImmutableList; -import org.apache.iceberg.relocated.com.google.common.collect.ImmutableMap; import org.apache.iceberg.relocated.com.google.common.collect.Iterables; import org.apache.iceberg.relocated.com.google.common.collect.Lists; import org.apache.iceberg.relocated.com.google.common.collect.Maps; @@ -233,7 +230,6 @@ public class HiveIcebergStorageHandler extends DefaultStorageHandler implements private static final String TABLE_NAME_SEPARATOR = ".."; public static final String TABLE_DEFAULT_LOCATION = "TABLE_DEFAULT_LOCATION"; - private static final String SPEC_ID = "spec-id"; private static final String PARTITION = "partition"; public static final String STATS = "/stats/snap-"; @@ -556,13 +552,9 @@ public Map computeBasicStatistics(Partish partish) { throw new UncheckedIOException(e); } - Transaction txn = IcebergAcidUtil.getOrCreateTransaction(table, conf); - txn.table().updatePartitionStatistics() + table.updatePartitionStatistics() .setPartitionStatistics(statsFile) .commit(); - if (txn.getClass() == BaseTransaction.class) { - txn.commitTransaction(); - } } } return getBasicStatistics(partish); @@ -585,18 +577,11 @@ private static Map getPartishSummary(Partish partish, Table tabl }).orNull(); if (partitionStats != null) { - Map stats = ImmutableMap.of( - TOTAL_DATA_FILES_PROP, String.valueOf(partitionStats.dataFileCount()), - TOTAL_RECORDS_PROP, String.valueOf(partitionStats.dataRecordCount()), - TOTAL_EQ_DELETES_PROP, String.valueOf(partitionStats.equalityDeleteRecordCount()), - TOTAL_POS_DELETES_PROP, String.valueOf(partitionStats.positionDeleteRecordCount()), - TOTAL_FILE_SIZE_PROP, String.valueOf(partitionStats.totalDataFileSizeInBytes()) - ); - return stats; + return IcebergTableUtil.toStatsMap(partitionStats); } else { - LOG.warn("Partition {} not found in stats file: {}", + LOG.warn("Partition {} not found in stats file: {}, falling back to metadata scan", partish.getPartition().getName(), statsFile.path()); - return null; + return IcebergTableUtil.getPartitionStats(table, partish.getPartition().getSpec(), snapshot); } } catch (IOException e) { throw new UncheckedIOException(e); @@ -611,7 +596,7 @@ private static Map getPartishSummary(Partish partish, Table tabl private Table getTable(org.apache.hadoop.hive.ql.metadata.Table hmsTable) { boolean skipCache = SessionStateUtil.getQueryState(conf) - .map(queryState -> queryState.getNumModifiedRows() > 0) + .map(qs -> !qs.isTxnOpen() && qs.getNumModifiedRows() > 0) .orElse(true); return IcebergTableUtil.getTable(conf, hmsTable.getTTable(), skipCache); } @@ -627,6 +612,7 @@ public boolean setColStatistics(org.apache.hadoop.hive.ql.metadata.Table hmsTabl return writeColStats(colStats, tbl); } + @SuppressWarnings("checkstyle:CyclomaticComplexity") private boolean writeColStats(List colStats, Table tbl) { try { if (!shouldRewriteColStats(tbl)) { @@ -635,41 +621,66 @@ private boolean writeColStats(List colStats, Table tbl) { StatisticsFile statisticsFile; String statsPath = tbl.location() + STATS + UUID.randomUUID(); - try (PuffinWriter puffinWriter = Puffin.write(tbl.io().newOutputFile(statsPath)) - .createdBy(Constants.HIVE_ENGINE).build()) { + try (PuffinWriter writer = Puffin.write(tbl.io().newOutputFile(statsPath)) + .createdBy(Constants.HIVE_ENGINE) + .build()) { + long snapshotId = tbl.currentSnapshot().snapshotId(); long snapshotSequenceNumber = tbl.currentSnapshot().sequenceNumber(); + Schema schema = tbl.spec().schema(); + + boolean first = true; - colStats.forEach(stats -> { + for (ColumnStatistics stats : colStats) { boolean isTblLevel = stats.getStatsDesc().isIsTblLevel(); - for (Serializable statsObj : isTblLevel ? stats.getStatsObj() : Collections.singletonList(stats)) { - byte[] serializeColStats = SerializationUtils.serialize(statsObj); - puffinWriter.add( - new Blob( + Map properties = isTblLevel ? Map.of() : + Map.of(PARTITION, String.valueOf(stats.getStatsDesc().getPartName())); + + List statsObjects = isTblLevel ? + stats.getStatsObj() : List.of(stats); + + List fieldIds = null; + + if (!isTblLevel) { + // For partition-level stats, we emit one blob per partition; + // therefore, only the first blob should contain the actual fieldIds. + fieldIds = !first ? List.of(-1) : + stats.getStatsObj().stream() + .map(obj -> schema.findField(obj.getColName()).fieldId()) + .toList(); + first = false; + } + + for (Serializable statsObj : statsObjects) { + byte[] serialized = SerializationUtils.serialize(statsObj); + + if (isTblLevel) { + fieldIds = List.of(schema.findField( + ((ColumnStatisticsObj) statsObj).getColName()).fieldId()); + } + + writer.add(new Blob( ColumnStatisticsObj.class.getSimpleName(), - ImmutableList.of(isTblLevel ? tbl.spec().schema().findField( - ((ColumnStatisticsObj) statsObj).getColName()).fieldId() : 1), + fieldIds, snapshotId, snapshotSequenceNumber, - ByteBuffer.wrap(serializeColStats), + ByteBuffer.wrap(serialized), PuffinCompressionCodec.NONE, - isTblLevel ? - ImmutableMap.of(SPEC_ID, String.valueOf(tbl.spec().specId())) : - ImmutableMap.of(PARTITION, String.valueOf(stats.getStatsDesc().getPartName())) - )); + properties + )); } - }); + } - puffinWriter.finish(); + writer.finish(); statisticsFile = new GenericStatisticsFile( snapshotId, statsPath, - puffinWriter.fileSize(), - puffinWriter.footerSize(), - puffinWriter.writtenBlobsMetadata().stream() + writer.fileSize(), + writer.footerSize(), + writer.writtenBlobsMetadata().stream() .map(GenericBlobMetadata::from) .collect(ImmutableList.toImmutableList()) ); @@ -683,14 +694,9 @@ private boolean writeColStats(List colStats, Table tbl) { } return false; } - - Transaction txn = IcebergAcidUtil.getOrCreateTransaction(tbl, conf); - txn.table().updateStatistics() + tbl.updateStatistics() .setStatistics(statisticsFile) .commit(); - if (txn.getClass() == BaseTransaction.class) { - txn.commitTransaction(); - } return true; } catch (Exception e) { @@ -722,13 +728,18 @@ public List getColStatistics(org.apache.hadoop.hive.ql.meta if (snapshot == null) { return Lists.newArrayList(); } + // If reading a non-current snapshot whose schema has undergone partition evolution, return an empty list. + // This should be revisited once isPartitioned() is refactored to provide full support for partitioned tables. + if (!snapshot.equals(table.currentSnapshot()) && + IcebergTableUtil.hasUndergonePartitionEvolution(snapshot, table.io())) { + return Lists.newArrayList(); + } Predicate filter; if (colNames != null) { Set columns = Sets.newHashSet(colNames); filter = metadata -> { - int specId = Integer.parseInt(metadata.properties().get(SPEC_ID)); - String column = table.specs().get(specId).schema().findColumnName(metadata.inputFields().getFirst()); + String column = table.schema().findColumnName(metadata.inputFields().getFirst()); return columns.contains(column); }; } else { @@ -800,9 +811,10 @@ private String getStatsSource() { } private boolean shouldRewriteColStats(Table tbl) { - return SessionStateUtil.getQueryState(conf).map(QueryState::getHiveOperation) - .filter(opType -> HiveOperation.ANALYZE_TABLE == opType).isPresent() || - IcebergTableUtil.getColStatsPath(tbl) != null; + return SessionStateUtil.getQueryState(conf) + .map(qs -> HiveOperation.ANALYZE_TABLE == qs.getHiveOperation()) + .orElse(false) || + IcebergTableUtil.getColStatsPath(tbl) != null; } private void checkAndMergeColStats(List statsNew, Table tbl) throws InvalidObjectException { @@ -1761,8 +1773,8 @@ private void fallbackToNonVectorizedModeBasedOnProperties(Properties tableProps) hasOrcTimeInSchema(tableProps, tableSchema) || !hasParquetNestedTypeWithinListOrMap(tableProps, tableSchema)) { // disable vectorization - SessionStateUtil.getQueryState(conf).ifPresent(queryState -> - queryState.getConf().setBoolVar(ConfVars.HIVE_VECTORIZATION_ENABLED, false)); + SessionStateUtil.getQueryState(conf).ifPresent(qs -> + qs.getConf().setBoolVar(ConfVars.HIVE_VECTORIZATION_ENABLED, false)); } } @@ -2047,10 +2059,9 @@ public boolean canUseTruncate(org.apache.hadoop.hive.ql.metadata.Table hmsTable, return false; } - Expression partitionExpr = IcebergTableUtil.generateExprForIdentityPartition( - table, partitionSpec, true); - - FindFiles.Builder builder = new FindFiles.Builder(table).withRecordsMatching(partitionExpr); + Expression partitionExpr = IcebergTableUtil.buildPartitionExpr(table, partitionSpec); + FindFiles.Builder builder = new FindFiles.Builder(table) + .withRecordsMatching(partitionExpr); Set dataFiles = Sets.newHashSet(builder.collect()); boolean result = true; @@ -2081,7 +2092,8 @@ public boolean isPartitioned(org.apache.hadoop.hive.ql.metadata.Table hmsTable) Snapshot snapshot = IcebergTableUtil.getTableSnapshot(table, hmsTable); boolean readsNonCurrentSnapshot = snapshot != null && !snapshot.equals(table.currentSnapshot()); - if (readsNonCurrentSnapshot && IcebergTableUtil.hasUndergonePartitionEvolution(table)) { + if (readsNonCurrentSnapshot && + IcebergTableUtil.hasUndergonePartitionEvolution(snapshot, table.io())) { return false; } return table.spec().isPartitioned(); @@ -2094,9 +2106,8 @@ public Partition getPartition(org.apache.hadoop.hive.ql.metadata.Table table, validatePartSpec(table, partitionSpec, policy); boolean isDescTable = SessionStateUtil.getQueryState(conf) - .map(QueryState::getHiveOperation) - .filter(op -> op == HiveOperation.DESCTABLE) - .isPresent(); + .map(qs -> HiveOperation.DESCTABLE == qs.getHiveOperation()) + .orElse(false); if (!isDescTable) { return createDummyPartitionHandle(table, partitionSpec); @@ -2233,31 +2244,38 @@ public List getPartitionsByExpr(org.apache.hadoop.hive.ql.metadata.Ta if (exp == null) { return ImmutableList.of(); } + Table table = IcebergTableUtil.getTable(conf, hmsTable.getTTable()); - int tableSpecId = table.spec().specId(); - Set partitions = Sets.newHashSet(); + Snapshot snapshot = IcebergTableUtil.getTableSnapshot(table, hmsTable); + + boolean readsCurrentSnapshot = snapshot != null && snapshot.equals(table.currentSnapshot()); + boolean filterBySpecId = latestSpecOnly != null && readsCurrentSnapshot; + + Predicate specFilter = specId -> + !filterBySpecId || latestSpecOnly == (specId == table.spec().specId()); TableScan scan = table.newScan().filter(exp) .caseSensitive(false).includeColumnStats().ignoreResiduals(); + if (snapshot != null) { + scan = scan.useSnapshot(snapshot.snapshotId()); + } + + Set partitions = Sets.newHashSet(); try (CloseableIterable tasks = scan.planFiles()) { FluentIterable.from(tasks) .filter(task -> task.spec().isPartitioned()) + .filter(task -> specFilter.test(task.file().specId())) .forEach(task -> { - DataFile file = task.file(); PartitionSpec spec = task.spec(); + PartitionData partitionData = IcebergTableUtil.toPartitionData(task.partition(), spec.partitionType()); + String partName = spec.partitionToPath(partitionData); - if (latestSpecOnly == null || latestSpecOnly && file.specId() == tableSpecId || - !latestSpecOnly && file.specId() != tableSpecId) { - PartitionData partitionData = IcebergTableUtil.toPartitionData(task.partition(), spec.partitionType()); - String partName = spec.partitionToPath(partitionData); - - Map partSpecMap = Maps.newLinkedHashMap(); - Warehouse.makeSpecFromName(partSpecMap, new Path(partName), null); + Map partSpecMap = Maps.newLinkedHashMap(); + Warehouse.makeSpecFromName(partSpecMap, new Path(partName), null); - DummyPartition partition = new DummyPartition(hmsTable, partName, partSpecMap); - partitions.add(partition); - } + DummyPartition partition = new DummyPartition(hmsTable, partName, partSpecMap); + partitions.add(partition); }); } catch (IOException e) { throw new SemanticException(String.format("Error while fetching the partitions due to: %s", e)); @@ -2269,9 +2287,15 @@ public List getPartitionsByExpr(org.apache.hadoop.hive.ql.metadata.Ta public boolean hasDataMatchingFilterExpr(org.apache.hadoop.hive.ql.metadata.Table hmsTable, ExprNodeDesc filter) { SearchArgument sarg = ConvertAstToSearchArg.create(conf, (ExprNodeGenericFuncDesc) filter); Expression exp = HiveIcebergFilterFactory.generateFilterExpression(sarg); + Table table = IcebergTableUtil.getTable(conf, hmsTable.getTTable()); + Snapshot snapshot = IcebergTableUtil.getTableSnapshot(table, hmsTable); + TableScan scan = table.newScan().filter(exp) .caseSensitive(false).includeColumnStats().ignoreResiduals(); + if (snapshot != null) { + scan = scan.useSnapshot(snapshot.snapshotId()); + } boolean result = false; try (CloseableIterable tasks = scan.planFiles()) { diff --git a/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/HiveTableUtil.java b/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/HiveTableUtil.java index fbdc36be3a19..9de7c0b1111d 100644 --- a/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/HiveTableUtil.java +++ b/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/HiveTableUtil.java @@ -172,8 +172,7 @@ public static void appendFiles(URI fromURI, String format, Table icebergTbl, boo if (isOverwrite) { DeleteFiles delete = transaction.newDelete(); if (partitionSpec != null) { - Expression partitionExpr = IcebergTableUtil.generateExprForIdentityPartition( - icebergTbl, partitionSpec, true); + Expression partitionExpr = IcebergTableUtil.buildPartitionExpr(icebergTbl, partitionSpec); delete.deleteFromRowFilter(partitionExpr); } else { delete.deleteFromRowFilter(Expressions.alwaysTrue()); diff --git a/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/IcebergTableUtil.java b/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/IcebergTableUtil.java index 86adf0ffcd2a..386473f46fee 100644 --- a/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/IcebergTableUtil.java +++ b/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/IcebergTableUtil.java @@ -27,6 +27,7 @@ import java.util.Iterator; import java.util.List; import java.util.Map; +import java.util.Objects; import java.util.Optional; import java.util.Properties; import java.util.Set; @@ -77,35 +78,40 @@ import org.apache.iceberg.PartitionField; import org.apache.iceberg.PartitionSpec; import org.apache.iceberg.PartitionStatisticsFile; +import org.apache.iceberg.PartitionStats; import org.apache.iceberg.Partitioning; import org.apache.iceberg.PartitionsTable; import org.apache.iceberg.Schema; import org.apache.iceberg.Snapshot; import org.apache.iceberg.SnapshotRef; +import org.apache.iceberg.SnapshotSummary; import org.apache.iceberg.StatisticsFile; import org.apache.iceberg.StructLike; import org.apache.iceberg.Table; import org.apache.iceberg.TableProperties; +import org.apache.iceberg.TableScan; import org.apache.iceberg.Transaction; import org.apache.iceberg.UpdatePartitionSpec; import org.apache.iceberg.catalog.TableIdentifier; +import org.apache.iceberg.expressions.Evaluator; import org.apache.iceberg.expressions.Expression; import org.apache.iceberg.expressions.Expressions; -import org.apache.iceberg.expressions.ResidualEvaluator; -import org.apache.iceberg.expressions.UnboundTerm; import org.apache.iceberg.hive.IcebergCatalogProperties; import org.apache.iceberg.io.CloseableIterable; +import org.apache.iceberg.io.FileIO; import org.apache.iceberg.mr.Catalogs; import org.apache.iceberg.mr.InputFormatConfig; import org.apache.iceberg.puffin.BlobMetadata; import org.apache.iceberg.puffin.Puffin; import org.apache.iceberg.puffin.PuffinReader; import org.apache.iceberg.relocated.com.google.common.collect.FluentIterable; +import org.apache.iceberg.relocated.com.google.common.collect.ImmutableMap; import org.apache.iceberg.relocated.com.google.common.collect.Iterables; import org.apache.iceberg.relocated.com.google.common.collect.Lists; import org.apache.iceberg.relocated.com.google.common.collect.Maps; import org.apache.iceberg.transforms.Transform; import org.apache.iceberg.types.Conversions; +import org.apache.iceberg.types.Type; import org.apache.iceberg.types.Types; import org.apache.iceberg.util.ByteBuffers; import org.apache.iceberg.util.Pair; @@ -128,6 +134,9 @@ public class IcebergTableUtil { public static final int SPEC_IDX = 1; public static final int PART_IDX = 0; + private static final String SPEC_ID_FIELD = "spec_id"; + private static final String NULL_VALUE = "null"; + private IcebergTableUtil() { } @@ -451,120 +460,149 @@ public static PartitionData toPartitionData(StructLike sourceKey, Types.StructTy return toPartitionData(projection, targetKeyType); } - public static Expression generateExprForIdentityPartition(Table table, Map partitionSpec, - boolean latestSpecOnly) throws SemanticException { - - Map partitionFields = getPartitionFields(table, latestSpecOnly).stream() - .collect(Collectors.toMap(PartitionField::name, Function.identity())); + /** + * Builds a filter expression for data table operations (deleteFromRowFilter, FindFiles). + * Only supports identity transforms. Keys are partition field names. + */ + static Expression buildPartitionExpr(Table table, Map partitionSpec) + throws SemanticException { - return generateExprForIdentityPartition(table, partitionSpec, partitionFields); + Map partitionFields = getPartitionFields(table, true).stream() + .collect(Collectors.toMap( + PartitionField::name, Function.identity()) + ); + return buildPartitionExpr(table, partitionSpec, partitionFields); } - public static Expression generateExprForIdentityPartition(Table table, Map partitionSpec, + static Expression buildPartitionExpr(Table table, Map partitionSpec, Map partitionFields) throws SemanticException { - return buildPartitionExpression( - partitionSpec, + Types.StructType partitionType = Partitioning.partitionType(table); + + return buildExpression(partitionSpec, (column, value) -> - buildIdentityPartitionPredicate(table, value, partitionFields.get(column)), - partitionFields::containsKey - ); + buildIdentityFieldPredicate(partitionType, partitionFields.get(column), value), + partitionFields::containsKey); } - public static Expression generateExprFromPartitionSpec(Table table, Map partitionSpec, + /** + * Builds a filter expression for the PARTITIONS metadata table from source column names. + * Handles partition evolution by OR-ing predicates across different transforms on the same source column. + */ + private static Expression buildPartitionsFilter(Table table, Map partitionSpec, boolean latestSpecOnly) throws SemanticException { // Group partition fields by source column name to handle partition evolution // where the same source column may have multiple transforms across different specs - Map> partitionFieldsBySourceColumn = - getPartitionFields(table, latestSpecOnly).stream() - .collect(Collectors.groupingBy( - pf -> table.schema().findColumnName(pf.sourceId())) - ); - - return buildPartitionExpression( - partitionSpec, + Map> bySourceColumn = getPartitionFields(table, latestSpecOnly).stream() + .collect(Collectors.groupingBy(pf -> + table.schema().findColumnName(pf.sourceId())) + ); + + return buildExpression(partitionSpec, (column, value) -> - buildTransformPartitionPredicate(table, value, partitionFieldsBySourceColumn.get(column)), - partitionFieldsBySourceColumn::containsKey - ); + buildSourceValuePredicate(table, value, bySourceColumn.get(column)), + bySourceColumn::containsKey); + } + + /** + * Builds a filter expression for the PARTITIONS metadata table from partition field names + * with already-transformed values (e.g. {key_bucket_8: 5}). + */ + private static Expression buildPartitionsFilterFromPath(Table table, Map partitionSpec) + throws SemanticException { + Types.StructType partitionType = Partitioning.partitionType(table); + + return buildExpression(partitionSpec, + (column, value) -> + buildFieldPredicate(partitionType, column, value, "partition."), + col -> partitionType.field(col) != null); + } + + static List getPartitionFields(Table table, boolean latestSpecOnly) { + if (latestSpecOnly) { + return table.spec().fields(); + } + return table.specs().values().stream() + .flatMap(spec -> spec.fields().stream() + .filter(f -> !f.transform().isVoid())) + .distinct() + .toList(); } @FunctionalInterface private interface PartitionPredicateBuilder { - Expression build(String partitionColumn, String partitionValue) throws SemanticException; + Expression build(String column, String value) throws SemanticException; } - private static Expression buildPartitionExpression( - Map partitionSpec, - PartitionPredicateBuilder predicateBuilder, - Predicate fieldValidator) throws SemanticException { - + private static Expression buildExpression(Map partitionSpec, + PartitionPredicateBuilder predicateBuilder, Predicate fieldValidator) throws SemanticException { Expression predicate = Expressions.alwaysTrue(); - for (Map.Entry entry : partitionSpec.entrySet()) { - String partitionColumn = entry.getKey(); - - // Validate field exists - if (!fieldValidator.test(partitionColumn)) { - throw new SemanticException( - "No partition column by the name: %s".formatted(partitionColumn)); + String column = entry.getKey(); + if (!fieldValidator.test(column)) { + throw new SemanticException("No partition column by the name: %s".formatted(column)); } - Expression columnPredicate = predicateBuilder.build(partitionColumn, entry.getValue()); - predicate = Expressions.and(predicate, columnPredicate); + predicate = Expressions.and(predicate, predicateBuilder.build(column, entry.getValue())); } - return predicate; } - private static Expression buildIdentityPartitionPredicate(Table table, String partitionValue, - PartitionField partitionField) throws SemanticException { + private static Expression buildFieldPredicate(Types.StructType partitionType, + String fieldName, String value, String keyPrefix) { + String key = keyPrefix + fieldName; + Object columnValue = parsePartitionValue(partitionType.field(fieldName).type(), value); - if (!partitionField.transform().isIdentity()) { - throw new SemanticException( - "Partition transforms are not supported here: %s".formatted(partitionField.name())); - } - Types.NestedField sourceField = table.schema().findField(partitionField.sourceId()); - Object columnValue = Conversions.fromPartitionString(sourceField.type(), partitionValue); + return columnValue == null ? + Expressions.isNull(key) : Expressions.equal(key, columnValue); + } - return Expressions.equal(partitionField.name(), columnValue); + private static Expression buildIdentityFieldPredicate(Types.StructType partitionType, + PartitionField field, String value) throws SemanticException { + if (!field.transform().isIdentity()) { + throw new SemanticException("Partition transforms are not supported here: %s".formatted(field.name())); + } + return buildFieldPredicate(partitionType, field.name(), value, ""); } - private static Expression buildTransformPartitionPredicate(Table table, String partitionValue, + private static Expression buildSourceValuePredicate(Table table, String partitionValue, List partitionFields) { // Get source field type from first partition field (all share same source) Types.NestedField sourceField = table.schema().findField( partitionFields.getFirst().sourceId()); - Object columnValue = Conversions.fromPartitionString(sourceField.type(), partitionValue); + Object columnValue = parsePartitionValue(sourceField.type(), partitionValue); - Expression predicate = Expressions.alwaysFalse(); + Expression partitionExpr = Expressions.alwaysFalse(); // Create OR expression for each transform on this source column for (PartitionField partitionField : partitionFields) { - // Apply the transform to the source value - @SuppressWarnings("unchecked") - Transform transform = (Transform) partitionField.transform(); - Object transformedValue = transform.bind(sourceField.type()).apply(columnValue); + Expression predicate = buildTransformedFieldPredicate(partitionField, columnValue, sourceField); + partitionExpr = Expressions.or(partitionExpr, predicate); + } - TransformSpec transformSpec = TransformSpec.fromString(transform.toString().toUpperCase(), sourceField.name()); - UnboundTerm term = SchemaUtils.toTerm(transformSpec); + return partitionExpr; + } - predicate = Expressions.or( - predicate, Expressions.equal(term, transformedValue)); + private static Expression buildTransformedFieldPredicate( + PartitionField partitionField, Object columnValue, Types.NestedField sourceField) { + String partitionKey = "partition." + partitionField.name(); + if (columnValue == null) { + return Expressions.isNull(partitionKey); } + // Apply the transform to the source value + @SuppressWarnings("unchecked") + Transform transform = (Transform) partitionField.transform(); + Object transformedValue = transform.bind(sourceField.type()).apply(columnValue); - return predicate; + return Expressions.equal(partitionKey, transformedValue); } - public static List getPartitionFields(Table table, boolean latestSpecOnly) { - if (latestSpecOnly) { - return table.spec().fields(); - } - return table.specs().values().stream() - .flatMap(spec -> spec.fields().stream()) - .filter(f -> !f.transform().isVoid()) - .toList(); + private static Object parsePartitionValue(Type type, String value) { + boolean isNullValue = NULL_VALUE.equalsIgnoreCase(value) && + !Types.StringType.get().equals(type); + return isNullValue ? + null : Conversions.fromPartitionString(type, value); } /** @@ -632,24 +670,40 @@ private static List getPartitionNames(Configuration conf, Comparator> specIdComparator) throws SemanticException { Table icebergTable = getTable(conf, table.getTTable()); - Expression partitionExpr = IcebergTableUtil.generateExprFromPartitionSpec( - icebergTable, partitionSpec, latestSpecOnly); - - int latestSpecId = icebergTable.spec().specId(); + Expression partitionExpr = buildPartitionsFilter(icebergTable, partitionSpec, latestSpecOnly); Types.StructType partitionType = Partitioning.partitionType(icebergTable); + Snapshot snapshot = IcebergTableUtil.getTableSnapshot(icebergTable, table); + boolean readsCurrentSnapshot = snapshot != null && snapshot.equals(icebergTable.currentSnapshot()); + + if (latestSpecOnly && readsCurrentSnapshot) { + partitionExpr = Expressions.and( + partitionExpr, Expressions.equal(SPEC_ID_FIELD, icebergTable.spec().specId())); + } + PartitionsTable partitionsTable = (PartitionsTable) MetadataTableUtils.createMetadataTableInstance( icebergTable, MetadataTableType.PARTITIONS); + Evaluator evaluator = new Evaluator(partitionsTable.schema().asStruct(), partitionExpr); + + TableScan scan = partitionsTable.newScan().filter(partitionExpr); + if (snapshot != null) { + scan = scan.useSnapshot(snapshot.snapshotId()); + } - try (CloseableIterable fileScanTasks = partitionsTable.newScan().planFiles()) { + try (CloseableIterable fileScanTasks = scan.planFiles()) { return FluentIterable.from(fileScanTasks) .transformAndConcat(task -> task.asDataTask().rows()) - .transform(row -> extractPartitionDataAndSpec(row, icebergTable, partitionType)) - .filter(entry -> matchesPartition(entry, partitionExpr, latestSpecOnly, latestSpecId)) - // Create (partitionPath, specId) entries for sorting - .transform(entry -> Maps.immutableEntry( - entry.getValue().partitionToPath(entry.getKey()), - entry.getValue().specId())) + .filter(evaluator::eval) + .transform(row -> { + PartitionSpec spec = icebergTable.specs().get(row.get(SPEC_IDX, Integer.class)); + if (!spec.isPartitioned()) { + return null; + } + PartitionData data = toPartitionData( + row.get(PART_IDX, StructProjection.class), partitionType, spec.partitionType()); + return Maps.immutableEntry(spec.partitionToPath(data), spec.specId()); + }) + .filter(Objects::nonNull) .toSortedList(specIdComparator).stream() .map(Map.Entry::getKey) .toList(); @@ -660,46 +714,64 @@ private static List getPartitionNames(Configuration conf, } /** - * Checks if a partition matches the filter expression and spec requirements. + * Returns aggregated partition statistics from the PARTITIONS metadata table as a summary map. + * @param table the iceberg table + * @param partitionSpec partition spec map for filtering, or null for all partitions + * @return summary map with record count, file count, file size, and delete counts */ - private static boolean matchesPartition(Map.Entry entry, - Expression filterExpression, boolean latestSpecOnly, int latestSpecId) { - PartitionData partitionData = entry.getKey(); - PartitionSpec spec = entry.getValue(); + static Map getPartitionStats(Table table, Map partitionSpec, + Snapshot snapshot) throws IOException { + PartitionsTable partitionsTable = (PartitionsTable) MetadataTableUtils.createMetadataTableInstance( + table, MetadataTableType.PARTITIONS); - // Filter unpartitioned tables - if (!spec.isPartitioned()) { - return false; + Expression filter; + TableScan scan = partitionsTable.newScan(); + if (snapshot != null) { + scan = scan.useSnapshot(snapshot.snapshotId()); } - // Filter by spec ID if requested - if (latestSpecOnly && spec.specId() != latestSpecId) { - return false; + try { + filter = buildPartitionsFilterFromPath(table, partitionSpec); + scan = scan.filter(filter); + } catch (SemanticException e) { + throw new IOException("Failed to build partition filter for " + partitionSpec, e); } - // Check if partition matches filter expression - ResidualEvaluator evaluator = - ResidualEvaluator.of(spec, filterExpression, false); - return evaluator - .residualFor(partitionData) - .isEquivalentTo(Expressions.alwaysTrue()); - } + Evaluator evaluator = new Evaluator(partitionsTable.schema().asStruct(), filter); + PartitionStats result; - /** - * Extracts partition data and spec from a partitions metadata table row. - */ - private static Map.Entry extractPartitionDataAndSpec( - StructLike row, Table icebergTable, Types.StructType partitionType) { + try (CloseableIterable fileScanTasks = scan.planFiles()) { + result = FluentIterable.from(fileScanTasks) + .transformAndConcat(task -> task.asDataTask().rows()) + .filter(evaluator::eval) + .transform(IcebergTableUtil::recordToPartitionStats) + .stream().reduce((left, right) -> { + left.appendStats(right); + return left; + }).orElse(null); + } - StructLike rawPartition = - row.get(IcebergTableUtil.PART_IDX, StructProjection.class); + if (result == null) { + result = new PartitionStats(null, 0); + } + return toStatsMap(result); + } - PartitionSpec spec = icebergTable.specs().get( - row.get(IcebergTableUtil.SPEC_IDX, Integer.class)); + static Map toStatsMap(PartitionStats stats) { + return ImmutableMap.of( + SnapshotSummary.TOTAL_DATA_FILES_PROP, String.valueOf(stats.dataFileCount()), + SnapshotSummary.TOTAL_RECORDS_PROP, String.valueOf(stats.dataRecordCount()), + SnapshotSummary.TOTAL_EQ_DELETES_PROP, String.valueOf(stats.equalityDeleteRecordCount()), + SnapshotSummary.TOTAL_POS_DELETES_PROP, String.valueOf(stats.positionDeleteRecordCount()), + SnapshotSummary.TOTAL_FILE_SIZE_PROP, String.valueOf(stats.totalDataFileSizeInBytes()) + ); + } - return Maps.immutableEntry( - IcebergTableUtil.toPartitionData( - rawPartition, partitionType, spec.partitionType()), - spec); + private static PartitionStats recordToPartitionStats(StructLike record) { + PartitionStats stats = new PartitionStats(record.get(PART_IDX, StructLike.class), -1); + for (int pos = 2; pos <= 7; pos++) { + stats.set(pos, record.get(pos, Object.class)); + } + return stats; } public static PartitionSpec getPartitionSpec(Table icebergTable, String partitionPath) @@ -765,12 +837,16 @@ public static ExecutorService newDeleteThreadPool(String completeName, int numTh } public static boolean hasUndergonePartitionEvolution(Table table) { - // The current spec is not necessary the latest which can happen when partition spec was changed to one of - // table's past specs. - return table.currentSnapshot() != null && - table.currentSnapshot().allManifests(table.io()).parallelStream() - .map(ManifestFile::partitionSpecId) - .anyMatch(id -> id != table.spec().specId()); + return table.specs().size() > 1; + } + + public static boolean hasUndergonePartitionEvolution(Snapshot snapshot, FileIO io) { + if (snapshot == null) { + return false; + } + List manifests = snapshot.allManifests(io); + return manifests.stream() + .anyMatch(m -> m.partitionSpecId() != 0); } public static > Set getPartitionNames(Table icebergTable, Iterable files, diff --git a/iceberg/iceberg-handler/src/test/results/positive/llap/iceberg_major_compaction_partition_evolution.q.out b/iceberg/iceberg-handler/src/test/results/positive/llap/iceberg_major_compaction_partition_evolution.q.out index 2915bf7d774d..ca1ff16f65ae 100644 --- a/iceberg/iceberg-handler/src/test/results/positive/llap/iceberg_major_compaction_partition_evolution.q.out +++ b/iceberg/iceberg-handler/src/test/results/positive/llap/iceberg_major_compaction_partition_evolution.q.out @@ -386,14 +386,14 @@ STAGE PLANS: TableScan alias: ice_orc Snapshot ref: tag_v1 - Statistics: Num rows: 4 Data size: 1568 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 4 Data size: 792 Basic stats: COMPLETE Column stats: COMPLETE Select Operator expressions: first_name (type: string), last_name (type: string), dept_id (type: bigint), team_id (type: bigint), company_id (type: bigint) outputColumnNames: _col0, _col1, _col2, _col3, _col4 - Statistics: Num rows: 4 Data size: 1568 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 4 Data size: 792 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator compressed: false - Statistics: Num rows: 4 Data size: 1568 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 4 Data size: 792 Basic stats: COMPLETE Column stats: COMPLETE table: input format: org.apache.hadoop.mapred.SequenceFileInputFormat output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat @@ -601,17 +601,17 @@ STAGE PLANS: alias: ice_orc filterExpr: company_id is not null (type: boolean) Snapshot ref: tag_v1 - Statistics: Num rows: 4 Data size: 1568 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 3 Data size: 594 Basic stats: COMPLETE Column stats: COMPLETE Filter Operator predicate: company_id is not null (type: boolean) - Statistics: Num rows: 4 Data size: 1568 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 3 Data size: 594 Basic stats: COMPLETE Column stats: COMPLETE Select Operator expressions: first_name (type: string), last_name (type: string), dept_id (type: bigint), team_id (type: bigint), company_id (type: bigint) outputColumnNames: _col0, _col1, _col2, _col3, _col4 - Statistics: Num rows: 4 Data size: 1568 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 3 Data size: 594 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator compressed: false - Statistics: Num rows: 4 Data size: 1568 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 3 Data size: 594 Basic stats: COMPLETE Column stats: COMPLETE table: input format: org.apache.hadoop.mapred.SequenceFileInputFormat output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat diff --git a/ql/src/java/org/apache/hadoop/hive/ql/QueryState.java b/ql/src/java/org/apache/hadoop/hive/ql/QueryState.java index 2a4e2155b7b0..7e2149518e90 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/QueryState.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/QueryState.java @@ -20,6 +20,7 @@ import java.util.HashMap; import java.util.Map; +import java.util.Optional; import java.util.concurrent.locks.ReentrantLock; import java.util.function.Supplier; @@ -198,6 +199,11 @@ public long getNumModifiedRows() { return numModifiedRows; } + public boolean isTxnOpen() { + return Optional.ofNullable(txnManager).map(HiveTxnManager::isTxnOpen) + .orElse(false); + } + public void setNumModifiedRows(long numModifiedRows) { this.numModifiedRows = numModifiedRows; } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/ddl/table/info/desc/DescTableOperation.java b/ql/src/java/org/apache/hadoop/hive/ql/ddl/table/info/desc/DescTableOperation.java index 6401f9a8d9b4..499b9967f78e 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/ddl/table/info/desc/DescTableOperation.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/ddl/table/info/desc/DescTableOperation.java @@ -194,10 +194,10 @@ private void getColumnDataColPathSpecified(Table table, Partition part, List colNames = Lists.newArrayList(colName.toLowerCase()); if (part == null) { - if (table.isPartitioned() && StatsUtils.checkCanProvidePartitionStats(table)) { + if (table.isPartitioned() && StatsUtils.checkCanProvideColumnStats(table)) { Map tableProps = table.getParameters() == null ? new HashMap<>() : table.getParameters(); - if (table.isPartitionKey(colNames.get(0))) { + if (table.isPartitionKey(colNames.getFirst())) { getColumnDataForPartitionKeyColumn(table, cols, colStats, colNames, tableProps); } else { getColumnsForNotPartitionKeyColumn(table, cols, colStats, deserializer, colNames, tableProps); @@ -224,7 +224,7 @@ private void getColumnDataColPathSpecified(Table table, Partition part, List cols, List colStats, List colNames, Map tableProps) throws HiveException, MetaException { - FieldSchema partCol = table.getPartColByName(colNames.get(0)); + FieldSchema partCol = table.getPartColByName(colNames.getFirst()); cols.add(partCol); PartitionIterable parts = new PartitionIterable(context.getDb(), table, null, MetastoreConf.getIntVar(context.getConf(), MetastoreConf.ConfVars.BATCH_RETRIEVE_MAX)); diff --git a/ql/src/java/org/apache/hadoop/hive/ql/stats/StatsUtils.java b/ql/src/java/org/apache/hadoop/hive/ql/stats/StatsUtils.java index c530633fbf1c..3f333886965a 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/stats/StatsUtils.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/stats/StatsUtils.java @@ -1968,6 +1968,10 @@ public static boolean checkCanProvidePartitionStats(Table table) { return !table.isNonNative() || table.getStorageHandler().canProvidePartitionStatistics(table); } + public static boolean checkCanProvideColumnStats(Table table) { + return !table.isNonNative() || table.getStorageHandler().canProvideColStatistics(table); + } + /** * Are the basic stats for the table up-to-date for query planning. * Can run additional checks compared to the version in StatsSetupConst. diff --git a/ql/src/test/org/apache/hadoop/hive/ql/ddl/table/info/desc/TestDescTableOperation.java b/ql/src/test/org/apache/hadoop/hive/ql/ddl/table/info/desc/TestDescTableOperation.java index e85f3efea78b..89f782430061 100644 --- a/ql/src/test/org/apache/hadoop/hive/ql/ddl/table/info/desc/TestDescTableOperation.java +++ b/ql/src/test/org/apache/hadoop/hive/ql/ddl/table/info/desc/TestDescTableOperation.java @@ -96,7 +96,7 @@ void testGetColumnDataForPartitionKeyColumnDifferentRanges( colStats.setCountDistint(100); colStats.setAvgColLen(4); - statsUtils.when(() -> StatsUtils.checkCanProvidePartitionStats(any())).thenReturn(true); + statsUtils.when(() -> StatsUtils.checkCanProvideColumnStats(any())).thenReturn(true); statsUtils.when(() -> StatsUtils.getColStatsForPartCol(any(), any(), any())).thenReturn(colStats); // Capture the ColStatistics passed to fillColumnStatisticsData @@ -107,7 +107,7 @@ void testGetColumnDataForPartitionKeyColumnDifferentRanges( DescTableOperation operation = new DescTableOperation(mockContext, mockDesc); // Execute - should no longer throw NullPointerException with null values of minValue or maxValue - assertDoesNotThrow(() -> operation.execute(), + assertDoesNotThrow(operation::execute, "Should handle Range with null minValue and maxValue without NPE"); // Verify that the ColStatistics.Range values were correctly passed From 2b45011924c10b28c246992c0916025fc8f6f9df Mon Sep 17 00:00:00 2001 From: Denys Kuzmenko Date: Sat, 21 Feb 2026 16:37:42 +0200 Subject: [PATCH 4/4] refactor/fix exception retry --- .../iceberg/hive/HiveTxnCoordinator.java | 38 +++++++------------ ...TestConcurrentMultiTableTransactions.java} | 4 +- ... => HiveIcebergStorageHandlerTxnStub.java} | 4 +- ...rStub.java => HiveTxnCoordinatorStub.java} | 4 +- .../ReExecuteOnWriteConflictPlugin.java | 9 +---- 5 files changed, 22 insertions(+), 37 deletions(-) rename iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/{TestXAConflictingDataFiles.java => TestConcurrentMultiTableTransactions.java} (98%) rename iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/test/concurrent/{XAHiveIcebergStorageHandlerStub.java => HiveIcebergStorageHandlerTxnStub.java} (89%) rename iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/test/concurrent/{XAHiveTxnCoordinatorStub.java => HiveTxnCoordinatorStub.java} (88%) diff --git a/iceberg/iceberg-catalog/src/main/java/org/apache/iceberg/hive/HiveTxnCoordinator.java b/iceberg/iceberg-catalog/src/main/java/org/apache/iceberg/hive/HiveTxnCoordinator.java index da3048096792..962b8f5579ab 100644 --- a/iceberg/iceberg-catalog/src/main/java/org/apache/iceberg/hive/HiveTxnCoordinator.java +++ b/iceberg/iceberg-catalog/src/main/java/org/apache/iceberg/hive/HiveTxnCoordinator.java @@ -108,20 +108,18 @@ public synchronized void commit() throws TException { base.propertyAsInt(COMMIT_TOTAL_RETRY_TIME_MS, COMMIT_TOTAL_RETRY_TIME_MS_DEFAULT), 2.0 /* exponential */) .onlyRetryOn(CommitFailedException.class) - .run(i -> doCommit(updates)); - - } catch (CommitStateUnknownException e) { - throw MetaStoreUtils.newMetaException(e); - - } catch (ValidationException | CommitFailedException e) { - // All retries exhausted — clean up manifests, metadata files, and uncommitted files - cleanUpOnCommitFailure(e); + .run(i -> { + try { + doCommit(updates); + } catch (RuntimeException e) { + cleanUpOnCommitFailure(e); + throw e; + } + }); + + } catch (ValidationException e) { throw MetaStoreUtils.newMetaException(e); - } catch (RuntimeException e) { - cleanUpOnCommitFailure(e); - throw e; - } finally { clearState(); } @@ -187,32 +185,21 @@ private void doCommit(List> updates) { le); } - releaseLocks(locks); - - } catch (CommitStateUnknownException e) { - // Commit may have succeeded — do NOT clean up metadata/manifests, only release locks - releaseLocks(locks); - throw e; - } catch (LockException e) { // Lock acquisition or pre-persist ensureActive failed — safe to retry - releaseLocks(locks); throw new CommitFailedException(e); } catch (TException e) { if (isCasFailure(e)) { - releaseLocks(locks); throw new CommitFailedException(e, "The table %s.%s has been modified concurrently", payload.getLast().getDb_name(), payload.getLast().getTable_name()); } // Non-CAS TException from updateTableParams — we can't tell if the batch update was applied - releaseLocks(locks); throw new CommitStateUnknownException(e); - } catch (RuntimeException e) { + } finally { releaseLocks(locks); - throw e; } } @@ -297,6 +284,9 @@ private void releaseLocks(List locks) { } private void cleanUpOnCommitFailure(Exception ex) { + if (ex instanceof CommitStateUnknownException) { + return; + } stagedUpdates.values().forEach(txn -> { if (!txn.ops().requireStrictCleanup() || ex instanceof CleanableFailure) { txn.cleanUpOnCommitFailure(); diff --git a/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/TestXAConflictingDataFiles.java b/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/TestConcurrentMultiTableTransactions.java similarity index 98% rename from iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/TestXAConflictingDataFiles.java rename to iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/TestConcurrentMultiTableTransactions.java index a91200de4d72..02199288d72d 100644 --- a/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/TestXAConflictingDataFiles.java +++ b/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/TestConcurrentMultiTableTransactions.java @@ -38,10 +38,10 @@ import org.junit.runners.Parameterized.Parameters; @WithMockedStorageHandler -public class TestXAConflictingDataFiles extends HiveIcebergStorageHandlerWithEngineBase { +public class TestConcurrentMultiTableTransactions extends HiveIcebergStorageHandlerWithEngineBase { public static final String XA_STORAGE_HANDLER_STUB = - "'org.apache.iceberg.mr.hive.test.concurrent.XAHiveIcebergStorageHandlerStub'"; + "'org.apache.iceberg.mr.hive.test.concurrent.HiveIcebergStorageHandlerTxnStub'"; @Parameters(name = "fileFormat={0}, catalog={1}, isVectorized={2}, formatVersion={3}") public static Collection parameters() { diff --git a/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/test/concurrent/XAHiveIcebergStorageHandlerStub.java b/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/test/concurrent/HiveIcebergStorageHandlerTxnStub.java similarity index 89% rename from iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/test/concurrent/XAHiveIcebergStorageHandlerStub.java rename to iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/test/concurrent/HiveIcebergStorageHandlerTxnStub.java index caf7681c927f..8810ad4d404b 100644 --- a/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/test/concurrent/XAHiveIcebergStorageHandlerStub.java +++ b/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/test/concurrent/HiveIcebergStorageHandlerTxnStub.java @@ -24,7 +24,7 @@ import org.apache.iceberg.hive.HiveTxnCoordinator; import org.apache.iceberg.mr.hive.HiveIcebergOutputCommitter; -public class XAHiveIcebergStorageHandlerStub extends HiveIcebergStorageHandlerStub { +public class HiveIcebergStorageHandlerTxnStub extends HiveIcebergStorageHandlerStub { @Override public HiveIcebergOutputCommitter getOutputCommitter() { @@ -32,7 +32,7 @@ public HiveIcebergOutputCommitter getOutputCommitter() { txnManager.getOrSetTxnCoordinator( HiveTxnCoordinator.class, - msClient -> new XAHiveTxnCoordinatorStub(conf, msClient)); + msClient -> new HiveTxnCoordinatorStub(conf, msClient)); return super.getOutputCommitter(); } diff --git a/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/test/concurrent/XAHiveTxnCoordinatorStub.java b/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/test/concurrent/HiveTxnCoordinatorStub.java similarity index 88% rename from iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/test/concurrent/XAHiveTxnCoordinatorStub.java rename to iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/test/concurrent/HiveTxnCoordinatorStub.java index fa3c2c531f3d..e2416507c04f 100644 --- a/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/test/concurrent/XAHiveTxnCoordinatorStub.java +++ b/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/test/concurrent/HiveTxnCoordinatorStub.java @@ -24,9 +24,9 @@ import org.apache.iceberg.hive.HiveTxnCoordinator; import org.apache.thrift.TException; -public class XAHiveTxnCoordinatorStub extends HiveTxnCoordinator { +public class HiveTxnCoordinatorStub extends HiveTxnCoordinator { - public XAHiveTxnCoordinatorStub(Configuration conf, IMetaStoreClient msClient) { + public HiveTxnCoordinatorStub(Configuration conf, IMetaStoreClient msClient) { super(conf, msClient); } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/reexec/ReExecuteOnWriteConflictPlugin.java b/ql/src/java/org/apache/hadoop/hive/ql/reexec/ReExecuteOnWriteConflictPlugin.java index 932e3375498e..f5f6309b0c2c 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/reexec/ReExecuteOnWriteConflictPlugin.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/reexec/ReExecuteOnWriteConflictPlugin.java @@ -26,16 +26,11 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import java.util.Set; - public class ReExecuteOnWriteConflictPlugin implements IReExecutionPlugin { private static final Logger LOG = LoggerFactory.getLogger(ReExecuteOnWriteConflictPlugin.class); private static boolean retryPossible; - private static final Set RETRYABLE_EXCEPTION_CLASS_NAMES = Set.of( - "org.apache.iceberg.exceptions.ValidationException", - "org.apache.iceberg.exceptions.CommitFailedException" - ); + private static final String validationException = "org.apache.iceberg.exceptions.ValidationException"; private static final class LocalHook implements ExecuteWithHookContext { @Override @@ -57,7 +52,7 @@ public void run(HookContext hookContext) { } private static boolean isRetryable(Throwable t) { - return RETRYABLE_EXCEPTION_CLASS_NAMES.contains(t.getClass().getName()); + return validationException.equals(t.getClass().getName()); } @Override