Index: metastore/src/model/package.jdo
===================================================================
--- metastore/src/model/package.jdo (revision 1235046)
+++ metastore/src/model/package.jdo (working copy)
@@ -214,8 +214,76 @@
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
@@ -274,6 +342,11 @@
+
+
+
+
+
@@ -701,5 +774,6 @@
+
Index: metastore/src/model/org/apache/hadoop/hive/metastore/model/MStorageDescriptor.java
===================================================================
--- metastore/src/model/org/apache/hadoop/hive/metastore/model/MStorageDescriptor.java (revision 1235046)
+++ metastore/src/model/org/apache/hadoop/hive/metastore/model/MStorageDescriptor.java (working copy)
@@ -20,6 +20,7 @@
import java.util.List;
import java.util.Map;
+import java.util.Set;
public class MStorageDescriptor {
private MColumnDescriptor cd;
@@ -32,6 +33,7 @@
private List bucketCols;
private List sortCols;
private Map parameters;
+ private Set clusterStorage;
public MStorageDescriptor() {}
@@ -63,7 +65,37 @@
this.parameters = parameters;
}
+ /**
+ * @param cd
+ * @param location
+ * @param inputFormat
+ * @param outputFormat
+ * @param isCompressed
+ * @param numBuckets
+ * @param serDeInfo
+ * @param bucketCols
+ * @param sortOrder
+ * @param parameters
+ * @param clusterStorage
+ */
+ public MStorageDescriptor(MColumnDescriptor cd, String location, String inputFormat,
+ String outputFormat, boolean isCompressed, int numBuckets, MSerDeInfo serDeInfo,
+ List bucketCols, List sortOrder, Map parameters,
+ Set clusterStorage) {
+ this.cd = cd;
+ this.location = location;
+ this.inputFormat = inputFormat;
+ this.outputFormat = outputFormat;
+ this.isCompressed = isCompressed;
+ this.numBuckets = numBuckets;
+ this.serDeInfo = serDeInfo;
+ this.bucketCols = bucketCols;
+ this.sortCols = sortOrder;
+ this.parameters = parameters;
+ this.clusterStorage = clusterStorage;
+ }
+
/**
* @return the location
*/
@@ -205,4 +237,21 @@
public List getSortCols() {
return sortCols;
}
+
+
+ /**
+ * @return list of cluster storage descriptor
+ */
+ public Set getClusterStorage() {
+ return clusterStorage;
+ }
+
+
+ /**
+ * @param clusterStorage list of cluster storages to set
+ */
+ public void setClusterStorage(
+ Set clusterStorage) {
+ this.clusterStorage = clusterStorage;
+ }
}
Index: metastore/src/model/org/apache/hadoop/hive/metastore/model/MClusterStorageDescriptor.java
===================================================================
--- metastore/src/model/org/apache/hadoop/hive/metastore/model/MClusterStorageDescriptor.java (revision 0)
+++ metastore/src/model/org/apache/hadoop/hive/metastore/model/MClusterStorageDescriptor.java (revision 0)
@@ -0,0 +1,103 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.hadoop.hive.metastore.model;
+
+import java.io.Serializable;
+import java.util.Map;
+
+public class MClusterStorageDescriptor implements Serializable {
+
+ private MCluster cluster;
+ private String location;
+ private boolean isPrimary;
+ private boolean dataSynced;
+ private Map parameters;
+
+ /**
+ * @return cluster object
+ */
+ public MCluster getCluster() {
+ return cluster;
+ }
+
+ /**
+ * @param cluster
+ */
+ public void setCluster(MCluster cluster) {
+ this.cluster = cluster;
+ }
+
+ /**
+ * @return data location stored in this cluster
+ */
+ public String getLocation() {
+ return location;
+ }
+
+ /**
+ * @param location location in this cluster
+ */
+ public void setLocation(String location) {
+ this.location = location;
+ }
+
+ /**
+ * @return parameters
+ */
+ public Map getParameters() {
+ return parameters;
+ }
+
+ /**
+ * @param parameters
+ */
+ public void setParameters(Map parameters) {
+ this.parameters = parameters;
+ }
+
+ /**
+ * @return isPrimary
+ */
+ public boolean getIsPrimary() {
+ return isPrimary;
+ }
+
+ /**
+ * @param isPrimary
+ */
+ public void setIsPrimary(boolean isPrimary) {
+ this.isPrimary = isPrimary;
+ }
+
+ /**
+ * @return is the replica's data up to date.
+ */
+ public boolean getDataSynced() {
+ return dataSynced;
+ }
+
+ /**
+ * set this replica's data to be up to date.
+ * @param dataSynced
+ */
+ public void setDataSynced(boolean dataSynced) {
+ this.dataSynced = dataSynced;
+ }
+
+}
Index: metastore/src/model/org/apache/hadoop/hive/metastore/model/MCluster.java
===================================================================
--- metastore/src/model/org/apache/hadoop/hive/metastore/model/MCluster.java (revision 0)
+++ metastore/src/model/org/apache/hadoop/hive/metastore/model/MCluster.java (revision 0)
@@ -0,0 +1,84 @@
+/**
+ * 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.model;
+
+import java.io.Serializable;
+import java.util.Map;
+
+public class MCluster implements Serializable {
+
+ private String clusterName;
+ private String description;
+ private String location;
+ private int createTime;
+ private Map parameters;
+
+ public MCluster() {
+ }
+
+ public MCluster(String clusterName, String description,
+ String location, int createTime, Map parameters) {
+ super();
+ this.clusterName = clusterName;
+ this.description = description;
+ this.location = location;
+ this.createTime = createTime;
+ this.parameters = parameters;
+ }
+
+ public String getClusterName() {
+ return clusterName;
+ }
+
+ public void setClusterName(String clusterName) {
+ this.clusterName = clusterName;
+ }
+
+ public String getDescription() {
+ return description;
+ }
+
+ public void setDescription(String description) {
+ this.description = description;
+ }
+
+ public Map getParameters() {
+ return parameters;
+ }
+
+ public void setParameters(Map parameters) {
+ this.parameters = parameters;
+ }
+
+ public String getLocation() {
+ return location;
+ }
+
+ public void setLocation(String location) {
+ this.location = location;
+ }
+
+ public int getCreateTime() {
+ return createTime;
+ }
+
+ public void setCreateTime(int createTime) {
+ this.createTime = createTime;
+ }
+}
Index: metastore/src/java/org/apache/hadoop/hive/metastore/RawStore.java
===================================================================
--- metastore/src/java/org/apache/hadoop/hive/metastore/RawStore.java (revision 1235046)
+++ metastore/src/java/org/apache/hadoop/hive/metastore/RawStore.java (working copy)
@@ -22,9 +22,11 @@
import java.util.Map;
import org.apache.hadoop.conf.Configurable;
+import org.apache.hadoop.hive.metastore.api.Cluster;
import org.apache.hadoop.hive.metastore.api.Database;
import org.apache.hadoop.hive.metastore.api.Index;
import org.apache.hadoop.hive.metastore.api.InvalidObjectException;
+import org.apache.hadoop.hive.metastore.api.InvalidOperationException;
import org.apache.hadoop.hive.metastore.api.InvalidPartitionException;
import org.apache.hadoop.hive.metastore.api.MetaException;
import org.apache.hadoop.hive.metastore.api.NoSuchObjectException;
@@ -189,6 +191,20 @@
public abstract boolean isPartitionMarkedForEvent(String dbName, String tblName, Map partName, PartitionEventType evtType) throws MetaException, UnknownTableException, InvalidPartitionException, UnknownPartitionException;
+ public abstract Boolean addCluster(Cluster cluster)
+ throws InvalidObjectException, MetaException;
+
+ public abstract Cluster getCluster(String name) throws MetaException;
+
+ public abstract List listClusters() throws MetaException;
+
+ public abstract boolean dropCluster(String clusterName)
+ throws MetaException, InvalidOperationException,
+ NoSuchObjectException;
+
+ public abstract void alterCluster(String clusterName,
+ Cluster cluster) throws MetaException;
+
public abstract boolean addRole(String rowName, String ownerName)
throws InvalidObjectException, MetaException, NoSuchObjectException;
@@ -305,4 +321,5 @@
throws MetaException, InvalidObjectException, NoSuchObjectException;
public abstract long cleanupEvents();
+
}
Index: metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java
===================================================================
--- metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java (revision 1235046)
+++ metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java (working copy)
@@ -22,6 +22,7 @@
import java.util.Map;
import org.apache.hadoop.hive.metastore.api.AlreadyExistsException;
+import org.apache.hadoop.hive.metastore.api.Cluster;
import org.apache.hadoop.hive.metastore.api.ConfigValSecurityException;
import org.apache.hadoop.hive.metastore.api.Database;
import org.apache.hadoop.hive.metastore.api.FieldSchema;
@@ -184,6 +185,24 @@
public void dropTable(String dbname, String tableName)
throws MetaException, TException, NoSuchObjectException;
+ /**
+ * Drop table on one cluster.
+ *
+ * @param name
+ * @param dbName
+ * @param tableName
+ * @param deleteData
+ * @param ignoreUnknownTab
+ * @throws NoSuchObjectException
+ * @throws MetaException
+ * @throws TException
+ * @throws InvalidOperationException
+ */
+ public void dropTableOnCluster(String name, String dbName,
+ String tableName, boolean deleteData, boolean ignoreUnknownTab)
+ throws NoSuchObjectException, MetaException, TException,
+ InvalidOperationException;
+
public boolean tableExists(String databaseName, String tableName) throws MetaException,
TException, UnknownDBException;
@@ -536,7 +555,23 @@
public boolean dropPartition(String db_name, String tbl_name,
String name, boolean deleteData) throws NoSuchObjectException,
MetaException, TException;
+
/**
+ * Drop partition on one cluster.
+ *
+ * @param clusterName
+ * @param dbName
+ * @param tblName
+ * @param partVals
+ * @param deleteData
+ * @return
+ */
+ public boolean dropPartitionWithClusterName(String clusterName,
+ String dbName, String tblName, List partVals,
+ boolean deleteData) throws NoSuchObjectException,
+ MetaException, TException, InvalidOperationException;
+
+ /**
* updates a partition to new partition
*
* @param dbName
@@ -846,5 +881,56 @@
*/
public void cancelDelegationToken(String tokenStrForm) throws MetaException, TException;
+ /**
+ * @param cluster
+ * @throws MetaException
+ * @throws TException
+ * @throws AlreadyExistsException
+ * @throws InvalidObjectException
+ */
+ public void createCluster(Cluster cluster)
+ throws AlreadyExistsException, MetaException, TException, InvalidObjectException;
+ /**
+ * @param name
+ * @throws NoSuchObjectException
+ * @throws MetaException
+ * @throws TException
+ * @throws InvalidOperationException
+ */
+ public void dropCluster(String name) throws NoSuchObjectException,
+ MetaException, TException, InvalidOperationException;
+
+ /**
+ * @param clusterName
+ * @return
+ * @throws NoSuchObjectException
+ * @throws MetaException
+ * @throws TException
+ */
+ public Cluster getCluster(String clusterName)
+ throws NoSuchObjectException, MetaException, TException;
+
+ /**
+ * alter the cluster object
+ *
+ * @param name
+ * @param cluster
+ * @return
+ * @throws NoSuchObjectException
+ * @throws AlreadyExistsException
+ */
+ public void alter_cluster(String name, Cluster cluster)
+ throws MetaException, TException, InvalidObjectException,
+ NoSuchObjectException, AlreadyExistsException;
+
+ /**
+ * return all clusters.
+ *
+ * @return
+ * @throws MetaException
+ * @throws TException
+ */
+ public List listClusters() throws MetaException, TException;
+
}
Index: metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java
===================================================================
--- metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java (revision 1235046)
+++ metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java (working copy)
@@ -40,6 +40,7 @@
import org.apache.hadoop.hive.conf.HiveConf;
import org.apache.hadoop.hive.conf.HiveConf.ConfVars;
import org.apache.hadoop.hive.metastore.api.AlreadyExistsException;
+import org.apache.hadoop.hive.metastore.api.Cluster;
import org.apache.hadoop.hive.metastore.api.ConfigValSecurityException;
import org.apache.hadoop.hive.metastore.api.Database;
import org.apache.hadoop.hive.metastore.api.FieldSchema;
@@ -1217,4 +1218,53 @@
return client.isPartitionMarkedForEvent(db_name, tbl_name, partKVs, eventType);
}
+ @Override
+ public void createCluster(Cluster cluster)
+ throws AlreadyExistsException, MetaException, TException, InvalidObjectException {
+ client.create_cluster(cluster);
+ }
+
+ @Override
+ public void dropCluster(String name) throws NoSuchObjectException,
+ MetaException, TException, InvalidOperationException {
+ client.drop_cluster(name);
+ }
+
+ @Override
+ public Cluster getCluster(String clusterName)
+ throws NoSuchObjectException, MetaException, TException {
+ assert clusterName != null;
+ return client.get_cluster(clusterName);
+ }
+
+ @Override
+ public List listClusters() throws MetaException, TException {
+ return client.list_clusters();
+ }
+
+ @Override
+ public void alter_cluster(String name, Cluster cluster)
+ throws MetaException, TException, InvalidObjectException,
+ NoSuchObjectException, AlreadyExistsException {
+ client.alter_cluster(name, cluster);
+ }
+
+ @Override
+ public boolean dropPartitionWithClusterName(String clusterName,
+ String dbName, String tblName, List partVals,
+ boolean deleteData) throws NoSuchObjectException, MetaException, TException,
+ InvalidOperationException {
+ return client.drop_partition_on_cluster(clusterName, dbName, tblName,
+ partVals, deleteData);
+ }
+
+ @Override
+ public void dropTableOnCluster(String clusterName, String dbName,
+ String tableName, boolean deleteData, boolean ignoreUnknownTab)
+ throws NoSuchObjectException, MetaException, TException,
+ InvalidOperationException {
+ client.drop_table_on_cluster(clusterName, dbName, tableName,
+ deleteData);
+ }
+
}
Index: metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java
===================================================================
--- metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java (revision 1235046)
+++ metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java (working copy)
@@ -55,6 +55,8 @@
import org.apache.hadoop.hive.conf.HiveConf;
import org.apache.hadoop.hive.conf.HiveConf.ConfVars;
import org.apache.hadoop.hive.metastore.api.AlreadyExistsException;
+import org.apache.hadoop.hive.metastore.api.Cluster;
+import org.apache.hadoop.hive.metastore.api.ClusterStorageDescriptor;
import org.apache.hadoop.hive.metastore.api.ConfigValSecurityException;
import org.apache.hadoop.hive.metastore.api.Constants;
import org.apache.hadoop.hive.metastore.api.Database;
@@ -253,6 +255,8 @@
alterHandlerName, AlterHandler.class), hiveConf);
wh = new Warehouse(hiveConf);
+ DEFAULT_CLUSTER_NAME = hiveConf.get("hive.metastore.cluster.default", "");
+
retryInterval = HiveConf.getIntVar(hiveConf,
HiveConf.ConfVars.METASTOREINTERVAL);
retryLimit = HiveConf.getIntVar(hiveConf,
@@ -616,6 +620,7 @@
}
private static final String DATABASE_WAREHOUSE_SUFFIX = ".db";
+ private String DEFAULT_CLUSTER_NAME = "";
private Path getDefaultDatabasePath(String dbName) throws MetaException {
if (dbName.equalsIgnoreCase(DEFAULT_DATABASE_NAME)) {
@@ -1100,9 +1105,11 @@
return (ms.getTable(dbname, name) != null);
}
- private void drop_table_core(final RawStore ms, final String dbname,
- final String name, final boolean deleteData)
- throws NoSuchObjectException, MetaException, IOException {
+ private void drop_table_core(final RawStore ms,
+ final String dbname, final String name,
+ final String clusterName, final boolean deleteData)
+ throws NoSuchObjectException, MetaException, IOException,
+ InvalidOperationException {
boolean success = false;
boolean isExternal = false;
@@ -1127,6 +1134,49 @@
"The table " + name + " is an index table. Please do drop index instead.");
}
+ isExternal = isExternal(tbl);
+
+ List clusterSDS = tbl.getSd().getClusterStorage();
+ boolean dropOnPrimary = false;
+ ClusterStorageDescriptor toRemoveClusterSD = null;
+ if(clusterSDS != null && !clusterSDS.isEmpty()) {
+ //check is any secondary cluster exists
+ //if has replicas, drop on primary is not allowed
+ boolean hasMoreReplica = clusterSDS.size() > 1;
+ for(ClusterStorageDescriptor clusterSD: clusterSDS) {
+ if (clusterName.equalsIgnoreCase(
+ clusterSD.getCluster().getName())) {
+ if(clusterSD.isPrimary()) {
+ dropOnPrimary = true;
+ }
+ toRemoveClusterSD = clusterSD;
+ tblPath = new Path(clusterSD.getLocation());
+ break;
+ }
+ }
+
+ if(tblPath == null) {
+ throw new InvalidOperationException("Table is not found on cluster " + clusterName);
+ }
+
+ if(hasMoreReplica && dropOnPrimary) {
+ throw new InvalidOperationException(
+ "Can not drop on primary cluster while there are more than one replica.");
+ }
+ } else {
+ //there is no cluster support for this table. ignore the cluster name
+ if(tbl.getSd().getLocation() != null && !tbl.getSd().getLocation().trim().equals("")) {
+ tblPath = new Path(tbl.getSd().getLocation());
+ }
+ dropOnPrimary = true;
+ }
+
+ if (!wh.isWritable(tblPath.getParent())) {
+ throw new MetaException("Table metadata not deleted since " +
+ tblPath.getParent() + " is not writable by " +
+ hiveConf.getUser());
+ }
+
if (!isIndexTable) {
try {
List indexes = ms.getIndexes(dbname, name, Short.MAX_VALUE);
@@ -1140,19 +1190,19 @@
throw new MetaException(e.getMessage());
}
}
- isExternal = isExternal(tbl);
- if (tbl.getSd().getLocation() != null) {
- tblPath = new Path(tbl.getSd().getLocation());
- if (!wh.isWritable(tblPath.getParent())) {
- throw new MetaException("Table metadata not deleted since " +
- tblPath.getParent() + " is not writable by " +
- hiveConf.getUser());
+
+ if(dropOnPrimary) {
+ if (!ms.dropTable(dbname, name)) {
+ throw new MetaException("Unable to drop table");
}
+ } else {
+ tbl.getSd().getClusterStorage().remove(toRemoveClusterSD);
+ try {
+ ms.alterTable(dbname, name, tbl);
+ } catch (InvalidObjectException e) {
+ throw new InvalidOperationException(e.getMessage());
+ }
}
-
- if (!ms.dropTable(dbname, name)) {
- throw new MetaException("Unable to drop table");
- }
success = ms.commitTransaction();
} finally {
if (!success) {
@@ -1176,7 +1226,8 @@
success = executeWithRetry(new Command() {
@Override
public Boolean run(RawStore ms) throws Exception {
- drop_table_core(ms, dbname, name, deleteData);
+ drop_table_core(ms, dbname, name, DEFAULT_CLUSTER_NAME,
+ deleteData);
return Boolean.TRUE;
}
});
@@ -1184,6 +1235,8 @@
throw e;
} catch (MetaException e) {
throw e;
+ } catch (InvalidOperationException e) {
+ throw new RuntimeException(e);
} catch (Exception e) {
assert(e instanceof RuntimeException);
throw (RuntimeException)e;
@@ -1193,6 +1246,38 @@
}
+ public void drop_table_on_cluster(final String cluster_name,
+ final String dbname, final String name,
+ final boolean deleteData) throws NoSuchObjectException,
+ MetaException, InvalidOperationException {
+ startTableFunction("drop_table_on_cluster", dbname, name);
+
+ boolean success = false;
+ try {
+ success = executeWithRetry(new Command() {
+ @Override
+ public Boolean run(RawStore ms) throws Exception {
+ drop_table_core(ms, dbname, name, cluster_name,
+ deleteData);
+ return Boolean.TRUE;
+ }
+ });
+ } catch (NoSuchObjectException e) {
+ throw e;
+ } catch (MetaException e) {
+ throw e;
+ } catch (InvalidOperationException e) {
+ throw e;
+ } catch (Exception e) {
+ assert(e instanceof RuntimeException);
+ throw (RuntimeException)e;
+ } finally {
+ endFunction("drop_table", success);
+ }
+
+ }
+
+
/**
* Is this an external table?
*
@@ -1742,6 +1827,13 @@
}
+ public boolean drop_partition_on_cluster(String cluster_name,
+ String db_name, String tbl_name, List part_vals,
+ boolean deleteData) throws NoSuchObjectException,
+ MetaException, InvalidOperationException{
+ return true;
+ }
+
public Partition get_partition(final String db_name, final String tbl_name,
final List part_vals) throws MetaException, NoSuchObjectException {
startPartitionFunction("get_partition", db_name, tbl_name, part_vals);
@@ -2519,8 +2611,8 @@
ret = executeWithRetry(new Command() {
@Override
public Boolean run(RawStore ms) throws Exception {
- return drop_index_by_name_core(ms, dbName, tblName,
- indexName, deleteData);
+ return drop_index_by_name_core(ms, DEFAULT_CLUSTER_NAME,
+ dbName, tblName, indexName, deleteData);
}
});
} catch (NoSuchObjectException e) {
@@ -2539,9 +2631,44 @@
return ret;
}
+ public boolean drop_index_by_name_on_cluster(
+ final String clusterName, final String dbName,
+ final String tblName, final String indexName,
+ final boolean deleteData) throws NoSuchObjectException,
+ MetaException, TException {
+ startFunction("drop_index_by_name_on_cluster", ": cluster="
+ + clusterName + " db=" + dbName + " tbl=" + tblName
+ + " index=" + indexName);
+
+ boolean ret = false;
+ try {
+ ret = executeWithRetry(new Command() {
+ @Override
+ public Boolean run(RawStore ms) throws Exception {
+ return drop_index_by_name_core(ms, clusterName, dbName,
+ tblName, indexName, deleteData);
+ }
+ });
+ } catch (NoSuchObjectException e) {
+ throw e;
+ } catch (MetaException e) {
+ throw e;
+ } catch (TException e) {
+ throw e;
+ } catch (Exception e) {
+ assert(e instanceof RuntimeException);
+ throw (RuntimeException)e;
+ } finally {
+ endFunction("drop_index_by_name_on_cluster", ret);
+ }
+
+ return ret;
+ }
+
private boolean drop_index_by_name_core(final RawStore ms,
- final String dbName, final String tblName,
- final String indexName, final boolean deleteData) throws NoSuchObjectException,
+ final String clusterName, final String dbName,
+ final String tblName, final String indexName,
+ final boolean deleteData) throws NoSuchObjectException,
MetaException, TException, IOException {
boolean success = false;
@@ -2554,28 +2681,71 @@
if (index == null) {
throw new NoSuchObjectException(indexName + " doesn't exist");
}
- ms.dropIndex(dbName, tblName, indexName);
String idxTblName = index.getIndexTableName();
+ Table tbl = null;
+ boolean dropOnPrimary = false;
+ ClusterStorageDescriptor toRemoveClusterSD = null;
+
if (idxTblName != null) {
- Table tbl = null;
- tbl = this.get_table(dbName, idxTblName);
+ //check the underlying index table
+ tbl = get_table(dbName, idxTblName);
if (tbl.getSd() == null) {
throw new MetaException("Table metadata is corrupted");
}
- if (tbl.getSd().getLocation() != null) {
+ List clusterSDS = tbl.getSd().getClusterStorage();
+ if(clusterSDS != null && !clusterSDS.isEmpty()) {
+ // check is any secondary cluster exists
+ // if has replicas, drop on primary is not allowed
+ boolean hasMoreReplica = clusterSDS.size() > 1;
+ for(ClusterStorageDescriptor clusterSD: clusterSDS) {
+ if (clusterName.equalsIgnoreCase(
+ clusterSD.getCluster().getName())) {
+ if(clusterSD.isPrimary()) {
+ dropOnPrimary = true;
+ }
+ toRemoveClusterSD = clusterSD;
+ tblPath = new Path(clusterSD.getLocation());
+ break;
+ }
+ }
+
+ if (hasMoreReplica && dropOnPrimary) {
+ throw new MetaException(
+ "Can not drop a underlying index table on primary cluster while there are more than one replica. " +
+ "Run drop index on non-primary cluster first.");
+ }
+ } else {
+ //there is no cluster support for this table. ignore the cluster name
tblPath = new Path(tbl.getSd().getLocation());
- if (!wh.isWritable(tblPath.getParent())) {
- throw new MetaException("Index table metadata not deleted since " +
- tblPath.getParent() + " is not writable by " +
- hiveConf.getUser());
+ dropOnPrimary = true;
+ }
+ }
+
+ if (tblPath != null && !wh.isWritable(tblPath.getParent())) {
+ throw new MetaException("Table metadata not deleted since "
+ + tblPath.getParent() + " is not writable by "
+ + hiveConf.getUser());
+ }
+
+ if (dropOnPrimary) {
+ ms.dropIndex(dbName, tblName, indexName);
+ }
+
+ if(tbl != null) {
+ if(dropOnPrimary) {
+ ms.dropTable(dbName, tblName);
+ } else {
+ if (toRemoveClusterSD != null) {
+ tbl.getSd().getClusterStorage().remove(toRemoveClusterSD);
+ try {
+ ms.alterTable(dbName, tblName, tbl);
+ } catch (InvalidObjectException e) {
+ throw new MetaException(e.getMessage());
+ }
}
}
- if (!ms.dropTable(dbName, idxTblName)) {
- throw new MetaException("Unable to drop underlying data table "
- + idxTblName + " for index " + idxTblName);
- }
}
success = ms.commitTransaction();
} finally {
@@ -2739,6 +2909,212 @@
}
@Override
+ public void create_cluster(final Cluster cluster)
+ throws AlreadyExistsException, InvalidObjectException,
+ MetaException, TException {
+
+ incrementCounter("create_cluster");
+ try {
+ executeWithRetry(new Command() {
+ @Override
+ public Boolean run(RawStore ms) throws Exception {
+ create_cluster_core(ms, cluster);
+ return Boolean.TRUE;
+ }
+ });
+ } catch (MetaException e) {
+ throw e;
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ private void create_cluster_core(RawStore ms, Cluster cluster)
+ throws AlreadyExistsException, MetaException,
+ InvalidObjectException {
+
+ if (!MetaStoreUtils.validateName(cluster.getName())) {
+ throw new InvalidObjectException(cluster.getName()
+ + " is not a valid cluster name");
+ }
+
+ boolean success = false;
+ try {
+ ms.openTransaction();
+
+ if (is_cluster_exists(ms, cluster.getName())) {
+ throw new AlreadyExistsException("Cluster "
+ + cluster.getName() + " already exists");
+ }
+
+ // set create time
+ long time = System.currentTimeMillis() / 1000;
+ cluster.setCreateTime((int) time);
+ ms.addCluster(cluster);
+ success = ms.commitTransaction();
+ } finally {
+ if (!success) {
+ ms.rollbackTransaction();
+ }
+ }
+ }
+
+ private boolean is_cluster_exists(RawStore ms, String name)
+ throws MetaException {
+ return ms.getCluster(name) != null;
+ }
+
+ private void drop_cluster_core(RawStore ms, final String clusterName)
+ throws NoSuchObjectException, InvalidOperationException, MetaException,
+ IOException {
+ boolean success = false;
+ try {
+ ms.openTransaction();
+ if (ms.dropCluster(clusterName)) {
+ success = ms.commitTransaction();
+ }
+ } finally {
+ if (!success) {
+ ms.rollbackTransaction();
+ }
+ }
+ }
+
+ public void drop_cluster(final String clusterName)
+ throws NoSuchObjectException, InvalidOperationException, MetaException {
+
+ startFunction("drop_cluster", ": " + clusterName);
+ boolean success = false;
+ try {
+ success = executeWithRetry(new Command() {
+ @Override
+ public Boolean run(RawStore ms) throws Exception {
+ drop_cluster_core(ms, clusterName);
+ return Boolean.TRUE;
+ }
+ });
+ } catch (NoSuchObjectException e) {
+ throw e;
+ } catch (InvalidOperationException e) {
+ throw e;
+ } catch (MetaException e) {
+ throw e;
+ } catch (Exception e) {
+ assert(e instanceof RuntimeException);
+ throw (RuntimeException)e;
+ } finally {
+ endFunction("drop_database", success);
+ }
+ }
+
+ @Override
+ public Cluster get_cluster(final String clusterName)
+ throws MetaException, NoSuchObjectException, TException {
+
+ incrementCounter("get_cluster");
+ try {
+ executeWithRetry(new Command() {
+ @Override
+ public Cluster run(RawStore ms) throws Exception {
+ Cluster ret = ms.getCluster(clusterName);
+ if (ret == null) {
+ throw new NoSuchObjectException(clusterName
+ + " cluster not found");
+ }
+ return ret;
+ }
+ });
+ } catch (MetaException e) {
+ throw e;
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ return null;
+ }
+
+ @Override
+ public List list_clusters() throws MetaException, TException {
+ incrementCounter("list_clusters");
+ try {
+ executeWithRetry(new Command>() {
+ @Override
+ public List run(RawStore ms) throws Exception {
+ List ret = ms.listClusters();
+ return ret;
+ }
+ });
+ } catch (MetaException e) {
+ throw e;
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ return null;
+ }
+
+ @Override
+ public void alter_cluster(final String clusterName, final Cluster cluster)
+ throws MetaException, InvalidObjectException, MetaException,
+ NoSuchObjectException, TException {
+
+ incrementCounter("create_cluster");
+ try {
+ executeWithRetry(new Command() {
+ @Override
+ public Boolean run(RawStore ms) throws Exception {
+ alter_cluster_core(ms, clusterName, cluster);
+ return Boolean.TRUE;
+ }
+ });
+ } catch (InvalidObjectException e) {
+ throw e;
+ } catch (NoSuchObjectException e) {
+ throw e;
+ } catch (MetaException e) {
+ throw e;
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ protected void alter_cluster_core(RawStore ms,
+ String clusterName, Cluster cluster) throws MetaException,
+ InvalidObjectException, NoSuchObjectException,
+ AlreadyExistsException {
+
+ cluster.setName(cluster.getName().toLowerCase());
+ if (!MetaStoreUtils.validateName(cluster.getName())) {
+ throw new InvalidObjectException(cluster.getName()
+ + " is not a valid cluster name");
+ }
+
+ boolean success = false;
+
+ try {
+ ms.openTransaction();
+ if (!is_cluster_exists(ms, clusterName)) {
+ throw new NoSuchObjectException("Cluster "
+ + cluster.getName() + " does not exist.");
+ }
+
+ if (!cluster.getName().equals(clusterName)) {
+ // this is rename operation
+ if (is_cluster_exists(ms, cluster.getName())) {
+ throw new AlreadyExistsException("Cluster "
+ + cluster.getName() + " already exists.");
+ }
+ }
+
+ ms.alterCluster(clusterName, cluster);
+ success = ms.commitTransaction();
+ } finally {
+ if (!success) {
+ ms.rollbackTransaction();
+ }
+ }
+
+ }
+
+ @Override
public PrincipalPrivilegeSet get_privilege_set(HiveObjectRef hiveObject,
String userName, List groupNames) throws MetaException,
TException {
@@ -3477,8 +3853,9 @@
TException {
Collections.addAll(groupNames, username);
return groupNames;
+ }
+
}
- }
/**
Index: metastore/src/java/org/apache/hadoop/hive/metastore/ObjectStore.java
===================================================================
--- metastore/src/java/org/apache/hadoop/hive/metastore/ObjectStore.java (revision 1235046)
+++ metastore/src/java/org/apache/hadoop/hive/metastore/ObjectStore.java (working copy)
@@ -54,6 +54,7 @@
import org.apache.hadoop.hive.common.classification.InterfaceStability;
import org.apache.hadoop.hive.conf.HiveConf;
import org.apache.hadoop.hive.conf.HiveConf.ConfVars;
+import org.apache.hadoop.hive.metastore.api.Cluster;
import org.apache.hadoop.hive.metastore.api.Database;
import org.apache.hadoop.hive.metastore.api.FieldSchema;
import org.apache.hadoop.hive.metastore.api.HiveObjectPrivilege;
@@ -61,6 +62,7 @@
import org.apache.hadoop.hive.metastore.api.HiveObjectType;
import org.apache.hadoop.hive.metastore.api.Index;
import org.apache.hadoop.hive.metastore.api.InvalidObjectException;
+import org.apache.hadoop.hive.metastore.api.InvalidOperationException;
import org.apache.hadoop.hive.metastore.api.InvalidPartitionException;
import org.apache.hadoop.hive.metastore.api.MetaException;
import org.apache.hadoop.hive.metastore.api.NoSuchObjectException;
@@ -79,6 +81,8 @@
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.model.MCluster;
+import org.apache.hadoop.hive.metastore.model.MClusterStorageDescriptor;
import org.apache.hadoop.hive.metastore.model.MColumnDescriptor;
import org.apache.hadoop.hive.metastore.model.MDBPrivilege;
import org.apache.hadoop.hive.metastore.model.MDatabase;
@@ -3917,4 +3921,169 @@
}
return delCnt;
}
+
+ @Override
+ public Boolean addCluster(Cluster cluster)
+ throws InvalidObjectException, MetaException {
+ boolean success = false;
+ boolean commited = false;
+ try {
+ openTransaction();
+ MCluster nameCheck = this.getMCluster(cluster.getName());
+ if (nameCheck != null) {
+ throw new InvalidObjectException("Cluster "
+ + cluster.getName() + " already exists.");
+ }
+ MCluster mCluster = convertToMCluster(cluster);
+ pm.makePersistent(mCluster);
+ commited = commitTransaction();
+ success = true;
+ } finally {
+ if (!commited) {
+ rollbackTransaction();
+ }
+ }
+ return success;
+ }
+
+ private MCluster convertToMCluster(Cluster cluster) {
+ int now = (int)(System.currentTimeMillis()/1000);
+ MCluster ret =
+ new MCluster(cluster.getName(), cluster.getComment(), cluster
+ .getLocationUri(), now, cluster.getParameters());
+ return ret;
+ }
+
+ private MCluster getMCluster(String clusterName) {
+ MCluster mcluster = null;
+ boolean commited = false;
+ try {
+ openTransaction();
+ Query query = pm.newQuery(MCluster.class, "clusterName == t1");
+ query.declareParameters("java.lang.String t1");
+ query.setUnique(true);
+ mcluster = (MCluster) query.execute(clusterName);
+ pm.retrieve(mcluster);
+ commited = commitTransaction();
+ } finally {
+ if (!commited) {
+ rollbackTransaction();
+ }
+ }
+ return mcluster;
+ }
+
+ @Override
+ public boolean dropCluster(String clusterName)
+ throws MetaException, InvalidOperationException, NoSuchObjectException {
+ boolean success = false;
+ try {
+ openTransaction();
+ MCluster mCluster = getMCluster(clusterName);
+ if (mCluster == null) {
+ throw new NoSuchObjectException(clusterName + " cluster does not exist.");
+ }
+ boolean inUse = clusterIsLive(mCluster);
+ if(inUse) {
+ throw new InvalidOperationException("cluster "
+ + clusterName + " is still in use.");
+ }
+ pm.deletePersistent(mCluster);
+ success = commitTransaction();
+ } finally {
+ if (!success) {
+ rollbackTransaction();
+ }
+ }
+ return success;
+ }
+
+ @Override
+ public Cluster getCluster(String clusterName) throws MetaException {
+ MCluster mCluster = getMCluster(clusterName);
+ if (mCluster == null) {
+ return null;
+ }
+ Cluster ret =
+ new Cluster(mCluster.getClusterName(), mCluster
+ .getDescription(), mCluster.getCreateTime(), mCluster
+ .getLocation(), mCluster.getParameters());
+ return ret;
+ }
+
+ private boolean clusterIsLive(MCluster mcluster) {
+ MClusterStorageDescriptor mClusterSD = null;
+ boolean commited = false;
+ try {
+ openTransaction();
+ Query query = pm.newQuery(MClusterStorageDescriptor.class, "cluster.clusterName == t1");
+ query.declareParameters("java.lang.String t1");
+ //only care about the first element
+ query.setUnique(true);
+ mClusterSD = (MClusterStorageDescriptor) query.execute(mcluster.getClusterName());
+ pm.retrieve(mClusterSD);
+ commited = commitTransaction();
+ } finally {
+ if (!commited) {
+ rollbackTransaction();
+ }
+ }
+ return mClusterSD == null;
+ }
+
+ @Override
+ public List listClusters() throws MetaException {
+
+ Collection mclusters = null;
+ List clusters = new ArrayList();
+ boolean commited = false;
+ try {
+ openTransaction();
+ Query query = pm.newQuery(MCluster.class);
+ query.setUnique(false);
+ mclusters = (Collection) query.execute();
+ pm.retrieveAll(mclusters);
+ for(MCluster mcluster: mclusters) {
+ clusters.add(convertToCluster(mcluster));
+ }
+ commited = commitTransaction();
+ } finally {
+ if (!commited) {
+ rollbackTransaction();
+ }
+ }
+ return clusters;
+ }
+
+ private Cluster convertToCluster(MCluster mcluster) {
+ return new Cluster(mcluster.getClusterName(), mcluster.getDescription(),
+ mcluster.getCreateTime(), mcluster.getLocation(),
+ mcluster.getParameters());
+ }
+
+ @Override
+ public void alterCluster(String clusterName, Cluster cluster)
+ throws MetaException {
+ boolean success = false;
+ try {
+ openTransaction();
+ clusterName = clusterName.toLowerCase();
+
+ MCluster oldCluster = getMCluster(clusterName);
+ if (oldCluster == null) {
+ throw new MetaException("cluster " + clusterName + " doesn't exist");
+ }
+
+ oldCluster.setClusterName(cluster.getName().toLowerCase());
+ oldCluster.setDescription(cluster.getComment());
+ oldCluster.setLocation(cluster.getLocationUri());
+ oldCluster.setParameters(cluster.getParameters());
+ // commit the changes
+ success = commitTransaction();
+ } finally {
+ if (!success) {
+ rollbackTransaction();
+ }
+ }
+ }
}
Index: metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py
===================================================================
--- metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py (revision 1235046)
+++ metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py (working copy)
@@ -945,6 +945,243 @@
def __ne__(self, other):
return not (self == other)
+class Cluster:
+ """
+ Attributes:
+ - name
+ - comment
+ - createTime
+ - locationUri
+ - parameters
+ """
+
+ thrift_spec = (
+ None, # 0
+ (1, TType.STRING, 'name', None, None, ), # 1
+ (2, TType.STRING, 'comment', None, None, ), # 2
+ (3, TType.I32, 'createTime', None, None, ), # 3
+ (4, TType.STRING, 'locationUri', None, None, ), # 4
+ (5, TType.MAP, 'parameters', (TType.STRING,None,TType.STRING,None), None, ), # 5
+ )
+
+ def __init__(self, name=None, comment=None, createTime=None, locationUri=None, parameters=None,):
+ self.name = name
+ self.comment = comment
+ self.createTime = createTime
+ self.locationUri = locationUri
+ self.parameters = parameters
+
+ def read(self, iprot):
+ if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+ fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+ return
+ iprot.readStructBegin()
+ while True:
+ (fname, ftype, fid) = iprot.readFieldBegin()
+ if ftype == TType.STOP:
+ break
+ if fid == 1:
+ if ftype == TType.STRING:
+ self.name = iprot.readString();
+ else:
+ iprot.skip(ftype)
+ elif fid == 2:
+ if ftype == TType.STRING:
+ self.comment = iprot.readString();
+ else:
+ iprot.skip(ftype)
+ elif fid == 3:
+ if ftype == TType.I32:
+ self.createTime = iprot.readI32();
+ else:
+ iprot.skip(ftype)
+ elif fid == 4:
+ if ftype == TType.STRING:
+ self.locationUri = iprot.readString();
+ else:
+ iprot.skip(ftype)
+ elif fid == 5:
+ if ftype == TType.MAP:
+ self.parameters = {}
+ (_ktype70, _vtype71, _size69 ) = iprot.readMapBegin()
+ for _i73 in xrange(_size69):
+ _key74 = iprot.readString();
+ _val75 = iprot.readString();
+ self.parameters[_key74] = _val75
+ iprot.readMapEnd()
+ else:
+ iprot.skip(ftype)
+ else:
+ iprot.skip(ftype)
+ iprot.readFieldEnd()
+ iprot.readStructEnd()
+
+ def write(self, oprot):
+ if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+ oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+ return
+ oprot.writeStructBegin('Cluster')
+ if self.name is not None:
+ oprot.writeFieldBegin('name', TType.STRING, 1)
+ oprot.writeString(self.name)
+ oprot.writeFieldEnd()
+ if self.comment is not None:
+ oprot.writeFieldBegin('comment', TType.STRING, 2)
+ oprot.writeString(self.comment)
+ oprot.writeFieldEnd()
+ if self.createTime is not None:
+ oprot.writeFieldBegin('createTime', TType.I32, 3)
+ oprot.writeI32(self.createTime)
+ oprot.writeFieldEnd()
+ if self.locationUri is not None:
+ oprot.writeFieldBegin('locationUri', TType.STRING, 4)
+ oprot.writeString(self.locationUri)
+ oprot.writeFieldEnd()
+ if self.parameters is not None:
+ oprot.writeFieldBegin('parameters', TType.MAP, 5)
+ oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.parameters))
+ for kiter76,viter77 in self.parameters.items():
+ oprot.writeString(kiter76)
+ oprot.writeString(viter77)
+ oprot.writeMapEnd()
+ oprot.writeFieldEnd()
+ oprot.writeFieldStop()
+ oprot.writeStructEnd()
+
+ def validate(self):
+ return
+
+
+ def __repr__(self):
+ L = ['%s=%r' % (key, value)
+ for key, value in self.__dict__.iteritems()]
+ return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+ def __eq__(self, other):
+ return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+ def __ne__(self, other):
+ return not (self == other)
+
+class ClusterStorageDescriptor:
+ """
+ Attributes:
+ - cluster
+ - location
+ - primary
+ - dataSynced
+ - parameters
+ """
+
+ thrift_spec = (
+ None, # 0
+ (1, TType.STRUCT, 'cluster', (Cluster, Cluster.thrift_spec), None, ), # 1
+ (2, TType.STRING, 'location', None, None, ), # 2
+ (3, TType.BOOL, 'primary', None, None, ), # 3
+ (4, TType.BOOL, 'dataSynced', None, None, ), # 4
+ (5, TType.MAP, 'parameters', (TType.STRING,None,TType.STRING,None), None, ), # 5
+ )
+
+ def __init__(self, cluster=None, location=None, primary=None, dataSynced=None, parameters=None,):
+ self.cluster = cluster
+ self.location = location
+ self.primary = primary
+ self.dataSynced = dataSynced
+ self.parameters = parameters
+
+ def read(self, iprot):
+ if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+ fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+ return
+ iprot.readStructBegin()
+ while True:
+ (fname, ftype, fid) = iprot.readFieldBegin()
+ if ftype == TType.STOP:
+ break
+ if fid == 1:
+ if ftype == TType.STRUCT:
+ self.cluster = Cluster()
+ self.cluster.read(iprot)
+ else:
+ iprot.skip(ftype)
+ elif fid == 2:
+ if ftype == TType.STRING:
+ self.location = iprot.readString();
+ else:
+ iprot.skip(ftype)
+ elif fid == 3:
+ if ftype == TType.BOOL:
+ self.primary = iprot.readBool();
+ else:
+ iprot.skip(ftype)
+ elif fid == 4:
+ if ftype == TType.BOOL:
+ self.dataSynced = iprot.readBool();
+ else:
+ iprot.skip(ftype)
+ elif fid == 5:
+ if ftype == TType.MAP:
+ self.parameters = {}
+ (_ktype79, _vtype80, _size78 ) = iprot.readMapBegin()
+ for _i82 in xrange(_size78):
+ _key83 = iprot.readString();
+ _val84 = iprot.readString();
+ self.parameters[_key83] = _val84
+ iprot.readMapEnd()
+ else:
+ iprot.skip(ftype)
+ else:
+ iprot.skip(ftype)
+ iprot.readFieldEnd()
+ iprot.readStructEnd()
+
+ def write(self, oprot):
+ if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+ oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+ return
+ oprot.writeStructBegin('ClusterStorageDescriptor')
+ if self.cluster is not None:
+ oprot.writeFieldBegin('cluster', TType.STRUCT, 1)
+ self.cluster.write(oprot)
+ oprot.writeFieldEnd()
+ if self.location is not None:
+ oprot.writeFieldBegin('location', TType.STRING, 2)
+ oprot.writeString(self.location)
+ oprot.writeFieldEnd()
+ if self.primary is not None:
+ oprot.writeFieldBegin('primary', TType.BOOL, 3)
+ oprot.writeBool(self.primary)
+ oprot.writeFieldEnd()
+ if self.dataSynced is not None:
+ oprot.writeFieldBegin('dataSynced', TType.BOOL, 4)
+ oprot.writeBool(self.dataSynced)
+ oprot.writeFieldEnd()
+ if self.parameters is not None:
+ oprot.writeFieldBegin('parameters', TType.MAP, 5)
+ oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.parameters))
+ for kiter85,viter86 in self.parameters.items():
+ oprot.writeString(kiter85)
+ oprot.writeString(viter86)
+ oprot.writeMapEnd()
+ oprot.writeFieldEnd()
+ oprot.writeFieldStop()
+ oprot.writeStructEnd()
+
+ def validate(self):
+ return
+
+
+ def __repr__(self):
+ L = ['%s=%r' % (key, value)
+ for key, value in self.__dict__.iteritems()]
+ return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+ def __eq__(self, other):
+ return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+ def __ne__(self, other):
+ return not (self == other)
+
class Database:
"""
Attributes:
@@ -998,11 +1235,11 @@
elif fid == 4:
if ftype == TType.MAP:
self.parameters = {}
- (_ktype70, _vtype71, _size69 ) = iprot.readMapBegin()
- for _i73 in xrange(_size69):
- _key74 = iprot.readString();
- _val75 = iprot.readString();
- self.parameters[_key74] = _val75
+ (_ktype88, _vtype89, _size87 ) = iprot.readMapBegin()
+ for _i91 in xrange(_size87):
+ _key92 = iprot.readString();
+ _val93 = iprot.readString();
+ self.parameters[_key92] = _val93
iprot.readMapEnd()
else:
iprot.skip(ftype)
@@ -1037,9 +1274,9 @@
if self.parameters is not None:
oprot.writeFieldBegin('parameters', TType.MAP, 4)
oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.parameters))
- for kiter76,viter77 in self.parameters.items():
- oprot.writeString(kiter76)
- oprot.writeString(viter77)
+ for kiter94,viter95 in self.parameters.items():
+ oprot.writeString(kiter94)
+ oprot.writeString(viter95)
oprot.writeMapEnd()
oprot.writeFieldEnd()
if self.privileges is not None:
@@ -1106,11 +1343,11 @@
elif fid == 3:
if ftype == TType.MAP:
self.parameters = {}
- (_ktype79, _vtype80, _size78 ) = iprot.readMapBegin()
- for _i82 in xrange(_size78):
- _key83 = iprot.readString();
- _val84 = iprot.readString();
- self.parameters[_key83] = _val84
+ (_ktype97, _vtype98, _size96 ) = iprot.readMapBegin()
+ for _i100 in xrange(_size96):
+ _key101 = iprot.readString();
+ _val102 = iprot.readString();
+ self.parameters[_key101] = _val102
iprot.readMapEnd()
else:
iprot.skip(ftype)
@@ -1135,9 +1372,9 @@
if self.parameters is not None:
oprot.writeFieldBegin('parameters', TType.MAP, 3)
oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.parameters))
- for kiter85,viter86 in self.parameters.items():
- oprot.writeString(kiter85)
- oprot.writeString(viter86)
+ for kiter103,viter104 in self.parameters.items():
+ oprot.writeString(kiter103)
+ oprot.writeString(viter104)
oprot.writeMapEnd()
oprot.writeFieldEnd()
oprot.writeFieldStop()
@@ -1243,6 +1480,7 @@
- bucketCols
- sortCols
- parameters
+ - clusterStorage
"""
thrift_spec = (
@@ -1257,9 +1495,10 @@
(8, TType.LIST, 'bucketCols', (TType.STRING,None), None, ), # 8
(9, TType.LIST, 'sortCols', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 9
(10, TType.MAP, 'parameters', (TType.STRING,None,TType.STRING,None), None, ), # 10
+ (11, TType.LIST, 'clusterStorage', (TType.STRUCT,(ClusterStorageDescriptor, ClusterStorageDescriptor.thrift_spec)), None, ), # 11
)
- def __init__(self, cols=None, location=None, inputFormat=None, outputFormat=None, compressed=None, numBuckets=None, serdeInfo=None, bucketCols=None, sortCols=None, parameters=None,):
+ def __init__(self, cols=None, location=None, inputFormat=None, outputFormat=None, compressed=None, numBuckets=None, serdeInfo=None, bucketCols=None, sortCols=None, parameters=None, clusterStorage=None,):
self.cols = cols
self.location = location
self.inputFormat = inputFormat
@@ -1270,6 +1509,7 @@
self.bucketCols = bucketCols
self.sortCols = sortCols
self.parameters = parameters
+ self.clusterStorage = clusterStorage
def read(self, iprot):
if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
@@ -1283,11 +1523,11 @@
if fid == 1:
if ftype == TType.LIST:
self.cols = []
- (_etype90, _size87) = iprot.readListBegin()
- for _i91 in xrange(_size87):
- _elem92 = FieldSchema()
- _elem92.read(iprot)
- self.cols.append(_elem92)
+ (_etype108, _size105) = iprot.readListBegin()
+ for _i109 in xrange(_size105):
+ _elem110 = FieldSchema()
+ _elem110.read(iprot)
+ self.cols.append(_elem110)
iprot.readListEnd()
else:
iprot.skip(ftype)
@@ -1325,35 +1565,46 @@
elif fid == 8:
if ftype == TType.LIST:
self.bucketCols = []
- (_etype96, _size93) = iprot.readListBegin()
- for _i97 in xrange(_size93):
- _elem98 = iprot.readString();
- self.bucketCols.append(_elem98)
+ (_etype114, _size111) = iprot.readListBegin()
+ for _i115 in xrange(_size111):
+ _elem116 = iprot.readString();
+ self.bucketCols.append(_elem116)
iprot.readListEnd()
else:
iprot.skip(ftype)
elif fid == 9:
if ftype == TType.LIST:
self.sortCols = []
- (_etype102, _size99) = iprot.readListBegin()
- for _i103 in xrange(_size99):
- _elem104 = Order()
- _elem104.read(iprot)
- self.sortCols.append(_elem104)
+ (_etype120, _size117) = iprot.readListBegin()
+ for _i121 in xrange(_size117):
+ _elem122 = Order()
+ _elem122.read(iprot)
+ self.sortCols.append(_elem122)
iprot.readListEnd()
else:
iprot.skip(ftype)
elif fid == 10:
if ftype == TType.MAP:
self.parameters = {}
- (_ktype106, _vtype107, _size105 ) = iprot.readMapBegin()
- for _i109 in xrange(_size105):
- _key110 = iprot.readString();
- _val111 = iprot.readString();
- self.parameters[_key110] = _val111
+ (_ktype124, _vtype125, _size123 ) = iprot.readMapBegin()
+ for _i127 in xrange(_size123):
+ _key128 = iprot.readString();
+ _val129 = iprot.readString();
+ self.parameters[_key128] = _val129
iprot.readMapEnd()
else:
iprot.skip(ftype)
+ elif fid == 11:
+ if ftype == TType.LIST:
+ self.clusterStorage = []
+ (_etype133, _size130) = iprot.readListBegin()
+ for _i134 in xrange(_size130):
+ _elem135 = ClusterStorageDescriptor()
+ _elem135.read(iprot)
+ self.clusterStorage.append(_elem135)
+ iprot.readListEnd()
+ else:
+ iprot.skip(ftype)
else:
iprot.skip(ftype)
iprot.readFieldEnd()
@@ -1367,8 +1618,8 @@
if self.cols is not None:
oprot.writeFieldBegin('cols', TType.LIST, 1)
oprot.writeListBegin(TType.STRUCT, len(self.cols))
- for iter112 in self.cols:
- iter112.write(oprot)
+ for iter136 in self.cols:
+ iter136.write(oprot)
oprot.writeListEnd()
oprot.writeFieldEnd()
if self.location is not None:
@@ -1398,25 +1649,32 @@
if self.bucketCols is not None:
oprot.writeFieldBegin('bucketCols', TType.LIST, 8)
oprot.writeListBegin(TType.STRING, len(self.bucketCols))
- for iter113 in self.bucketCols:
- oprot.writeString(iter113)
+ for iter137 in self.bucketCols:
+ oprot.writeString(iter137)
oprot.writeListEnd()
oprot.writeFieldEnd()
if self.sortCols is not None:
oprot.writeFieldBegin('sortCols', TType.LIST, 9)
oprot.writeListBegin(TType.STRUCT, len(self.sortCols))
- for iter114 in self.sortCols:
- iter114.write(oprot)
+ for iter138 in self.sortCols:
+ iter138.write(oprot)
oprot.writeListEnd()
oprot.writeFieldEnd()
if self.parameters is not None:
oprot.writeFieldBegin('parameters', TType.MAP, 10)
oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.parameters))
- for kiter115,viter116 in self.parameters.items():
- oprot.writeString(kiter115)
- oprot.writeString(viter116)
+ for kiter139,viter140 in self.parameters.items():
+ oprot.writeString(kiter139)
+ oprot.writeString(viter140)
oprot.writeMapEnd()
oprot.writeFieldEnd()
+ if self.clusterStorage is not None:
+ oprot.writeFieldBegin('clusterStorage', TType.LIST, 11)
+ oprot.writeListBegin(TType.STRUCT, len(self.clusterStorage))
+ for iter141 in self.clusterStorage:
+ iter141.write(oprot)
+ oprot.writeListEnd()
+ oprot.writeFieldEnd()
oprot.writeFieldStop()
oprot.writeStructEnd()
@@ -1533,22 +1791,22 @@
elif fid == 8:
if ftype == TType.LIST:
self.partitionKeys = []
- (_etype120, _size117) = iprot.readListBegin()
- for _i121 in xrange(_size117):
- _elem122 = FieldSchema()
- _elem122.read(iprot)
- self.partitionKeys.append(_elem122)
+ (_etype145, _size142) = iprot.readListBegin()
+ for _i146 in xrange(_size142):
+ _elem147 = FieldSchema()
+ _elem147.read(iprot)
+ self.partitionKeys.append(_elem147)
iprot.readListEnd()
else:
iprot.skip(ftype)
elif fid == 9:
if ftype == TType.MAP:
self.parameters = {}
- (_ktype124, _vtype125, _size123 ) = iprot.readMapBegin()
- for _i127 in xrange(_size123):
- _key128 = iprot.readString();
- _val129 = iprot.readString();
- self.parameters[_key128] = _val129
+ (_ktype149, _vtype150, _size148 ) = iprot.readMapBegin()
+ for _i152 in xrange(_size148):
+ _key153 = iprot.readString();
+ _val154 = iprot.readString();
+ self.parameters[_key153] = _val154
iprot.readMapEnd()
else:
iprot.skip(ftype)
@@ -1614,16 +1872,16 @@
if self.partitionKeys is not None:
oprot.writeFieldBegin('partitionKeys', TType.LIST, 8)
oprot.writeListBegin(TType.STRUCT, len(self.partitionKeys))
- for iter130 in self.partitionKeys:
- iter130.write(oprot)
+ for iter155 in self.partitionKeys:
+ iter155.write(oprot)
oprot.writeListEnd()
oprot.writeFieldEnd()
if self.parameters is not None:
oprot.writeFieldBegin('parameters', TType.MAP, 9)
oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.parameters))
- for kiter131,viter132 in self.parameters.items():
- oprot.writeString(kiter131)
- oprot.writeString(viter132)
+ for kiter156,viter157 in self.parameters.items():
+ oprot.writeString(kiter156)
+ oprot.writeString(viter157)
oprot.writeMapEnd()
oprot.writeFieldEnd()
if self.viewOriginalText is not None:
@@ -1707,10 +1965,10 @@
if fid == 1:
if ftype == TType.LIST:
self.values = []
- (_etype136, _size133) = iprot.readListBegin()
- for _i137 in xrange(_size133):
- _elem138 = iprot.readString();
- self.values.append(_elem138)
+ (_etype161, _size158) = iprot.readListBegin()
+ for _i162 in xrange(_size158):
+ _elem163 = iprot.readString();
+ self.values.append(_elem163)
iprot.readListEnd()
else:
iprot.skip(ftype)
@@ -1743,11 +2001,11 @@
elif fid == 7:
if ftype == TType.MAP:
self.parameters = {}
- (_ktype140, _vtype141, _size139 ) = iprot.readMapBegin()
- for _i143 in xrange(_size139):
- _key144 = iprot.readString();
- _val145 = iprot.readString();
- self.parameters[_key144] = _val145
+ (_ktype165, _vtype166, _size164 ) = iprot.readMapBegin()
+ for _i168 in xrange(_size164):
+ _key169 = iprot.readString();
+ _val170 = iprot.readString();
+ self.parameters[_key169] = _val170
iprot.readMapEnd()
else:
iprot.skip(ftype)
@@ -1770,8 +2028,8 @@
if self.values is not None:
oprot.writeFieldBegin('values', TType.LIST, 1)
oprot.writeListBegin(TType.STRING, len(self.values))
- for iter146 in self.values:
- oprot.writeString(iter146)
+ for iter171 in self.values:
+ oprot.writeString(iter171)
oprot.writeListEnd()
oprot.writeFieldEnd()
if self.dbName is not None:
@@ -1797,9 +2055,9 @@
if self.parameters is not None:
oprot.writeFieldBegin('parameters', TType.MAP, 7)
oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.parameters))
- for kiter147,viter148 in self.parameters.items():
- oprot.writeString(kiter147)
- oprot.writeString(viter148)
+ for kiter172,viter173 in self.parameters.items():
+ oprot.writeString(kiter172)
+ oprot.writeString(viter173)
oprot.writeMapEnd()
oprot.writeFieldEnd()
if self.privileges is not None:
@@ -1918,11 +2176,11 @@
elif fid == 9:
if ftype == TType.MAP:
self.parameters = {}
- (_ktype150, _vtype151, _size149 ) = iprot.readMapBegin()
- for _i153 in xrange(_size149):
- _key154 = iprot.readString();
- _val155 = iprot.readString();
- self.parameters[_key154] = _val155
+ (_ktype175, _vtype176, _size174 ) = iprot.readMapBegin()
+ for _i178 in xrange(_size174):
+ _key179 = iprot.readString();
+ _val180 = iprot.readString();
+ self.parameters[_key179] = _val180
iprot.readMapEnd()
else:
iprot.skip(ftype)
@@ -1976,9 +2234,9 @@
if self.parameters is not None:
oprot.writeFieldBegin('parameters', TType.MAP, 9)
oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.parameters))
- for kiter156,viter157 in self.parameters.items():
- oprot.writeString(kiter156)
- oprot.writeString(viter157)
+ for kiter181,viter182 in self.parameters.items():
+ oprot.writeString(kiter181)
+ oprot.writeString(viter182)
oprot.writeMapEnd()
oprot.writeFieldEnd()
if self.deferredRebuild is not None:
@@ -2032,22 +2290,22 @@
if fid == 1:
if ftype == TType.LIST:
self.fieldSchemas = []
- (_etype161, _size158) = iprot.readListBegin()
- for _i162 in xrange(_size158):
- _elem163 = FieldSchema()
- _elem163.read(iprot)
- self.fieldSchemas.append(_elem163)
+ (_etype186, _size183) = iprot.readListBegin()
+ for _i187 in xrange(_size183):
+ _elem188 = FieldSchema()
+ _elem188.read(iprot)
+ self.fieldSchemas.append(_elem188)
iprot.readListEnd()
else:
iprot.skip(ftype)
elif fid == 2:
if ftype == TType.MAP:
self.properties = {}
- (_ktype165, _vtype166, _size164 ) = iprot.readMapBegin()
- for _i168 in xrange(_size164):
- _key169 = iprot.readString();
- _val170 = iprot.readString();
- self.properties[_key169] = _val170
+ (_ktype190, _vtype191, _size189 ) = iprot.readMapBegin()
+ for _i193 in xrange(_size189):
+ _key194 = iprot.readString();
+ _val195 = iprot.readString();
+ self.properties[_key194] = _val195
iprot.readMapEnd()
else:
iprot.skip(ftype)
@@ -2064,16 +2322,16 @@
if self.fieldSchemas is not None:
oprot.writeFieldBegin('fieldSchemas', TType.LIST, 1)
oprot.writeListBegin(TType.STRUCT, len(self.fieldSchemas))
- for iter171 in self.fieldSchemas:
- iter171.write(oprot)
+ for iter196 in self.fieldSchemas:
+ iter196.write(oprot)
oprot.writeListEnd()
oprot.writeFieldEnd()
if self.properties is not None:
oprot.writeFieldBegin('properties', TType.MAP, 2)
oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.properties))
- for kiter172,viter173 in self.properties.items():
- oprot.writeString(kiter172)
- oprot.writeString(viter173)
+ for kiter197,viter198 in self.properties.items():
+ oprot.writeString(kiter197)
+ oprot.writeString(viter198)
oprot.writeMapEnd()
oprot.writeFieldEnd()
oprot.writeFieldStop()
Index: metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py
===================================================================
--- metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py (revision 1235046)
+++ metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py (working copy)
@@ -121,6 +121,16 @@
"""
pass
+ def drop_table_on_cluster(self, cluster_name, dbname, name, deleteData):
+ """
+ Parameters:
+ - cluster_name
+ - dbname
+ - name
+ - deleteData
+ """
+ pass
+
def get_tables(self, db_name, pattern):
"""
Parameters:
@@ -212,6 +222,17 @@
"""
pass
+ def drop_partition_on_cluster(self, cluster_name, db_name, tbl_name, part_vals, deleteData):
+ """
+ Parameters:
+ - cluster_name
+ - db_name
+ - tbl_name
+ - part_vals
+ - deleteData
+ """
+ pass
+
def drop_partition_by_name(self, db_name, tbl_name, part_name, deleteData):
"""
Parameters:
@@ -447,6 +468,38 @@
"""
pass
+ def create_cluster(self, cluster):
+ """
+ Parameters:
+ - cluster
+ """
+ pass
+
+ def drop_cluster(self, cluster_name):
+ """
+ Parameters:
+ - cluster_name
+ """
+ pass
+
+ def get_cluster(self, cluster_name):
+ """
+ Parameters:
+ - cluster_name
+ """
+ pass
+
+ def list_clusters(self, ):
+ pass
+
+ def alter_cluster(self, cluster_name, cluster):
+ """
+ Parameters:
+ - cluster_name
+ - cluster
+ """
+ pass
+
def create_role(self, role):
"""
Parameters:
@@ -1046,6 +1099,46 @@
raise result.o3
return
+ def drop_table_on_cluster(self, cluster_name, dbname, name, deleteData):
+ """
+ Parameters:
+ - cluster_name
+ - dbname
+ - name
+ - deleteData
+ """
+ self.send_drop_table_on_cluster(cluster_name, dbname, name, deleteData)
+ self.recv_drop_table_on_cluster()
+
+ def send_drop_table_on_cluster(self, cluster_name, dbname, name, deleteData):
+ self._oprot.writeMessageBegin('drop_table_on_cluster', TMessageType.CALL, self._seqid)
+ args = drop_table_on_cluster_args()
+ args.cluster_name = cluster_name
+ args.dbname = dbname
+ args.name = name
+ args.deleteData = deleteData
+ args.write(self._oprot)
+ self._oprot.writeMessageEnd()
+ self._oprot.trans.flush()
+
+ def recv_drop_table_on_cluster(self, ):
+ (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+ if mtype == TMessageType.EXCEPTION:
+ x = TApplicationException()
+ x.read(self._iprot)
+ self._iprot.readMessageEnd()
+ raise x
+ result = drop_table_on_cluster_result()
+ result.read(self._iprot)
+ self._iprot.readMessageEnd()
+ if result.o1 is not None:
+ raise result.o1
+ if result.o2 is not None:
+ raise result.o2
+ if result.o3 is not None:
+ raise result.o3
+ return
+
def get_tables(self, db_name, pattern):
"""
Parameters:
@@ -1454,6 +1547,50 @@
raise result.o2
raise TApplicationException(TApplicationException.MISSING_RESULT, "drop_partition failed: unknown result");
+ def drop_partition_on_cluster(self, cluster_name, db_name, tbl_name, part_vals, deleteData):
+ """
+ Parameters:
+ - cluster_name
+ - db_name
+ - tbl_name
+ - part_vals
+ - deleteData
+ """
+ self.send_drop_partition_on_cluster(cluster_name, db_name, tbl_name, part_vals, deleteData)
+ return self.recv_drop_partition_on_cluster()
+
+ def send_drop_partition_on_cluster(self, cluster_name, db_name, tbl_name, part_vals, deleteData):
+ self._oprot.writeMessageBegin('drop_partition_on_cluster', TMessageType.CALL, self._seqid)
+ args = drop_partition_on_cluster_args()
+ args.cluster_name = cluster_name
+ args.db_name = db_name
+ args.tbl_name = tbl_name
+ args.part_vals = part_vals
+ args.deleteData = deleteData
+ args.write(self._oprot)
+ self._oprot.writeMessageEnd()
+ self._oprot.trans.flush()
+
+ def recv_drop_partition_on_cluster(self, ):
+ (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+ if mtype == TMessageType.EXCEPTION:
+ x = TApplicationException()
+ x.read(self._iprot)
+ self._iprot.readMessageEnd()
+ raise x
+ result = drop_partition_on_cluster_result()
+ result.read(self._iprot)
+ self._iprot.readMessageEnd()
+ if result.success is not None:
+ return result.success
+ if result.o1 is not None:
+ raise result.o1
+ if result.o2 is not None:
+ raise result.o2
+ if result.o3 is not None:
+ raise result.o3
+ raise TApplicationException(TApplicationException.MISSING_RESULT, "drop_partition_on_cluster failed: unknown result");
+
def drop_partition_by_name(self, db_name, tbl_name, part_name, deleteData):
"""
Parameters:
@@ -2424,6 +2561,173 @@
raise result.o2
raise TApplicationException(TApplicationException.MISSING_RESULT, "get_index_names failed: unknown result");
+ def create_cluster(self, cluster):
+ """
+ Parameters:
+ - cluster
+ """
+ self.send_create_cluster(cluster)
+ self.recv_create_cluster()
+
+ def send_create_cluster(self, cluster):
+ self._oprot.writeMessageBegin('create_cluster', TMessageType.CALL, self._seqid)
+ args = create_cluster_args()
+ args.cluster = cluster
+ args.write(self._oprot)
+ self._oprot.writeMessageEnd()
+ self._oprot.trans.flush()
+
+ def recv_create_cluster(self, ):
+ (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+ if mtype == TMessageType.EXCEPTION:
+ x = TApplicationException()
+ x.read(self._iprot)
+ self._iprot.readMessageEnd()
+ raise x
+ result = create_cluster_result()
+ result.read(self._iprot)
+ self._iprot.readMessageEnd()
+ if result.o1 is not None:
+ raise result.o1
+ if result.o2 is not None:
+ raise result.o2
+ if result.o3 is not None:
+ raise result.o3
+ return
+
+ def drop_cluster(self, cluster_name):
+ """
+ Parameters:
+ - cluster_name
+ """
+ self.send_drop_cluster(cluster_name)
+ self.recv_drop_cluster()
+
+ def send_drop_cluster(self, cluster_name):
+ self._oprot.writeMessageBegin('drop_cluster', TMessageType.CALL, self._seqid)
+ args = drop_cluster_args()
+ args.cluster_name = cluster_name
+ args.write(self._oprot)
+ self._oprot.writeMessageEnd()
+ self._oprot.trans.flush()
+
+ def recv_drop_cluster(self, ):
+ (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+ if mtype == TMessageType.EXCEPTION:
+ x = TApplicationException()
+ x.read(self._iprot)
+ self._iprot.readMessageEnd()
+ raise x
+ result = drop_cluster_result()
+ result.read(self._iprot)
+ self._iprot.readMessageEnd()
+ if result.o1 is not None:
+ raise result.o1
+ if result.o2 is not None:
+ raise result.o2
+ if result.o3 is not None:
+ raise result.o3
+ return
+
+ def get_cluster(self, cluster_name):
+ """
+ Parameters:
+ - cluster_name
+ """
+ self.send_get_cluster(cluster_name)
+ return self.recv_get_cluster()
+
+ def send_get_cluster(self, cluster_name):
+ self._oprot.writeMessageBegin('get_cluster', TMessageType.CALL, self._seqid)
+ args = get_cluster_args()
+ args.cluster_name = cluster_name
+ args.write(self._oprot)
+ self._oprot.writeMessageEnd()
+ self._oprot.trans.flush()
+
+ def recv_get_cluster(self, ):
+ (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+ if mtype == TMessageType.EXCEPTION:
+ x = TApplicationException()
+ x.read(self._iprot)
+ self._iprot.readMessageEnd()
+ raise x
+ result = get_cluster_result()
+ result.read(self._iprot)
+ self._iprot.readMessageEnd()
+ if result.success is not None:
+ return result.success
+ if result.o1 is not None:
+ raise result.o1
+ if result.o2 is not None:
+ raise result.o2
+ raise TApplicationException(TApplicationException.MISSING_RESULT, "get_cluster failed: unknown result");
+
+ def list_clusters(self, ):
+ self.send_list_clusters()
+ return self.recv_list_clusters()
+
+ def send_list_clusters(self, ):
+ self._oprot.writeMessageBegin('list_clusters', TMessageType.CALL, self._seqid)
+ args = list_clusters_args()
+ args.write(self._oprot)
+ self._oprot.writeMessageEnd()
+ self._oprot.trans.flush()
+
+ def recv_list_clusters(self, ):
+ (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+ if mtype == TMessageType.EXCEPTION:
+ x = TApplicationException()
+ x.read(self._iprot)
+ self._iprot.readMessageEnd()
+ raise x
+ result = list_clusters_result()
+ result.read(self._iprot)
+ self._iprot.readMessageEnd()
+ if result.success is not None:
+ return result.success
+ if result.o1 is not None:
+ raise result.o1
+ raise TApplicationException(TApplicationException.MISSING_RESULT, "list_clusters failed: unknown result");
+
+ def alter_cluster(self, cluster_name, cluster):
+ """
+ Parameters:
+ - cluster_name
+ - cluster
+ """
+ self.send_alter_cluster(cluster_name, cluster)
+ self.recv_alter_cluster()
+
+ def send_alter_cluster(self, cluster_name, cluster):
+ self._oprot.writeMessageBegin('alter_cluster', TMessageType.CALL, self._seqid)
+ args = alter_cluster_args()
+ args.cluster_name = cluster_name
+ args.cluster = cluster
+ args.write(self._oprot)
+ self._oprot.writeMessageEnd()
+ self._oprot.trans.flush()
+
+ def recv_alter_cluster(self, ):
+ (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+ if mtype == TMessageType.EXCEPTION:
+ x = TApplicationException()
+ x.read(self._iprot)
+ self._iprot.readMessageEnd()
+ raise x
+ result = alter_cluster_result()
+ result.read(self._iprot)
+ self._iprot.readMessageEnd()
+ if result.o1 is not None:
+ raise result.o1
+ if result.o2 is not None:
+ raise result.o2
+ if result.o3 is not None:
+ raise result.o3
+ if result.o4 is not None:
+ raise result.o4
+ return
+
def create_role(self, role):
"""
Parameters:
@@ -2911,6 +3215,7 @@
self._processMap["get_schema"] = Processor.process_get_schema
self._processMap["create_table"] = Processor.process_create_table
self._processMap["drop_table"] = Processor.process_drop_table
+ self._processMap["drop_table_on_cluster"] = Processor.process_drop_table_on_cluster
self._processMap["get_tables"] = Processor.process_get_tables
self._processMap["get_all_tables"] = Processor.process_get_all_tables
self._processMap["get_table"] = Processor.process_get_table
@@ -2922,6 +3227,7 @@
self._processMap["append_partition"] = Processor.process_append_partition
self._processMap["append_partition_by_name"] = Processor.process_append_partition_by_name
self._processMap["drop_partition"] = Processor.process_drop_partition
+ self._processMap["drop_partition_on_cluster"] = Processor.process_drop_partition_on_cluster
self._processMap["drop_partition_by_name"] = Processor.process_drop_partition_by_name
self._processMap["get_partition"] = Processor.process_get_partition
self._processMap["get_partition_with_auth"] = Processor.process_get_partition_with_auth
@@ -2947,6 +3253,11 @@
self._processMap["get_index_by_name"] = Processor.process_get_index_by_name
self._processMap["get_indexes"] = Processor.process_get_indexes
self._processMap["get_index_names"] = Processor.process_get_index_names
+ self._processMap["create_cluster"] = Processor.process_create_cluster
+ self._processMap["drop_cluster"] = Processor.process_drop_cluster
+ self._processMap["get_cluster"] = Processor.process_get_cluster
+ self._processMap["list_clusters"] = Processor.process_list_clusters
+ self._processMap["alter_cluster"] = Processor.process_alter_cluster
self._processMap["create_role"] = Processor.process_create_role
self._processMap["drop_role"] = Processor.process_drop_role
self._processMap["get_role_names"] = Processor.process_get_role_names
@@ -3209,6 +3520,24 @@
oprot.writeMessageEnd()
oprot.trans.flush()
+ def process_drop_table_on_cluster(self, seqid, iprot, oprot):
+ args = drop_table_on_cluster_args()
+ args.read(iprot)
+ iprot.readMessageEnd()
+ result = drop_table_on_cluster_result()
+ try:
+ self._handler.drop_table_on_cluster(args.cluster_name, args.dbname, args.name, args.deleteData)
+ except NoSuchObjectException, o1:
+ result.o1 = o1
+ except MetaException, o2:
+ result.o2 = o2
+ except InvalidOperationException, o3:
+ result.o3 = o3
+ oprot.writeMessageBegin("drop_table_on_cluster", TMessageType.REPLY, seqid)
+ result.write(oprot)
+ oprot.writeMessageEnd()
+ oprot.trans.flush()
+
def process_get_tables(self, seqid, iprot, oprot):
args = get_tables_args()
args.read(iprot)
@@ -3393,6 +3722,24 @@
oprot.writeMessageEnd()
oprot.trans.flush()
+ def process_drop_partition_on_cluster(self, seqid, iprot, oprot):
+ args = drop_partition_on_cluster_args()
+ args.read(iprot)
+ iprot.readMessageEnd()
+ result = drop_partition_on_cluster_result()
+ try:
+ result.success = self._handler.drop_partition_on_cluster(args.cluster_name, args.db_name, args.tbl_name, args.part_vals, args.deleteData)
+ except NoSuchObjectException, o1:
+ result.o1 = o1
+ except MetaException, o2:
+ result.o2 = o2
+ except InvalidOperationException, o3:
+ result.o3 = o3
+ oprot.writeMessageBegin("drop_partition_on_cluster", TMessageType.REPLY, seqid)
+ result.write(oprot)
+ oprot.writeMessageEnd()
+ oprot.trans.flush()
+
def process_drop_partition_by_name(self, seqid, iprot, oprot):
args = drop_partition_by_name_args()
args.read(iprot)
@@ -3801,6 +4148,92 @@
oprot.writeMessageEnd()
oprot.trans.flush()
+ def process_create_cluster(self, seqid, iprot, oprot):
+ args = create_cluster_args()
+ args.read(iprot)
+ iprot.readMessageEnd()
+ result = create_cluster_result()
+ try:
+ self._handler.create_cluster(args.cluster)
+ except AlreadyExistsException, o1:
+ result.o1 = o1
+ except InvalidObjectException, o2:
+ result.o2 = o2
+ except MetaException, o3:
+ result.o3 = o3
+ oprot.writeMessageBegin("create_cluster", TMessageType.REPLY, seqid)
+ result.write(oprot)
+ oprot.writeMessageEnd()
+ oprot.trans.flush()
+
+ def process_drop_cluster(self, seqid, iprot, oprot):
+ args = drop_cluster_args()
+ args.read(iprot)
+ iprot.readMessageEnd()
+ result = drop_cluster_result()
+ try:
+ self._handler.drop_cluster(args.cluster_name)
+ except NoSuchObjectException, o1:
+ result.o1 = o1
+ except InvalidOperationException, o2:
+ result.o2 = o2
+ except MetaException, o3:
+ result.o3 = o3
+ oprot.writeMessageBegin("drop_cluster", TMessageType.REPLY, seqid)
+ result.write(oprot)
+ oprot.writeMessageEnd()
+ oprot.trans.flush()
+
+ def process_get_cluster(self, seqid, iprot, oprot):
+ args = get_cluster_args()
+ args.read(iprot)
+ iprot.readMessageEnd()
+ result = get_cluster_result()
+ try:
+ result.success = self._handler.get_cluster(args.cluster_name)
+ except MetaException, o1:
+ result.o1 = o1
+ except NoSuchObjectException, o2:
+ result.o2 = o2
+ oprot.writeMessageBegin("get_cluster", TMessageType.REPLY, seqid)
+ result.write(oprot)
+ oprot.writeMessageEnd()
+ oprot.trans.flush()
+
+ def process_list_clusters(self, seqid, iprot, oprot):
+ args = list_clusters_args()
+ args.read(iprot)
+ iprot.readMessageEnd()
+ result = list_clusters_result()
+ try:
+ result.success = self._handler.list_clusters()
+ except MetaException, o1:
+ result.o1 = o1
+ oprot.writeMessageBegin("list_clusters", TMessageType.REPLY, seqid)
+ result.write(oprot)
+ oprot.writeMessageEnd()
+ oprot.trans.flush()
+
+ def process_alter_cluster(self, seqid, iprot, oprot):
+ args = alter_cluster_args()
+ args.read(iprot)
+ iprot.readMessageEnd()
+ result = alter_cluster_result()
+ try:
+ self._handler.alter_cluster(args.cluster_name, args.cluster)
+ except MetaException, o1:
+ result.o1 = o1
+ except InvalidObjectException, o2:
+ result.o2 = o2
+ except NoSuchObjectException, o3:
+ result.o3 = o3
+ except AlreadyExistsException, o4:
+ result.o4 = o4
+ oprot.writeMessageBegin("alter_cluster", TMessageType.REPLY, seqid)
+ result.write(oprot)
+ oprot.writeMessageEnd()
+ oprot.trans.flush()
+
def process_create_role(self, seqid, iprot, oprot):
args = create_role_args()
args.read(iprot)
@@ -4553,10 +4986,10 @@
if fid == 0:
if ftype == TType.LIST:
self.success = []
- (_etype177, _size174) = iprot.readListBegin()
- for _i178 in xrange(_size174):
- _elem179 = iprot.readString();
- self.success.append(_elem179)
+ (_etype202, _size199) = iprot.readListBegin()
+ for _i203 in xrange(_size199):
+ _elem204 = iprot.readString();
+ self.success.append(_elem204)
iprot.readListEnd()
else:
iprot.skip(ftype)
@@ -4579,8 +5012,8 @@
if self.success is not None:
oprot.writeFieldBegin('success', TType.LIST, 0)
oprot.writeListBegin(TType.STRING, len(self.success))
- for iter180 in self.success:
- oprot.writeString(iter180)
+ for iter205 in self.success:
+ oprot.writeString(iter205)
oprot.writeListEnd()
oprot.writeFieldEnd()
if self.o1 is not None:
@@ -4675,10 +5108,10 @@
if fid == 0:
if ftype == TType.LIST:
self.success = []
- (_etype184, _size181) = iprot.readListBegin()
- for _i185 in xrange(_size181):
- _elem186 = iprot.readString();
- self.success.append(_elem186)
+ (_etype209, _size206) = iprot.readListBegin()
+ for _i210 in xrange(_size206):
+ _elem211 = iprot.readString();
+ self.success.append(_elem211)
iprot.readListEnd()
else:
iprot.skip(ftype)
@@ -4701,8 +5134,8 @@
if self.success is not None:
oprot.writeFieldBegin('success', TType.LIST, 0)
oprot.writeListBegin(TType.STRING, len(self.success))
- for iter187 in self.success:
- oprot.writeString(iter187)
+ for iter212 in self.success:
+ oprot.writeString(iter212)
oprot.writeListEnd()
oprot.writeFieldEnd()
if self.o1 is not None:
@@ -5412,12 +5845,12 @@
if fid == 0:
if ftype == TType.MAP:
self.success = {}
- (_ktype189, _vtype190, _size188 ) = iprot.readMapBegin()
- for _i192 in xrange(_size188):
- _key193 = iprot.readString();
- _val194 = Type()
- _val194.read(iprot)
- self.success[_key193] = _val194
+ (_ktype214, _vtype215, _size213 ) = iprot.readMapBegin()
+ for _i217 in xrange(_size213):
+ _key218 = iprot.readString();
+ _val219 = Type()
+ _val219.read(iprot)
+ self.success[_key218] = _val219
iprot.readMapEnd()
else:
iprot.skip(ftype)
@@ -5440,9 +5873,9 @@
if self.success is not None:
oprot.writeFieldBegin('success', TType.MAP, 0)
oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success))
- for kiter195,viter196 in self.success.items():
- oprot.writeString(kiter195)
- viter196.write(oprot)
+ for kiter220,viter221 in self.success.items():
+ oprot.writeString(kiter220)
+ viter221.write(oprot)
oprot.writeMapEnd()
oprot.writeFieldEnd()
if self.o2 is not None:
@@ -5573,11 +6006,11 @@
if fid == 0:
if ftype == TType.LIST:
self.success = []
- (_etype200, _size197) = iprot.readListBegin()
- for _i201 in xrange(_size197):
- _elem202 = FieldSchema()
- _elem202.read(iprot)
- self.success.append(_elem202)
+ (_etype225, _size222) = iprot.readListBegin()
+ for _i226 in xrange(_size222):
+ _elem227 = FieldSchema()
+ _elem227.read(iprot)
+ self.success.append(_elem227)
iprot.readListEnd()
else:
iprot.skip(ftype)
@@ -5612,8 +6045,8 @@
if self.success is not None:
oprot.writeFieldBegin('success', TType.LIST, 0)
oprot.writeListBegin(TType.STRUCT, len(self.success))
- for iter203 in self.success:
- iter203.write(oprot)
+ for iter228 in self.success:
+ iter228.write(oprot)
oprot.writeListEnd()
oprot.writeFieldEnd()
if self.o1 is not None:
@@ -5752,11 +6185,11 @@
if fid == 0:
if ftype == TType.LIST:
self.success = []
- (_etype207, _size204) = iprot.readListBegin()
- for _i208 in xrange(_size204):
- _elem209 = FieldSchema()
- _elem209.read(iprot)
- self.success.append(_elem209)
+ (_etype232, _size229) = iprot.readListBegin()
+ for _i233 in xrange(_size229):
+ _elem234 = FieldSchema()
+ _elem234.read(iprot)
+ self.success.append(_elem234)
iprot.readListEnd()
else:
iprot.skip(ftype)
@@ -5791,8 +6224,8 @@
if self.success is not None:
oprot.writeFieldBegin('success', TType.LIST, 0)
oprot.writeListBegin(TType.STRUCT, len(self.success))
- for iter210 in self.success:
- iter210.write(oprot)
+ for iter235 in self.success:
+ iter235.write(oprot)
oprot.writeListEnd()
oprot.writeFieldEnd()
if self.o1 is not None:
@@ -6144,6 +6577,189 @@
def __ne__(self, other):
return not (self == other)
+class drop_table_on_cluster_args:
+ """
+ Attributes:
+ - cluster_name
+ - dbname
+ - name
+ - deleteData
+ """
+
+ thrift_spec = (
+ None, # 0
+ (1, TType.STRING, 'cluster_name', None, None, ), # 1
+ (2, TType.STRING, 'dbname', None, None, ), # 2
+ (3, TType.STRING, 'name', None, None, ), # 3
+ (4, TType.BOOL, 'deleteData', None, None, ), # 4
+ )
+
+ def __init__(self, cluster_name=None, dbname=None, name=None, deleteData=None,):
+ self.cluster_name = cluster_name
+ self.dbname = dbname
+ self.name = name
+ self.deleteData = deleteData
+
+ def read(self, iprot):
+ if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+ fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+ return
+ iprot.readStructBegin()
+ while True:
+ (fname, ftype, fid) = iprot.readFieldBegin()
+ if ftype == TType.STOP:
+ break
+ if fid == 1:
+ if ftype == TType.STRING:
+ self.cluster_name = iprot.readString();
+ else:
+ iprot.skip(ftype)
+ elif fid == 2:
+ if ftype == TType.STRING:
+ self.dbname = iprot.readString();
+ else:
+ iprot.skip(ftype)
+ elif fid == 3:
+ if ftype == TType.STRING:
+ self.name = iprot.readString();
+ else:
+ iprot.skip(ftype)
+ elif fid == 4:
+ if ftype == TType.BOOL:
+ self.deleteData = iprot.readBool();
+ else:
+ iprot.skip(ftype)
+ else:
+ iprot.skip(ftype)
+ iprot.readFieldEnd()
+ iprot.readStructEnd()
+
+ def write(self, oprot):
+ if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+ oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+ return
+ oprot.writeStructBegin('drop_table_on_cluster_args')
+ if self.cluster_name is not None:
+ oprot.writeFieldBegin('cluster_name', TType.STRING, 1)
+ oprot.writeString(self.cluster_name)
+ oprot.writeFieldEnd()
+ if self.dbname is not None:
+ oprot.writeFieldBegin('dbname', TType.STRING, 2)
+ oprot.writeString(self.dbname)
+ oprot.writeFieldEnd()
+ if self.name is not None:
+ oprot.writeFieldBegin('name', TType.STRING, 3)
+ oprot.writeString(self.name)
+ oprot.writeFieldEnd()
+ if self.deleteData is not None:
+ oprot.writeFieldBegin('deleteData', TType.BOOL, 4)
+ oprot.writeBool(self.deleteData)
+ oprot.writeFieldEnd()
+ oprot.writeFieldStop()
+ oprot.writeStructEnd()
+
+ def validate(self):
+ return
+
+
+ def __repr__(self):
+ L = ['%s=%r' % (key, value)
+ for key, value in self.__dict__.iteritems()]
+ return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+ def __eq__(self, other):
+ return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+ def __ne__(self, other):
+ return not (self == other)
+
+class drop_table_on_cluster_result:
+ """
+ Attributes:
+ - o1
+ - o2
+ - o3
+ """
+
+ thrift_spec = (
+ None, # 0
+ (1, TType.STRUCT, 'o1', (NoSuchObjectException, NoSuchObjectException.thrift_spec), None, ), # 1
+ (2, TType.STRUCT, 'o2', (MetaException, MetaException.thrift_spec), None, ), # 2
+ (3, TType.STRUCT, 'o3', (InvalidOperationException, InvalidOperationException.thrift_spec), None, ), # 3
+ )
+
+ def __init__(self, o1=None, o2=None, o3=None,):
+ self.o1 = o1
+ self.o2 = o2
+ self.o3 = o3
+
+ def read(self, iprot):
+ if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+ fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+ return
+ iprot.readStructBegin()
+ while True:
+ (fname, ftype, fid) = iprot.readFieldBegin()
+ if ftype == TType.STOP:
+ break
+ if fid == 1:
+ if ftype == TType.STRUCT:
+ self.o1 = NoSuchObjectException()
+ self.o1.read(iprot)
+ else:
+ iprot.skip(ftype)
+ elif fid == 2:
+ if ftype == TType.STRUCT:
+ self.o2 = MetaException()
+ self.o2.read(iprot)
+ else:
+ iprot.skip(ftype)
+ elif fid == 3:
+ if ftype == TType.STRUCT:
+ self.o3 = InvalidOperationException()
+ self.o3.read(iprot)
+ else:
+ iprot.skip(ftype)
+ else:
+ iprot.skip(ftype)
+ iprot.readFieldEnd()
+ iprot.readStructEnd()
+
+ def write(self, oprot):
+ if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+ oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+ return
+ oprot.writeStructBegin('drop_table_on_cluster_result')
+ if self.o1 is not None:
+ oprot.writeFieldBegin('o1', TType.STRUCT, 1)
+ self.o1.write(oprot)
+ oprot.writeFieldEnd()
+ if self.o2 is not None:
+ oprot.writeFieldBegin('o2', TType.STRUCT, 2)
+ self.o2.write(oprot)
+ oprot.writeFieldEnd()
+ if self.o3 is not None:
+ oprot.writeFieldBegin('o3', TType.STRUCT, 3)
+ self.o3.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__.iteritems()]
+ return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+ def __eq__(self, other):
+ return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+ def __ne__(self, other):
+ return not (self == other)
+
class get_tables_args:
"""
Attributes:
@@ -6244,10 +6860,10 @@
if fid == 0:
if ftype == TType.LIST:
self.success = []
- (_etype214, _size211) = iprot.readListBegin()
- for _i215 in xrange(_size211):
- _elem216 = iprot.readString();
- self.success.append(_elem216)
+ (_etype239, _size236) = iprot.readListBegin()
+ for _i240 in xrange(_size236):
+ _elem241 = iprot.readString();
+ self.success.append(_elem241)
iprot.readListEnd()
else:
iprot.skip(ftype)
@@ -6270,8 +6886,8 @@
if self.success is not None:
oprot.writeFieldBegin('success', TType.LIST, 0)
oprot.writeListBegin(TType.STRING, len(self.success))
- for iter217 in self.success:
- oprot.writeString(iter217)
+ for iter242 in self.success:
+ oprot.writeString(iter242)
oprot.writeListEnd()
oprot.writeFieldEnd()
if self.o1 is not None:
@@ -6384,10 +7000,10 @@
if fid == 0:
if ftype == TType.LIST:
self.success = []
- (_etype221, _size218) = iprot.readListBegin()
- for _i222 in xrange(_size218):
- _elem223 = iprot.readString();
- self.success.append(_elem223)
+ (_etype246, _size243) = iprot.readListBegin()
+ for _i247 in xrange(_size243):
+ _elem248 = iprot.readString();
+ self.success.append(_elem248)
iprot.readListEnd()
else:
iprot.skip(ftype)
@@ -6410,8 +7026,8 @@
if self.success is not None:
oprot.writeFieldBegin('success', TType.LIST, 0)
oprot.writeListBegin(TType.STRING, len(self.success))
- for iter224 in self.success:
- oprot.writeString(iter224)
+ for iter249 in self.success:
+ oprot.writeString(iter249)
oprot.writeListEnd()
oprot.writeFieldEnd()
if self.o1 is not None:
@@ -6628,10 +7244,10 @@
elif fid == 2:
if ftype == TType.LIST:
self.tbl_names = []
- (_etype228, _size225) = iprot.readListBegin()
- for _i229 in xrange(_size225):
- _elem230 = iprot.readString();
- self.tbl_names.append(_elem230)
+ (_etype253, _size250) = iprot.readListBegin()
+ for _i254 in xrange(_size250):
+ _elem255 = iprot.readString();
+ self.tbl_names.append(_elem255)
iprot.readListEnd()
else:
iprot.skip(ftype)
@@ -6652,8 +7268,8 @@
if self.tbl_names is not None:
oprot.writeFieldBegin('tbl_names', TType.LIST, 2)
oprot.writeListBegin(TType.STRING, len(self.tbl_names))
- for iter231 in self.tbl_names:
- oprot.writeString(iter231)
+ for iter256 in self.tbl_names:
+ oprot.writeString(iter256)
oprot.writeListEnd()
oprot.writeFieldEnd()
oprot.writeFieldStop()
@@ -6708,11 +7324,11 @@
if fid == 0:
if ftype == TType.LIST:
self.success = []
- (_etype235, _size232) = iprot.readListBegin()
- for _i236 in xrange(_size232):
- _elem237 = Table()
- _elem237.read(iprot)
- self.success.append(_elem237)
+ (_etype260, _size257) = iprot.readListBegin()
+ for _i261 in xrange(_size257):
+ _elem262 = Table()
+ _elem262.read(iprot)
+ self.success.append(_elem262)
iprot.readListEnd()
else:
iprot.skip(ftype)
@@ -6747,8 +7363,8 @@
if self.success is not None:
oprot.writeFieldBegin('success', TType.LIST, 0)
oprot.writeListBegin(TType.STRUCT, len(self.success))
- for iter238 in self.success:
- iter238.write(oprot)
+ for iter263 in self.success:
+ iter263.write(oprot)
oprot.writeListEnd()
oprot.writeFieldEnd()
if self.o1 is not None:
@@ -6899,10 +7515,10 @@
if fid == 0:
if ftype == TType.LIST:
self.success = []
- (_etype242, _size239) = iprot.readListBegin()
- for _i243 in xrange(_size239):
- _elem244 = iprot.readString();
- self.success.append(_elem244)
+ (_etype267, _size264) = iprot.readListBegin()
+ for _i268 in xrange(_size264):
+ _elem269 = iprot.readString();
+ self.success.append(_elem269)
iprot.readListEnd()
else:
iprot.skip(ftype)
@@ -6937,8 +7553,8 @@
if self.success is not None:
oprot.writeFieldBegin('success', TType.LIST, 0)
oprot.writeListBegin(TType.STRING, len(self.success))
- for iter245 in self.success:
- oprot.writeString(iter245)
+ for iter270 in self.success:
+ oprot.writeString(iter270)
oprot.writeListEnd()
oprot.writeFieldEnd()
if self.o1 is not None:
@@ -7316,11 +7932,11 @@
if fid == 1:
if ftype == TType.LIST:
self.new_parts = []
- (_etype249, _size246) = iprot.readListBegin()
- for _i250 in xrange(_size246):
- _elem251 = Partition()
- _elem251.read(iprot)
- self.new_parts.append(_elem251)
+ (_etype274, _size271) = iprot.readListBegin()
+ for _i275 in xrange(_size271):
+ _elem276 = Partition()
+ _elem276.read(iprot)
+ self.new_parts.append(_elem276)
iprot.readListEnd()
else:
iprot.skip(ftype)
@@ -7337,8 +7953,8 @@
if self.new_parts is not None:
oprot.writeFieldBegin('new_parts', TType.LIST, 1)
oprot.writeListBegin(TType.STRUCT, len(self.new_parts))
- for iter252 in self.new_parts:
- iter252.write(oprot)
+ for iter277 in self.new_parts:
+ iter277.write(oprot)
oprot.writeListEnd()
oprot.writeFieldEnd()
oprot.writeFieldStop()
@@ -7499,10 +8115,10 @@
elif fid == 3:
if ftype == TType.LIST:
self.part_vals = []
- (_etype256, _size253) = iprot.readListBegin()
- for _i257 in xrange(_size253):
- _elem258 = iprot.readString();
- self.part_vals.append(_elem258)
+ (_etype281, _size278) = iprot.readListBegin()
+ for _i282 in xrange(_size278):
+ _elem283 = iprot.readString();
+ self.part_vals.append(_elem283)
iprot.readListEnd()
else:
iprot.skip(ftype)
@@ -7527,8 +8143,8 @@
if self.part_vals is not None:
oprot.writeFieldBegin('part_vals', TType.LIST, 3)
oprot.writeListBegin(TType.STRING, len(self.part_vals))
- for iter259 in self.part_vals:
- oprot.writeString(iter259)
+ for iter284 in self.part_vals:
+ oprot.writeString(iter284)
oprot.writeListEnd()
oprot.writeFieldEnd()
oprot.writeFieldStop()
@@ -7876,10 +8492,10 @@
elif fid == 3:
if ftype == TType.LIST:
self.part_vals = []
- (_etype263, _size260) = iprot.readListBegin()
- for _i264 in xrange(_size260):
- _elem265 = iprot.readString();
- self.part_vals.append(_elem265)
+ (_etype288, _size285) = iprot.readListBegin()
+ for _i289 in xrange(_size285):
+ _elem290 = iprot.readString();
+ self.part_vals.append(_elem290)
iprot.readListEnd()
else:
iprot.skip(ftype)
@@ -7909,8 +8525,8 @@
if self.part_vals is not None:
oprot.writeFieldBegin('part_vals', TType.LIST, 3)
oprot.writeListBegin(TType.STRING, len(self.part_vals))
- for iter266 in self.part_vals:
- oprot.writeString(iter266)
+ for iter291 in self.part_vals:
+ oprot.writeString(iter291)
oprot.writeListEnd()
oprot.writeFieldEnd()
if self.deleteData is not None:
@@ -8020,6 +8636,220 @@
def __ne__(self, other):
return not (self == other)
+class drop_partition_on_cluster_args:
+ """
+ Attributes:
+ - cluster_name
+ - db_name
+ - tbl_name
+ - part_vals
+ - deleteData
+ """
+
+ thrift_spec = (
+ None, # 0
+ (1, TType.STRING, 'cluster_name', None, None, ), # 1
+ (2, TType.STRING, 'db_name', None, None, ), # 2
+ (3, TType.STRING, 'tbl_name', None, None, ), # 3
+ (4, TType.LIST, 'part_vals', (TType.STRING,None), None, ), # 4
+ (5, TType.BOOL, 'deleteData', None, None, ), # 5
+ )
+
+ def __init__(self, cluster_name=None, db_name=None, tbl_name=None, part_vals=None, deleteData=None,):
+ self.cluster_name = cluster_name
+ self.db_name = db_name
+ self.tbl_name = tbl_name
+ self.part_vals = part_vals
+ self.deleteData = deleteData
+
+ def read(self, iprot):
+ if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+ fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+ return
+ iprot.readStructBegin()
+ while True:
+ (fname, ftype, fid) = iprot.readFieldBegin()
+ if ftype == TType.STOP:
+ break
+ if fid == 1:
+ if ftype == TType.STRING:
+ self.cluster_name = iprot.readString();
+ else:
+ iprot.skip(ftype)
+ elif fid == 2:
+ if ftype == TType.STRING:
+ self.db_name = iprot.readString();
+ else:
+ iprot.skip(ftype)
+ elif fid == 3:
+ if ftype == TType.STRING:
+ self.tbl_name = iprot.readString();
+ else:
+ iprot.skip(ftype)
+ elif fid == 4:
+ if ftype == TType.LIST:
+ self.part_vals = []
+ (_etype295, _size292) = iprot.readListBegin()
+ for _i296 in xrange(_size292):
+ _elem297 = iprot.readString();
+ self.part_vals.append(_elem297)
+ iprot.readListEnd()
+ else:
+ iprot.skip(ftype)
+ elif fid == 5:
+ if ftype == TType.BOOL:
+ self.deleteData = iprot.readBool();
+ else:
+ iprot.skip(ftype)
+ else:
+ iprot.skip(ftype)
+ iprot.readFieldEnd()
+ iprot.readStructEnd()
+
+ def write(self, oprot):
+ if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+ oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+ return
+ oprot.writeStructBegin('drop_partition_on_cluster_args')
+ if self.cluster_name is not None:
+ oprot.writeFieldBegin('cluster_name', TType.STRING, 1)
+ oprot.writeString(self.cluster_name)
+ oprot.writeFieldEnd()
+ if self.db_name is not None:
+ oprot.writeFieldBegin('db_name', TType.STRING, 2)
+ oprot.writeString(self.db_name)
+ oprot.writeFieldEnd()
+ if self.tbl_name is not None:
+ oprot.writeFieldBegin('tbl_name', TType.STRING, 3)
+ oprot.writeString(self.tbl_name)
+ oprot.writeFieldEnd()
+ if self.part_vals is not None:
+ oprot.writeFieldBegin('part_vals', TType.LIST, 4)
+ oprot.writeListBegin(TType.STRING, len(self.part_vals))
+ for iter298 in self.part_vals:
+ oprot.writeString(iter298)
+ oprot.writeListEnd()
+ oprot.writeFieldEnd()
+ if self.deleteData is not None:
+ oprot.writeFieldBegin('deleteData', TType.BOOL, 5)
+ oprot.writeBool(self.deleteData)
+ oprot.writeFieldEnd()
+ oprot.writeFieldStop()
+ oprot.writeStructEnd()
+
+ def validate(self):
+ return
+
+
+ def __repr__(self):
+ L = ['%s=%r' % (key, value)
+ for key, value in self.__dict__.iteritems()]
+ return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+ def __eq__(self, other):
+ return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+ def __ne__(self, other):
+ return not (self == other)
+
+class drop_partition_on_cluster_result:
+ """
+ Attributes:
+ - success
+ - o1
+ - o2
+ - o3
+ """
+
+ thrift_spec = (
+ (0, TType.BOOL, 'success', None, None, ), # 0
+ (1, TType.STRUCT, 'o1', (NoSuchObjectException, NoSuchObjectException.thrift_spec), None, ), # 1
+ (2, TType.STRUCT, 'o2', (MetaException, MetaException.thrift_spec), None, ), # 2
+ (3, TType.STRUCT, 'o3', (InvalidOperationException, InvalidOperationException.thrift_spec), None, ), # 3
+ )
+
+ def __init__(self, success=None, o1=None, o2=None, o3=None,):
+ self.success = success
+ self.o1 = o1
+ self.o2 = o2
+ self.o3 = o3
+
+ def read(self, iprot):
+ if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+ fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+ return
+ iprot.readStructBegin()
+ while True:
+ (fname, ftype, fid) = iprot.readFieldBegin()
+ if ftype == TType.STOP:
+ break
+ if fid == 0:
+ if ftype == TType.BOOL:
+ self.success = iprot.readBool();
+ else:
+ iprot.skip(ftype)
+ elif fid == 1:
+ if ftype == TType.STRUCT:
+ self.o1 = NoSuchObjectException()
+ self.o1.read(iprot)
+ else:
+ iprot.skip(ftype)
+ elif fid == 2:
+ if ftype == TType.STRUCT:
+ self.o2 = MetaException()
+ self.o2.read(iprot)
+ else:
+ iprot.skip(ftype)
+ elif fid == 3:
+ if ftype == TType.STRUCT:
+ self.o3 = InvalidOperationException()
+ self.o3.read(iprot)
+ else:
+ iprot.skip(ftype)
+ else:
+ iprot.skip(ftype)
+ iprot.readFieldEnd()
+ iprot.readStructEnd()
+
+ def write(self, oprot):
+ if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+ oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+ return
+ oprot.writeStructBegin('drop_partition_on_cluster_result')
+ if self.success is not None:
+ oprot.writeFieldBegin('success', TType.BOOL, 0)
+ oprot.writeBool(self.success)
+ oprot.writeFieldEnd()
+ if self.o1 is not None:
+ oprot.writeFieldBegin('o1', TType.STRUCT, 1)
+ self.o1.write(oprot)
+ oprot.writeFieldEnd()
+ if self.o2 is not None:
+ oprot.writeFieldBegin('o2', TType.STRUCT, 2)
+ self.o2.write(oprot)
+ oprot.writeFieldEnd()
+ if self.o3 is not None:
+ oprot.writeFieldBegin('o3', TType.STRUCT, 3)
+ self.o3.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__.iteritems()]
+ return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+ def __eq__(self, other):
+ return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+ def __ne__(self, other):
+ return not (self == other)
+
class drop_partition_by_name_args:
"""
Attributes:
@@ -8243,10 +9073,10 @@
elif fid == 3:
if ftype == TType.LIST:
self.part_vals = []
- (_etype270, _size267) = iprot.readListBegin()
- for _i271 in xrange(_size267):
- _elem272 = iprot.readString();
- self.part_vals.append(_elem272)
+ (_etype302, _size299) = iprot.readListBegin()
+ for _i303 in xrange(_size299):
+ _elem304 = iprot.readString();
+ self.part_vals.append(_elem304)
iprot.readListEnd()
else:
iprot.skip(ftype)
@@ -8271,8 +9101,8 @@
if self.part_vals is not None:
oprot.writeFieldBegin('part_vals', TType.LIST, 3)
oprot.writeListBegin(TType.STRING, len(self.part_vals))
- for iter273 in self.part_vals:
- oprot.writeString(iter273)
+ for iter305 in self.part_vals:
+ oprot.writeString(iter305)
oprot.writeListEnd()
oprot.writeFieldEnd()
oprot.writeFieldStop()
@@ -8427,10 +9257,10 @@
elif fid == 3:
if ftype == TType.LIST:
self.part_vals = []
- (_etype277, _size274) = iprot.readListBegin()
- for _i278 in xrange(_size274):
- _elem279 = iprot.readString();
- self.part_vals.append(_elem279)
+ (_etype309, _size306) = iprot.readListBegin()
+ for _i310 in xrange(_size306):
+ _elem311 = iprot.readString();
+ self.part_vals.append(_elem311)
iprot.readListEnd()
else:
iprot.skip(ftype)
@@ -8442,10 +9272,10 @@
elif fid == 5:
if ftype == TType.LIST:
self.group_names = []
- (_etype283, _size280) = iprot.readListBegin()
- for _i284 in xrange(_size280):
- _elem285 = iprot.readString();
- self.group_names.append(_elem285)
+ (_etype315, _size312) = iprot.readListBegin()
+ for _i316 in xrange(_size312):
+ _elem317 = iprot.readString();
+ self.group_names.append(_elem317)
iprot.readListEnd()
else:
iprot.skip(ftype)
@@ -8470,8 +9300,8 @@
if self.part_vals is not None:
oprot.writeFieldBegin('part_vals', TType.LIST, 3)
oprot.writeListBegin(TType.STRING, len(self.part_vals))
- for iter286 in self.part_vals:
- oprot.writeString(iter286)
+ for iter318 in self.part_vals:
+ oprot.writeString(iter318)
oprot.writeListEnd()
oprot.writeFieldEnd()
if self.user_name is not None:
@@ -8481,8 +9311,8 @@
if self.group_names is not None:
oprot.writeFieldBegin('group_names', TType.LIST, 5)
oprot.writeListBegin(TType.STRING, len(self.group_names))
- for iter287 in self.group_names:
- oprot.writeString(iter287)
+ for iter319 in self.group_names:
+ oprot.writeString(iter319)
oprot.writeListEnd()
oprot.writeFieldEnd()
oprot.writeFieldStop()
@@ -8874,11 +9704,11 @@
if fid == 0:
if ftype == TType.LIST:
self.success = []
- (_etype291, _size288) = iprot.readListBegin()
- for _i292 in xrange(_size288):
- _elem293 = Partition()
- _elem293.read(iprot)
- self.success.append(_elem293)
+ (_etype323, _size320) = iprot.readListBegin()
+ for _i324 in xrange(_size320):
+ _elem325 = Partition()
+ _elem325.read(iprot)
+ self.success.append(_elem325)
iprot.readListEnd()
else:
iprot.skip(ftype)
@@ -8907,8 +9737,8 @@
if self.success is not None:
oprot.writeFieldBegin('success', TType.LIST, 0)
oprot.writeListBegin(TType.STRUCT, len(self.success))
- for iter294 in self.success:
- iter294.write(oprot)
+ for iter326 in self.success:
+ iter326.write(oprot)
oprot.writeListEnd()
oprot.writeFieldEnd()
if self.o1 is not None:
@@ -8995,10 +9825,10 @@
elif fid == 5:
if ftype == TType.LIST:
self.group_names = []
- (_etype298, _size295) = iprot.readListBegin()
- for _i299 in xrange(_size295):
- _elem300 = iprot.readString();
- self.group_names.append(_elem300)
+ (_etype330, _size327) = iprot.readListBegin()
+ for _i331 in xrange(_size327):
+ _elem332 = iprot.readString();
+ self.group_names.append(_elem332)
iprot.readListEnd()
else:
iprot.skip(ftype)
@@ -9031,8 +9861,8 @@
if self.group_names is not None:
oprot.writeFieldBegin('group_names', TType.LIST, 5)
oprot.writeListBegin(TType.STRING, len(self.group_names))
- for iter301 in self.group_names:
- oprot.writeString(iter301)
+ for iter333 in self.group_names:
+ oprot.writeString(iter333)
oprot.writeListEnd()
oprot.writeFieldEnd()
oprot.writeFieldStop()
@@ -9084,11 +9914,11 @@
if fid == 0:
if ftype == TType.LIST:
self.success = []
- (_etype305, _size302) = iprot.readListBegin()
- for _i306 in xrange(_size302):
- _elem307 = Partition()
- _elem307.read(iprot)
- self.success.append(_elem307)
+ (_etype337, _size334) = iprot.readListBegin()
+ for _i338 in xrange(_size334):
+ _elem339 = Partition()
+ _elem339.read(iprot)
+ self.success.append(_elem339)
iprot.readListEnd()
else:
iprot.skip(ftype)
@@ -9117,8 +9947,8 @@
if self.success is not None:
oprot.writeFieldBegin('success', TType.LIST, 0)
oprot.writeListBegin(TType.STRUCT, len(self.success))
- for iter308 in self.success:
- iter308.write(oprot)
+ for iter340 in self.success:
+ iter340.write(oprot)
oprot.writeListEnd()
oprot.writeFieldEnd()
if self.o1 is not None:
@@ -9259,10 +10089,10 @@
if fid == 0:
if ftype == TType.LIST:
self.success = []
- (_etype312, _size309) = iprot.readListBegin()
- for _i313 in xrange(_size309):
- _elem314 = iprot.readString();
- self.success.append(_elem314)
+ (_etype344, _size341) = iprot.readListBegin()
+ for _i345 in xrange(_size341):
+ _elem346 = iprot.readString();
+ self.success.append(_elem346)
iprot.readListEnd()
else:
iprot.skip(ftype)
@@ -9285,8 +10115,8 @@
if self.success is not None:
oprot.writeFieldBegin('success', TType.LIST, 0)
oprot.writeListBegin(TType.STRING, len(self.success))
- for iter315 in self.success:
- oprot.writeString(iter315)
+ for iter347 in self.success:
+ oprot.writeString(iter347)
oprot.writeListEnd()
oprot.writeFieldEnd()
if self.o2 is not None:
@@ -9356,10 +10186,10 @@
elif fid == 3:
if ftype == TType.LIST:
self.part_vals = []
- (_etype319, _size316) = iprot.readListBegin()
- for _i320 in xrange(_size316):
- _elem321 = iprot.readString();
- self.part_vals.append(_elem321)
+ (_etype351, _size348) = iprot.readListBegin()
+ for _i352 in xrange(_size348):
+ _elem353 = iprot.readString();
+ self.part_vals.append(_elem353)
iprot.readListEnd()
else:
iprot.skip(ftype)
@@ -9389,8 +10219,8 @@
if self.part_vals is not None:
oprot.writeFieldBegin('part_vals', TType.LIST, 3)
oprot.writeListBegin(TType.STRING, len(self.part_vals))
- for iter322 in self.part_vals:
- oprot.writeString(iter322)
+ for iter354 in self.part_vals:
+ oprot.writeString(iter354)
oprot.writeListEnd()
oprot.writeFieldEnd()
if self.max_parts is not None:
@@ -9446,11 +10276,11 @@
if fid == 0:
if ftype == TType.LIST:
self.success = []
- (_etype326, _size323) = iprot.readListBegin()
- for _i327 in xrange(_size323):
- _elem328 = Partition()
- _elem328.read(iprot)
- self.success.append(_elem328)
+ (_etype358, _size355) = iprot.readListBegin()
+ for _i359 in xrange(_size355):
+ _elem360 = Partition()
+ _elem360.read(iprot)
+ self.success.append(_elem360)
iprot.readListEnd()
else:
iprot.skip(ftype)
@@ -9479,8 +10309,8 @@
if self.success is not None:
oprot.writeFieldBegin('success', TType.LIST, 0)
oprot.writeListBegin(TType.STRUCT, len(self.success))
- for iter329 in self.success:
- iter329.write(oprot)
+ for iter361 in self.success:
+ iter361.write(oprot)
oprot.writeListEnd()
oprot.writeFieldEnd()
if self.o1 is not None:
@@ -9560,10 +10390,10 @@
elif fid == 3:
if ftype == TType.LIST:
self.part_vals = []
- (_etype333, _size330) = iprot.readListBegin()
- for _i334 in xrange(_size330):
- _elem335 = iprot.readString();
- self.part_vals.append(_elem335)
+ (_etype365, _size362) = iprot.readListBegin()
+ for _i366 in xrange(_size362):
+ _elem367 = iprot.readString();
+ self.part_vals.append(_elem367)
iprot.readListEnd()
else:
iprot.skip(ftype)
@@ -9580,10 +10410,10 @@
elif fid == 6:
if ftype == TType.LIST:
self.group_names = []
- (_etype339, _size336) = iprot.readListBegin()
- for _i340 in xrange(_size336):
- _elem341 = iprot.readString();
- self.group_names.append(_elem341)
+ (_etype371, _size368) = iprot.readListBegin()
+ for _i372 in xrange(_size368):
+ _elem373 = iprot.readString();
+ self.group_names.append(_elem373)
iprot.readListEnd()
else:
iprot.skip(ftype)
@@ -9608,8 +10438,8 @@
if self.part_vals is not None:
oprot.writeFieldBegin('part_vals', TType.LIST, 3)
oprot.writeListBegin(TType.STRING, len(self.part_vals))
- for iter342 in self.part_vals:
- oprot.writeString(iter342)
+ for iter374 in self.part_vals:
+ oprot.writeString(iter374)
oprot.writeListEnd()
oprot.writeFieldEnd()
if self.max_parts is not None:
@@ -9623,8 +10453,8 @@
if self.group_names is not None:
oprot.writeFieldBegin('group_names', TType.LIST, 6)
oprot.writeListBegin(TType.STRING, len(self.group_names))
- for iter343 in self.group_names:
- oprot.writeString(iter343)
+ for iter375 in self.group_names:
+ oprot.writeString(iter375)
oprot.writeListEnd()
oprot.writeFieldEnd()
oprot.writeFieldStop()
@@ -9676,11 +10506,11 @@
if fid == 0:
if ftype == TType.LIST:
self.success = []
- (_etype347, _size344) = iprot.readListBegin()
- for _i348 in xrange(_size344):
- _elem349 = Partition()
- _elem349.read(iprot)
- self.success.append(_elem349)
+ (_etype379, _size376) = iprot.readListBegin()
+ for _i380 in xrange(_size376):
+ _elem381 = Partition()
+ _elem381.read(iprot)
+ self.success.append(_elem381)
iprot.readListEnd()
else:
iprot.skip(ftype)
@@ -9709,8 +10539,8 @@
if self.success is not None:
oprot.writeFieldBegin('success', TType.LIST, 0)
oprot.writeListBegin(TType.STRUCT, len(self.success))
- for iter350 in self.success:
- iter350.write(oprot)
+ for iter382 in self.success:
+ iter382.write(oprot)
oprot.writeListEnd()
oprot.writeFieldEnd()
if self.o1 is not None:
@@ -9784,10 +10614,10 @@
elif fid == 3:
if ftype == TType.LIST:
self.part_vals = []
- (_etype354, _size351) = iprot.readListBegin()
- for _i355 in xrange(_size351):
- _elem356 = iprot.readString();
- self.part_vals.append(_elem356)
+ (_etype386, _size383) = iprot.readListBegin()
+ for _i387 in xrange(_size383):
+ _elem388 = iprot.readString();
+ self.part_vals.append(_elem388)
iprot.readListEnd()
else:
iprot.skip(ftype)
@@ -9817,8 +10647,8 @@
if self.part_vals is not None:
oprot.writeFieldBegin('part_vals', TType.LIST, 3)
oprot.writeListBegin(TType.STRING, len(self.part_vals))
- for iter357 in self.part_vals:
- oprot.writeString(iter357)
+ for iter389 in self.part_vals:
+ oprot.writeString(iter389)
oprot.writeListEnd()
oprot.writeFieldEnd()
if self.max_parts is not None:
@@ -9874,10 +10704,10 @@
if fid == 0:
if ftype == TType.LIST:
self.success = []
- (_etype361, _size358) = iprot.readListBegin()
- for _i362 in xrange(_size358):
- _elem363 = iprot.readString();
- self.success.append(_elem363)
+ (_etype393, _size390) = iprot.readListBegin()
+ for _i394 in xrange(_size390):
+ _elem395 = iprot.readString();
+ self.success.append(_elem395)
iprot.readListEnd()
else:
iprot.skip(ftype)
@@ -9906,8 +10736,8 @@
if self.success is not None:
oprot.writeFieldBegin('success', TType.LIST, 0)
oprot.writeListBegin(TType.STRING, len(self.success))
- for iter364 in self.success:
- oprot.writeString(iter364)
+ for iter396 in self.success:
+ oprot.writeString(iter396)
oprot.writeListEnd()
oprot.writeFieldEnd()
if self.o1 is not None:
@@ -10063,11 +10893,11 @@
if fid == 0:
if ftype == TType.LIST:
self.success = []
- (_etype368, _size365) = iprot.readListBegin()
- for _i369 in xrange(_size365):
- _elem370 = Partition()
- _elem370.read(iprot)
- self.success.append(_elem370)
+ (_etype400, _size397) = iprot.readListBegin()
+ for _i401 in xrange(_size397):
+ _elem402 = Partition()
+ _elem402.read(iprot)
+ self.success.append(_elem402)
iprot.readListEnd()
else:
iprot.skip(ftype)
@@ -10096,8 +10926,8 @@
if self.success is not None:
oprot.writeFieldBegin('success', TType.LIST, 0)
oprot.writeListBegin(TType.STRUCT, len(self.success))
- for iter371 in self.success:
- iter371.write(oprot)
+ for iter403 in self.success:
+ iter403.write(oprot)
oprot.writeListEnd()
oprot.writeFieldEnd()
if self.o1 is not None:
@@ -10168,10 +10998,10 @@
elif fid == 3:
if ftype == TType.LIST:
self.names = []
- (_etype375, _size372) = iprot.readListBegin()
- for _i376 in xrange(_size372):
- _elem377 = iprot.readString();
- self.names.append(_elem377)
+ (_etype407, _size404) = iprot.readListBegin()
+ for _i408 in xrange(_size404):
+ _elem409 = iprot.readString();
+ self.names.append(_elem409)
iprot.readListEnd()
else:
iprot.skip(ftype)
@@ -10196,8 +11026,8 @@
if self.names is not None:
oprot.writeFieldBegin('names', TType.LIST, 3)
oprot.writeListBegin(TType.STRING, len(self.names))
- for iter378 in self.names:
- oprot.writeString(iter378)
+ for iter410 in self.names:
+ oprot.writeString(iter410)
oprot.writeListEnd()
oprot.writeFieldEnd()
oprot.writeFieldStop()
@@ -10249,11 +11079,11 @@
if fid == 0:
if ftype == TType.LIST:
self.success = []
- (_etype382, _size379) = iprot.readListBegin()
- for _i383 in xrange(_size379):
- _elem384 = Partition()
- _elem384.read(iprot)
- self.success.append(_elem384)
+ (_etype414, _size411) = iprot.readListBegin()
+ for _i415 in xrange(_size411):
+ _elem416 = Partition()
+ _elem416.read(iprot)
+ self.success.append(_elem416)
iprot.readListEnd()
else:
iprot.skip(ftype)
@@ -10282,8 +11112,8 @@
if self.success is not None:
oprot.writeFieldBegin('success', TType.LIST, 0)
oprot.writeListBegin(TType.STRUCT, len(self.success))
- for iter385 in self.success:
- iter385.write(oprot)
+ for iter417 in self.success:
+ iter417.write(oprot)
oprot.writeListEnd()
oprot.writeFieldEnd()
if self.o1 is not None:
@@ -10516,10 +11346,10 @@
elif fid == 3:
if ftype == TType.LIST:
self.part_vals = []
- (_etype389, _size386) = iprot.readListBegin()
- for _i390 in xrange(_size386):
- _elem391 = iprot.readString();
- self.part_vals.append(_elem391)
+ (_etype421, _size418) = iprot.readListBegin()
+ for _i422 in xrange(_size418):
+ _elem423 = iprot.readString();
+ self.part_vals.append(_elem423)
iprot.readListEnd()
else:
iprot.skip(ftype)
@@ -10550,8 +11380,8 @@
if self.part_vals is not None:
oprot.writeFieldBegin('part_vals', TType.LIST, 3)
oprot.writeListBegin(TType.STRING, len(self.part_vals))
- for iter392 in self.part_vals:
- oprot.writeString(iter392)
+ for iter424 in self.part_vals:
+ oprot.writeString(iter424)
oprot.writeListEnd()
oprot.writeFieldEnd()
if self.new_part is not None:
@@ -10882,10 +11712,10 @@
if fid == 0:
if ftype == TType.LIST:
self.success = []
- (_etype396, _size393) = iprot.readListBegin()
- for _i397 in xrange(_size393):
- _elem398 = iprot.readString();
- self.success.append(_elem398)
+ (_etype428, _size425) = iprot.readListBegin()
+ for _i429 in xrange(_size425):
+ _elem430 = iprot.readString();
+ self.success.append(_elem430)
iprot.readListEnd()
else:
iprot.skip(ftype)
@@ -10908,8 +11738,8 @@
if self.success is not None:
oprot.writeFieldBegin('success', TType.LIST, 0)
oprot.writeListBegin(TType.STRING, len(self.success))
- for iter399 in self.success:
- oprot.writeString(iter399)
+ for iter431 in self.success:
+ oprot.writeString(iter431)
oprot.writeListEnd()
oprot.writeFieldEnd()
if self.o1 is not None:
@@ -11022,11 +11852,11 @@
if fid == 0:
if ftype == TType.MAP:
self.success = {}
- (_ktype401, _vtype402, _size400 ) = iprot.readMapBegin()
- for _i404 in xrange(_size400):
- _key405 = iprot.readString();
- _val406 = iprot.readString();
- self.success[_key405] = _val406
+ (_ktype433, _vtype434, _size432 ) = iprot.readMapBegin()
+ for _i436 in xrange(_size432):
+ _key437 = iprot.readString();
+ _val438 = iprot.readString();
+ self.success[_key437] = _val438
iprot.readMapEnd()
else:
iprot.skip(ftype)
@@ -11049,9 +11879,9 @@
if self.success is not None:
oprot.writeFieldBegin('success', TType.MAP, 0)
oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
- for kiter407,viter408 in self.success.items():
- oprot.writeString(kiter407)
- oprot.writeString(viter408)
+ for kiter439,viter440 in self.success.items():
+ oprot.writeString(kiter439)
+ oprot.writeString(viter440)
oprot.writeMapEnd()
oprot.writeFieldEnd()
if self.o1 is not None:
@@ -11121,11 +11951,11 @@
elif fid == 3:
if ftype == TType.MAP:
self.part_vals = {}
- (_ktype410, _vtype411, _size409 ) = iprot.readMapBegin()
- for _i413 in xrange(_size409):
- _key414 = iprot.readString();
- _val415 = iprot.readString();
- self.part_vals[_key414] = _val415
+ (_ktype442, _vtype443, _size441 ) = iprot.readMapBegin()
+ for _i445 in xrange(_size441):
+ _key446 = iprot.readString();
+ _val447 = iprot.readString();
+ self.part_vals[_key446] = _val447
iprot.readMapEnd()
else:
iprot.skip(ftype)
@@ -11155,9 +11985,9 @@
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 kiter416,viter417 in self.part_vals.items():
- oprot.writeString(kiter416)
- oprot.writeString(viter417)
+ for kiter448,viter449 in self.part_vals.items():
+ oprot.writeString(kiter448)
+ oprot.writeString(viter449)
oprot.writeMapEnd()
oprot.writeFieldEnd()
if self.eventType is not None:
@@ -11353,11 +12183,11 @@
elif fid == 3:
if ftype == TType.MAP:
self.part_vals = {}
- (_ktype419, _vtype420, _size418 ) = iprot.readMapBegin()
- for _i422 in xrange(_size418):
- _key423 = iprot.readString();
- _val424 = iprot.readString();
- self.part_vals[_key423] = _val424
+ (_ktype451, _vtype452, _size450 ) = iprot.readMapBegin()
+ for _i454 in xrange(_size450):
+ _key455 = iprot.readString();
+ _val456 = iprot.readString();
+ self.part_vals[_key455] = _val456
iprot.readMapEnd()
else:
iprot.skip(ftype)
@@ -11387,9 +12217,9 @@
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 kiter425,viter426 in self.part_vals.items():
- oprot.writeString(kiter425)
- oprot.writeString(viter426)
+ for kiter457,viter458 in self.part_vals.items():
+ oprot.writeString(kiter457)
+ oprot.writeString(viter458)
oprot.writeMapEnd()
oprot.writeFieldEnd()
if self.eventType is not None:
@@ -12361,11 +13191,11 @@
if fid == 0:
if ftype == TType.LIST:
self.success = []
- (_etype430, _size427) = iprot.readListBegin()
- for _i431 in xrange(_size427):
- _elem432 = Index()
- _elem432.read(iprot)
- self.success.append(_elem432)
+ (_etype462, _size459) = iprot.readListBegin()
+ for _i463 in xrange(_size459):
+ _elem464 = Index()
+ _elem464.read(iprot)
+ self.success.append(_elem464)
iprot.readListEnd()
else:
iprot.skip(ftype)
@@ -12394,8 +13224,8 @@
if self.success is not None:
oprot.writeFieldBegin('success', TType.LIST, 0)
oprot.writeListBegin(TType.STRUCT, len(self.success))
- for iter433 in self.success:
- iter433.write(oprot)
+ for iter465 in self.success:
+ iter465.write(oprot)
oprot.writeListEnd()
oprot.writeFieldEnd()
if self.o1 is not None:
@@ -12536,10 +13366,10 @@
if fid == 0:
if ftype == TType.LIST:
self.success = []
- (_etype437, _size434) = iprot.readListBegin()
- for _i438 in xrange(_size434):
- _elem439 = iprot.readString();
- self.success.append(_elem439)
+ (_etype469, _size466) = iprot.readListBegin()
+ for _i470 in xrange(_size466):
+ _elem471 = iprot.readString();
+ self.success.append(_elem471)
iprot.readListEnd()
else:
iprot.skip(ftype)
@@ -12562,8 +13392,8 @@
if self.success is not None:
oprot.writeFieldBegin('success', TType.LIST, 0)
oprot.writeListBegin(TType.STRING, len(self.success))
- for iter440 in self.success:
- oprot.writeString(iter440)
+ for iter472 in self.success:
+ oprot.writeString(iter472)
oprot.writeListEnd()
oprot.writeFieldEnd()
if self.o2 is not None:
@@ -12588,6 +13418,743 @@
def __ne__(self, other):
return not (self == other)
+class create_cluster_args:
+ """
+ Attributes:
+ - cluster
+ """
+
+ thrift_spec = (
+ None, # 0
+ (1, TType.STRUCT, 'cluster', (Cluster, Cluster.thrift_spec), None, ), # 1
+ )
+
+ def __init__(self, cluster=None,):
+ self.cluster = cluster
+
+ def read(self, iprot):
+ if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+ fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+ return
+ iprot.readStructBegin()
+ while True:
+ (fname, ftype, fid) = iprot.readFieldBegin()
+ if ftype == TType.STOP:
+ break
+ if fid == 1:
+ if ftype == TType.STRUCT:
+ self.cluster = Cluster()
+ self.cluster.read(iprot)
+ else:
+ iprot.skip(ftype)
+ else:
+ iprot.skip(ftype)
+ iprot.readFieldEnd()
+ iprot.readStructEnd()
+
+ def write(self, oprot):
+ if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+ oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+ return
+ oprot.writeStructBegin('create_cluster_args')
+ if self.cluster is not None:
+ oprot.writeFieldBegin('cluster', TType.STRUCT, 1)
+ self.cluster.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__.iteritems()]
+ return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+ def __eq__(self, other):
+ return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+ def __ne__(self, other):
+ return not (self == other)
+
+class create_cluster_result:
+ """
+ Attributes:
+ - o1
+ - o2
+ - o3
+ """
+
+ thrift_spec = (
+ None, # 0
+ (1, TType.STRUCT, 'o1', (AlreadyExistsException, AlreadyExistsException.thrift_spec), None, ), # 1
+ (2, TType.STRUCT, 'o2', (InvalidObjectException, InvalidObjectException.thrift_spec), None, ), # 2
+ (3, TType.STRUCT, 'o3', (MetaException, MetaException.thrift_spec), None, ), # 3
+ )
+
+ def __init__(self, o1=None, o2=None, o3=None,):
+ self.o1 = o1
+ self.o2 = o2
+ self.o3 = o3
+
+ def read(self, iprot):
+ if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+ fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+ return
+ iprot.readStructBegin()
+ while True:
+ (fname, ftype, fid) = iprot.readFieldBegin()
+ if ftype == TType.STOP:
+ break
+ if fid == 1:
+ if ftype == TType.STRUCT:
+ self.o1 = AlreadyExistsException()
+ self.o1.read(iprot)
+ else:
+ iprot.skip(ftype)
+ elif fid == 2:
+ if ftype == TType.STRUCT:
+ self.o2 = InvalidObjectException()
+ self.o2.read(iprot)
+ else:
+ iprot.skip(ftype)
+ elif fid == 3:
+ if ftype == TType.STRUCT:
+ self.o3 = MetaException()
+ self.o3.read(iprot)
+ else:
+ iprot.skip(ftype)
+ else:
+ iprot.skip(ftype)
+ iprot.readFieldEnd()
+ iprot.readStructEnd()
+
+ def write(self, oprot):
+ if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+ oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+ return
+ oprot.writeStructBegin('create_cluster_result')
+ if self.o1 is not None:
+ oprot.writeFieldBegin('o1', TType.STRUCT, 1)
+ self.o1.write(oprot)
+ oprot.writeFieldEnd()
+ if self.o2 is not None:
+ oprot.writeFieldBegin('o2', TType.STRUCT, 2)
+ self.o2.write(oprot)
+ oprot.writeFieldEnd()
+ if self.o3 is not None:
+ oprot.writeFieldBegin('o3', TType.STRUCT, 3)
+ self.o3.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__.iteritems()]
+ return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+ def __eq__(self, other):
+ return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+ def __ne__(self, other):
+ return not (self == other)
+
+class drop_cluster_args:
+ """
+ Attributes:
+ - cluster_name
+ """
+
+ thrift_spec = (
+ None, # 0
+ (1, TType.STRING, 'cluster_name', None, None, ), # 1
+ )
+
+ def __init__(self, cluster_name=None,):
+ self.cluster_name = cluster_name
+
+ def read(self, iprot):
+ if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+ fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+ return
+ iprot.readStructBegin()
+ while True:
+ (fname, ftype, fid) = iprot.readFieldBegin()
+ if ftype == TType.STOP:
+ break
+ if fid == 1:
+ if ftype == TType.STRING:
+ self.cluster_name = iprot.readString();
+ else:
+ iprot.skip(ftype)
+ else:
+ iprot.skip(ftype)
+ iprot.readFieldEnd()
+ iprot.readStructEnd()
+
+ def write(self, oprot):
+ if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+ oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+ return
+ oprot.writeStructBegin('drop_cluster_args')
+ if self.cluster_name is not None:
+ oprot.writeFieldBegin('cluster_name', TType.STRING, 1)
+ oprot.writeString(self.cluster_name)
+ oprot.writeFieldEnd()
+ oprot.writeFieldStop()
+ oprot.writeStructEnd()
+
+ def validate(self):
+ return
+
+
+ def __repr__(self):
+ L = ['%s=%r' % (key, value)
+ for key, value in self.__dict__.iteritems()]
+ return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+ def __eq__(self, other):
+ return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+ def __ne__(self, other):
+ return not (self == other)
+
+class drop_cluster_result:
+ """
+ Attributes:
+ - o1
+ - o2
+ - o3
+ """
+
+ thrift_spec = (
+ None, # 0
+ (1, TType.STRUCT, 'o1', (NoSuchObjectException, NoSuchObjectException.thrift_spec), None, ), # 1
+ (2, TType.STRUCT, 'o2', (InvalidOperationException, InvalidOperationException.thrift_spec), None, ), # 2
+ (3, TType.STRUCT, 'o3', (MetaException, MetaException.thrift_spec), None, ), # 3
+ )
+
+ def __init__(self, o1=None, o2=None, o3=None,):
+ self.o1 = o1
+ self.o2 = o2
+ self.o3 = o3
+
+ def read(self, iprot):
+ if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+ fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+ return
+ iprot.readStructBegin()
+ while True:
+ (fname, ftype, fid) = iprot.readFieldBegin()
+ if ftype == TType.STOP:
+ break
+ if fid == 1:
+ if ftype == TType.STRUCT:
+ self.o1 = NoSuchObjectException()
+ self.o1.read(iprot)
+ else:
+ iprot.skip(ftype)
+ elif fid == 2:
+ if ftype == TType.STRUCT:
+ self.o2 = InvalidOperationException()
+ self.o2.read(iprot)
+ else:
+ iprot.skip(ftype)
+ elif fid == 3:
+ if ftype == TType.STRUCT:
+ self.o3 = MetaException()
+ self.o3.read(iprot)
+ else:
+ iprot.skip(ftype)
+ else:
+ iprot.skip(ftype)
+ iprot.readFieldEnd()
+ iprot.readStructEnd()
+
+ def write(self, oprot):
+ if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+ oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+ return
+ oprot.writeStructBegin('drop_cluster_result')
+ if self.o1 is not None:
+ oprot.writeFieldBegin('o1', TType.STRUCT, 1)
+ self.o1.write(oprot)
+ oprot.writeFieldEnd()
+ if self.o2 is not None:
+ oprot.writeFieldBegin('o2', TType.STRUCT, 2)
+ self.o2.write(oprot)
+ oprot.writeFieldEnd()
+ if self.o3 is not None:
+ oprot.writeFieldBegin('o3', TType.STRUCT, 3)
+ self.o3.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__.iteritems()]
+ return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+ def __eq__(self, other):
+ return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+ def __ne__(self, other):
+ return not (self == other)
+
+class get_cluster_args:
+ """
+ Attributes:
+ - cluster_name
+ """
+
+ thrift_spec = (
+ None, # 0
+ (1, TType.STRING, 'cluster_name', None, None, ), # 1
+ )
+
+ def __init__(self, cluster_name=None,):
+ self.cluster_name = cluster_name
+
+ def read(self, iprot):
+ if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+ fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+ return
+ iprot.readStructBegin()
+ while True:
+ (fname, ftype, fid) = iprot.readFieldBegin()
+ if ftype == TType.STOP:
+ break
+ if fid == 1:
+ if ftype == TType.STRING:
+ self.cluster_name = iprot.readString();
+ else:
+ iprot.skip(ftype)
+ else:
+ iprot.skip(ftype)
+ iprot.readFieldEnd()
+ iprot.readStructEnd()
+
+ def write(self, oprot):
+ if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+ oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+ return
+ oprot.writeStructBegin('get_cluster_args')
+ if self.cluster_name is not None:
+ oprot.writeFieldBegin('cluster_name', TType.STRING, 1)
+ oprot.writeString(self.cluster_name)
+ oprot.writeFieldEnd()
+ oprot.writeFieldStop()
+ oprot.writeStructEnd()
+
+ def validate(self):
+ return
+
+
+ def __repr__(self):
+ L = ['%s=%r' % (key, value)
+ for key, value in self.__dict__.iteritems()]
+ return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+ def __eq__(self, other):
+ return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+ def __ne__(self, other):
+ return not (self == other)
+
+class get_cluster_result:
+ """
+ Attributes:
+ - success
+ - o1
+ - o2
+ """
+
+ thrift_spec = (
+ (0, TType.STRUCT, 'success', (Cluster, Cluster.thrift_spec), None, ), # 0
+ (1, TType.STRUCT, 'o1', (MetaException, MetaException.thrift_spec), None, ), # 1
+ (2, TType.STRUCT, 'o2', (NoSuchObjectException, NoSuchObjectException.thrift_spec), None, ), # 2
+ )
+
+ def __init__(self, success=None, o1=None, o2=None,):
+ self.success = success
+ self.o1 = o1
+ self.o2 = o2
+
+ def read(self, iprot):
+ if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+ fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+ return
+ iprot.readStructBegin()
+ while True:
+ (fname, ftype, fid) = iprot.readFieldBegin()
+ if ftype == TType.STOP:
+ break
+ if fid == 0:
+ if ftype == TType.STRUCT:
+ self.success = Cluster()
+ self.success.read(iprot)
+ else:
+ iprot.skip(ftype)
+ elif fid == 1:
+ if ftype == TType.STRUCT:
+ self.o1 = MetaException()
+ self.o1.read(iprot)
+ else:
+ iprot.skip(ftype)
+ elif fid == 2:
+ if ftype == TType.STRUCT:
+ self.o2 = NoSuchObjectException()
+ self.o2.read(iprot)
+ else:
+ iprot.skip(ftype)
+ else:
+ iprot.skip(ftype)
+ iprot.readFieldEnd()
+ iprot.readStructEnd()
+
+ def write(self, oprot):
+ if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+ oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+ return
+ oprot.writeStructBegin('get_cluster_result')
+ if self.success is not None:
+ oprot.writeFieldBegin('success', TType.STRUCT, 0)
+ self.success.write(oprot)
+ oprot.writeFieldEnd()
+ if self.o1 is not None:
+ oprot.writeFieldBegin('o1', TType.STRUCT, 1)
+ self.o1.write(oprot)
+ oprot.writeFieldEnd()
+ if self.o2 is not None:
+ oprot.writeFieldBegin('o2', TType.STRUCT, 2)
+ self.o2.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__.iteritems()]
+ return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+ def __eq__(self, other):
+ return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+ def __ne__(self, other):
+ return not (self == other)
+
+class list_clusters_args:
+
+ thrift_spec = (
+ )
+
+ def read(self, iprot):
+ if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+ fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+ return
+ iprot.readStructBegin()
+ while True:
+ (fname, ftype, fid) = iprot.readFieldBegin()
+ if ftype == TType.STOP:
+ break
+ else:
+ iprot.skip(ftype)
+ iprot.readFieldEnd()
+ iprot.readStructEnd()
+
+ def write(self, oprot):
+ if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+ oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+ return
+ oprot.writeStructBegin('list_clusters_args')
+ oprot.writeFieldStop()
+ oprot.writeStructEnd()
+
+ def validate(self):
+ return
+
+
+ def __repr__(self):
+ L = ['%s=%r' % (key, value)
+ for key, value in self.__dict__.iteritems()]
+ return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+ def __eq__(self, other):
+ return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+ def __ne__(self, other):
+ return not (self == other)
+
+class list_clusters_result:
+ """
+ Attributes:
+ - success
+ - o1
+ """
+
+ thrift_spec = (
+ (0, TType.LIST, 'success', (TType.STRUCT,(Cluster, Cluster.thrift_spec)), None, ), # 0
+ (1, TType.STRUCT, 'o1', (MetaException, MetaException.thrift_spec), None, ), # 1
+ )
+
+ def __init__(self, success=None, o1=None,):
+ self.success = success
+ self.o1 = o1
+
+ def read(self, iprot):
+ if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+ fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+ return
+ iprot.readStructBegin()
+ while True:
+ (fname, ftype, fid) = iprot.readFieldBegin()
+ if ftype == TType.STOP:
+ break
+ if fid == 0:
+ if ftype == TType.LIST:
+ self.success = []
+ (_etype476, _size473) = iprot.readListBegin()
+ for _i477 in xrange(_size473):
+ _elem478 = Cluster()
+ _elem478.read(iprot)
+ self.success.append(_elem478)
+ iprot.readListEnd()
+ else:
+ iprot.skip(ftype)
+ elif fid == 1:
+ if ftype == TType.STRUCT:
+ self.o1 = MetaException()
+ self.o1.read(iprot)
+ else:
+ iprot.skip(ftype)
+ else:
+ iprot.skip(ftype)
+ iprot.readFieldEnd()
+ iprot.readStructEnd()
+
+ def write(self, oprot):
+ if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+ oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+ return
+ oprot.writeStructBegin('list_clusters_result')
+ if self.success is not None:
+ oprot.writeFieldBegin('success', TType.LIST, 0)
+ oprot.writeListBegin(TType.STRUCT, len(self.success))
+ for iter479 in self.success:
+ iter479.write(oprot)
+ oprot.writeListEnd()
+ oprot.writeFieldEnd()
+ 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__.iteritems()]
+ return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+ def __eq__(self, other):
+ return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+ def __ne__(self, other):
+ return not (self == other)
+
+class alter_cluster_args:
+ """
+ Attributes:
+ - cluster_name
+ - cluster
+ """
+
+ thrift_spec = (
+ None, # 0
+ (1, TType.STRING, 'cluster_name', None, None, ), # 1
+ (2, TType.STRUCT, 'cluster', (Cluster, Cluster.thrift_spec), None, ), # 2
+ )
+
+ def __init__(self, cluster_name=None, cluster=None,):
+ self.cluster_name = cluster_name
+ self.cluster = cluster
+
+ def read(self, iprot):
+ if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+ fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+ return
+ iprot.readStructBegin()
+ while True:
+ (fname, ftype, fid) = iprot.readFieldBegin()
+ if ftype == TType.STOP:
+ break
+ if fid == 1:
+ if ftype == TType.STRING:
+ self.cluster_name = iprot.readString();
+ else:
+ iprot.skip(ftype)
+ elif fid == 2:
+ if ftype == TType.STRUCT:
+ self.cluster = Cluster()
+ self.cluster.read(iprot)
+ else:
+ iprot.skip(ftype)
+ else:
+ iprot.skip(ftype)
+ iprot.readFieldEnd()
+ iprot.readStructEnd()
+
+ def write(self, oprot):
+ if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+ oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+ return
+ oprot.writeStructBegin('alter_cluster_args')
+ if self.cluster_name is not None:
+ oprot.writeFieldBegin('cluster_name', TType.STRING, 1)
+ oprot.writeString(self.cluster_name)
+ oprot.writeFieldEnd()
+ if self.cluster is not None:
+ oprot.writeFieldBegin('cluster', TType.STRUCT, 2)
+ self.cluster.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__.iteritems()]
+ return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+ def __eq__(self, other):
+ return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+ def __ne__(self, other):
+ return not (self == other)
+
+class alter_cluster_result:
+ """
+ Attributes:
+ - o1
+ - o2
+ - o3
+ - o4
+ """
+
+ thrift_spec = (
+ None, # 0
+ (1, TType.STRUCT, 'o1', (MetaException, MetaException.thrift_spec), None, ), # 1
+ (2, TType.STRUCT, 'o2', (InvalidObjectException, InvalidObjectException.thrift_spec), None, ), # 2
+ (3, TType.STRUCT, 'o3', (NoSuchObjectException, NoSuchObjectException.thrift_spec), None, ), # 3
+ (4, TType.STRUCT, 'o4', (AlreadyExistsException, AlreadyExistsException.thrift_spec), None, ), # 4
+ )
+
+ def __init__(self, o1=None, o2=None, o3=None, o4=None,):
+ self.o1 = o1
+ self.o2 = o2
+ self.o3 = o3
+ self.o4 = o4
+
+ def read(self, iprot):
+ if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+ fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+ return
+ iprot.readStructBegin()
+ while True:
+ (fname, ftype, fid) = iprot.readFieldBegin()
+ if ftype == TType.STOP:
+ break
+ if fid == 1:
+ if ftype == TType.STRUCT:
+ self.o1 = MetaException()
+ self.o1.read(iprot)
+ else:
+ iprot.skip(ftype)
+ elif fid == 2:
+ if ftype == TType.STRUCT:
+ self.o2 = InvalidObjectException()
+ self.o2.read(iprot)
+ else:
+ iprot.skip(ftype)
+ elif fid == 3:
+ if ftype == TType.STRUCT:
+ self.o3 = NoSuchObjectException()
+ self.o3.read(iprot)
+ else:
+ iprot.skip(ftype)
+ elif fid == 4:
+ if ftype == TType.STRUCT:
+ self.o4 = AlreadyExistsException()
+ self.o4.read(iprot)
+ else:
+ iprot.skip(ftype)
+ else:
+ iprot.skip(ftype)
+ iprot.readFieldEnd()
+ iprot.readStructEnd()
+
+ def write(self, oprot):
+ if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+ oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+ return
+ oprot.writeStructBegin('alter_cluster_result')
+ if self.o1 is not None:
+ oprot.writeFieldBegin('o1', TType.STRUCT, 1)
+ self.o1.write(oprot)
+ oprot.writeFieldEnd()
+ if self.o2 is not None:
+ oprot.writeFieldBegin('o2', TType.STRUCT, 2)
+ self.o2.write(oprot)
+ oprot.writeFieldEnd()
+ if self.o3 is not None:
+ oprot.writeFieldBegin('o3', TType.STRUCT, 3)
+ self.o3.write(oprot)
+ oprot.writeFieldEnd()
+ if self.o4 is not None:
+ oprot.writeFieldBegin('o4', TType.STRUCT, 4)
+ self.o4.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__.iteritems()]
+ return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+ def __eq__(self, other):
+ return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+ def __ne__(self, other):
+ return not (self == other)
+
class create_role_args:
"""
Attributes:
@@ -12923,10 +14490,10 @@
if fid == 0:
if ftype == TType.LIST:
self.success = []
- (_etype444, _size441) = iprot.readListBegin()
- for _i445 in xrange(_size441):
- _elem446 = iprot.readString();
- self.success.append(_elem446)
+ (_etype483, _size480) = iprot.readListBegin()
+ for _i484 in xrange(_size480):
+ _elem485 = iprot.readString();
+ self.success.append(_elem485)
iprot.readListEnd()
else:
iprot.skip(ftype)
@@ -12949,8 +14516,8 @@
if self.success is not None:
oprot.writeFieldBegin('success', TType.LIST, 0)
oprot.writeListBegin(TType.STRING, len(self.success))
- for iter447 in self.success:
- oprot.writeString(iter447)
+ for iter486 in self.success:
+ oprot.writeString(iter486)
oprot.writeListEnd()
oprot.writeFieldEnd()
if self.o1 is not None:
@@ -13423,11 +14990,11 @@
if fid == 0:
if ftype == TType.LIST:
self.success = []
- (_etype451, _size448) = iprot.readListBegin()
- for _i452 in xrange(_size448):
- _elem453 = Role()
- _elem453.read(iprot)
- self.success.append(_elem453)
+ (_etype490, _size487) = iprot.readListBegin()
+ for _i491 in xrange(_size487):
+ _elem492 = Role()
+ _elem492.read(iprot)
+ self.success.append(_elem492)
iprot.readListEnd()
else:
iprot.skip(ftype)
@@ -13450,8 +15017,8 @@
if self.success is not None:
oprot.writeFieldBegin('success', TType.LIST, 0)
oprot.writeListBegin(TType.STRUCT, len(self.success))
- for iter454 in self.success:
- iter454.write(oprot)
+ for iter493 in self.success:
+ iter493.write(oprot)
oprot.writeListEnd()
oprot.writeFieldEnd()
if self.o1 is not None:
@@ -13519,10 +15086,10 @@
elif fid == 3:
if ftype == TType.LIST:
self.group_names = []
- (_etype458, _size455) = iprot.readListBegin()
- for _i459 in xrange(_size455):
- _elem460 = iprot.readString();
- self.group_names.append(_elem460)
+ (_etype497, _size494) = iprot.readListBegin()
+ for _i498 in xrange(_size494):
+ _elem499 = iprot.readString();
+ self.group_names.append(_elem499)
iprot.readListEnd()
else:
iprot.skip(ftype)
@@ -13547,8 +15114,8 @@
if self.group_names is not None:
oprot.writeFieldBegin('group_names', TType.LIST, 3)
oprot.writeListBegin(TType.STRING, len(self.group_names))
- for iter461 in self.group_names:
- oprot.writeString(iter461)
+ for iter500 in self.group_names:
+ oprot.writeString(iter500)
oprot.writeListEnd()
oprot.writeFieldEnd()
oprot.writeFieldStop()
@@ -13755,11 +15322,11 @@
if fid == 0:
if ftype == TType.LIST:
self.success = []
- (_etype465, _size462) = iprot.readListBegin()
- for _i466 in xrange(_size462):
- _elem467 = HiveObjectPrivilege()
- _elem467.read(iprot)
- self.success.append(_elem467)
+ (_etype504, _size501) = iprot.readListBegin()
+ for _i505 in xrange(_size501):
+ _elem506 = HiveObjectPrivilege()
+ _elem506.read(iprot)
+ self.success.append(_elem506)
iprot.readListEnd()
else:
iprot.skip(ftype)
@@ -13782,8 +15349,8 @@
if self.success is not None:
oprot.writeFieldBegin('success', TType.LIST, 0)
oprot.writeListBegin(TType.STRUCT, len(self.success))
- for iter468 in self.success:
- iter468.write(oprot)
+ for iter507 in self.success:
+ iter507.write(oprot)
oprot.writeListEnd()
oprot.writeFieldEnd()
if self.o1 is not None:
@@ -14108,10 +15675,10 @@
elif fid == 2:
if ftype == TType.LIST:
self.group_names = []
- (_etype472, _size469) = iprot.readListBegin()
- for _i473 in xrange(_size469):
- _elem474 = iprot.readString();
- self.group_names.append(_elem474)
+ (_etype511, _size508) = iprot.readListBegin()
+ for _i512 in xrange(_size508):
+ _elem513 = iprot.readString();
+ self.group_names.append(_elem513)
iprot.readListEnd()
else:
iprot.skip(ftype)
@@ -14132,8 +15699,8 @@
if self.group_names is not None:
oprot.writeFieldBegin('group_names', TType.LIST, 2)
oprot.writeListBegin(TType.STRING, len(self.group_names))
- for iter475 in self.group_names:
- oprot.writeString(iter475)
+ for iter514 in self.group_names:
+ oprot.writeString(iter514)
oprot.writeListEnd()
oprot.writeFieldEnd()
oprot.writeFieldStop()
@@ -14182,10 +15749,10 @@
if fid == 0:
if ftype == TType.LIST:
self.success = []
- (_etype479, _size476) = iprot.readListBegin()
- for _i480 in xrange(_size476):
- _elem481 = iprot.readString();
- self.success.append(_elem481)
+ (_etype518, _size515) = iprot.readListBegin()
+ for _i519 in xrange(_size515):
+ _elem520 = iprot.readString();
+ self.success.append(_elem520)
iprot.readListEnd()
else:
iprot.skip(ftype)
@@ -14208,8 +15775,8 @@
if self.success is not None:
oprot.writeFieldBegin('success', TType.LIST, 0)
oprot.writeListBegin(TType.STRING, len(self.success))
- for iter482 in self.success:
- oprot.writeString(iter482)
+ for iter521 in self.success:
+ oprot.writeString(iter521)
oprot.writeListEnd()
oprot.writeFieldEnd()
if self.o1 is not None:
Index: metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote
===================================================================
--- metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote (revision 1235046)
+++ metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote (working copy)
@@ -35,6 +35,7 @@
print ' get_schema(string db_name, string table_name)'
print ' void create_table(Table tbl)'
print ' void drop_table(string dbname, string name, bool deleteData)'
+ print ' void drop_table_on_cluster(string cluster_name, string dbname, string name, bool deleteData)'
print ' get_tables(string db_name, string pattern)'
print ' get_all_tables(string db_name)'
print ' Table get_table(string dbname, string tbl_name)'
@@ -46,6 +47,7 @@
print ' Partition append_partition(string db_name, string tbl_name, part_vals)'
print ' Partition append_partition_by_name(string db_name, string tbl_name, string part_name)'
print ' bool drop_partition(string db_name, string tbl_name, part_vals, bool deleteData)'
+ print ' bool drop_partition_on_cluster(string cluster_name, string db_name, string tbl_name, part_vals, bool deleteData)'
print ' bool drop_partition_by_name(string db_name, string tbl_name, string part_name, bool deleteData)'
print ' Partition get_partition(string db_name, string tbl_name, part_vals)'
print ' Partition get_partition_with_auth(string db_name, string tbl_name, part_vals, string user_name, group_names)'
@@ -71,6 +73,11 @@
print ' Index get_index_by_name(string db_name, string tbl_name, string index_name)'
print ' get_indexes(string db_name, string tbl_name, i16 max_indexes)'
print ' get_index_names(string db_name, string tbl_name, i16 max_indexes)'
+ print ' void create_cluster(Cluster cluster)'
+ print ' void drop_cluster(string cluster_name)'
+ print ' Cluster get_cluster(string cluster_name)'
+ print ' list_clusters()'
+ print ' void alter_cluster(string cluster_name, Cluster cluster)'
print ' bool create_role(Role role)'
print ' bool drop_role(string role_name)'
print ' get_role_names()'
@@ -219,6 +226,12 @@
sys.exit(1)
pp.pprint(client.drop_table(args[0],args[1],eval(args[2]),))
+elif cmd == 'drop_table_on_cluster':
+ if len(args) != 4:
+ print 'drop_table_on_cluster requires 4 args'
+ sys.exit(1)
+ pp.pprint(client.drop_table_on_cluster(args[0],args[1],args[2],eval(args[3]),))
+
elif cmd == 'get_tables':
if len(args) != 2:
print 'get_tables requires 2 args'
@@ -285,6 +298,12 @@
sys.exit(1)
pp.pprint(client.drop_partition(args[0],args[1],eval(args[2]),eval(args[3]),))
+elif cmd == 'drop_partition_on_cluster':
+ if len(args) != 5:
+ print 'drop_partition_on_cluster requires 5 args'
+ sys.exit(1)
+ pp.pprint(client.drop_partition_on_cluster(args[0],args[1],args[2],eval(args[3]),eval(args[4]),))
+
elif cmd == 'drop_partition_by_name':
if len(args) != 4:
print 'drop_partition_by_name requires 4 args'
@@ -435,6 +454,36 @@
sys.exit(1)
pp.pprint(client.get_index_names(args[0],args[1],eval(args[2]),))
+elif cmd == 'create_cluster':
+ if len(args) != 1:
+ print 'create_cluster requires 1 args'
+ sys.exit(1)
+ pp.pprint(client.create_cluster(eval(args[0]),))
+
+elif cmd == 'drop_cluster':
+ if len(args) != 1:
+ print 'drop_cluster requires 1 args'
+ sys.exit(1)
+ pp.pprint(client.drop_cluster(args[0],))
+
+elif cmd == 'get_cluster':
+ if len(args) != 1:
+ print 'get_cluster requires 1 args'
+ sys.exit(1)
+ pp.pprint(client.get_cluster(args[0],))
+
+elif cmd == 'list_clusters':
+ if len(args) != 0:
+ print 'list_clusters requires 0 args'
+ sys.exit(1)
+ pp.pprint(client.list_clusters())
+
+elif cmd == 'alter_cluster':
+ if len(args) != 2:
+ print 'alter_cluster requires 2 args'
+ sys.exit(1)
+ pp.pprint(client.alter_cluster(args[0],eval(args[1]),))
+
elif cmd == 'create_role':
if len(args) != 1:
print 'create_role requires 1 args'
Index: metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp
===================================================================
--- metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp (revision 1235046)
+++ metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp (working copy)
@@ -715,14 +715,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size155;
- ::apache::thrift::protocol::TType _etype158;
- iprot->readListBegin(_etype158, _size155);
- this->success.resize(_size155);
- uint32_t _i159;
- for (_i159 = 0; _i159 < _size155; ++_i159)
+ uint32_t _size177;
+ ::apache::thrift::protocol::TType _etype180;
+ iprot->readListBegin(_etype180, _size177);
+ this->success.resize(_size177);
+ uint32_t _i181;
+ for (_i181 = 0; _i181 < _size177; ++_i181)
{
- xfer += iprot->readString(this->success[_i159]);
+ xfer += iprot->readString(this->success[_i181]);
}
iprot->readListEnd();
}
@@ -761,10 +761,10 @@
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 _iter160;
- for (_iter160 = this->success.begin(); _iter160 != this->success.end(); ++_iter160)
+ std::vector ::const_iterator _iter182;
+ for (_iter182 = this->success.begin(); _iter182 != this->success.end(); ++_iter182)
{
- xfer += oprot->writeString((*_iter160));
+ xfer += oprot->writeString((*_iter182));
}
xfer += oprot->writeListEnd();
}
@@ -803,14 +803,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size161;
- ::apache::thrift::protocol::TType _etype164;
- iprot->readListBegin(_etype164, _size161);
- (*(this->success)).resize(_size161);
- uint32_t _i165;
- for (_i165 = 0; _i165 < _size161; ++_i165)
+ uint32_t _size183;
+ ::apache::thrift::protocol::TType _etype186;
+ iprot->readListBegin(_etype186, _size183);
+ (*(this->success)).resize(_size183);
+ uint32_t _i187;
+ for (_i187 = 0; _i187 < _size183; ++_i187)
{
- xfer += iprot->readString((*(this->success))[_i165]);
+ xfer += iprot->readString((*(this->success))[_i187]);
}
iprot->readListEnd();
}
@@ -911,14 +911,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size166;
- ::apache::thrift::protocol::TType _etype169;
- iprot->readListBegin(_etype169, _size166);
- this->success.resize(_size166);
- uint32_t _i170;
- for (_i170 = 0; _i170 < _size166; ++_i170)
+ uint32_t _size188;
+ ::apache::thrift::protocol::TType _etype191;
+ iprot->readListBegin(_etype191, _size188);
+ this->success.resize(_size188);
+ uint32_t _i192;
+ for (_i192 = 0; _i192 < _size188; ++_i192)
{
- xfer += iprot->readString(this->success[_i170]);
+ xfer += iprot->readString(this->success[_i192]);
}
iprot->readListEnd();
}
@@ -957,10 +957,10 @@
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 _iter171;
- for (_iter171 = this->success.begin(); _iter171 != this->success.end(); ++_iter171)
+ std::vector ::const_iterator _iter193;
+ for (_iter193 = this->success.begin(); _iter193 != this->success.end(); ++_iter193)
{
- xfer += oprot->writeString((*_iter171));
+ xfer += oprot->writeString((*_iter193));
}
xfer += oprot->writeListEnd();
}
@@ -999,14 +999,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size172;
- ::apache::thrift::protocol::TType _etype175;
- iprot->readListBegin(_etype175, _size172);
- (*(this->success)).resize(_size172);
- uint32_t _i176;
- for (_i176 = 0; _i176 < _size172; ++_i176)
+ uint32_t _size194;
+ ::apache::thrift::protocol::TType _etype197;
+ iprot->readListBegin(_etype197, _size194);
+ (*(this->success)).resize(_size194);
+ uint32_t _i198;
+ for (_i198 = 0; _i198 < _size194; ++_i198)
{
- xfer += iprot->readString((*(this->success))[_i176]);
+ xfer += iprot->readString((*(this->success))[_i198]);
}
iprot->readListEnd();
}
@@ -1927,17 +1927,17 @@
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
this->success.clear();
- uint32_t _size177;
- ::apache::thrift::protocol::TType _ktype178;
- ::apache::thrift::protocol::TType _vtype179;
- iprot->readMapBegin(_ktype178, _vtype179, _size177);
- uint32_t _i181;
- for (_i181 = 0; _i181 < _size177; ++_i181)
+ uint32_t _size199;
+ ::apache::thrift::protocol::TType _ktype200;
+ ::apache::thrift::protocol::TType _vtype201;
+ iprot->readMapBegin(_ktype200, _vtype201, _size199);
+ uint32_t _i203;
+ for (_i203 = 0; _i203 < _size199; ++_i203)
{
- std::string _key182;
- xfer += iprot->readString(_key182);
- Type& _val183 = this->success[_key182];
- xfer += _val183.read(iprot);
+ std::string _key204;
+ xfer += iprot->readString(_key204);
+ Type& _val205 = this->success[_key204];
+ xfer += _val205.read(iprot);
}
iprot->readMapEnd();
}
@@ -1976,11 +1976,11 @@
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 _iter184;
- for (_iter184 = this->success.begin(); _iter184 != this->success.end(); ++_iter184)
+ std::map ::const_iterator _iter206;
+ for (_iter206 = this->success.begin(); _iter206 != this->success.end(); ++_iter206)
{
- xfer += oprot->writeString(_iter184->first);
- xfer += _iter184->second.write(oprot);
+ xfer += oprot->writeString(_iter206->first);
+ xfer += _iter206->second.write(oprot);
}
xfer += oprot->writeMapEnd();
}
@@ -2019,17 +2019,17 @@
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
(*(this->success)).clear();
- uint32_t _size185;
- ::apache::thrift::protocol::TType _ktype186;
- ::apache::thrift::protocol::TType _vtype187;
- iprot->readMapBegin(_ktype186, _vtype187, _size185);
- uint32_t _i189;
- for (_i189 = 0; _i189 < _size185; ++_i189)
+ uint32_t _size207;
+ ::apache::thrift::protocol::TType _ktype208;
+ ::apache::thrift::protocol::TType _vtype209;
+ iprot->readMapBegin(_ktype208, _vtype209, _size207);
+ uint32_t _i211;
+ for (_i211 = 0; _i211 < _size207; ++_i211)
{
- std::string _key190;
- xfer += iprot->readString(_key190);
- Type& _val191 = (*(this->success))[_key190];
- xfer += _val191.read(iprot);
+ std::string _key212;
+ xfer += iprot->readString(_key212);
+ Type& _val213 = (*(this->success))[_key212];
+ xfer += _val213.read(iprot);
}
iprot->readMapEnd();
}
@@ -2158,14 +2158,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size192;
- ::apache::thrift::protocol::TType _etype195;
- iprot->readListBegin(_etype195, _size192);
- this->success.resize(_size192);
- uint32_t _i196;
- for (_i196 = 0; _i196 < _size192; ++_i196)
+ uint32_t _size214;
+ ::apache::thrift::protocol::TType _etype217;
+ iprot->readListBegin(_etype217, _size214);
+ this->success.resize(_size214);
+ uint32_t _i218;
+ for (_i218 = 0; _i218 < _size214; ++_i218)
{
- xfer += this->success[_i196].read(iprot);
+ xfer += this->success[_i218].read(iprot);
}
iprot->readListEnd();
}
@@ -2220,10 +2220,10 @@
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 _iter197;
- for (_iter197 = this->success.begin(); _iter197 != this->success.end(); ++_iter197)
+ std::vector ::const_iterator _iter219;
+ for (_iter219 = this->success.begin(); _iter219 != this->success.end(); ++_iter219)
{
- xfer += (*_iter197).write(oprot);
+ xfer += (*_iter219).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -2270,14 +2270,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size198;
- ::apache::thrift::protocol::TType _etype201;
- iprot->readListBegin(_etype201, _size198);
- (*(this->success)).resize(_size198);
- uint32_t _i202;
- for (_i202 = 0; _i202 < _size198; ++_i202)
+ uint32_t _size220;
+ ::apache::thrift::protocol::TType _etype223;
+ iprot->readListBegin(_etype223, _size220);
+ (*(this->success)).resize(_size220);
+ uint32_t _i224;
+ for (_i224 = 0; _i224 < _size220; ++_i224)
{
- xfer += (*(this->success))[_i202].read(iprot);
+ xfer += (*(this->success))[_i224].read(iprot);
}
iprot->readListEnd();
}
@@ -2422,14 +2422,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size203;
- ::apache::thrift::protocol::TType _etype206;
- iprot->readListBegin(_etype206, _size203);
- this->success.resize(_size203);
- uint32_t _i207;
- for (_i207 = 0; _i207 < _size203; ++_i207)
+ uint32_t _size225;
+ ::apache::thrift::protocol::TType _etype228;
+ iprot->readListBegin(_etype228, _size225);
+ this->success.resize(_size225);
+ uint32_t _i229;
+ for (_i229 = 0; _i229 < _size225; ++_i229)
{
- xfer += this->success[_i207].read(iprot);
+ xfer += this->success[_i229].read(iprot);
}
iprot->readListEnd();
}
@@ -2484,10 +2484,10 @@
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 _iter208;
- for (_iter208 = this->success.begin(); _iter208 != this->success.end(); ++_iter208)
+ std::vector ::const_iterator _iter230;
+ for (_iter230 = this->success.begin(); _iter230 != this->success.end(); ++_iter230)
{
- xfer += (*_iter208).write(oprot);
+ xfer += (*_iter230).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -2534,14 +2534,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size209;
- ::apache::thrift::protocol::TType _etype212;
- iprot->readListBegin(_etype212, _size209);
- (*(this->success)).resize(_size209);
- uint32_t _i213;
- for (_i213 = 0; _i213 < _size209; ++_i213)
+ uint32_t _size231;
+ ::apache::thrift::protocol::TType _etype234;
+ iprot->readListBegin(_etype234, _size231);
+ (*(this->success)).resize(_size231);
+ uint32_t _i235;
+ for (_i235 = 0; _i235 < _size231; ++_i235)
{
- xfer += (*(this->success))[_i213].read(iprot);
+ xfer += (*(this->success))[_i235].read(iprot);
}
iprot->readListEnd();
}
@@ -3010,6 +3010,246 @@
return xfer;
}
+uint32_t ThriftHiveMetastore_drop_table_on_cluster_args::read(::apache::thrift::protocol::TProtocol* 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_STRING) {
+ xfer += iprot->readString(this->cluster_name);
+ this->__isset.cluster_name = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->dbname);
+ this->__isset.dbname = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->name);
+ this->__isset.name = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->deleteData);
+ this->__isset.deleteData = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_drop_table_on_cluster_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_table_on_cluster_args");
+ xfer += oprot->writeFieldBegin("cluster_name", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->cluster_name);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->dbname);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 3);
+ xfer += oprot->writeString(this->name);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 4);
+ xfer += oprot->writeBool(this->deleteData);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_drop_table_on_cluster_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_table_on_cluster_pargs");
+ xfer += oprot->writeFieldBegin("cluster_name", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString((*(this->cluster_name)));
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString((*(this->dbname)));
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 3);
+ xfer += oprot->writeString((*(this->name)));
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 4);
+ xfer += oprot->writeBool((*(this->deleteData)));
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_drop_table_on_cluster_result::read(::apache::thrift::protocol::TProtocol* 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_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_drop_table_on_cluster_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_table_on_cluster_result");
+
+ 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;
+}
+
+uint32_t ThriftHiveMetastore_drop_table_on_cluster_presult::read(::apache::thrift::protocol::TProtocol* 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_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_get_tables_args::read(::apache::thrift::protocol::TProtocol* iprot) {
uint32_t xfer = 0;
@@ -3110,14 +3350,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size214;
- ::apache::thrift::protocol::TType _etype217;
- iprot->readListBegin(_etype217, _size214);
- this->success.resize(_size214);
- uint32_t _i218;
- for (_i218 = 0; _i218 < _size214; ++_i218)
+ uint32_t _size236;
+ ::apache::thrift::protocol::TType _etype239;
+ iprot->readListBegin(_etype239, _size236);
+ this->success.resize(_size236);
+ uint32_t _i240;
+ for (_i240 = 0; _i240 < _size236; ++_i240)
{
- xfer += iprot->readString(this->success[_i218]);
+ xfer += iprot->readString(this->success[_i240]);
}
iprot->readListEnd();
}
@@ -3156,10 +3396,10 @@
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 _iter219;
- for (_iter219 = this->success.begin(); _iter219 != this->success.end(); ++_iter219)
+ std::vector ::const_iterator _iter241;
+ for (_iter241 = this->success.begin(); _iter241 != this->success.end(); ++_iter241)
{
- xfer += oprot->writeString((*_iter219));
+ xfer += oprot->writeString((*_iter241));
}
xfer += oprot->writeListEnd();
}
@@ -3198,14 +3438,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size220;
- ::apache::thrift::protocol::TType _etype223;
- iprot->readListBegin(_etype223, _size220);
- (*(this->success)).resize(_size220);
- uint32_t _i224;
- for (_i224 = 0; _i224 < _size220; ++_i224)
+ uint32_t _size242;
+ ::apache::thrift::protocol::TType _etype245;
+ iprot->readListBegin(_etype245, _size242);
+ (*(this->success)).resize(_size242);
+ uint32_t _i246;
+ for (_i246 = 0; _i246 < _size242; ++_i246)
{
- xfer += iprot->readString((*(this->success))[_i224]);
+ xfer += iprot->readString((*(this->success))[_i246]);
}
iprot->readListEnd();
}
@@ -3320,14 +3560,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size225;
- ::apache::thrift::protocol::TType _etype228;
- iprot->readListBegin(_etype228, _size225);
- this->success.resize(_size225);
- uint32_t _i229;
- for (_i229 = 0; _i229 < _size225; ++_i229)
+ uint32_t _size247;
+ ::apache::thrift::protocol::TType _etype250;
+ iprot->readListBegin(_etype250, _size247);
+ this->success.resize(_size247);
+ uint32_t _i251;
+ for (_i251 = 0; _i251 < _size247; ++_i251)
{
- xfer += iprot->readString(this->success[_i229]);
+ xfer += iprot->readString(this->success[_i251]);
}
iprot->readListEnd();
}
@@ -3366,10 +3606,10 @@
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 _iter230;
- for (_iter230 = this->success.begin(); _iter230 != this->success.end(); ++_iter230)
+ std::vector ::const_iterator _iter252;
+ for (_iter252 = this->success.begin(); _iter252 != this->success.end(); ++_iter252)
{
- xfer += oprot->writeString((*_iter230));
+ xfer += oprot->writeString((*_iter252));
}
xfer += oprot->writeListEnd();
}
@@ -3408,14 +3648,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size231;
- ::apache::thrift::protocol::TType _etype234;
- iprot->readListBegin(_etype234, _size231);
- (*(this->success)).resize(_size231);
- uint32_t _i235;
- for (_i235 = 0; _i235 < _size231; ++_i235)
+ uint32_t _size253;
+ ::apache::thrift::protocol::TType _etype256;
+ iprot->readListBegin(_etype256, _size253);
+ (*(this->success)).resize(_size253);
+ uint32_t _i257;
+ for (_i257 = 0; _i257 < _size253; ++_i257)
{
- xfer += iprot->readString((*(this->success))[_i235]);
+ xfer += iprot->readString((*(this->success))[_i257]);
}
iprot->readListEnd();
}
@@ -3688,14 +3928,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->tbl_names.clear();
- uint32_t _size236;
- ::apache::thrift::protocol::TType _etype239;
- iprot->readListBegin(_etype239, _size236);
- this->tbl_names.resize(_size236);
- uint32_t _i240;
- for (_i240 = 0; _i240 < _size236; ++_i240)
+ uint32_t _size258;
+ ::apache::thrift::protocol::TType _etype261;
+ iprot->readListBegin(_etype261, _size258);
+ this->tbl_names.resize(_size258);
+ uint32_t _i262;
+ for (_i262 = 0; _i262 < _size258; ++_i262)
{
- xfer += iprot->readString(this->tbl_names[_i240]);
+ xfer += iprot->readString(this->tbl_names[_i262]);
}
iprot->readListEnd();
}
@@ -3725,10 +3965,10 @@
xfer += oprot->writeFieldBegin("tbl_names", ::apache::thrift::protocol::T_LIST, 2);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->tbl_names.size()));
- std::vector ::const_iterator _iter241;
- for (_iter241 = this->tbl_names.begin(); _iter241 != this->tbl_names.end(); ++_iter241)
+ std::vector ::const_iterator _iter263;
+ for (_iter263 = this->tbl_names.begin(); _iter263 != this->tbl_names.end(); ++_iter263)
{
- xfer += oprot->writeString((*_iter241));
+ xfer += oprot->writeString((*_iter263));
}
xfer += oprot->writeListEnd();
}
@@ -3747,10 +3987,10 @@
xfer += oprot->writeFieldBegin("tbl_names", ::apache::thrift::protocol::T_LIST, 2);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->tbl_names)).size()));
- std::vector ::const_iterator _iter242;
- for (_iter242 = (*(this->tbl_names)).begin(); _iter242 != (*(this->tbl_names)).end(); ++_iter242)
+ std::vector ::const_iterator _iter264;
+ for (_iter264 = (*(this->tbl_names)).begin(); _iter264 != (*(this->tbl_names)).end(); ++_iter264)
{
- xfer += oprot->writeString((*_iter242));
+ xfer += oprot->writeString((*_iter264));
}
xfer += oprot->writeListEnd();
}
@@ -3784,14 +4024,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size243;
- ::apache::thrift::protocol::TType _etype246;
- iprot->readListBegin(_etype246, _size243);
- this->success.resize(_size243);
- uint32_t _i247;
- for (_i247 = 0; _i247 < _size243; ++_i247)
+ uint32_t _size265;
+ ::apache::thrift::protocol::TType _etype268;
+ iprot->readListBegin(_etype268, _size265);
+ this->success.resize(_size265);
+ uint32_t _i269;
+ for (_i269 = 0; _i269 < _size265; ++_i269)
{
- xfer += this->success[_i247].read(iprot);
+ xfer += this->success[_i269].read(iprot);
}
iprot->readListEnd();
}
@@ -3846,10 +4086,10 @@
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 _iter248;
- for (_iter248 = this->success.begin(); _iter248 != this->success.end(); ++_iter248)
+ std::vector ::const_iterator _iter270;
+ for (_iter270 = this->success.begin(); _iter270 != this->success.end(); ++_iter270)
{
- xfer += (*_iter248).write(oprot);
+ xfer += (*_iter270).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -3896,14 +4136,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size249;
- ::apache::thrift::protocol::TType _etype252;
- iprot->readListBegin(_etype252, _size249);
- (*(this->success)).resize(_size249);
- uint32_t _i253;
- for (_i253 = 0; _i253 < _size249; ++_i253)
+ uint32_t _size271;
+ ::apache::thrift::protocol::TType _etype274;
+ iprot->readListBegin(_etype274, _size271);
+ (*(this->success)).resize(_size271);
+ uint32_t _i275;
+ for (_i275 = 0; _i275 < _size271; ++_i275)
{
- xfer += (*(this->success))[_i253].read(iprot);
+ xfer += (*(this->success))[_i275].read(iprot);
}
iprot->readListEnd();
}
@@ -4062,14 +4302,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size254;
- ::apache::thrift::protocol::TType _etype257;
- iprot->readListBegin(_etype257, _size254);
- this->success.resize(_size254);
- uint32_t _i258;
- for (_i258 = 0; _i258 < _size254; ++_i258)
+ uint32_t _size276;
+ ::apache::thrift::protocol::TType _etype279;
+ iprot->readListBegin(_etype279, _size276);
+ this->success.resize(_size276);
+ uint32_t _i280;
+ for (_i280 = 0; _i280 < _size276; ++_i280)
{
- xfer += iprot->readString(this->success[_i258]);
+ xfer += iprot->readString(this->success[_i280]);
}
iprot->readListEnd();
}
@@ -4124,10 +4364,10 @@
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 _iter259;
- for (_iter259 = this->success.begin(); _iter259 != this->success.end(); ++_iter259)
+ std::vector ::const_iterator _iter281;
+ for (_iter281 = this->success.begin(); _iter281 != this->success.end(); ++_iter281)
{
- xfer += oprot->writeString((*_iter259));
+ xfer += oprot->writeString((*_iter281));
}
xfer += oprot->writeListEnd();
}
@@ -4174,14 +4414,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size260;
- ::apache::thrift::protocol::TType _etype263;
- iprot->readListBegin(_etype263, _size260);
- (*(this->success)).resize(_size260);
- uint32_t _i264;
- for (_i264 = 0; _i264 < _size260; ++_i264)
+ uint32_t _size282;
+ ::apache::thrift::protocol::TType _etype285;
+ iprot->readListBegin(_etype285, _size282);
+ (*(this->success)).resize(_size282);
+ uint32_t _i286;
+ for (_i286 = 0; _i286 < _size282; ++_i286)
{
- xfer += iprot->readString((*(this->success))[_i264]);
+ xfer += iprot->readString((*(this->success))[_i286]);
}
iprot->readListEnd();
}
@@ -4674,14 +4914,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->new_parts.clear();
- uint32_t _size265;
- ::apache::thrift::protocol::TType _etype268;
- iprot->readListBegin(_etype268, _size265);
- this->new_parts.resize(_size265);
- uint32_t _i269;
- for (_i269 = 0; _i269 < _size265; ++_i269)
+ uint32_t _size287;
+ ::apache::thrift::protocol::TType _etype290;
+ iprot->readListBegin(_etype290, _size287);
+ this->new_parts.resize(_size287);
+ uint32_t _i291;
+ for (_i291 = 0; _i291 < _size287; ++_i291)
{
- xfer += this->new_parts[_i269].read(iprot);
+ xfer += this->new_parts[_i291].read(iprot);
}
iprot->readListEnd();
}
@@ -4708,10 +4948,10 @@
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 _iter270;
- for (_iter270 = this->new_parts.begin(); _iter270 != this->new_parts.end(); ++_iter270)
+ std::vector ::const_iterator _iter292;
+ for (_iter292 = this->new_parts.begin(); _iter292 != this->new_parts.end(); ++_iter292)
{
- xfer += (*_iter270).write(oprot);
+ xfer += (*_iter292).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -4727,10 +4967,10 @@
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 _iter271;
- for (_iter271 = (*(this->new_parts)).begin(); _iter271 != (*(this->new_parts)).end(); ++_iter271)
+ std::vector ::const_iterator _iter293;
+ for (_iter293 = (*(this->new_parts)).begin(); _iter293 != (*(this->new_parts)).end(); ++_iter293)
{
- xfer += (*_iter271).write(oprot);
+ xfer += (*_iter293).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -4936,14 +5176,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->part_vals.clear();
- uint32_t _size272;
- ::apache::thrift::protocol::TType _etype275;
- iprot->readListBegin(_etype275, _size272);
- this->part_vals.resize(_size272);
- uint32_t _i276;
- for (_i276 = 0; _i276 < _size272; ++_i276)
+ uint32_t _size294;
+ ::apache::thrift::protocol::TType _etype297;
+ iprot->readListBegin(_etype297, _size294);
+ this->part_vals.resize(_size294);
+ uint32_t _i298;
+ for (_i298 = 0; _i298 < _size294; ++_i298)
{
- xfer += iprot->readString(this->part_vals[_i276]);
+ xfer += iprot->readString(this->part_vals[_i298]);
}
iprot->readListEnd();
}
@@ -4976,10 +5216,10 @@
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 _iter277;
- for (_iter277 = this->part_vals.begin(); _iter277 != this->part_vals.end(); ++_iter277)
+ std::vector ::const_iterator _iter299;
+ for (_iter299 = this->part_vals.begin(); _iter299 != this->part_vals.end(); ++_iter299)
{
- xfer += oprot->writeString((*_iter277));
+ xfer += oprot->writeString((*_iter299));
}
xfer += oprot->writeListEnd();
}
@@ -5001,10 +5241,10 @@
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 _iter278;
- for (_iter278 = (*(this->part_vals)).begin(); _iter278 != (*(this->part_vals)).end(); ++_iter278)
+ std::vector ::const_iterator _iter300;
+ for (_iter300 = (*(this->part_vals)).begin(); _iter300 != (*(this->part_vals)).end(); ++_iter300)
{
- xfer += oprot->writeString((*_iter278));
+ xfer += oprot->writeString((*_iter300));
}
xfer += oprot->writeListEnd();
}
@@ -5456,14 +5696,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->part_vals.clear();
- uint32_t _size279;
- ::apache::thrift::protocol::TType _etype282;
- iprot->readListBegin(_etype282, _size279);
- this->part_vals.resize(_size279);
- uint32_t _i283;
- for (_i283 = 0; _i283 < _size279; ++_i283)
+ uint32_t _size301;
+ ::apache::thrift::protocol::TType _etype304;
+ iprot->readListBegin(_etype304, _size301);
+ this->part_vals.resize(_size301);
+ uint32_t _i305;
+ for (_i305 = 0; _i305 < _size301; ++_i305)
{
- xfer += iprot->readString(this->part_vals[_i283]);
+ xfer += iprot->readString(this->part_vals[_i305]);
}
iprot->readListEnd();
}
@@ -5504,10 +5744,10 @@
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 _iter284;
- for (_iter284 = this->part_vals.begin(); _iter284 != this->part_vals.end(); ++_iter284)
+ std::vector ::const_iterator _iter306;
+ for (_iter306 = this->part_vals.begin(); _iter306 != this->part_vals.end(); ++_iter306)
{
- xfer += oprot->writeString((*_iter284));
+ xfer += oprot->writeString((*_iter306));
}
xfer += oprot->writeListEnd();
}
@@ -5532,10 +5772,10 @@
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 _iter285;
- for (_iter285 = (*(this->part_vals)).begin(); _iter285 != (*(this->part_vals)).end(); ++_iter285)
+ std::vector ::const_iterator _iter307;
+ for (_iter307 = (*(this->part_vals)).begin(); _iter307 != (*(this->part_vals)).end(); ++_iter307)
{
- xfer += oprot->writeString((*_iter285));
+ xfer += oprot->writeString((*_iter307));
}
xfer += oprot->writeListEnd();
}
@@ -5684,6 +5924,308 @@
return xfer;
}
+uint32_t ThriftHiveMetastore_drop_partition_on_cluster_args::read(::apache::thrift::protocol::TProtocol* 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_STRING) {
+ xfer += iprot->readString(this->cluster_name);
+ this->__isset.cluster_name = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->db_name);
+ this->__isset.db_name = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->tbl_name);
+ this->__isset.tbl_name = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->part_vals.clear();
+ uint32_t _size308;
+ ::apache::thrift::protocol::TType _etype311;
+ iprot->readListBegin(_etype311, _size308);
+ this->part_vals.resize(_size308);
+ uint32_t _i312;
+ for (_i312 = 0; _i312 < _size308; ++_i312)
+ {
+ xfer += iprot->readString(this->part_vals[_i312]);
+ }
+ iprot->readListEnd();
+ }
+ this->__isset.part_vals = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 5:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->deleteData);
+ this->__isset.deleteData = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_drop_partition_on_cluster_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_partition_on_cluster_args");
+ xfer += oprot->writeFieldBegin("cluster_name", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->cluster_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("tbl_name", ::apache::thrift::protocol::T_STRING, 3);
+ xfer += oprot->writeString(this->tbl_name);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 4);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size()));
+ std::vector ::const_iterator _iter313;
+ for (_iter313 = this->part_vals.begin(); _iter313 != this->part_vals.end(); ++_iter313)
+ {
+ xfer += oprot->writeString((*_iter313));
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 5);
+ xfer += oprot->writeBool(this->deleteData);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_drop_partition_on_cluster_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_partition_on_cluster_pargs");
+ xfer += oprot->writeFieldBegin("cluster_name", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString((*(this->cluster_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("tbl_name", ::apache::thrift::protocol::T_STRING, 3);
+ xfer += oprot->writeString((*(this->tbl_name)));
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 4);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size()));
+ std::vector ::const_iterator _iter314;
+ for (_iter314 = (*(this->part_vals)).begin(); _iter314 != (*(this->part_vals)).end(); ++_iter314)
+ {
+ xfer += oprot->writeString((*_iter314));
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 5);
+ xfer += oprot->writeBool((*(this->deleteData)));
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_drop_partition_on_cluster_result::read(::apache::thrift::protocol::TProtocol* 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_BOOL) {
+ xfer += iprot->readBool(this->success);
+ 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_drop_partition_on_cluster_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_partition_on_cluster_result");
+
+ if (this->__isset.success) {
+ xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0);
+ xfer += oprot->writeBool(this->success);
+ 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;
+}
+
+uint32_t ThriftHiveMetastore_drop_partition_on_cluster_presult::read(::apache::thrift::protocol::TProtocol* 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_BOOL) {
+ xfer += iprot->readBool((*(this->success)));
+ 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_drop_partition_by_name_args::read(::apache::thrift::protocol::TProtocol* iprot) {
uint32_t xfer = 0;
@@ -5964,14 +6506,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->part_vals.clear();
- uint32_t _size286;
- ::apache::thrift::protocol::TType _etype289;
- iprot->readListBegin(_etype289, _size286);
- this->part_vals.resize(_size286);
- uint32_t _i290;
- for (_i290 = 0; _i290 < _size286; ++_i290)
+ uint32_t _size315;
+ ::apache::thrift::protocol::TType _etype318;
+ iprot->readListBegin(_etype318, _size315);
+ this->part_vals.resize(_size315);
+ uint32_t _i319;
+ for (_i319 = 0; _i319 < _size315; ++_i319)
{
- xfer += iprot->readString(this->part_vals[_i290]);
+ xfer += iprot->readString(this->part_vals[_i319]);
}
iprot->readListEnd();
}
@@ -6004,10 +6546,10 @@
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 _iter291;
- for (_iter291 = this->part_vals.begin(); _iter291 != this->part_vals.end(); ++_iter291)
+ std::vector ::const_iterator _iter320;
+ for (_iter320 = this->part_vals.begin(); _iter320 != this->part_vals.end(); ++_iter320)
{
- xfer += oprot->writeString((*_iter291));
+ xfer += oprot->writeString((*_iter320));
}
xfer += oprot->writeListEnd();
}
@@ -6029,10 +6571,10 @@
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 _iter292;
- for (_iter292 = (*(this->part_vals)).begin(); _iter292 != (*(this->part_vals)).end(); ++_iter292)
+ std::vector ::const_iterator _iter321;
+ for (_iter321 = (*(this->part_vals)).begin(); _iter321 != (*(this->part_vals)).end(); ++_iter321)
{
- xfer += oprot->writeString((*_iter292));
+ xfer += oprot->writeString((*_iter321));
}
xfer += oprot->writeListEnd();
}
@@ -6218,14 +6760,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->part_vals.clear();
- uint32_t _size293;
- ::apache::thrift::protocol::TType _etype296;
- iprot->readListBegin(_etype296, _size293);
- this->part_vals.resize(_size293);
- uint32_t _i297;
- for (_i297 = 0; _i297 < _size293; ++_i297)
+ uint32_t _size322;
+ ::apache::thrift::protocol::TType _etype325;
+ iprot->readListBegin(_etype325, _size322);
+ this->part_vals.resize(_size322);
+ uint32_t _i326;
+ for (_i326 = 0; _i326 < _size322; ++_i326)
{
- xfer += iprot->readString(this->part_vals[_i297]);
+ xfer += iprot->readString(this->part_vals[_i326]);
}
iprot->readListEnd();
}
@@ -6246,14 +6788,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->group_names.clear();
- uint32_t _size298;
- ::apache::thrift::protocol::TType _etype301;
- iprot->readListBegin(_etype301, _size298);
- this->group_names.resize(_size298);
- uint32_t _i302;
- for (_i302 = 0; _i302 < _size298; ++_i302)
+ uint32_t _size327;
+ ::apache::thrift::protocol::TType _etype330;
+ iprot->readListBegin(_etype330, _size327);
+ this->group_names.resize(_size327);
+ uint32_t _i331;
+ for (_i331 = 0; _i331 < _size327; ++_i331)
{
- xfer += iprot->readString(this->group_names[_i302]);
+ xfer += iprot->readString(this->group_names[_i331]);
}
iprot->readListEnd();
}
@@ -6286,10 +6828,10 @@
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 _iter303;
- for (_iter303 = this->part_vals.begin(); _iter303 != this->part_vals.end(); ++_iter303)
+ std::vector ::const_iterator _iter332;
+ for (_iter332 = this->part_vals.begin(); _iter332 != this->part_vals.end(); ++_iter332)
{
- xfer += oprot->writeString((*_iter303));
+ xfer += oprot->writeString((*_iter332));
}
xfer += oprot->writeListEnd();
}
@@ -6300,10 +6842,10 @@
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 _iter304;
- for (_iter304 = this->group_names.begin(); _iter304 != this->group_names.end(); ++_iter304)
+ std::vector ::const_iterator _iter333;
+ for (_iter333 = this->group_names.begin(); _iter333 != this->group_names.end(); ++_iter333)
{
- xfer += oprot->writeString((*_iter304));
+ xfer += oprot->writeString((*_iter333));
}
xfer += oprot->writeListEnd();
}
@@ -6325,10 +6867,10 @@
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 _iter305;
- for (_iter305 = (*(this->part_vals)).begin(); _iter305 != (*(this->part_vals)).end(); ++_iter305)
+ std::vector ::const_iterator _iter334;
+ for (_iter334 = (*(this->part_vals)).begin(); _iter334 != (*(this->part_vals)).end(); ++_iter334)
{
- xfer += oprot->writeString((*_iter305));
+ xfer += oprot->writeString((*_iter334));
}
xfer += oprot->writeListEnd();
}
@@ -6339,10 +6881,10 @@
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 _iter306;
- for (_iter306 = (*(this->group_names)).begin(); _iter306 != (*(this->group_names)).end(); ++_iter306)
+ std::vector ::const_iterator _iter335;
+ for (_iter335 = (*(this->group_names)).begin(); _iter335 != (*(this->group_names)).end(); ++_iter335)
{
- xfer += oprot->writeString((*_iter306));
+ xfer += oprot->writeString((*_iter335));
}
xfer += oprot->writeListEnd();
}
@@ -6828,14 +7370,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size307;
- ::apache::thrift::protocol::TType _etype310;
- iprot->readListBegin(_etype310, _size307);
- this->success.resize(_size307);
- uint32_t _i311;
- for (_i311 = 0; _i311 < _size307; ++_i311)
+ uint32_t _size336;
+ ::apache::thrift::protocol::TType _etype339;
+ iprot->readListBegin(_etype339, _size336);
+ this->success.resize(_size336);
+ uint32_t _i340;
+ for (_i340 = 0; _i340 < _size336; ++_i340)
{
- xfer += this->success[_i311].read(iprot);
+ xfer += this->success[_i340].read(iprot);
}
iprot->readListEnd();
}
@@ -6882,10 +7424,10 @@
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 _iter312;
- for (_iter312 = this->success.begin(); _iter312 != this->success.end(); ++_iter312)
+ std::vector ::const_iterator _iter341;
+ for (_iter341 = this->success.begin(); _iter341 != this->success.end(); ++_iter341)
{
- xfer += (*_iter312).write(oprot);
+ xfer += (*_iter341).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -6928,14 +7470,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size313;
- ::apache::thrift::protocol::TType _etype316;
- iprot->readListBegin(_etype316, _size313);
- (*(this->success)).resize(_size313);
- uint32_t _i317;
- for (_i317 = 0; _i317 < _size313; ++_i317)
+ uint32_t _size342;
+ ::apache::thrift::protocol::TType _etype345;
+ iprot->readListBegin(_etype345, _size342);
+ (*(this->success)).resize(_size342);
+ uint32_t _i346;
+ for (_i346 = 0; _i346 < _size342; ++_i346)
{
- xfer += (*(this->success))[_i317].read(iprot);
+ xfer += (*(this->success))[_i346].read(iprot);
}
iprot->readListEnd();
}
@@ -7028,14 +7570,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->group_names.clear();
- uint32_t _size318;
- ::apache::thrift::protocol::TType _etype321;
- iprot->readListBegin(_etype321, _size318);
- this->group_names.resize(_size318);
- uint32_t _i322;
- for (_i322 = 0; _i322 < _size318; ++_i322)
+ uint32_t _size347;
+ ::apache::thrift::protocol::TType _etype350;
+ iprot->readListBegin(_etype350, _size347);
+ this->group_names.resize(_size347);
+ uint32_t _i351;
+ for (_i351 = 0; _i351 < _size347; ++_i351)
{
- xfer += iprot->readString(this->group_names[_i322]);
+ xfer += iprot->readString(this->group_names[_i351]);
}
iprot->readListEnd();
}
@@ -7074,10 +7616,10 @@
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 _iter323;
- for (_iter323 = this->group_names.begin(); _iter323 != this->group_names.end(); ++_iter323)
+ std::vector ::const_iterator _iter352;
+ for (_iter352 = this->group_names.begin(); _iter352 != this->group_names.end(); ++_iter352)
{
- xfer += oprot->writeString((*_iter323));
+ xfer += oprot->writeString((*_iter352));
}
xfer += oprot->writeListEnd();
}
@@ -7105,10 +7647,10 @@
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 _iter324;
- for (_iter324 = (*(this->group_names)).begin(); _iter324 != (*(this->group_names)).end(); ++_iter324)
+ std::vector ::const_iterator _iter353;
+ for (_iter353 = (*(this->group_names)).begin(); _iter353 != (*(this->group_names)).end(); ++_iter353)
{
- xfer += oprot->writeString((*_iter324));
+ xfer += oprot->writeString((*_iter353));
}
xfer += oprot->writeListEnd();
}
@@ -7142,14 +7684,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size325;
- ::apache::thrift::protocol::TType _etype328;
- iprot->readListBegin(_etype328, _size325);
- this->success.resize(_size325);
- uint32_t _i329;
- for (_i329 = 0; _i329 < _size325; ++_i329)
+ uint32_t _size354;
+ ::apache::thrift::protocol::TType _etype357;
+ iprot->readListBegin(_etype357, _size354);
+ this->success.resize(_size354);
+ uint32_t _i358;
+ for (_i358 = 0; _i358 < _size354; ++_i358)
{
- xfer += this->success[_i329].read(iprot);
+ xfer += this->success[_i358].read(iprot);
}
iprot->readListEnd();
}
@@ -7196,10 +7738,10 @@
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 _iter330;
- for (_iter330 = this->success.begin(); _iter330 != this->success.end(); ++_iter330)
+ std::vector ::const_iterator _iter359;
+ for (_iter359 = this->success.begin(); _iter359 != this->success.end(); ++_iter359)
{
- xfer += (*_iter330).write(oprot);
+ xfer += (*_iter359).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -7242,14 +7784,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size331;
- ::apache::thrift::protocol::TType _etype334;
- iprot->readListBegin(_etype334, _size331);
- (*(this->success)).resize(_size331);
- uint32_t _i335;
- for (_i335 = 0; _i335 < _size331; ++_i335)
+ uint32_t _size360;
+ ::apache::thrift::protocol::TType _etype363;
+ iprot->readListBegin(_etype363, _size360);
+ (*(this->success)).resize(_size360);
+ uint32_t _i364;
+ for (_i364 = 0; _i364 < _size360; ++_i364)
{
- xfer += (*(this->success))[_i335].read(iprot);
+ xfer += (*(this->success))[_i364].read(iprot);
}
iprot->readListEnd();
}
@@ -7400,14 +7942,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size336;
- ::apache::thrift::protocol::TType _etype339;
- iprot->readListBegin(_etype339, _size336);
- this->success.resize(_size336);
- uint32_t _i340;
- for (_i340 = 0; _i340 < _size336; ++_i340)
+ uint32_t _size365;
+ ::apache::thrift::protocol::TType _etype368;
+ iprot->readListBegin(_etype368, _size365);
+ this->success.resize(_size365);
+ uint32_t _i369;
+ for (_i369 = 0; _i369 < _size365; ++_i369)
{
- xfer += iprot->readString(this->success[_i340]);
+ xfer += iprot->readString(this->success[_i369]);
}
iprot->readListEnd();
}
@@ -7446,10 +7988,10 @@
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 _iter341;
- for (_iter341 = this->success.begin(); _iter341 != this->success.end(); ++_iter341)
+ std::vector ::const_iterator _iter370;
+ for (_iter370 = this->success.begin(); _iter370 != this->success.end(); ++_iter370)
{
- xfer += oprot->writeString((*_iter341));
+ xfer += oprot->writeString((*_iter370));
}
xfer += oprot->writeListEnd();
}
@@ -7488,14 +8030,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size342;
- ::apache::thrift::protocol::TType _etype345;
- iprot->readListBegin(_etype345, _size342);
- (*(this->success)).resize(_size342);
- uint32_t _i346;
- for (_i346 = 0; _i346 < _size342; ++_i346)
+ uint32_t _size371;
+ ::apache::thrift::protocol::TType _etype374;
+ iprot->readListBegin(_etype374, _size371);
+ (*(this->success)).resize(_size371);
+ uint32_t _i375;
+ for (_i375 = 0; _i375 < _size371; ++_i375)
{
- xfer += iprot->readString((*(this->success))[_i346]);
+ xfer += iprot->readString((*(this->success))[_i375]);
}
iprot->readListEnd();
}
@@ -7564,14 +8106,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->part_vals.clear();
- uint32_t _size347;
- ::apache::thrift::protocol::TType _etype350;
- iprot->readListBegin(_etype350, _size347);
- this->part_vals.resize(_size347);
- uint32_t _i351;
- for (_i351 = 0; _i351 < _size347; ++_i351)
+ uint32_t _size376;
+ ::apache::thrift::protocol::TType _etype379;
+ iprot->readListBegin(_etype379, _size376);
+ this->part_vals.resize(_size376);
+ uint32_t _i380;
+ for (_i380 = 0; _i380 < _size376; ++_i380)
{
- xfer += iprot->readString(this->part_vals[_i351]);
+ xfer += iprot->readString(this->part_vals[_i380]);
}
iprot->readListEnd();
}
@@ -7612,10 +8154,10 @@
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 _iter352;
- for (_iter352 = this->part_vals.begin(); _iter352 != this->part_vals.end(); ++_iter352)
+ std::vector ::const_iterator _iter381;
+ for (_iter381 = this->part_vals.begin(); _iter381 != this->part_vals.end(); ++_iter381)
{
- xfer += oprot->writeString((*_iter352));
+ xfer += oprot->writeString((*_iter381));
}
xfer += oprot->writeListEnd();
}
@@ -7640,10 +8182,10 @@
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 _iter353;
- for (_iter353 = (*(this->part_vals)).begin(); _iter353 != (*(this->part_vals)).end(); ++_iter353)
+ std::vector ::const_iterator _iter382;
+ for (_iter382 = (*(this->part_vals)).begin(); _iter382 != (*(this->part_vals)).end(); ++_iter382)
{
- xfer += oprot->writeString((*_iter353));
+ xfer += oprot->writeString((*_iter382));
}
xfer += oprot->writeListEnd();
}
@@ -7680,14 +8222,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size354;
- ::apache::thrift::protocol::TType _etype357;
- iprot->readListBegin(_etype357, _size354);
- this->success.resize(_size354);
- uint32_t _i358;
- for (_i358 = 0; _i358 < _size354; ++_i358)
+ uint32_t _size383;
+ ::apache::thrift::protocol::TType _etype386;
+ iprot->readListBegin(_etype386, _size383);
+ this->success.resize(_size383);
+ uint32_t _i387;
+ for (_i387 = 0; _i387 < _size383; ++_i387)
{
- xfer += this->success[_i358].read(iprot);
+ xfer += this->success[_i387].read(iprot);
}
iprot->readListEnd();
}
@@ -7734,10 +8276,10 @@
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 _iter359;
- for (_iter359 = this->success.begin(); _iter359 != this->success.end(); ++_iter359)
+ std::vector ::const_iterator _iter388;
+ for (_iter388 = this->success.begin(); _iter388 != this->success.end(); ++_iter388)
{
- xfer += (*_iter359).write(oprot);
+ xfer += (*_iter388).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -7780,14 +8322,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size360;
- ::apache::thrift::protocol::TType _etype363;
- iprot->readListBegin(_etype363, _size360);
- (*(this->success)).resize(_size360);
- uint32_t _i364;
- for (_i364 = 0; _i364 < _size360; ++_i364)
+ uint32_t _size389;
+ ::apache::thrift::protocol::TType _etype392;
+ iprot->readListBegin(_etype392, _size389);
+ (*(this->success)).resize(_size389);
+ uint32_t _i393;
+ for (_i393 = 0; _i393 < _size389; ++_i393)
{
- xfer += (*(this->success))[_i364].read(iprot);
+ xfer += (*(this->success))[_i393].read(iprot);
}
iprot->readListEnd();
}
@@ -7864,14 +8406,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->part_vals.clear();
- uint32_t _size365;
- ::apache::thrift::protocol::TType _etype368;
- iprot->readListBegin(_etype368, _size365);
- this->part_vals.resize(_size365);
- uint32_t _i369;
- for (_i369 = 0; _i369 < _size365; ++_i369)
+ uint32_t _size394;
+ ::apache::thrift::protocol::TType _etype397;
+ iprot->readListBegin(_etype397, _size394);
+ this->part_vals.resize(_size394);
+ uint32_t _i398;
+ for (_i398 = 0; _i398 < _size394; ++_i398)
{
- xfer += iprot->readString(this->part_vals[_i369]);
+ xfer += iprot->readString(this->part_vals[_i398]);
}
iprot->readListEnd();
}
@@ -7900,14 +8442,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->group_names.clear();
- uint32_t _size370;
- ::apache::thrift::protocol::TType _etype373;
- iprot->readListBegin(_etype373, _size370);
- this->group_names.resize(_size370);
- uint32_t _i374;
- for (_i374 = 0; _i374 < _size370; ++_i374)
+ uint32_t _size399;
+ ::apache::thrift::protocol::TType _etype402;
+ iprot->readListBegin(_etype402, _size399);
+ this->group_names.resize(_size399);
+ uint32_t _i403;
+ for (_i403 = 0; _i403 < _size399; ++_i403)
{
- xfer += iprot->readString(this->group_names[_i374]);
+ xfer += iprot->readString(this->group_names[_i403]);
}
iprot->readListEnd();
}
@@ -7940,10 +8482,10 @@
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 _iter375;
- for (_iter375 = this->part_vals.begin(); _iter375 != this->part_vals.end(); ++_iter375)
+ std::vector ::const_iterator _iter404;
+ for (_iter404 = this->part_vals.begin(); _iter404 != this->part_vals.end(); ++_iter404)
{
- xfer += oprot->writeString((*_iter375));
+ xfer += oprot->writeString((*_iter404));
}
xfer += oprot->writeListEnd();
}
@@ -7957,10 +8499,10 @@
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 _iter376;
- for (_iter376 = this->group_names.begin(); _iter376 != this->group_names.end(); ++_iter376)
+ std::vector ::const_iterator _iter405;
+ for (_iter405 = this->group_names.begin(); _iter405 != this->group_names.end(); ++_iter405)
{
- xfer += oprot->writeString((*_iter376));
+ xfer += oprot->writeString((*_iter405));
}
xfer += oprot->writeListEnd();
}
@@ -7982,10 +8524,10 @@
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 _iter377;
- for (_iter377 = (*(this->part_vals)).begin(); _iter377 != (*(this->part_vals)).end(); ++_iter377)
+ std::vector ::const_iterator _iter406;
+ for (_iter406 = (*(this->part_vals)).begin(); _iter406 != (*(this->part_vals)).end(); ++_iter406)
{
- xfer += oprot->writeString((*_iter377));
+ xfer += oprot->writeString((*_iter406));
}
xfer += oprot->writeListEnd();
}
@@ -7999,10 +8541,10 @@
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 _iter378;
- for (_iter378 = (*(this->group_names)).begin(); _iter378 != (*(this->group_names)).end(); ++_iter378)
+ std::vector ::const_iterator _iter407;
+ for (_iter407 = (*(this->group_names)).begin(); _iter407 != (*(this->group_names)).end(); ++_iter407)
{
- xfer += oprot->writeString((*_iter378));
+ xfer += oprot->writeString((*_iter407));
}
xfer += oprot->writeListEnd();
}
@@ -8036,14 +8578,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size379;
- ::apache::thrift::protocol::TType _etype382;
- iprot->readListBegin(_etype382, _size379);
- this->success.resize(_size379);
- uint32_t _i383;
- for (_i383 = 0; _i383 < _size379; ++_i383)
+ uint32_t _size408;
+ ::apache::thrift::protocol::TType _etype411;
+ iprot->readListBegin(_etype411, _size408);
+ this->success.resize(_size408);
+ uint32_t _i412;
+ for (_i412 = 0; _i412 < _size408; ++_i412)
{
- xfer += this->success[_i383].read(iprot);
+ xfer += this->success[_i412].read(iprot);
}
iprot->readListEnd();
}
@@ -8090,10 +8632,10 @@
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 _iter384;
- for (_iter384 = this->success.begin(); _iter384 != this->success.end(); ++_iter384)
+ std::vector ::const_iterator _iter413;
+ for (_iter413 = this->success.begin(); _iter413 != this->success.end(); ++_iter413)
{
- xfer += (*_iter384).write(oprot);
+ xfer += (*_iter413).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -8136,14 +8678,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size385;
- ::apache::thrift::protocol::TType _etype388;
- iprot->readListBegin(_etype388, _size385);
- (*(this->success)).resize(_size385);
- uint32_t _i389;
- for (_i389 = 0; _i389 < _size385; ++_i389)
+ uint32_t _size414;
+ ::apache::thrift::protocol::TType _etype417;
+ iprot->readListBegin(_etype417, _size414);
+ (*(this->success)).resize(_size414);
+ uint32_t _i418;
+ for (_i418 = 0; _i418 < _size414; ++_i418)
{
- xfer += (*(this->success))[_i389].read(iprot);
+ xfer += (*(this->success))[_i418].read(iprot);
}
iprot->readListEnd();
}
@@ -8220,14 +8762,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->part_vals.clear();
- uint32_t _size390;
- ::apache::thrift::protocol::TType _etype393;
- iprot->readListBegin(_etype393, _size390);
- this->part_vals.resize(_size390);
- uint32_t _i394;
- for (_i394 = 0; _i394 < _size390; ++_i394)
+ uint32_t _size419;
+ ::apache::thrift::protocol::TType _etype422;
+ iprot->readListBegin(_etype422, _size419);
+ this->part_vals.resize(_size419);
+ uint32_t _i423;
+ for (_i423 = 0; _i423 < _size419; ++_i423)
{
- xfer += iprot->readString(this->part_vals[_i394]);
+ xfer += iprot->readString(this->part_vals[_i423]);
}
iprot->readListEnd();
}
@@ -8268,10 +8810,10 @@
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 _iter395;
- for (_iter395 = this->part_vals.begin(); _iter395 != this->part_vals.end(); ++_iter395)
+ std::vector ::const_iterator _iter424;
+ for (_iter424 = this->part_vals.begin(); _iter424 != this->part_vals.end(); ++_iter424)
{
- xfer += oprot->writeString((*_iter395));
+ xfer += oprot->writeString((*_iter424));
}
xfer += oprot->writeListEnd();
}
@@ -8296,10 +8838,10 @@
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 _iter396;
- for (_iter396 = (*(this->part_vals)).begin(); _iter396 != (*(this->part_vals)).end(); ++_iter396)
+ std::vector ::const_iterator _iter425;
+ for (_iter425 = (*(this->part_vals)).begin(); _iter425 != (*(this->part_vals)).end(); ++_iter425)
{
- xfer += oprot->writeString((*_iter396));
+ xfer += oprot->writeString((*_iter425));
}
xfer += oprot->writeListEnd();
}
@@ -8336,14 +8878,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size397;
- ::apache::thrift::protocol::TType _etype400;
- iprot->readListBegin(_etype400, _size397);
- this->success.resize(_size397);
- uint32_t _i401;
- for (_i401 = 0; _i401 < _size397; ++_i401)
+ uint32_t _size426;
+ ::apache::thrift::protocol::TType _etype429;
+ iprot->readListBegin(_etype429, _size426);
+ this->success.resize(_size426);
+ uint32_t _i430;
+ for (_i430 = 0; _i430 < _size426; ++_i430)
{
- xfer += iprot->readString(this->success[_i401]);
+ xfer += iprot->readString(this->success[_i430]);
}
iprot->readListEnd();
}
@@ -8390,10 +8932,10 @@
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 _iter402;
- for (_iter402 = this->success.begin(); _iter402 != this->success.end(); ++_iter402)
+ std::vector ::const_iterator _iter431;
+ for (_iter431 = this->success.begin(); _iter431 != this->success.end(); ++_iter431)
{
- xfer += oprot->writeString((*_iter402));
+ xfer += oprot->writeString((*_iter431));
}
xfer += oprot->writeListEnd();
}
@@ -8436,14 +8978,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size403;
- ::apache::thrift::protocol::TType _etype406;
- iprot->readListBegin(_etype406, _size403);
- (*(this->success)).resize(_size403);
- uint32_t _i407;
- for (_i407 = 0; _i407 < _size403; ++_i407)
+ uint32_t _size432;
+ ::apache::thrift::protocol::TType _etype435;
+ iprot->readListBegin(_etype435, _size432);
+ (*(this->success)).resize(_size432);
+ uint32_t _i436;
+ for (_i436 = 0; _i436 < _size432; ++_i436)
{
- xfer += iprot->readString((*(this->success))[_i407]);
+ xfer += iprot->readString((*(this->success))[_i436]);
}
iprot->readListEnd();
}
@@ -8608,14 +9150,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size408;
- ::apache::thrift::protocol::TType _etype411;
- iprot->readListBegin(_etype411, _size408);
- this->success.resize(_size408);
- uint32_t _i412;
- for (_i412 = 0; _i412 < _size408; ++_i412)
+ uint32_t _size437;
+ ::apache::thrift::protocol::TType _etype440;
+ iprot->readListBegin(_etype440, _size437);
+ this->success.resize(_size437);
+ uint32_t _i441;
+ for (_i441 = 0; _i441 < _size437; ++_i441)
{
- xfer += this->success[_i412].read(iprot);
+ xfer += this->success[_i441].read(iprot);
}
iprot->readListEnd();
}
@@ -8662,10 +9204,10 @@
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 _iter413;
- for (_iter413 = this->success.begin(); _iter413 != this->success.end(); ++_iter413)
+ std::vector ::const_iterator _iter442;
+ for (_iter442 = this->success.begin(); _iter442 != this->success.end(); ++_iter442)
{
- xfer += (*_iter413).write(oprot);
+ xfer += (*_iter442).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -8708,14 +9250,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size414;
- ::apache::thrift::protocol::TType _etype417;
- iprot->readListBegin(_etype417, _size414);
- (*(this->success)).resize(_size414);
- uint32_t _i418;
- for (_i418 = 0; _i418 < _size414; ++_i418)
+ uint32_t _size443;
+ ::apache::thrift::protocol::TType _etype446;
+ iprot->readListBegin(_etype446, _size443);
+ (*(this->success)).resize(_size443);
+ uint32_t _i447;
+ for (_i447 = 0; _i447 < _size443; ++_i447)
{
- xfer += (*(this->success))[_i418].read(iprot);
+ xfer += (*(this->success))[_i447].read(iprot);
}
iprot->readListEnd();
}
@@ -8792,14 +9334,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->names.clear();
- uint32_t _size419;
- ::apache::thrift::protocol::TType _etype422;
- iprot->readListBegin(_etype422, _size419);
- this->names.resize(_size419);
- uint32_t _i423;
- for (_i423 = 0; _i423 < _size419; ++_i423)
+ uint32_t _size448;
+ ::apache::thrift::protocol::TType _etype451;
+ iprot->readListBegin(_etype451, _size448);
+ this->names.resize(_size448);
+ uint32_t _i452;
+ for (_i452 = 0; _i452 < _size448; ++_i452)
{
- xfer += iprot->readString(this->names[_i423]);
+ xfer += iprot->readString(this->names[_i452]);
}
iprot->readListEnd();
}
@@ -8832,10 +9374,10 @@
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 _iter424;
- for (_iter424 = this->names.begin(); _iter424 != this->names.end(); ++_iter424)
+ std::vector ::const_iterator _iter453;
+ for (_iter453 = this->names.begin(); _iter453 != this->names.end(); ++_iter453)
{
- xfer += oprot->writeString((*_iter424));
+ xfer += oprot->writeString((*_iter453));
}
xfer += oprot->writeListEnd();
}
@@ -8857,10 +9399,10 @@
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 _iter425;
- for (_iter425 = (*(this->names)).begin(); _iter425 != (*(this->names)).end(); ++_iter425)
+ std::vector ::const_iterator _iter454;
+ for (_iter454 = (*(this->names)).begin(); _iter454 != (*(this->names)).end(); ++_iter454)
{
- xfer += oprot->writeString((*_iter425));
+ xfer += oprot->writeString((*_iter454));
}
xfer += oprot->writeListEnd();
}
@@ -8894,14 +9436,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size426;
- ::apache::thrift::protocol::TType _etype429;
- iprot->readListBegin(_etype429, _size426);
- this->success.resize(_size426);
- uint32_t _i430;
- for (_i430 = 0; _i430 < _size426; ++_i430)
+ uint32_t _size455;
+ ::apache::thrift::protocol::TType _etype458;
+ iprot->readListBegin(_etype458, _size455);
+ this->success.resize(_size455);
+ uint32_t _i459;
+ for (_i459 = 0; _i459 < _size455; ++_i459)
{
- xfer += this->success[_i430].read(iprot);
+ xfer += this->success[_i459].read(iprot);
}
iprot->readListEnd();
}
@@ -8948,10 +9490,10 @@
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 _iter431;
- for (_iter431 = this->success.begin(); _iter431 != this->success.end(); ++_iter431)
+ std::vector ::const_iterator _iter460;
+ for (_iter460 = this->success.begin(); _iter460 != this->success.end(); ++_iter460)
{
- xfer += (*_iter431).write(oprot);
+ xfer += (*_iter460).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -8994,14 +9536,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size432;
- ::apache::thrift::protocol::TType _etype435;
- iprot->readListBegin(_etype435, _size432);
- (*(this->success)).resize(_size432);
- uint32_t _i436;
- for (_i436 = 0; _i436 < _size432; ++_i436)
+ uint32_t _size461;
+ ::apache::thrift::protocol::TType _etype464;
+ iprot->readListBegin(_etype464, _size461);
+ (*(this->success)).resize(_size461);
+ uint32_t _i465;
+ for (_i465 = 0; _i465 < _size461; ++_i465)
{
- xfer += (*(this->success))[_i436].read(iprot);
+ xfer += (*(this->success))[_i465].read(iprot);
}
iprot->readListEnd();
}
@@ -9284,14 +9826,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->part_vals.clear();
- uint32_t _size437;
- ::apache::thrift::protocol::TType _etype440;
- iprot->readListBegin(_etype440, _size437);
- this->part_vals.resize(_size437);
- uint32_t _i441;
- for (_i441 = 0; _i441 < _size437; ++_i441)
+ uint32_t _size466;
+ ::apache::thrift::protocol::TType _etype469;
+ iprot->readListBegin(_etype469, _size466);
+ this->part_vals.resize(_size466);
+ uint32_t _i470;
+ for (_i470 = 0; _i470 < _size466; ++_i470)
{
- xfer += iprot->readString(this->part_vals[_i441]);
+ xfer += iprot->readString(this->part_vals[_i470]);
}
iprot->readListEnd();
}
@@ -9332,10 +9874,10 @@
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 _iter442;
- for (_iter442 = this->part_vals.begin(); _iter442 != this->part_vals.end(); ++_iter442)
+ std::vector ::const_iterator _iter471;
+ for (_iter471 = this->part_vals.begin(); _iter471 != this->part_vals.end(); ++_iter471)
{
- xfer += oprot->writeString((*_iter442));
+ xfer += oprot->writeString((*_iter471));
}
xfer += oprot->writeListEnd();
}
@@ -9360,10 +9902,10 @@
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 _iter443;
- for (_iter443 = (*(this->part_vals)).begin(); _iter443 != (*(this->part_vals)).end(); ++_iter443)
+ std::vector ::const_iterator _iter472;
+ for (_iter472 = (*(this->part_vals)).begin(); _iter472 != (*(this->part_vals)).end(); ++_iter472)
{
- xfer += oprot->writeString((*_iter443));
+ xfer += oprot->writeString((*_iter472));
}
xfer += oprot->writeListEnd();
}
@@ -9770,14 +10312,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size444;
- ::apache::thrift::protocol::TType _etype447;
- iprot->readListBegin(_etype447, _size444);
- this->success.resize(_size444);
- uint32_t _i448;
- for (_i448 = 0; _i448 < _size444; ++_i448)
+ uint32_t _size473;
+ ::apache::thrift::protocol::TType _etype476;
+ iprot->readListBegin(_etype476, _size473);
+ this->success.resize(_size473);
+ uint32_t _i477;
+ for (_i477 = 0; _i477 < _size473; ++_i477)
{
- xfer += iprot->readString(this->success[_i448]);
+ xfer += iprot->readString(this->success[_i477]);
}
iprot->readListEnd();
}
@@ -9816,10 +10358,10 @@
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 _iter449;
- for (_iter449 = this->success.begin(); _iter449 != this->success.end(); ++_iter449)
+ std::vector ::const_iterator _iter478;
+ for (_iter478 = this->success.begin(); _iter478 != this->success.end(); ++_iter478)
{
- xfer += oprot->writeString((*_iter449));
+ xfer += oprot->writeString((*_iter478));
}
xfer += oprot->writeListEnd();
}
@@ -9858,14 +10400,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size450;
- ::apache::thrift::protocol::TType _etype453;
- iprot->readListBegin(_etype453, _size450);
- (*(this->success)).resize(_size450);
- uint32_t _i454;
- for (_i454 = 0; _i454 < _size450; ++_i454)
+ uint32_t _size479;
+ ::apache::thrift::protocol::TType _etype482;
+ iprot->readListBegin(_etype482, _size479);
+ (*(this->success)).resize(_size479);
+ uint32_t _i483;
+ for (_i483 = 0; _i483 < _size479; ++_i483)
{
- xfer += iprot->readString((*(this->success))[_i454]);
+ xfer += iprot->readString((*(this->success))[_i483]);
}
iprot->readListEnd();
}
@@ -9980,17 +10522,17 @@
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
this->success.clear();
- uint32_t _size455;
- ::apache::thrift::protocol::TType _ktype456;
- ::apache::thrift::protocol::TType _vtype457;
- iprot->readMapBegin(_ktype456, _vtype457, _size455);
- uint32_t _i459;
- for (_i459 = 0; _i459 < _size455; ++_i459)
+ uint32_t _size484;
+ ::apache::thrift::protocol::TType _ktype485;
+ ::apache::thrift::protocol::TType _vtype486;
+ iprot->readMapBegin(_ktype485, _vtype486, _size484);
+ uint32_t _i488;
+ for (_i488 = 0; _i488 < _size484; ++_i488)
{
- std::string _key460;
- xfer += iprot->readString(_key460);
- std::string& _val461 = this->success[_key460];
- xfer += iprot->readString(_val461);
+ std::string _key489;
+ xfer += iprot->readString(_key489);
+ std::string& _val490 = this->success[_key489];
+ xfer += iprot->readString(_val490);
}
iprot->readMapEnd();
}
@@ -10029,11 +10571,11 @@
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 _iter462;
- for (_iter462 = this->success.begin(); _iter462 != this->success.end(); ++_iter462)
+ std::map ::const_iterator _iter491;
+ for (_iter491 = this->success.begin(); _iter491 != this->success.end(); ++_iter491)
{
- xfer += oprot->writeString(_iter462->first);
- xfer += oprot->writeString(_iter462->second);
+ xfer += oprot->writeString(_iter491->first);
+ xfer += oprot->writeString(_iter491->second);
}
xfer += oprot->writeMapEnd();
}
@@ -10072,17 +10614,17 @@
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
(*(this->success)).clear();
- uint32_t _size463;
- ::apache::thrift::protocol::TType _ktype464;
- ::apache::thrift::protocol::TType _vtype465;
- iprot->readMapBegin(_ktype464, _vtype465, _size463);
- uint32_t _i467;
- for (_i467 = 0; _i467 < _size463; ++_i467)
+ uint32_t _size492;
+ ::apache::thrift::protocol::TType _ktype493;
+ ::apache::thrift::protocol::TType _vtype494;
+ iprot->readMapBegin(_ktype493, _vtype494, _size492);
+ uint32_t _i496;
+ for (_i496 = 0; _i496 < _size492; ++_i496)
{
- std::string _key468;
- xfer += iprot->readString(_key468);
- std::string& _val469 = (*(this->success))[_key468];
- xfer += iprot->readString(_val469);
+ std::string _key497;
+ xfer += iprot->readString(_key497);
+ std::string& _val498 = (*(this->success))[_key497];
+ xfer += iprot->readString(_val498);
}
iprot->readMapEnd();
}
@@ -10151,17 +10693,17 @@
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
this->part_vals.clear();
- uint32_t _size470;
- ::apache::thrift::protocol::TType _ktype471;
- ::apache::thrift::protocol::TType _vtype472;
- iprot->readMapBegin(_ktype471, _vtype472, _size470);
- uint32_t _i474;
- for (_i474 = 0; _i474 < _size470; ++_i474)
+ uint32_t _size499;
+ ::apache::thrift::protocol::TType _ktype500;
+ ::apache::thrift::protocol::TType _vtype501;
+ iprot->readMapBegin(_ktype500, _vtype501, _size499);
+ uint32_t _i503;
+ for (_i503 = 0; _i503 < _size499; ++_i503)
{
- std::string _key475;
- xfer += iprot->readString(_key475);
- std::string& _val476 = this->part_vals[_key475];
- xfer += iprot->readString(_val476);
+ std::string _key504;
+ xfer += iprot->readString(_key504);
+ std::string& _val505 = this->part_vals[_key504];
+ xfer += iprot->readString(_val505);
}
iprot->readMapEnd();
}
@@ -10172,9 +10714,9 @@
break;
case 4:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast477;
- xfer += iprot->readI32(ecast477);
- this->eventType = (PartitionEventType::type)ecast477;
+ int32_t ecast506;
+ xfer += iprot->readI32(ecast506);
+ this->eventType = (PartitionEventType::type)ecast506;
this->__isset.eventType = true;
} else {
xfer += iprot->skip(ftype);
@@ -10204,11 +10746,11 @@
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 _iter478;
- for (_iter478 = this->part_vals.begin(); _iter478 != this->part_vals.end(); ++_iter478)
+ std::map ::const_iterator _iter507;
+ for (_iter507 = this->part_vals.begin(); _iter507 != this->part_vals.end(); ++_iter507)
{
- xfer += oprot->writeString(_iter478->first);
- xfer += oprot->writeString(_iter478->second);
+ xfer += oprot->writeString(_iter507->first);
+ xfer += oprot->writeString(_iter507->second);
}
xfer += oprot->writeMapEnd();
}
@@ -10233,11 +10775,11 @@
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 _iter479;
- for (_iter479 = (*(this->part_vals)).begin(); _iter479 != (*(this->part_vals)).end(); ++_iter479)
+ std::map ::const_iterator _iter508;
+ for (_iter508 = (*(this->part_vals)).begin(); _iter508 != (*(this->part_vals)).end(); ++_iter508)
{
- xfer += oprot->writeString(_iter479->first);
- xfer += oprot->writeString(_iter479->second);
+ xfer += oprot->writeString(_iter508->first);
+ xfer += oprot->writeString(_iter508->second);
}
xfer += oprot->writeMapEnd();
}
@@ -10486,17 +11028,17 @@
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
this->part_vals.clear();
- uint32_t _size480;
- ::apache::thrift::protocol::TType _ktype481;
- ::apache::thrift::protocol::TType _vtype482;
- iprot->readMapBegin(_ktype481, _vtype482, _size480);
- uint32_t _i484;
- for (_i484 = 0; _i484 < _size480; ++_i484)
+ uint32_t _size509;
+ ::apache::thrift::protocol::TType _ktype510;
+ ::apache::thrift::protocol::TType _vtype511;
+ iprot->readMapBegin(_ktype510, _vtype511, _size509);
+ uint32_t _i513;
+ for (_i513 = 0; _i513 < _size509; ++_i513)
{
- std::string _key485;
- xfer += iprot->readString(_key485);
- std::string& _val486 = this->part_vals[_key485];
- xfer += iprot->readString(_val486);
+ std::string _key514;
+ xfer += iprot->readString(_key514);
+ std::string& _val515 = this->part_vals[_key514];
+ xfer += iprot->readString(_val515);
}
iprot->readMapEnd();
}
@@ -10507,9 +11049,9 @@
break;
case 4:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast487;
- xfer += iprot->readI32(ecast487);
- this->eventType = (PartitionEventType::type)ecast487;
+ int32_t ecast516;
+ xfer += iprot->readI32(ecast516);
+ this->eventType = (PartitionEventType::type)ecast516;
this->__isset.eventType = true;
} else {
xfer += iprot->skip(ftype);
@@ -10539,11 +11081,11 @@
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 _iter488;
- for (_iter488 = this->part_vals.begin(); _iter488 != this->part_vals.end(); ++_iter488)
+ std::map ::const_iterator _iter517;
+ for (_iter517 = this->part_vals.begin(); _iter517 != this->part_vals.end(); ++_iter517)
{
- xfer += oprot->writeString(_iter488->first);
- xfer += oprot->writeString(_iter488->second);
+ xfer += oprot->writeString(_iter517->first);
+ xfer += oprot->writeString(_iter517->second);
}
xfer += oprot->writeMapEnd();
}
@@ -10568,11 +11110,11 @@
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 _iter489;
- for (_iter489 = (*(this->part_vals)).begin(); _iter489 != (*(this->part_vals)).end(); ++_iter489)
+ std::map ::const_iterator _iter518;
+ for (_iter518 = (*(this->part_vals)).begin(); _iter518 != (*(this->part_vals)).end(); ++_iter518)
{
- xfer += oprot->writeString(_iter489->first);
- xfer += oprot->writeString(_iter489->second);
+ xfer += oprot->writeString(_iter518->first);
+ xfer += oprot->writeString(_iter518->second);
}
xfer += oprot->writeMapEnd();
}
@@ -11833,14 +12375,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size490;
- ::apache::thrift::protocol::TType _etype493;
- iprot->readListBegin(_etype493, _size490);
- this->success.resize(_size490);
- uint32_t _i494;
- for (_i494 = 0; _i494 < _size490; ++_i494)
+ uint32_t _size519;
+ ::apache::thrift::protocol::TType _etype522;
+ iprot->readListBegin(_etype522, _size519);
+ this->success.resize(_size519);
+ uint32_t _i523;
+ for (_i523 = 0; _i523 < _size519; ++_i523)
{
- xfer += this->success[_i494].read(iprot);
+ xfer += this->success[_i523].read(iprot);
}
iprot->readListEnd();
}
@@ -11887,10 +12429,10 @@
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 _iter495;
- for (_iter495 = this->success.begin(); _iter495 != this->success.end(); ++_iter495)
+ std::vector ::const_iterator _iter524;
+ for (_iter524 = this->success.begin(); _iter524 != this->success.end(); ++_iter524)
{
- xfer += (*_iter495).write(oprot);
+ xfer += (*_iter524).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -11933,14 +12475,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size496;
- ::apache::thrift::protocol::TType _etype499;
- iprot->readListBegin(_etype499, _size496);
- (*(this->success)).resize(_size496);
- uint32_t _i500;
- for (_i500 = 0; _i500 < _size496; ++_i500)
+ uint32_t _size525;
+ ::apache::thrift::protocol::TType _etype528;
+ iprot->readListBegin(_etype528, _size525);
+ (*(this->success)).resize(_size525);
+ uint32_t _i529;
+ for (_i529 = 0; _i529 < _size525; ++_i529)
{
- xfer += (*(this->success))[_i500].read(iprot);
+ xfer += (*(this->success))[_i529].read(iprot);
}
iprot->readListEnd();
}
@@ -12091,14 +12633,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size501;
- ::apache::thrift::protocol::TType _etype504;
- iprot->readListBegin(_etype504, _size501);
- this->success.resize(_size501);
- uint32_t _i505;
- for (_i505 = 0; _i505 < _size501; ++_i505)
+ uint32_t _size530;
+ ::apache::thrift::protocol::TType _etype533;
+ iprot->readListBegin(_etype533, _size530);
+ this->success.resize(_size530);
+ uint32_t _i534;
+ for (_i534 = 0; _i534 < _size530; ++_i534)
{
- xfer += iprot->readString(this->success[_i505]);
+ xfer += iprot->readString(this->success[_i534]);
}
iprot->readListEnd();
}
@@ -12137,10 +12679,10 @@
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 _iter506;
- for (_iter506 = this->success.begin(); _iter506 != this->success.end(); ++_iter506)
+ std::vector ::const_iterator _iter535;
+ for (_iter535 = this->success.begin(); _iter535 != this->success.end(); ++_iter535)
{
- xfer += oprot->writeString((*_iter506));
+ xfer += oprot->writeString((*_iter535));
}
xfer += oprot->writeListEnd();
}
@@ -12179,14 +12721,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size507;
- ::apache::thrift::protocol::TType _etype510;
- iprot->readListBegin(_etype510, _size507);
- (*(this->success)).resize(_size507);
- uint32_t _i511;
- for (_i511 = 0; _i511 < _size507; ++_i511)
+ uint32_t _size536;
+ ::apache::thrift::protocol::TType _etype539;
+ iprot->readListBegin(_etype539, _size536);
+ (*(this->success)).resize(_size536);
+ uint32_t _i540;
+ for (_i540 = 0; _i540 < _size536; ++_i540)
{
- xfer += iprot->readString((*(this->success))[_i511]);
+ xfer += iprot->readString((*(this->success))[_i540]);
}
iprot->readListEnd();
}
@@ -12215,6 +12757,1028 @@
return xfer;
}
+uint32_t ThriftHiveMetastore_create_cluster_args::read(::apache::thrift::protocol::TProtocol* 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_STRUCT) {
+ xfer += this->cluster.read(iprot);
+ this->__isset.cluster = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_create_cluster_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_cluster_args");
+ xfer += oprot->writeFieldBegin("cluster", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->cluster.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_create_cluster_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_cluster_pargs");
+ xfer += oprot->writeFieldBegin("cluster", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += (*(this->cluster)).write(oprot);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_create_cluster_result::read(::apache::thrift::protocol::TProtocol* 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_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_create_cluster_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_cluster_result");
+
+ 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;
+}
+
+uint32_t ThriftHiveMetastore_create_cluster_presult::read(::apache::thrift::protocol::TProtocol* 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_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_drop_cluster_args::read(::apache::thrift::protocol::TProtocol* 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_STRING) {
+ xfer += iprot->readString(this->cluster_name);
+ this->__isset.cluster_name = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_drop_cluster_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_cluster_args");
+ xfer += oprot->writeFieldBegin("cluster_name", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->cluster_name);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_drop_cluster_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_cluster_pargs");
+ xfer += oprot->writeFieldBegin("cluster_name", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString((*(this->cluster_name)));
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_drop_cluster_result::read(::apache::thrift::protocol::TProtocol* 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_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_drop_cluster_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_cluster_result");
+
+ 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;
+}
+
+uint32_t ThriftHiveMetastore_drop_cluster_presult::read(::apache::thrift::protocol::TProtocol* 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_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_get_cluster_args::read(::apache::thrift::protocol::TProtocol* 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_STRING) {
+ xfer += iprot->readString(this->cluster_name);
+ this->__isset.cluster_name = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_get_cluster_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_cluster_args");
+ xfer += oprot->writeFieldBegin("cluster_name", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->cluster_name);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_get_cluster_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_cluster_pargs");
+ xfer += oprot->writeFieldBegin("cluster_name", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString((*(this->cluster_name)));
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_get_cluster_result::read(::apache::thrift::protocol::TProtocol* 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;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_get_cluster_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_cluster_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();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_get_cluster_presult::read(::apache::thrift::protocol::TProtocol* 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;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_list_clusters_args::read(::apache::thrift::protocol::TProtocol* 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)
+ {
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_list_clusters_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_list_clusters_args");
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_list_clusters_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_list_clusters_pargs");
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_list_clusters_result::read(::apache::thrift::protocol::TProtocol* 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_LIST) {
+ {
+ this->success.clear();
+ uint32_t _size541;
+ ::apache::thrift::protocol::TType _etype544;
+ iprot->readListBegin(_etype544, _size541);
+ this->success.resize(_size541);
+ uint32_t _i545;
+ for (_i545 = 0; _i545 < _size541; ++_i545)
+ {
+ xfer += this->success[_i545].read(iprot);
+ }
+ iprot->readListEnd();
+ }
+ 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;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_list_clusters_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_list_clusters_result");
+
+ if (this->__isset.success) {
+ 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 _iter546;
+ for (_iter546 = this->success.begin(); _iter546 != this->success.end(); ++_iter546)
+ {
+ xfer += (*_iter546).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ 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();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_list_clusters_presult::read(::apache::thrift::protocol::TProtocol* 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_LIST) {
+ {
+ (*(this->success)).clear();
+ uint32_t _size547;
+ ::apache::thrift::protocol::TType _etype550;
+ iprot->readListBegin(_etype550, _size547);
+ (*(this->success)).resize(_size547);
+ uint32_t _i551;
+ for (_i551 = 0; _i551 < _size547; ++_i551)
+ {
+ xfer += (*(this->success))[_i551].read(iprot);
+ }
+ iprot->readListEnd();
+ }
+ 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;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_alter_cluster_args::read(::apache::thrift::protocol::TProtocol* 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_STRING) {
+ xfer += iprot->readString(this->cluster_name);
+ this->__isset.cluster_name = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->cluster.read(iprot);
+ this->__isset.cluster = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_alter_cluster_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_cluster_args");
+ xfer += oprot->writeFieldBegin("cluster_name", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->cluster_name);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("cluster", ::apache::thrift::protocol::T_STRUCT, 2);
+ xfer += this->cluster.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_alter_cluster_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_cluster_pargs");
+ xfer += oprot->writeFieldBegin("cluster_name", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString((*(this->cluster_name)));
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("cluster", ::apache::thrift::protocol::T_STRUCT, 2);
+ xfer += (*(this->cluster)).write(oprot);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_alter_cluster_result::read(::apache::thrift::protocol::TProtocol* 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_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;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o4.read(iprot);
+ this->__isset.o4 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_alter_cluster_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_cluster_result");
+
+ 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();
+ } else if (this->__isset.o4) {
+ xfer += oprot->writeFieldBegin("o4", ::apache::thrift::protocol::T_STRUCT, 4);
+ xfer += this->o4.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_alter_cluster_presult::read(::apache::thrift::protocol::TProtocol* 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_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;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o4.read(iprot);
+ this->__isset.o4 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
uint32_t ThriftHiveMetastore_create_role_args::read(::apache::thrift::protocol::TProtocol* iprot) {
uint32_t xfer = 0;
@@ -12643,14 +14207,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size512;
- ::apache::thrift::protocol::TType _etype515;
- iprot->readListBegin(_etype515, _size512);
- this->success.resize(_size512);
- uint32_t _i516;
- for (_i516 = 0; _i516 < _size512; ++_i516)
+ uint32_t _size552;
+ ::apache::thrift::protocol::TType _etype555;
+ iprot->readListBegin(_etype555, _size552);
+ this->success.resize(_size552);
+ uint32_t _i556;
+ for (_i556 = 0; _i556 < _size552; ++_i556)
{
- xfer += iprot->readString(this->success[_i516]);
+ xfer += iprot->readString(this->success[_i556]);
}
iprot->readListEnd();
}
@@ -12689,10 +14253,10 @@
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 _iter517;
- for (_iter517 = this->success.begin(); _iter517 != this->success.end(); ++_iter517)
+ std::vector ::const_iterator _iter557;
+ for (_iter557 = this->success.begin(); _iter557 != this->success.end(); ++_iter557)
{
- xfer += oprot->writeString((*_iter517));
+ xfer += oprot->writeString((*_iter557));
}
xfer += oprot->writeListEnd();
}
@@ -12731,14 +14295,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size518;
- ::apache::thrift::protocol::TType _etype521;
- iprot->readListBegin(_etype521, _size518);
- (*(this->success)).resize(_size518);
- uint32_t _i522;
- for (_i522 = 0; _i522 < _size518; ++_i522)
+ uint32_t _size558;
+ ::apache::thrift::protocol::TType _etype561;
+ iprot->readListBegin(_etype561, _size558);
+ (*(this->success)).resize(_size558);
+ uint32_t _i562;
+ for (_i562 = 0; _i562 < _size558; ++_i562)
{
- xfer += iprot->readString((*(this->success))[_i522]);
+ xfer += iprot->readString((*(this->success))[_i562]);
}
iprot->readListEnd();
}
@@ -12805,9 +14369,9 @@
break;
case 3:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast523;
- xfer += iprot->readI32(ecast523);
- this->principal_type = (PrincipalType::type)ecast523;
+ int32_t ecast563;
+ xfer += iprot->readI32(ecast563);
+ this->principal_type = (PrincipalType::type)ecast563;
this->__isset.principal_type = true;
} else {
xfer += iprot->skip(ftype);
@@ -12823,9 +14387,9 @@
break;
case 5:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast524;
- xfer += iprot->readI32(ecast524);
- this->grantorType = (PrincipalType::type)ecast524;
+ int32_t ecast564;
+ xfer += iprot->readI32(ecast564);
+ this->grantorType = (PrincipalType::type)ecast564;
this->__isset.grantorType = true;
} else {
xfer += iprot->skip(ftype);
@@ -13057,9 +14621,9 @@
break;
case 3:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast525;
- xfer += iprot->readI32(ecast525);
- this->principal_type = (PrincipalType::type)ecast525;
+ int32_t ecast565;
+ xfer += iprot->readI32(ecast565);
+ this->principal_type = (PrincipalType::type)ecast565;
this->__isset.principal_type = true;
} else {
xfer += iprot->skip(ftype);
@@ -13257,9 +14821,9 @@
break;
case 2:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast526;
- xfer += iprot->readI32(ecast526);
- this->principal_type = (PrincipalType::type)ecast526;
+ int32_t ecast566;
+ xfer += iprot->readI32(ecast566);
+ this->principal_type = (PrincipalType::type)ecast566;
this->__isset.principal_type = true;
} else {
xfer += iprot->skip(ftype);
@@ -13329,14 +14893,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size527;
- ::apache::thrift::protocol::TType _etype530;
- iprot->readListBegin(_etype530, _size527);
- this->success.resize(_size527);
- uint32_t _i531;
- for (_i531 = 0; _i531 < _size527; ++_i531)
+ uint32_t _size567;
+ ::apache::thrift::protocol::TType _etype570;
+ iprot->readListBegin(_etype570, _size567);
+ this->success.resize(_size567);
+ uint32_t _i571;
+ for (_i571 = 0; _i571 < _size567; ++_i571)
{
- xfer += this->success[_i531].read(iprot);
+ xfer += this->success[_i571].read(iprot);
}
iprot->readListEnd();
}
@@ -13375,10 +14939,10 @@
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 _iter532;
- for (_iter532 = this->success.begin(); _iter532 != this->success.end(); ++_iter532)
+ std::vector ::const_iterator _iter572;
+ for (_iter572 = this->success.begin(); _iter572 != this->success.end(); ++_iter572)
{
- xfer += (*_iter532).write(oprot);
+ xfer += (*_iter572).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -13417,14 +14981,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size533;
- ::apache::thrift::protocol::TType _etype536;
- iprot->readListBegin(_etype536, _size533);
- (*(this->success)).resize(_size533);
- uint32_t _i537;
- for (_i537 = 0; _i537 < _size533; ++_i537)
+ uint32_t _size573;
+ ::apache::thrift::protocol::TType _etype576;
+ iprot->readListBegin(_etype576, _size573);
+ (*(this->success)).resize(_size573);
+ uint32_t _i577;
+ for (_i577 = 0; _i577 < _size573; ++_i577)
{
- xfer += (*(this->success))[_i537].read(iprot);
+ xfer += (*(this->success))[_i577].read(iprot);
}
iprot->readListEnd();
}
@@ -13493,14 +15057,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->group_names.clear();
- uint32_t _size538;
- ::apache::thrift::protocol::TType _etype541;
- iprot->readListBegin(_etype541, _size538);
- this->group_names.resize(_size538);
- uint32_t _i542;
- for (_i542 = 0; _i542 < _size538; ++_i542)
+ uint32_t _size578;
+ ::apache::thrift::protocol::TType _etype581;
+ iprot->readListBegin(_etype581, _size578);
+ this->group_names.resize(_size578);
+ uint32_t _i582;
+ for (_i582 = 0; _i582 < _size578; ++_i582)
{
- xfer += iprot->readString(this->group_names[_i542]);
+ xfer += iprot->readString(this->group_names[_i582]);
}
iprot->readListEnd();
}
@@ -13533,10 +15097,10 @@
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 _iter543;
- for (_iter543 = this->group_names.begin(); _iter543 != this->group_names.end(); ++_iter543)
+ std::vector ::const_iterator _iter583;
+ for (_iter583 = this->group_names.begin(); _iter583 != this->group_names.end(); ++_iter583)
{
- xfer += oprot->writeString((*_iter543));
+ xfer += oprot->writeString((*_iter583));
}
xfer += oprot->writeListEnd();
}
@@ -13558,10 +15122,10 @@
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 _iter544;
- for (_iter544 = (*(this->group_names)).begin(); _iter544 != (*(this->group_names)).end(); ++_iter544)
+ std::vector ::const_iterator _iter584;
+ for (_iter584 = (*(this->group_names)).begin(); _iter584 != (*(this->group_names)).end(); ++_iter584)
{
- xfer += oprot->writeString((*_iter544));
+ xfer += oprot->writeString((*_iter584));
}
xfer += oprot->writeListEnd();
}
@@ -13717,9 +15281,9 @@
break;
case 2:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast545;
- xfer += iprot->readI32(ecast545);
- this->principal_type = (PrincipalType::type)ecast545;
+ int32_t ecast585;
+ xfer += iprot->readI32(ecast585);
+ this->principal_type = (PrincipalType::type)ecast585;
this->__isset.principal_type = true;
} else {
xfer += iprot->skip(ftype);
@@ -13803,14 +15367,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size546;
- ::apache::thrift::protocol::TType _etype549;
- iprot->readListBegin(_etype549, _size546);
- this->success.resize(_size546);
- uint32_t _i550;
- for (_i550 = 0; _i550 < _size546; ++_i550)
+ uint32_t _size586;
+ ::apache::thrift::protocol::TType _etype589;
+ iprot->readListBegin(_etype589, _size586);
+ this->success.resize(_size586);
+ uint32_t _i590;
+ for (_i590 = 0; _i590 < _size586; ++_i590)
{
- xfer += this->success[_i550].read(iprot);
+ xfer += this->success[_i590].read(iprot);
}
iprot->readListEnd();
}
@@ -13849,10 +15413,10 @@
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 _iter551;
- for (_iter551 = this->success.begin(); _iter551 != this->success.end(); ++_iter551)
+ std::vector ::const_iterator _iter591;
+ for (_iter591 = this->success.begin(); _iter591 != this->success.end(); ++_iter591)
{
- xfer += (*_iter551).write(oprot);
+ xfer += (*_iter591).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -13891,14 +15455,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size552;
- ::apache::thrift::protocol::TType _etype555;
- iprot->readListBegin(_etype555, _size552);
- (*(this->success)).resize(_size552);
- uint32_t _i556;
- for (_i556 = 0; _i556 < _size552; ++_i556)
+ uint32_t _size592;
+ ::apache::thrift::protocol::TType _etype595;
+ iprot->readListBegin(_etype595, _size592);
+ (*(this->success)).resize(_size592);
+ uint32_t _i596;
+ for (_i596 = 0; _i596 < _size592; ++_i596)
{
- xfer += (*(this->success))[_i556].read(iprot);
+ xfer += (*(this->success))[_i596].read(iprot);
}
iprot->readListEnd();
}
@@ -14315,14 +15879,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->group_names.clear();
- uint32_t _size557;
- ::apache::thrift::protocol::TType _etype560;
- iprot->readListBegin(_etype560, _size557);
- this->group_names.resize(_size557);
- uint32_t _i561;
- for (_i561 = 0; _i561 < _size557; ++_i561)
+ uint32_t _size597;
+ ::apache::thrift::protocol::TType _etype600;
+ iprot->readListBegin(_etype600, _size597);
+ this->group_names.resize(_size597);
+ uint32_t _i601;
+ for (_i601 = 0; _i601 < _size597; ++_i601)
{
- xfer += iprot->readString(this->group_names[_i561]);
+ xfer += iprot->readString(this->group_names[_i601]);
}
iprot->readListEnd();
}
@@ -14352,10 +15916,10 @@
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 _iter562;
- for (_iter562 = this->group_names.begin(); _iter562 != this->group_names.end(); ++_iter562)
+ std::vector ::const_iterator _iter602;
+ for (_iter602 = this->group_names.begin(); _iter602 != this->group_names.end(); ++_iter602)
{
- xfer += oprot->writeString((*_iter562));
+ xfer += oprot->writeString((*_iter602));
}
xfer += oprot->writeListEnd();
}
@@ -14374,10 +15938,10 @@
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 _iter563;
- for (_iter563 = (*(this->group_names)).begin(); _iter563 != (*(this->group_names)).end(); ++_iter563)
+ std::vector ::const_iterator _iter603;
+ for (_iter603 = (*(this->group_names)).begin(); _iter603 != (*(this->group_names)).end(); ++_iter603)
{
- xfer += oprot->writeString((*_iter563));
+ xfer += oprot->writeString((*_iter603));
}
xfer += oprot->writeListEnd();
}
@@ -14411,14 +15975,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size564;
- ::apache::thrift::protocol::TType _etype567;
- iprot->readListBegin(_etype567, _size564);
- this->success.resize(_size564);
- uint32_t _i568;
- for (_i568 = 0; _i568 < _size564; ++_i568)
+ uint32_t _size604;
+ ::apache::thrift::protocol::TType _etype607;
+ iprot->readListBegin(_etype607, _size604);
+ this->success.resize(_size604);
+ uint32_t _i608;
+ for (_i608 = 0; _i608 < _size604; ++_i608)
{
- xfer += iprot->readString(this->success[_i568]);
+ xfer += iprot->readString(this->success[_i608]);
}
iprot->readListEnd();
}
@@ -14457,10 +16021,10 @@
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 _iter569;
- for (_iter569 = this->success.begin(); _iter569 != this->success.end(); ++_iter569)
+ std::vector ::const_iterator _iter609;
+ for (_iter609 = this->success.begin(); _iter609 != this->success.end(); ++_iter609)
{
- xfer += oprot->writeString((*_iter569));
+ xfer += oprot->writeString((*_iter609));
}
xfer += oprot->writeListEnd();
}
@@ -14499,14 +16063,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size570;
- ::apache::thrift::protocol::TType _etype573;
- iprot->readListBegin(_etype573, _size570);
- (*(this->success)).resize(_size570);
- uint32_t _i574;
- for (_i574 = 0; _i574 < _size570; ++_i574)
+ uint32_t _size610;
+ ::apache::thrift::protocol::TType _etype613;
+ iprot->readListBegin(_etype613, _size610);
+ (*(this->success)).resize(_size610);
+ uint32_t _i614;
+ for (_i614 = 0; _i614 < _size610; ++_i614)
{
- xfer += iprot->readString((*(this->success))[_i574]);
+ xfer += iprot->readString((*(this->success))[_i614]);
}
iprot->readListEnd();
}
@@ -15952,6 +17516,71 @@
return;
}
+void ThriftHiveMetastoreClient::drop_table_on_cluster(const std::string& cluster_name, const std::string& dbname, const std::string& name, const bool deleteData)
+{
+ send_drop_table_on_cluster(cluster_name, dbname, name, deleteData);
+ recv_drop_table_on_cluster();
+}
+
+void ThriftHiveMetastoreClient::send_drop_table_on_cluster(const std::string& cluster_name, const std::string& dbname, const std::string& name, const bool deleteData)
+{
+ int32_t cseqid = 0;
+ oprot_->writeMessageBegin("drop_table_on_cluster", ::apache::thrift::protocol::T_CALL, cseqid);
+
+ ThriftHiveMetastore_drop_table_on_cluster_pargs args;
+ args.cluster_name = &cluster_name;
+ args.dbname = &dbname;
+ args.name = &name;
+ args.deleteData = &deleteData;
+ args.write(oprot_);
+
+ oprot_->writeMessageEnd();
+ oprot_->getTransport()->writeEnd();
+ oprot_->getTransport()->flush();
+}
+
+void ThriftHiveMetastoreClient::recv_drop_table_on_cluster()
+{
+
+ 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("drop_table_on_cluster") != 0) {
+ iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ }
+ ThriftHiveMetastore_drop_table_on_cluster_presult result;
+ result.read(iprot_);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+
+ if (result.__isset.o1) {
+ throw result.o1;
+ }
+ if (result.__isset.o2) {
+ throw result.o2;
+ }
+ if (result.__isset.o3) {
+ throw result.o3;
+ }
+ return;
+}
+
void ThriftHiveMetastoreClient::get_tables(std::vector & _return, const std::string& db_name, const std::string& pattern)
{
send_get_tables(db_name, pattern);
@@ -16677,6 +18306,77 @@
throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "drop_partition failed: unknown result");
}
+bool ThriftHiveMetastoreClient::drop_partition_on_cluster(const std::string& cluster_name, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const bool deleteData)
+{
+ send_drop_partition_on_cluster(cluster_name, db_name, tbl_name, part_vals, deleteData);
+ return recv_drop_partition_on_cluster();
+}
+
+void ThriftHiveMetastoreClient::send_drop_partition_on_cluster(const std::string& cluster_name, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const bool deleteData)
+{
+ int32_t cseqid = 0;
+ oprot_->writeMessageBegin("drop_partition_on_cluster", ::apache::thrift::protocol::T_CALL, cseqid);
+
+ ThriftHiveMetastore_drop_partition_on_cluster_pargs args;
+ args.cluster_name = &cluster_name;
+ args.db_name = &db_name;
+ args.tbl_name = &tbl_name;
+ args.part_vals = &part_vals;
+ args.deleteData = &deleteData;
+ args.write(oprot_);
+
+ oprot_->writeMessageEnd();
+ oprot_->getTransport()->writeEnd();
+ oprot_->getTransport()->flush();
+}
+
+bool ThriftHiveMetastoreClient::recv_drop_partition_on_cluster()
+{
+
+ 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("drop_partition_on_cluster") != 0) {
+ iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ }
+ bool _return;
+ ThriftHiveMetastore_drop_partition_on_cluster_presult result;
+ result.success = &_return;
+ result.read(iprot_);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+
+ if (result.__isset.success) {
+ return _return;
+ }
+ if (result.__isset.o1) {
+ throw result.o1;
+ }
+ if (result.__isset.o2) {
+ throw result.o2;
+ }
+ if (result.__isset.o3) {
+ throw result.o3;
+ }
+ throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "drop_partition_on_cluster failed: unknown result");
+}
+
bool ThriftHiveMetastoreClient::drop_partition_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const bool deleteData)
{
send_drop_partition_by_name(db_name, tbl_name, part_name, deleteData);
@@ -18329,6 +20029,320 @@
throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_index_names failed: unknown result");
}
+void ThriftHiveMetastoreClient::create_cluster(const Cluster& cluster)
+{
+ send_create_cluster(cluster);
+ recv_create_cluster();
+}
+
+void ThriftHiveMetastoreClient::send_create_cluster(const Cluster& cluster)
+{
+ int32_t cseqid = 0;
+ oprot_->writeMessageBegin("create_cluster", ::apache::thrift::protocol::T_CALL, cseqid);
+
+ ThriftHiveMetastore_create_cluster_pargs args;
+ args.cluster = &cluster;
+ args.write(oprot_);
+
+ oprot_->writeMessageEnd();
+ oprot_->getTransport()->writeEnd();
+ oprot_->getTransport()->flush();
+}
+
+void ThriftHiveMetastoreClient::recv_create_cluster()
+{
+
+ 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("create_cluster") != 0) {
+ iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ }
+ ThriftHiveMetastore_create_cluster_presult result;
+ result.read(iprot_);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+
+ if (result.__isset.o1) {
+ throw result.o1;
+ }
+ if (result.__isset.o2) {
+ throw result.o2;
+ }
+ if (result.__isset.o3) {
+ throw result.o3;
+ }
+ return;
+}
+
+void ThriftHiveMetastoreClient::drop_cluster(const std::string& cluster_name)
+{
+ send_drop_cluster(cluster_name);
+ recv_drop_cluster();
+}
+
+void ThriftHiveMetastoreClient::send_drop_cluster(const std::string& cluster_name)
+{
+ int32_t cseqid = 0;
+ oprot_->writeMessageBegin("drop_cluster", ::apache::thrift::protocol::T_CALL, cseqid);
+
+ ThriftHiveMetastore_drop_cluster_pargs args;
+ args.cluster_name = &cluster_name;
+ args.write(oprot_);
+
+ oprot_->writeMessageEnd();
+ oprot_->getTransport()->writeEnd();
+ oprot_->getTransport()->flush();
+}
+
+void ThriftHiveMetastoreClient::recv_drop_cluster()
+{
+
+ 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("drop_cluster") != 0) {
+ iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ }
+ ThriftHiveMetastore_drop_cluster_presult result;
+ result.read(iprot_);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+
+ if (result.__isset.o1) {
+ throw result.o1;
+ }
+ if (result.__isset.o2) {
+ throw result.o2;
+ }
+ if (result.__isset.o3) {
+ throw result.o3;
+ }
+ return;
+}
+
+void ThriftHiveMetastoreClient::get_cluster(Cluster& _return, const std::string& cluster_name)
+{
+ send_get_cluster(cluster_name);
+ recv_get_cluster(_return);
+}
+
+void ThriftHiveMetastoreClient::send_get_cluster(const std::string& cluster_name)
+{
+ int32_t cseqid = 0;
+ oprot_->writeMessageBegin("get_cluster", ::apache::thrift::protocol::T_CALL, cseqid);
+
+ ThriftHiveMetastore_get_cluster_pargs args;
+ args.cluster_name = &cluster_name;
+ args.write(oprot_);
+
+ oprot_->writeMessageEnd();
+ oprot_->getTransport()->writeEnd();
+ oprot_->getTransport()->flush();
+}
+
+void ThriftHiveMetastoreClient::recv_get_cluster(Cluster& _return)
+{
+
+ 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("get_cluster") != 0) {
+ iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ }
+ ThriftHiveMetastore_get_cluster_presult result;
+ result.success = &_return;
+ result.read(iprot_);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+
+ if (result.__isset.success) {
+ // _return pointer has now been filled
+ return;
+ }
+ if (result.__isset.o1) {
+ throw result.o1;
+ }
+ if (result.__isset.o2) {
+ throw result.o2;
+ }
+ throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_cluster failed: unknown result");
+}
+
+void ThriftHiveMetastoreClient::list_clusters(std::vector & _return)
+{
+ send_list_clusters();
+ recv_list_clusters(_return);
+}
+
+void ThriftHiveMetastoreClient::send_list_clusters()
+{
+ int32_t cseqid = 0;
+ oprot_->writeMessageBegin("list_clusters", ::apache::thrift::protocol::T_CALL, cseqid);
+
+ ThriftHiveMetastore_list_clusters_pargs args;
+ args.write(oprot_);
+
+ oprot_->writeMessageEnd();
+ oprot_->getTransport()->writeEnd();
+ oprot_->getTransport()->flush();
+}
+
+void ThriftHiveMetastoreClient::recv_list_clusters(std::vector & _return)
+{
+
+ 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("list_clusters") != 0) {
+ iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ }
+ ThriftHiveMetastore_list_clusters_presult result;
+ result.success = &_return;
+ result.read(iprot_);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+
+ if (result.__isset.success) {
+ // _return pointer has now been filled
+ return;
+ }
+ if (result.__isset.o1) {
+ throw result.o1;
+ }
+ throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "list_clusters failed: unknown result");
+}
+
+void ThriftHiveMetastoreClient::alter_cluster(const std::string& cluster_name, const Cluster& cluster)
+{
+ send_alter_cluster(cluster_name, cluster);
+ recv_alter_cluster();
+}
+
+void ThriftHiveMetastoreClient::send_alter_cluster(const std::string& cluster_name, const Cluster& cluster)
+{
+ int32_t cseqid = 0;
+ oprot_->writeMessageBegin("alter_cluster", ::apache::thrift::protocol::T_CALL, cseqid);
+
+ ThriftHiveMetastore_alter_cluster_pargs args;
+ args.cluster_name = &cluster_name;
+ args.cluster = &cluster;
+ args.write(oprot_);
+
+ oprot_->writeMessageEnd();
+ oprot_->getTransport()->writeEnd();
+ oprot_->getTransport()->flush();
+}
+
+void ThriftHiveMetastoreClient::recv_alter_cluster()
+{
+
+ 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("alter_cluster") != 0) {
+ iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ }
+ ThriftHiveMetastore_alter_cluster_presult result;
+ result.read(iprot_);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+
+ if (result.__isset.o1) {
+ throw result.o1;
+ }
+ if (result.__isset.o2) {
+ throw result.o2;
+ }
+ if (result.__isset.o3) {
+ throw result.o3;
+ }
+ if (result.__isset.o4) {
+ throw result.o4;
+ }
+ return;
+}
+
bool ThriftHiveMetastoreClient::create_role(const Role& role)
{
send_create_role(role);
@@ -20074,6 +22088,68 @@
}
}
+void ThriftHiveMetastoreProcessor::process_drop_table_on_cluster(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+ void* ctx = NULL;
+ if (eventHandler_.get() != NULL) {
+ ctx = eventHandler_->getContext("ThriftHiveMetastore.drop_table_on_cluster", callContext);
+ }
+ ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "ThriftHiveMetastore.drop_table_on_cluster");
+
+ if (eventHandler_.get() != NULL) {
+ eventHandler_->preRead(ctx, "ThriftHiveMetastore.drop_table_on_cluster");
+ }
+
+ ThriftHiveMetastore_drop_table_on_cluster_args args;
+ args.read(iprot);
+ iprot->readMessageEnd();
+ uint32_t bytes = iprot->getTransport()->readEnd();
+
+ if (eventHandler_.get() != NULL) {
+ eventHandler_->postRead(ctx, "ThriftHiveMetastore.drop_table_on_cluster", bytes);
+ }
+
+ ThriftHiveMetastore_drop_table_on_cluster_result result;
+ try {
+ iface_->drop_table_on_cluster(args.cluster_name, args.dbname, args.name, args.deleteData);
+ } catch (NoSuchObjectException &o1) {
+ result.o1 = o1;
+ result.__isset.o1 = true;
+ } catch (MetaException &o2) {
+ result.o2 = o2;
+ result.__isset.o2 = true;
+ } catch (InvalidOperationException &o3) {
+ result.o3 = o3;
+ result.__isset.o3 = true;
+ } catch (const std::exception& e) {
+ if (eventHandler_.get() != NULL) {
+ eventHandler_->handlerError(ctx, "ThriftHiveMetastore.drop_table_on_cluster");
+ }
+
+ ::apache::thrift::TApplicationException x(e.what());
+ oprot->writeMessageBegin("drop_table_on_cluster", ::apache::thrift::protocol::T_EXCEPTION, seqid);
+ x.write(oprot);
+ oprot->writeMessageEnd();
+ oprot->getTransport()->writeEnd();
+ oprot->getTransport()->flush();
+ return;
+ }
+
+ if (eventHandler_.get() != NULL) {
+ eventHandler_->preWrite(ctx, "ThriftHiveMetastore.drop_table_on_cluster");
+ }
+
+ oprot->writeMessageBegin("drop_table_on_cluster", ::apache::thrift::protocol::T_REPLY, seqid);
+ result.write(oprot);
+ oprot->writeMessageEnd();
+ bytes = oprot->getTransport()->writeEnd();
+ oprot->getTransport()->flush();
+
+ if (eventHandler_.get() != NULL) {
+ eventHandler_->postWrite(ctx, "ThriftHiveMetastore.drop_table_on_cluster", bytes);
+ }
+}
+
void ThriftHiveMetastoreProcessor::process_get_tables(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
{
void* ctx = NULL;
@@ -20745,6 +22821,69 @@
}
}
+void ThriftHiveMetastoreProcessor::process_drop_partition_on_cluster(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+ void* ctx = NULL;
+ if (eventHandler_.get() != NULL) {
+ ctx = eventHandler_->getContext("ThriftHiveMetastore.drop_partition_on_cluster", callContext);
+ }
+ ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "ThriftHiveMetastore.drop_partition_on_cluster");
+
+ if (eventHandler_.get() != NULL) {
+ eventHandler_->preRead(ctx, "ThriftHiveMetastore.drop_partition_on_cluster");
+ }
+
+ ThriftHiveMetastore_drop_partition_on_cluster_args args;
+ args.read(iprot);
+ iprot->readMessageEnd();
+ uint32_t bytes = iprot->getTransport()->readEnd();
+
+ if (eventHandler_.get() != NULL) {
+ eventHandler_->postRead(ctx, "ThriftHiveMetastore.drop_partition_on_cluster", bytes);
+ }
+
+ ThriftHiveMetastore_drop_partition_on_cluster_result result;
+ try {
+ result.success = iface_->drop_partition_on_cluster(args.cluster_name, args.db_name, args.tbl_name, args.part_vals, args.deleteData);
+ result.__isset.success = true;
+ } catch (NoSuchObjectException &o1) {
+ result.o1 = o1;
+ result.__isset.o1 = true;
+ } catch (MetaException &o2) {
+ result.o2 = o2;
+ result.__isset.o2 = true;
+ } catch (InvalidOperationException &o3) {
+ result.o3 = o3;
+ result.__isset.o3 = true;
+ } catch (const std::exception& e) {
+ if (eventHandler_.get() != NULL) {
+ eventHandler_->handlerError(ctx, "ThriftHiveMetastore.drop_partition_on_cluster");
+ }
+
+ ::apache::thrift::TApplicationException x(e.what());
+ oprot->writeMessageBegin("drop_partition_on_cluster", ::apache::thrift::protocol::T_EXCEPTION, seqid);
+ x.write(oprot);
+ oprot->writeMessageEnd();
+ oprot->getTransport()->writeEnd();
+ oprot->getTransport()->flush();
+ return;
+ }
+
+ if (eventHandler_.get() != NULL) {
+ eventHandler_->preWrite(ctx, "ThriftHiveMetastore.drop_partition_on_cluster");
+ }
+
+ oprot->writeMessageBegin("drop_partition_on_cluster", ::apache::thrift::protocol::T_REPLY, seqid);
+ result.write(oprot);
+ oprot->writeMessageEnd();
+ bytes = oprot->getTransport()->writeEnd();
+ oprot->getTransport()->flush();
+
+ if (eventHandler_.get() != NULL) {
+ eventHandler_->postWrite(ctx, "ThriftHiveMetastore.drop_partition_on_cluster", bytes);
+ }
+}
+
void ThriftHiveMetastoreProcessor::process_drop_partition_by_name(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
{
void* ctx = NULL;
@@ -22253,6 +24392,312 @@
}
}
+void ThriftHiveMetastoreProcessor::process_create_cluster(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+ void* ctx = NULL;
+ if (eventHandler_.get() != NULL) {
+ ctx = eventHandler_->getContext("ThriftHiveMetastore.create_cluster", callContext);
+ }
+ ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "ThriftHiveMetastore.create_cluster");
+
+ if (eventHandler_.get() != NULL) {
+ eventHandler_->preRead(ctx, "ThriftHiveMetastore.create_cluster");
+ }
+
+ ThriftHiveMetastore_create_cluster_args args;
+ args.read(iprot);
+ iprot->readMessageEnd();
+ uint32_t bytes = iprot->getTransport()->readEnd();
+
+ if (eventHandler_.get() != NULL) {
+ eventHandler_->postRead(ctx, "ThriftHiveMetastore.create_cluster", bytes);
+ }
+
+ ThriftHiveMetastore_create_cluster_result result;
+ try {
+ iface_->create_cluster(args.cluster);
+ } catch (AlreadyExistsException &o1) {
+ result.o1 = o1;
+ result.__isset.o1 = true;
+ } catch (InvalidObjectException &o2) {
+ result.o2 = o2;
+ result.__isset.o2 = true;
+ } catch (MetaException &o3) {
+ result.o3 = o3;
+ result.__isset.o3 = true;
+ } catch (const std::exception& e) {
+ if (eventHandler_.get() != NULL) {
+ eventHandler_->handlerError(ctx, "ThriftHiveMetastore.create_cluster");
+ }
+
+ ::apache::thrift::TApplicationException x(e.what());
+ oprot->writeMessageBegin("create_cluster", ::apache::thrift::protocol::T_EXCEPTION, seqid);
+ x.write(oprot);
+ oprot->writeMessageEnd();
+ oprot->getTransport()->writeEnd();
+ oprot->getTransport()->flush();
+ return;
+ }
+
+ if (eventHandler_.get() != NULL) {
+ eventHandler_->preWrite(ctx, "ThriftHiveMetastore.create_cluster");
+ }
+
+ oprot->writeMessageBegin("create_cluster", ::apache::thrift::protocol::T_REPLY, seqid);
+ result.write(oprot);
+ oprot->writeMessageEnd();
+ bytes = oprot->getTransport()->writeEnd();
+ oprot->getTransport()->flush();
+
+ if (eventHandler_.get() != NULL) {
+ eventHandler_->postWrite(ctx, "ThriftHiveMetastore.create_cluster", bytes);
+ }
+}
+
+void ThriftHiveMetastoreProcessor::process_drop_cluster(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+ void* ctx = NULL;
+ if (eventHandler_.get() != NULL) {
+ ctx = eventHandler_->getContext("ThriftHiveMetastore.drop_cluster", callContext);
+ }
+ ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "ThriftHiveMetastore.drop_cluster");
+
+ if (eventHandler_.get() != NULL) {
+ eventHandler_->preRead(ctx, "ThriftHiveMetastore.drop_cluster");
+ }
+
+ ThriftHiveMetastore_drop_cluster_args args;
+ args.read(iprot);
+ iprot->readMessageEnd();
+ uint32_t bytes = iprot->getTransport()->readEnd();
+
+ if (eventHandler_.get() != NULL) {
+ eventHandler_->postRead(ctx, "ThriftHiveMetastore.drop_cluster", bytes);
+ }
+
+ ThriftHiveMetastore_drop_cluster_result result;
+ try {
+ iface_->drop_cluster(args.cluster_name);
+ } catch (NoSuchObjectException &o1) {
+ result.o1 = o1;
+ result.__isset.o1 = true;
+ } catch (InvalidOperationException &o2) {
+ result.o2 = o2;
+ result.__isset.o2 = true;
+ } catch (MetaException &o3) {
+ result.o3 = o3;
+ result.__isset.o3 = true;
+ } catch (const std::exception& e) {
+ if (eventHandler_.get() != NULL) {
+ eventHandler_->handlerError(ctx, "ThriftHiveMetastore.drop_cluster");
+ }
+
+ ::apache::thrift::TApplicationException x(e.what());
+ oprot->writeMessageBegin("drop_cluster", ::apache::thrift::protocol::T_EXCEPTION, seqid);
+ x.write(oprot);
+ oprot->writeMessageEnd();
+ oprot->getTransport()->writeEnd();
+ oprot->getTransport()->flush();
+ return;
+ }
+
+ if (eventHandler_.get() != NULL) {
+ eventHandler_->preWrite(ctx, "ThriftHiveMetastore.drop_cluster");
+ }
+
+ oprot->writeMessageBegin("drop_cluster", ::apache::thrift::protocol::T_REPLY, seqid);
+ result.write(oprot);
+ oprot->writeMessageEnd();
+ bytes = oprot->getTransport()->writeEnd();
+ oprot->getTransport()->flush();
+
+ if (eventHandler_.get() != NULL) {
+ eventHandler_->postWrite(ctx, "ThriftHiveMetastore.drop_cluster", bytes);
+ }
+}
+
+void ThriftHiveMetastoreProcessor::process_get_cluster(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+ void* ctx = NULL;
+ if (eventHandler_.get() != NULL) {
+ ctx = eventHandler_->getContext("ThriftHiveMetastore.get_cluster", callContext);
+ }
+ ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "ThriftHiveMetastore.get_cluster");
+
+ if (eventHandler_.get() != NULL) {
+ eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_cluster");
+ }
+
+ ThriftHiveMetastore_get_cluster_args args;
+ args.read(iprot);
+ iprot->readMessageEnd();
+ uint32_t bytes = iprot->getTransport()->readEnd();
+
+ if (eventHandler_.get() != NULL) {
+ eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_cluster", bytes);
+ }
+
+ ThriftHiveMetastore_get_cluster_result result;
+ try {
+ iface_->get_cluster(result.success, args.cluster_name);
+ result.__isset.success = true;
+ } catch (MetaException &o1) {
+ result.o1 = o1;
+ result.__isset.o1 = true;
+ } catch (NoSuchObjectException &o2) {
+ result.o2 = o2;
+ result.__isset.o2 = true;
+ } catch (const std::exception& e) {
+ if (eventHandler_.get() != NULL) {
+ eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_cluster");
+ }
+
+ ::apache::thrift::TApplicationException x(e.what());
+ oprot->writeMessageBegin("get_cluster", ::apache::thrift::protocol::T_EXCEPTION, seqid);
+ x.write(oprot);
+ oprot->writeMessageEnd();
+ oprot->getTransport()->writeEnd();
+ oprot->getTransport()->flush();
+ return;
+ }
+
+ if (eventHandler_.get() != NULL) {
+ eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_cluster");
+ }
+
+ oprot->writeMessageBegin("get_cluster", ::apache::thrift::protocol::T_REPLY, seqid);
+ result.write(oprot);
+ oprot->writeMessageEnd();
+ bytes = oprot->getTransport()->writeEnd();
+ oprot->getTransport()->flush();
+
+ if (eventHandler_.get() != NULL) {
+ eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_cluster", bytes);
+ }
+}
+
+void ThriftHiveMetastoreProcessor::process_list_clusters(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+ void* ctx = NULL;
+ if (eventHandler_.get() != NULL) {
+ ctx = eventHandler_->getContext("ThriftHiveMetastore.list_clusters", callContext);
+ }
+ ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "ThriftHiveMetastore.list_clusters");
+
+ if (eventHandler_.get() != NULL) {
+ eventHandler_->preRead(ctx, "ThriftHiveMetastore.list_clusters");
+ }
+
+ ThriftHiveMetastore_list_clusters_args args;
+ args.read(iprot);
+ iprot->readMessageEnd();
+ uint32_t bytes = iprot->getTransport()->readEnd();
+
+ if (eventHandler_.get() != NULL) {
+ eventHandler_->postRead(ctx, "ThriftHiveMetastore.list_clusters", bytes);
+ }
+
+ ThriftHiveMetastore_list_clusters_result result;
+ try {
+ iface_->list_clusters(result.success);
+ result.__isset.success = true;
+ } catch (MetaException &o1) {
+ result.o1 = o1;
+ result.__isset.o1 = true;
+ } catch (const std::exception& e) {
+ if (eventHandler_.get() != NULL) {
+ eventHandler_->handlerError(ctx, "ThriftHiveMetastore.list_clusters");
+ }
+
+ ::apache::thrift::TApplicationException x(e.what());
+ oprot->writeMessageBegin("list_clusters", ::apache::thrift::protocol::T_EXCEPTION, seqid);
+ x.write(oprot);
+ oprot->writeMessageEnd();
+ oprot->getTransport()->writeEnd();
+ oprot->getTransport()->flush();
+ return;
+ }
+
+ if (eventHandler_.get() != NULL) {
+ eventHandler_->preWrite(ctx, "ThriftHiveMetastore.list_clusters");
+ }
+
+ oprot->writeMessageBegin("list_clusters", ::apache::thrift::protocol::T_REPLY, seqid);
+ result.write(oprot);
+ oprot->writeMessageEnd();
+ bytes = oprot->getTransport()->writeEnd();
+ oprot->getTransport()->flush();
+
+ if (eventHandler_.get() != NULL) {
+ eventHandler_->postWrite(ctx, "ThriftHiveMetastore.list_clusters", bytes);
+ }
+}
+
+void ThriftHiveMetastoreProcessor::process_alter_cluster(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+ void* ctx = NULL;
+ if (eventHandler_.get() != NULL) {
+ ctx = eventHandler_->getContext("ThriftHiveMetastore.alter_cluster", callContext);
+ }
+ ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "ThriftHiveMetastore.alter_cluster");
+
+ if (eventHandler_.get() != NULL) {
+ eventHandler_->preRead(ctx, "ThriftHiveMetastore.alter_cluster");
+ }
+
+ ThriftHiveMetastore_alter_cluster_args args;
+ args.read(iprot);
+ iprot->readMessageEnd();
+ uint32_t bytes = iprot->getTransport()->readEnd();
+
+ if (eventHandler_.get() != NULL) {
+ eventHandler_->postRead(ctx, "ThriftHiveMetastore.alter_cluster", bytes);
+ }
+
+ ThriftHiveMetastore_alter_cluster_result result;
+ try {
+ iface_->alter_cluster(args.cluster_name, args.cluster);
+ } catch (MetaException &o1) {
+ result.o1 = o1;
+ result.__isset.o1 = true;
+ } catch (InvalidObjectException &o2) {
+ result.o2 = o2;
+ result.__isset.o2 = true;
+ } catch (NoSuchObjectException &o3) {
+ result.o3 = o3;
+ result.__isset.o3 = true;
+ } catch (AlreadyExistsException &o4) {
+ result.o4 = o4;
+ result.__isset.o4 = true;
+ } catch (const std::exception& e) {
+ if (eventHandler_.get() != NULL) {
+ eventHandler_->handlerError(ctx, "ThriftHiveMetastore.alter_cluster");
+ }
+
+ ::apache::thrift::TApplicationException x(e.what());
+ oprot->writeMessageBegin("alter_cluster", ::apache::thrift::protocol::T_EXCEPTION, seqid);
+ x.write(oprot);
+ oprot->writeMessageEnd();
+ oprot->getTransport()->writeEnd();
+ oprot->getTransport()->flush();
+ return;
+ }
+
+ if (eventHandler_.get() != NULL) {
+ eventHandler_->preWrite(ctx, "ThriftHiveMetastore.alter_cluster");
+ }
+
+ oprot->writeMessageBegin("alter_cluster", ::apache::thrift::protocol::T_REPLY, seqid);
+ result.write(oprot);
+ oprot->writeMessageEnd();
+ bytes = oprot->getTransport()->writeEnd();
+ oprot->getTransport()->flush();
+
+ if (eventHandler_.get() != NULL) {
+ eventHandler_->postWrite(ctx, "ThriftHiveMetastore.alter_cluster", bytes);
+ }
+}
+
void ThriftHiveMetastoreProcessor::process_create_role(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
{
void* ctx = NULL;
Index: metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
===================================================================
--- metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp (revision 1235046)
+++ metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp (working copy)
@@ -964,10 +964,10 @@
return xfer;
}
-const char* Database::ascii_fingerprint = "213967572143E49C9F1A23F7A866E2F5";
-const uint8_t Database::binary_fingerprint[16] = {0x21,0x39,0x67,0x57,0x21,0x43,0xE4,0x9C,0x9F,0x1A,0x23,0xF7,0xA8,0x66,0xE2,0xF5};
+const char* Cluster::ascii_fingerprint = "6971B678D1662B9E434D9D489082F97C";
+const uint8_t Cluster::binary_fingerprint[16] = {0x69,0x71,0xB6,0x78,0xD1,0x66,0x2B,0x9E,0x43,0x4D,0x9D,0x48,0x90,0x82,0xF9,0x7C};
-uint32_t Database::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t Cluster::read(::apache::thrift::protocol::TProtocol* iprot) {
uint32_t xfer = 0;
std::string fname;
@@ -997,13 +997,21 @@
break;
case 2:
if (ftype == ::apache::thrift::protocol::T_STRING) {
- xfer += iprot->readString(this->description);
- this->__isset.description = true;
+ xfer += iprot->readString(this->comment);
+ this->__isset.comment = true;
} else {
xfer += iprot->skip(ftype);
}
break;
case 3:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ xfer += iprot->readI32(this->createTime);
+ this->__isset.createTime = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
if (ftype == ::apache::thrift::protocol::T_STRING) {
xfer += iprot->readString(this->locationUri);
this->__isset.locationUri = true;
@@ -1011,7 +1019,7 @@
xfer += iprot->skip(ftype);
}
break;
- case 4:
+ case 5:
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
this->parameters.clear();
@@ -1034,7 +1042,243 @@
xfer += iprot->skip(ftype);
}
break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Cluster::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Cluster");
+ xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->name);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("comment", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->comment);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("createTime", ::apache::thrift::protocol::T_I32, 3);
+ xfer += oprot->writeI32(this->createTime);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("locationUri", ::apache::thrift::protocol::T_STRING, 4);
+ xfer += oprot->writeString(this->locationUri);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 5);
+ {
+ xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->parameters.size()));
+ std::map ::const_iterator _iter70;
+ for (_iter70 = this->parameters.begin(); _iter70 != this->parameters.end(); ++_iter70)
+ {
+ xfer += oprot->writeString(_iter70->first);
+ xfer += oprot->writeString(_iter70->second);
+ }
+ xfer += oprot->writeMapEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+const char* ClusterStorageDescriptor::ascii_fingerprint = "F831BE62975A31F6DF2D936BBB5998A3";
+const uint8_t ClusterStorageDescriptor::binary_fingerprint[16] = {0xF8,0x31,0xBE,0x62,0x97,0x5A,0x31,0xF6,0xDF,0x2D,0x93,0x6B,0xBB,0x59,0x98,0xA3};
+
+uint32_t ClusterStorageDescriptor::read(::apache::thrift::protocol::TProtocol* 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_STRUCT) {
+ xfer += this->cluster.read(iprot);
+ this->__isset.cluster = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->location);
+ this->__isset.location = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->primary);
+ this->__isset.primary = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->dataSynced);
+ this->__isset.dataSynced = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
case 5:
+ if (ftype == ::apache::thrift::protocol::T_MAP) {
+ {
+ this->parameters.clear();
+ uint32_t _size71;
+ ::apache::thrift::protocol::TType _ktype72;
+ ::apache::thrift::protocol::TType _vtype73;
+ iprot->readMapBegin(_ktype72, _vtype73, _size71);
+ uint32_t _i75;
+ for (_i75 = 0; _i75 < _size71; ++_i75)
+ {
+ std::string _key76;
+ xfer += iprot->readString(_key76);
+ std::string& _val77 = this->parameters[_key76];
+ xfer += iprot->readString(_val77);
+ }
+ iprot->readMapEnd();
+ }
+ this->__isset.parameters = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t ClusterStorageDescriptor::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ClusterStorageDescriptor");
+ xfer += oprot->writeFieldBegin("cluster", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->cluster.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("location", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->location);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("primary", ::apache::thrift::protocol::T_BOOL, 3);
+ xfer += oprot->writeBool(this->primary);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("dataSynced", ::apache::thrift::protocol::T_BOOL, 4);
+ xfer += oprot->writeBool(this->dataSynced);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 5);
+ {
+ xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->parameters.size()));
+ std::map ::const_iterator _iter78;
+ for (_iter78 = this->parameters.begin(); _iter78 != this->parameters.end(); ++_iter78)
+ {
+ xfer += oprot->writeString(_iter78->first);
+ xfer += oprot->writeString(_iter78->second);
+ }
+ xfer += oprot->writeMapEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+const char* Database::ascii_fingerprint = "213967572143E49C9F1A23F7A866E2F5";
+const uint8_t Database::binary_fingerprint[16] = {0x21,0x39,0x67,0x57,0x21,0x43,0xE4,0x9C,0x9F,0x1A,0x23,0xF7,0xA8,0x66,0xE2,0xF5};
+
+uint32_t Database::read(::apache::thrift::protocol::TProtocol* 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_STRING) {
+ xfer += iprot->readString(this->name);
+ this->__isset.name = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->description);
+ this->__isset.description = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->locationUri);
+ this->__isset.locationUri = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_MAP) {
+ {
+ this->parameters.clear();
+ uint32_t _size79;
+ ::apache::thrift::protocol::TType _ktype80;
+ ::apache::thrift::protocol::TType _vtype81;
+ iprot->readMapBegin(_ktype80, _vtype81, _size79);
+ uint32_t _i83;
+ for (_i83 = 0; _i83 < _size79; ++_i83)
+ {
+ std::string _key84;
+ xfer += iprot->readString(_key84);
+ std::string& _val85 = this->parameters[_key84];
+ xfer += iprot->readString(_val85);
+ }
+ iprot->readMapEnd();
+ }
+ this->__isset.parameters = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 5:
if (ftype == ::apache::thrift::protocol::T_STRUCT) {
xfer += this->privileges.read(iprot);
this->__isset.privileges = true;
@@ -1069,11 +1313,11 @@
xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 4);
{
xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->parameters.size()));
- std::map ::const_iterator _iter70;
- for (_iter70 = this->parameters.begin(); _iter70 != this->parameters.end(); ++_iter70)
+ std::map ::const_iterator _iter86;
+ for (_iter86 = this->parameters.begin(); _iter86 != this->parameters.end(); ++_iter86)
{
- xfer += oprot->writeString(_iter70->first);
- xfer += oprot->writeString(_iter70->second);
+ xfer += oprot->writeString(_iter86->first);
+ xfer += oprot->writeString(_iter86->second);
}
xfer += oprot->writeMapEnd();
}
@@ -1131,17 +1375,17 @@
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
this->parameters.clear();
- uint32_t _size71;
- ::apache::thrift::protocol::TType _ktype72;
- ::apache::thrift::protocol::TType _vtype73;
- iprot->readMapBegin(_ktype72, _vtype73, _size71);
- uint32_t _i75;
- for (_i75 = 0; _i75 < _size71; ++_i75)
+ uint32_t _size87;
+ ::apache::thrift::protocol::TType _ktype88;
+ ::apache::thrift::protocol::TType _vtype89;
+ iprot->readMapBegin(_ktype88, _vtype89, _size87);
+ uint32_t _i91;
+ for (_i91 = 0; _i91 < _size87; ++_i91)
{
- std::string _key76;
- xfer += iprot->readString(_key76);
- std::string& _val77 = this->parameters[_key76];
- xfer += iprot->readString(_val77);
+ std::string _key92;
+ xfer += iprot->readString(_key92);
+ std::string& _val93 = this->parameters[_key92];
+ xfer += iprot->readString(_val93);
}
iprot->readMapEnd();
}
@@ -1174,11 +1418,11 @@
xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 3);
{
xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->parameters.size()));
- std::map ::const_iterator _iter78;
- for (_iter78 = this->parameters.begin(); _iter78 != this->parameters.end(); ++_iter78)
+ std::map ::const_iterator _iter94;
+ for (_iter94 = this->parameters.begin(); _iter94 != this->parameters.end(); ++_iter94)
{
- xfer += oprot->writeString(_iter78->first);
- xfer += oprot->writeString(_iter78->second);
+ xfer += oprot->writeString(_iter94->first);
+ xfer += oprot->writeString(_iter94->second);
}
xfer += oprot->writeMapEnd();
}
@@ -1253,8 +1497,8 @@
return xfer;
}
-const char* StorageDescriptor::ascii_fingerprint = "11E4CE18F895C13812C853DFDCD1293F";
-const uint8_t StorageDescriptor::binary_fingerprint[16] = {0x11,0xE4,0xCE,0x18,0xF8,0x95,0xC1,0x38,0x12,0xC8,0x53,0xDF,0xDC,0xD1,0x29,0x3F};
+const char* StorageDescriptor::ascii_fingerprint = "6E2134C82A6349BD16FC74AAA1974949";
+const uint8_t StorageDescriptor::binary_fingerprint[16] = {0x6E,0x21,0x34,0xC8,0x2A,0x63,0x49,0xBD,0x16,0xFC,0x74,0xAA,0xA1,0x97,0x49,0x49};
uint32_t StorageDescriptor::read(::apache::thrift::protocol::TProtocol* iprot) {
@@ -1280,14 +1524,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->cols.clear();
- uint32_t _size79;
- ::apache::thrift::protocol::TType _etype82;
- iprot->readListBegin(_etype82, _size79);
- this->cols.resize(_size79);
- uint32_t _i83;
- for (_i83 = 0; _i83 < _size79; ++_i83)
+ uint32_t _size95;
+ ::apache::thrift::protocol::TType _etype98;
+ iprot->readListBegin(_etype98, _size95);
+ this->cols.resize(_size95);
+ uint32_t _i99;
+ for (_i99 = 0; _i99 < _size95; ++_i99)
{
- xfer += this->cols[_i83].read(iprot);
+ xfer += this->cols[_i99].read(iprot);
}
iprot->readListEnd();
}
@@ -1348,14 +1592,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->bucketCols.clear();
- uint32_t _size84;
- ::apache::thrift::protocol::TType _etype87;
- iprot->readListBegin(_etype87, _size84);
- this->bucketCols.resize(_size84);
- uint32_t _i88;
- for (_i88 = 0; _i88 < _size84; ++_i88)
+ uint32_t _size100;
+ ::apache::thrift::protocol::TType _etype103;
+ iprot->readListBegin(_etype103, _size100);
+ this->bucketCols.resize(_size100);
+ uint32_t _i104;
+ for (_i104 = 0; _i104 < _size100; ++_i104)
{
- xfer += iprot->readString(this->bucketCols[_i88]);
+ xfer += iprot->readString(this->bucketCols[_i104]);
}
iprot->readListEnd();
}
@@ -1368,14 +1612,14 @@
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->sortCols.clear();
- uint32_t _size89;
- ::apache::thrift::protocol::TType _etype92;
- iprot->readListBegin(_etype92, _size89);
- this->sortCols.resize(_size89);
- uint32_t _i93;
- for (_i93 = 0; _i93 < _size89; ++_i93)
+ uint32_t _size105;
+ ::apache::thrift::protocol::TType _etype108;
+ iprot->readListBegin(_etype108, _size105);
+ this->sortCols.resize(_size105);
+ uint32_t _i109;
+ for (_i109 = 0; _i109 < _size105; ++_i109)
{
- xfer += this->sortCols[_i93].read(iprot);
+ xfer += this->sortCols[_i109].read(iprot);
}
iprot->readListEnd();
}
@@ -1388,17 +1632,17 @@
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
this->parameters.clear();
- uint32_t _size94;
- ::apache::thrift::protocol::TType _ktype95;
- ::apache::thrift::protocol::TType _vtype96;
- iprot->readMapBegin(_ktype95, _vtype96, _size94);
- uint32_t _i98;
- for (_i98 = 0; _i98 < _size94; ++_i98)
+ uint32_t _size110;
+ ::apache::thrift::protocol::TType _ktype111;
+ ::apache::thrift::protocol::TType _vtype112;
+ iprot->readMapBegin(_ktype111, _vtype112, _size110);
+ uint32_t _i114;
+ for (_i114 = 0; _i114 < _size110; ++_i114)
{
- std::string _key99;
- xfer += iprot->readString(_key99);
- std::string& _val100 = this->parameters[_key99];
- xfer += iprot->readString(_val100);
+ std::string _key115;
+ xfer += iprot->readString(_key115);
+ std::string& _val116 = this->parameters[_key115];
+ xfer += iprot->readString(_val116);
}
iprot->readMapEnd();
}
@@ -1407,6 +1651,26 @@
xfer += iprot->skip(ftype);
}
break;
+ case 11:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->clusterStorage.clear();
+ uint32_t _size117;
+ ::apache::thrift::protocol::TType _etype120;
+ iprot->readListBegin(_etype120, _size117);
+ this->clusterStorage.resize(_size117);
+ uint32_t _i121;
+ for (_i121 = 0; _i121 < _size117; ++_i121)
+ {
+ xfer += this->clusterStorage[_i121].read(iprot);
+ }
+ iprot->readListEnd();
+ }
+ this->__isset.clusterStorage = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
default:
xfer += iprot->skip(ftype);
break;
@@ -1425,10 +1689,10 @@
xfer += oprot->writeFieldBegin("cols", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->cols.size()));
- std::vector ::const_iterator _iter101;
- for (_iter101 = this->cols.begin(); _iter101 != this->cols.end(); ++_iter101)
+ std::vector ::const_iterator _iter122;
+ for (_iter122 = this->cols.begin(); _iter122 != this->cols.end(); ++_iter122)
{
- xfer += (*_iter101).write(oprot);
+ xfer += (*_iter122).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -1454,10 +1718,10 @@
xfer += oprot->writeFieldBegin("bucketCols", ::apache::thrift::protocol::T_LIST, 8);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast