diff --git itests/hcatalog-unit/src/test/java/org/apache/hive/hcatalog/listener/DummyRawStoreFailEvent.java itests/hcatalog-unit/src/test/java/org/apache/hive/hcatalog/listener/DummyRawStoreFailEvent.java index 431186e39e..5a627ce6bc 100644 --- itests/hcatalog-unit/src/test/java/org/apache/hive/hcatalog/listener/DummyRawStoreFailEvent.java +++ itests/hcatalog-unit/src/test/java/org/apache/hive/hcatalog/listener/DummyRawStoreFailEvent.java @@ -20,7 +20,6 @@ import java.nio.ByteBuffer; import java.util.ArrayList; -import java.util.Collection; import java.util.Collections; import java.util.List; import java.util.Map; @@ -32,6 +31,7 @@ import org.apache.hadoop.hive.metastore.RawStore; import org.apache.hadoop.hive.metastore.TableType; import org.apache.hadoop.hive.metastore.api.AggrStats; +import org.apache.hadoop.hive.metastore.api.AlreadyExistsException; import org.apache.hadoop.hive.metastore.api.ColumnStatistics; import org.apache.hadoop.hive.metastore.api.ColumnStatisticsObj; import org.apache.hadoop.hive.metastore.api.CurrentNotificationEventId; @@ -59,6 +59,7 @@ import org.apache.hadoop.hive.metastore.api.PrincipalType; import org.apache.hadoop.hive.metastore.api.PrivilegeBag; import org.apache.hadoop.hive.metastore.api.WMResourcePlan; +import org.apache.hadoop.hive.metastore.api.WMTrigger; import org.apache.hadoop.hive.metastore.api.Role; import org.apache.hadoop.hive.metastore.api.RolePrincipalGrant; import org.apache.hadoop.hive.metastore.api.SQLForeignKey; @@ -978,7 +979,8 @@ public String getMetastoreDbUuid() throws MetaException { } @Override - public void createResourcePlan(WMResourcePlan resourcePlan) throws MetaException { + public void createResourcePlan(WMResourcePlan resourcePlan) + throws AlreadyExistsException, MetaException { objectStore.createResourcePlan(resourcePlan); } @@ -994,7 +996,8 @@ public WMResourcePlan getResourcePlan(String name) throws NoSuchObjectException @Override public void alterResourcePlan(String name, WMResourcePlan resourcePlan) - throws NoSuchObjectException, InvalidOperationException, MetaException { + throws AlreadyExistsException, NoSuchObjectException, InvalidOperationException, + MetaException { objectStore.alterResourcePlan(name, resourcePlan); } @@ -1008,4 +1011,29 @@ public boolean validateResourcePlan(String name) public void dropResourcePlan(String name) throws NoSuchObjectException, MetaException { objectStore.dropResourcePlan(name); } + + @Override + public void createWMTrigger(WMTrigger trigger) + throws AlreadyExistsException, MetaException, NoSuchObjectException, + InvalidOperationException { + objectStore.createWMTrigger(trigger); + } + + @Override + public void alterWMTrigger(WMTrigger trigger) + throws NoSuchObjectException, InvalidOperationException, MetaException { + objectStore.alterWMTrigger(trigger); + } + + @Override + public void dropWMTrigger(String resourcePlanName, String triggerName) + throws NoSuchObjectException, InvalidOperationException, MetaException { + objectStore.dropWMTrigger(resourcePlanName, triggerName); + } + + @Override + public List getTriggersForResourcePlan(String resourcePlanName) + throws NoSuchObjectException, MetaException { + return objectStore.getTriggersForResourcePlan(resourcePlanName); + } } diff --git metastore/scripts/upgrade/hive/hive-schema-3.0.0.hive.sql metastore/scripts/upgrade/hive/hive-schema-3.0.0.hive.sql index ca7af06e7a..c1578fcda9 100644 --- metastore/scripts/upgrade/hive/hive-schema-3.0.0.hive.sql +++ metastore/scripts/upgrade/hive/hive-schema-3.0.0.hive.sql @@ -964,6 +964,29 @@ FROM \"WM_RESOURCEPLAN\"" ); +CREATE TABLE IF NOT EXISTS `WM_TRIGGERS` ( + `RP_NAME` string, + `NAME` string, + `TRIGGER_EXPRESSION` string, + `ACTION_EXPRESSION` string +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + r.NAME RP_NAME, + t.NAME NAME, + TRIGGER_EXPRESSION, + ACTION_EXPRESSION +FROM + WM_TRIGGER t +JOIN + WM_RESOURCEPLAN r +ON + t.RP_ID = r.RP_ID" +); + DROP DATABASE IF EXISTS INFORMATION_SCHEMA; CREATE DATABASE INFORMATION_SCHEMA; diff --git metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java index 6783e5bc96..7337c1ca6c 100644 --- metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java +++ metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java @@ -7453,11 +7453,62 @@ public WMDropResourcePlanResponse drop_resource_plan(WMDropResourcePlanRequest r try { getMS().dropResourcePlan(request.getResourcePlanName()); return new WMDropResourcePlanResponse(); + } catch (MetaException e) { + LOG.error("Exception while trying to drop resource plan", e); + throw e; + } + } + + @Override + public WMCreateTriggerResponse create_wm_trigger(WMCreateTriggerRequest request) + throws AlreadyExistsException, InvalidObjectException, MetaException, TException { + try { + getMS().createWMTrigger(request.getTrigger()); + return new WMCreateTriggerResponse(); + } catch (MetaException e) { + LOG.error("Exception while trying to create trigger", e); + throw e; + } + } + + @Override + public WMAlterTriggerResponse alter_wm_trigger(WMAlterTriggerRequest request) + throws NoSuchObjectException, InvalidObjectException, MetaException, TException { + try { + getMS().alterWMTrigger(request.getTrigger()); + return new WMAlterTriggerResponse(); + } catch (MetaException e) { + LOG.error("Exception while trying to alter trigger", e); + throw e; + } + } + + @Override + public WMDropTriggerResponse drop_wm_trigger(WMDropTriggerRequest request) + throws NoSuchObjectException, InvalidOperationException, MetaException, TException { + try { + getMS().dropWMTrigger(request.getResourcePlanName(), request.getTriggerName()); + return new WMDropTriggerResponse(); } catch (MetaException e) { LOG.error("Exception while trying to retrieve resource plans", e); throw e; } } + + @Override + public WMGetTriggersForResourePlanResponse get_triggers_for_resourceplan( + WMGetTriggersForResourePlanRequest request) + throws NoSuchObjectException, MetaException, TException { + try { + List triggers = getMS().getTriggersForResourcePlan(request.getResourcePlanName()); + WMGetTriggersForResourePlanResponse response = new WMGetTriggersForResourePlanResponse(); + response.setTriggers(triggers); + return response; + } catch (MetaException e) { + LOG.error("Exception while trying to retrieve triggers plans", e); + throw e; + } + } } public static IHMSHandler newRetryingHMSHandler(IHMSHandler baseHandler, HiveConf hiveConf) diff --git metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java index 0e24ba70b6..dfb0a6d6aa 100644 --- metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java +++ metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java @@ -2683,4 +2683,37 @@ public boolean validateResourcePlan(String resourcePlanName) request.setResourcePlanName(resourcePlanName); return client.validate_resource_plan(request).isIsValid(); } + + @Override + public void createWMTrigger(WMTrigger trigger) + throws InvalidObjectException, MetaException, TException { + WMCreateTriggerRequest request = new WMCreateTriggerRequest(); + request.setTrigger(trigger); + client.create_wm_trigger(request); + } + + @Override + public void alterWMTrigger(WMTrigger trigger) + throws NoSuchObjectException, InvalidObjectException, MetaException, TException { + WMAlterTriggerRequest request = new WMAlterTriggerRequest(); + request.setTrigger(trigger); + client.alter_wm_trigger(request); + } + + @Override + public void dropWMTrigger(String resourcePlanName, String triggerName) + throws NoSuchObjectException, MetaException, TException { + WMDropTriggerRequest request = new WMDropTriggerRequest(); + request.setResourcePlanName(resourcePlanName); + request.setTriggerName(triggerName); + client.drop_wm_trigger(request); + } + + @Override + public List getTriggersForResourcePlan(String resourcePlan) + throws NoSuchObjectException, MetaException, TException { + WMGetTriggersForResourePlanRequest request = new WMGetTriggersForResourePlanRequest(); + request.setResourcePlanName(resourcePlan); + return client.get_triggers_for_resourceplan(request).getTriggers(); + } } diff --git metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java index 62a3735a68..5aa20c582b 100644 --- metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java +++ metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java @@ -87,6 +87,7 @@ import org.apache.hadoop.hive.metastore.api.PrincipalType; import org.apache.hadoop.hive.metastore.api.PrivilegeBag; import org.apache.hadoop.hive.metastore.api.WMResourcePlan; +import org.apache.hadoop.hive.metastore.api.WMTrigger; import org.apache.hadoop.hive.metastore.api.Role; import org.apache.hadoop.hive.metastore.api.SQLForeignKey; import org.apache.hadoop.hive.metastore.api.SQLNotNullConstraint; @@ -1784,4 +1785,16 @@ void alterResourcePlan(String resourcePlanName, WMResourcePlan resourcePlan) boolean validateResourcePlan(String resourcePlanName) throws NoSuchObjectException, InvalidObjectException, MetaException, TException; + + void createWMTrigger(WMTrigger trigger) + throws InvalidObjectException, MetaException, TException; + + void alterWMTrigger(WMTrigger trigger) + throws NoSuchObjectException, InvalidObjectException, MetaException, TException; + + void dropWMTrigger(String resourcePlanName, String triggerName) + throws NoSuchObjectException, MetaException, TException; + + List getTriggersForResourcePlan(String resourcePlan) + throws NoSuchObjectException, MetaException, TException; } diff --git metastore/src/test/org/apache/hadoop/hive/metastore/DummyRawStoreControlledCommit.java metastore/src/test/org/apache/hadoop/hive/metastore/DummyRawStoreControlledCommit.java index a6f4ee2f56..610b9fafd5 100644 --- metastore/src/test/org/apache/hadoop/hive/metastore/DummyRawStoreControlledCommit.java +++ metastore/src/test/org/apache/hadoop/hive/metastore/DummyRawStoreControlledCommit.java @@ -27,6 +27,7 @@ import org.apache.hadoop.conf.Configurable; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hive.metastore.api.AggrStats; +import org.apache.hadoop.hive.metastore.api.AlreadyExistsException; import org.apache.hadoop.hive.metastore.api.ColumnStatistics; import org.apache.hadoop.hive.metastore.api.ColumnStatisticsObj; import org.apache.hadoop.hive.metastore.api.CurrentNotificationEventId; @@ -54,6 +55,7 @@ import org.apache.hadoop.hive.metastore.api.PrincipalType; import org.apache.hadoop.hive.metastore.api.PrivilegeBag; import org.apache.hadoop.hive.metastore.api.WMResourcePlan; +import org.apache.hadoop.hive.metastore.api.WMTrigger; import org.apache.hadoop.hive.metastore.api.Role; import org.apache.hadoop.hive.metastore.api.RolePrincipalGrant; import org.apache.hadoop.hive.metastore.api.SQLForeignKey; @@ -937,7 +939,8 @@ public String getMetastoreDbUuid() throws MetaException { } @Override - public void createResourcePlan(WMResourcePlan resourcePlan) throws MetaException { + public void createResourcePlan(WMResourcePlan resourcePlan) + throws AlreadyExistsException, MetaException { objectStore.createResourcePlan(resourcePlan); } @@ -953,7 +956,8 @@ public WMResourcePlan getResourcePlan(String name) throws NoSuchObjectException @Override public void alterResourcePlan(String name, WMResourcePlan resourcePlan) - throws NoSuchObjectException, InvalidOperationException, MetaException { + throws AlreadyExistsException, NoSuchObjectException, InvalidOperationException, + MetaException { objectStore.alterResourcePlan(name, resourcePlan); } @@ -967,4 +971,29 @@ public boolean validateResourcePlan(String name) public void dropResourcePlan(String name) throws NoSuchObjectException, MetaException { objectStore.dropResourcePlan(name); } + + @Override + public void createWMTrigger(WMTrigger trigger) + throws AlreadyExistsException, MetaException, NoSuchObjectException, + InvalidOperationException { + objectStore.createWMTrigger(trigger); + } + + @Override + public void alterWMTrigger(WMTrigger trigger) + throws NoSuchObjectException, InvalidOperationException, MetaException { + objectStore.alterWMTrigger(trigger); + } + + @Override + public void dropWMTrigger(String resourcePlanName, String triggerName) + throws NoSuchObjectException, InvalidOperationException, MetaException { + objectStore.dropWMTrigger(resourcePlanName, triggerName); + } + + @Override + public List getTriggersForResourcePlan(String resourcePlanName) + throws NoSuchObjectException, MetaException { + return objectStore.getTriggersForResourcePlan(resourcePlanName); + } } diff --git metastore/src/test/org/apache/hadoop/hive/metastore/DummyRawStoreForJdoConnection.java metastore/src/test/org/apache/hadoop/hive/metastore/DummyRawStoreForJdoConnection.java index 320ade19ad..84b70d88b0 100644 --- metastore/src/test/org/apache/hadoop/hive/metastore/DummyRawStoreForJdoConnection.java +++ metastore/src/test/org/apache/hadoop/hive/metastore/DummyRawStoreForJdoConnection.java @@ -55,6 +55,7 @@ import org.apache.hadoop.hive.metastore.api.PrincipalType; import org.apache.hadoop.hive.metastore.api.PrivilegeBag; import org.apache.hadoop.hive.metastore.api.WMResourcePlan; +import org.apache.hadoop.hive.metastore.api.WMTrigger; import org.apache.hadoop.hive.metastore.api.Role; import org.apache.hadoop.hive.metastore.api.RolePrincipalGrant; import org.apache.hadoop.hive.metastore.api.SQLForeignKey; @@ -977,4 +978,24 @@ public boolean validateResourcePlan(String name) @Override public void dropResourcePlan(String name) throws NoSuchObjectException, MetaException { } + + @Override + public void createWMTrigger(WMTrigger trigger) throws MetaException { + } + + @Override + public void alterWMTrigger(WMTrigger trigger) + throws NoSuchObjectException, InvalidOperationException, MetaException { + } + + @Override + public void dropWMTrigger(String resourcePlanName, String triggerName) + throws NoSuchObjectException, MetaException { + } + + @Override + public List getTriggersForResourcePlan(String resourcePlanName) + throws NoSuchObjectException, MetaException { + return null; + } } diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/DDLTask.java ql/src/java/org/apache/hadoop/hive/ql/exec/DDLTask.java index 87f6e1d64e..17bb474a88 100644 --- ql/src/java/org/apache/hadoop/hive/ql/exec/DDLTask.java +++ ql/src/java/org/apache/hadoop/hive/ql/exec/DDLTask.java @@ -20,7 +20,6 @@ import static org.apache.commons.lang.StringUtils.join; import static org.apache.hadoop.hive.metastore.api.hive_metastoreConstants.META_TABLE_STORAGE; -import static org.apache.hadoop.util.StringUtils.stringifyException; import java.io.BufferedWriter; import java.io.DataOutputStream; @@ -88,6 +87,7 @@ import org.apache.hadoop.hive.metastore.api.Order; import org.apache.hadoop.hive.metastore.api.PrincipalType; import org.apache.hadoop.hive.metastore.api.WMResourcePlan; +import org.apache.hadoop.hive.metastore.api.WMTrigger; import org.apache.hadoop.hive.metastore.api.RolePrincipalGrant; import org.apache.hadoop.hive.metastore.api.SQLForeignKey; import org.apache.hadoop.hive.metastore.api.SQLNotNullConstraint; @@ -167,6 +167,7 @@ import org.apache.hadoop.hive.ql.plan.AlterTableDesc.AlterTableTypes; import org.apache.hadoop.hive.ql.plan.AlterTableExchangePartition; import org.apache.hadoop.hive.ql.plan.AlterTableSimpleDesc; +import org.apache.hadoop.hive.ql.plan.AlterWMTriggerDesc; import org.apache.hadoop.hive.ql.plan.CacheMetadataDesc; import org.apache.hadoop.hive.ql.plan.ColStatistics; import org.apache.hadoop.hive.ql.plan.CreateDatabaseDesc; @@ -175,6 +176,7 @@ import org.apache.hadoop.hive.ql.plan.CreateTableDesc; import org.apache.hadoop.hive.ql.plan.CreateTableLikeDesc; import org.apache.hadoop.hive.ql.plan.CreateViewDesc; +import org.apache.hadoop.hive.ql.plan.CreateWMTriggerDesc; import org.apache.hadoop.hive.ql.plan.DDLWork; import org.apache.hadoop.hive.ql.plan.DescDatabaseDesc; import org.apache.hadoop.hive.ql.plan.DescFunctionDesc; @@ -183,6 +185,7 @@ import org.apache.hadoop.hive.ql.plan.DropIndexDesc; import org.apache.hadoop.hive.ql.plan.DropResourcePlanDesc; import org.apache.hadoop.hive.ql.plan.DropTableDesc; +import org.apache.hadoop.hive.ql.plan.DropWMTriggerDesc; import org.apache.hadoop.hive.ql.plan.FileMergeDesc; import org.apache.hadoop.hive.ql.plan.GrantDesc; import org.apache.hadoop.hive.ql.plan.GrantRevokeRoleDDL; @@ -627,6 +630,18 @@ public int execute(DriverContext driverContext) { if (work.getDropResourcePlanDesc() != null) { return dropResourcePlan(db, work.getDropResourcePlanDesc()); } + + if (work.getCreateWMTriggerDesc() != null) { + return createWMTrigger(db, work.getCreateWMTriggerDesc()); + } + + if (work.getAlterWMTriggerDesc() != null) { + return alterWMTrigger(db, work.getAlterWMTriggerDesc()); + } + + if (work.getDropWMTriggerDesc() != null) { + return dropWMTrigger(db, work.getDropWMTriggerDesc()); + } } catch (Throwable e) { failed(e); return 1; @@ -656,7 +671,7 @@ private int showResourcePlans(Hive db, ShowResourcePlanDesc showResourcePlanDesc if (rpName != null) { resourcePlans = Collections.singletonList(db.getResourcePlan(rpName)); } else { - resourcePlans = db.geAllResourcePlans(); + resourcePlans = db.getAllResourcePlans(); } formatter.showResourcePlans(out, resourcePlans); } catch (Exception e) { @@ -697,6 +712,27 @@ private int dropResourcePlan(Hive db, DropResourcePlanDesc desc) throws HiveExce return 0; } + private int createWMTrigger(Hive db, CreateWMTriggerDesc desc) throws HiveException { + WMTrigger trigger = new WMTrigger(desc.getRpName(), desc.getTriggerName()); + trigger.setTriggerExpression(desc.getTriggerExpression()); + trigger.setActionExpression(desc.getActionExpression()); + db.createWMTrigger(trigger); + return 0; + } + + private int alterWMTrigger(Hive db, AlterWMTriggerDesc desc) throws HiveException { + WMTrigger trigger = new WMTrigger(desc.getRpName(), desc.getTriggerName()); + trigger.setTriggerExpression(desc.getTriggerExpression()); + trigger.setActionExpression(desc.getActionExpression()); + db.alterWMTrigger(trigger); + return 0; + } + + private int dropWMTrigger(Hive db, DropWMTriggerDesc desc) throws HiveException { + db.dropWMTrigger(desc.getRpName(), desc.getTriggerName()); + return 0; + } + private int preInsertWork(Hive db, PreInsertTableDesc preInsertTableDesc) throws HiveException { try{ HiveMetaHook hook = preInsertTableDesc.getTable().getStorageHandler().getMetaHook(); diff --git ql/src/java/org/apache/hadoop/hive/ql/metadata/Hive.java ql/src/java/org/apache/hadoop/hive/ql/metadata/Hive.java index ed9d576fd6..ea43963609 100644 --- ql/src/java/org/apache/hadoop/hive/ql/metadata/Hive.java +++ ql/src/java/org/apache/hadoop/hive/ql/metadata/Hive.java @@ -119,6 +119,7 @@ import org.apache.hadoop.hive.metastore.api.PrincipalType; import org.apache.hadoop.hive.metastore.api.PrivilegeBag; import org.apache.hadoop.hive.metastore.api.WMResourcePlan; +import org.apache.hadoop.hive.metastore.api.WMTrigger; import org.apache.hadoop.hive.metastore.api.Role; import org.apache.hadoop.hive.metastore.api.RolePrincipalGrant; import org.apache.hadoop.hive.metastore.api.SQLForeignKey; @@ -4714,7 +4715,7 @@ public WMResourcePlan getResourcePlan(String rpName) throws HiveException { } } - public List geAllResourcePlans() throws HiveException { + public List getAllResourcePlans() throws HiveException { try { return getMSC().getAllResourcePlans(); } catch (Exception e) { @@ -4745,4 +4746,28 @@ public boolean validateResourcePlan(String rpName) throws HiveException { throw new HiveException(e); } } + + public void createWMTrigger(WMTrigger trigger) throws HiveException { + try { + getMSC().createWMTrigger(trigger); + } catch (Exception e) { + throw new HiveException(e); + } + } + + public void alterWMTrigger(WMTrigger trigger) throws HiveException { + try { + getMSC().alterWMTrigger(trigger); + } catch (Exception e) { + throw new HiveException(e); + } + } + + public void dropWMTrigger(String rpName, String triggerName) throws HiveException { + try { + getMSC().dropWMTrigger(rpName, triggerName); + } catch (Exception e) { + throw new HiveException(e); + } + } }; diff --git ql/src/java/org/apache/hadoop/hive/ql/parse/DDLSemanticAnalyzer.java ql/src/java/org/apache/hadoop/hive/ql/parse/DDLSemanticAnalyzer.java index dc29b122c9..6a2ff75c84 100644 --- ql/src/java/org/apache/hadoop/hive/ql/parse/DDLSemanticAnalyzer.java +++ ql/src/java/org/apache/hadoop/hive/ql/parse/DDLSemanticAnalyzer.java @@ -92,11 +92,13 @@ import org.apache.hadoop.hive.ql.plan.AlterTableDesc.AlterTableTypes; import org.apache.hadoop.hive.ql.plan.AlterTableExchangePartition; import org.apache.hadoop.hive.ql.plan.AlterTableSimpleDesc; +import org.apache.hadoop.hive.ql.plan.AlterWMTriggerDesc; import org.apache.hadoop.hive.ql.plan.CacheMetadataDesc; import org.apache.hadoop.hive.ql.plan.ColumnStatsUpdateWork; import org.apache.hadoop.hive.ql.plan.CreateDatabaseDesc; import org.apache.hadoop.hive.ql.plan.CreateIndexDesc; import org.apache.hadoop.hive.ql.plan.CreateResourcePlanDesc; +import org.apache.hadoop.hive.ql.plan.CreateWMTriggerDesc; import org.apache.hadoop.hive.ql.plan.DDLWork; import org.apache.hadoop.hive.ql.plan.DescDatabaseDesc; import org.apache.hadoop.hive.ql.plan.DescFunctionDesc; @@ -105,6 +107,7 @@ import org.apache.hadoop.hive.ql.plan.DropIndexDesc; import org.apache.hadoop.hive.ql.plan.DropResourcePlanDesc; import org.apache.hadoop.hive.ql.plan.DropTableDesc; +import org.apache.hadoop.hive.ql.plan.DropWMTriggerDesc; import org.apache.hadoop.hive.ql.plan.ExprNodeColumnDesc; import org.apache.hadoop.hive.ql.plan.ExprNodeConstantDesc; import org.apache.hadoop.hive.ql.plan.ExprNodeDesc; @@ -165,7 +168,6 @@ import java.net.URI; import java.net.URISyntaxException; import java.util.ArrayList; -import java.util.Arrays; import java.util.Collection; import java.util.HashMap; import java.util.HashSet; @@ -559,6 +561,15 @@ public void analyzeInternal(ASTNode input) throws SemanticException { case HiveParser.TOK_DROP_RP: analyzeDropResourcePlan(ast); break; + case HiveParser.TOK_CREATE_TRIGGER: + analyzeCreateTrigger(ast); + break; + case HiveParser.TOK_ALTER_TRIGGER: + analyzeAlterTrigger(ast); + break; + case HiveParser.TOK_DROP_TRIGGER: + analyzeDropTrigger(ast); + break; default: throw new SemanticException("Unsupported command: " + ast); } @@ -924,6 +935,85 @@ private void analyzeDropResourcePlan(ASTNode ast) throws SemanticException { new DDLWork(getInputs(), getOutputs(), desc), conf)); } + private void analyzeCreateTrigger(ASTNode ast) throws SemanticException { + if (ast.getChildCount() != 4) { + throw new SemanticException("Invalid syntax for create trigger statement"); + } + String rpName = unescapeIdentifier(ast.getChild(0).getText()); + String triggerName = unescapeIdentifier(ast.getChild(1).getText()); + String triggerExpression = buildTriggerExpression((ASTNode)ast.getChild(2)); + String actionExpression = buildTriggerActionExpression((ASTNode)ast.getChild(3)); + + CreateWMTriggerDesc desc = + new CreateWMTriggerDesc(rpName, triggerName, triggerExpression, actionExpression); + rootTasks.add(TaskFactory.get( + new DDLWork(getInputs(), getOutputs(), desc), conf)); + } + + private String buildTriggerExpression(ASTNode ast) throws SemanticException { + if (ast.getType() != HiveParser.TOK_TRIGGER_EXPRESSION || ast.getChildCount() == 0) { + throw new SemanticException("Invalid trigger expression."); + } + StringBuilder builder = new StringBuilder(); + for (int i = 0; i < ast.getChildCount(); ++i) { + builder.append(ast.getChild(i).getText()); + builder.append(' '); + } + builder.deleteCharAt(builder.length() - 1); + return builder.toString(); + } + + private String poolPath(ASTNode ast) { + StringBuilder builder = new StringBuilder(); + builder.append(ast.getText()); + for (int i = 0; i < ast.getChildCount(); ++i) { + builder.append(ast.getChild(i).getText()); + } + return builder.toString(); + } + + private String buildTriggerActionExpression(ASTNode ast) throws SemanticException { + switch (ast.getType()) { + case HiveParser.KW_KILL: + return "KILL"; + case HiveParser.KW_MOVE: + if (ast.getChildCount() != 1) { + throw new SemanticException("Invalid move to clause in trigger action."); + } + String poolPath = poolPath((ASTNode)ast.getChild(0)); + return "MOVE TO " + poolPath; + default: + throw new SemanticException("Unknown token in action clause: " + ast.getType()); + } + } + + private void analyzeAlterTrigger(ASTNode ast) throws SemanticException { + if (ast.getChildCount() != 4) { + throw new SemanticException("Invalid syntax for alter trigger statement"); + } + String rpName = unescapeIdentifier(ast.getChild(0).getText()); + String triggerName = unescapeIdentifier(ast.getChild(1).getText()); + String triggerExpression = buildTriggerExpression((ASTNode)ast.getChild(2)); + String actionExpression = buildTriggerActionExpression((ASTNode)ast.getChild(3)); + + AlterWMTriggerDesc desc = + new AlterWMTriggerDesc(rpName, triggerName, triggerExpression, actionExpression); + rootTasks.add(TaskFactory.get( + new DDLWork(getInputs(), getOutputs(), desc), conf)); + } + + private void analyzeDropTrigger(ASTNode ast) throws SemanticException { + if (ast.getChildCount() != 2) { + throw new SemanticException("Invalid syntax for drop trigger."); + } + String rpName = ast.getChild(0).getText(); + String triggerName = ast.getChild(1).getText(); + + DropWMTriggerDesc desc = new DropWMTriggerDesc(rpName, triggerName); + rootTasks.add(TaskFactory.get( + new DDLWork(getInputs(), getOutputs(), desc), conf)); + } + private void analyzeCreateDatabase(ASTNode ast) throws SemanticException { String dbName = unescapeIdentifier(ast.getChild(0).getText()); boolean ifNotExists = false; diff --git ql/src/java/org/apache/hadoop/hive/ql/parse/HiveLexer.g ql/src/java/org/apache/hadoop/hive/ql/parse/HiveLexer.g index 99ed71a5fa..0263df0d04 100644 --- ql/src/java/org/apache/hadoop/hive/ql/parse/HiveLexer.g +++ ql/src/java/org/apache/hadoop/hive/ql/parse/HiveLexer.g @@ -358,6 +358,8 @@ KW_PLAN: 'PLAN'; KW_QUERY_PARALLELISM: 'QUERY_PARALLELISM'; KW_PLANS: 'PLANS'; KW_ACTIVATE: 'ACTIVATE'; +KW_MOVE: 'MOVE'; +KW_DO: 'DO'; // Operators // NOTE: if you add a new function/operator, add it to sysFuncNames so that describe function _FUNC_ will work. diff --git ql/src/java/org/apache/hadoop/hive/ql/parse/HiveParser.g ql/src/java/org/apache/hadoop/hive/ql/parse/HiveParser.g index 053393ce51..306559c722 100644 --- ql/src/java/org/apache/hadoop/hive/ql/parse/HiveParser.g +++ ql/src/java/org/apache/hadoop/hive/ql/parse/HiveParser.g @@ -413,6 +413,10 @@ TOK_VALIDATE; TOK_ACTIVATE; TOK_QUERY_PARALLELISM; TOK_RENAME; +TOK_CREATE_TRIGGER; +TOK_ALTER_TRIGGER; +TOK_DROP_TRIGGER; +TOK_TRIGGER_EXPRESSION; } @@ -590,6 +594,8 @@ import org.apache.hadoop.hive.conf.HiveConf; xlateMap.put("KW_QUERY_PARALLELISM", "QUERY_PARALLELISM"); xlateMap.put("KW_PLANS", "PLANS"); xlateMap.put("KW_ACTIVATE", "ACTIVATE"); + xlateMap.put("KW_MOVE", "MOVE"); + xlateMap.put("KW_DO", "DO"); // Operators xlateMap.put("DOT", "."); @@ -931,6 +937,9 @@ ddlStatement | createResourcePlanStatement | alterResourcePlanStatement | dropResourcePlanStatement + | createTriggerStatement + | alterTriggerStatement + | dropTriggerStatement ; ifExists @@ -1015,6 +1024,81 @@ dropResourcePlanStatement -> ^(TOK_DROP_RP $name) ; +poolPath +@init { pushMsg("poolPath", state); } +@after { popMsg(state); } + : identifier^ (DOT identifier)* + ; + +triggerExpression +@init { pushMsg("triggerExpression", state); } +@after { popMsg(state); } + : triggerOrExpression -> ^(TOK_TRIGGER_EXPRESSION triggerOrExpression) + ; + +triggerOrExpression +@init { pushMsg("triggerOrExpression", state); } +@after { popMsg(state); } + : triggerAndExpression (KW_OR triggerAndExpression)* + ; + +triggerAndExpression +@init { pushMsg("triggerAndExpression", state); } +@after { popMsg(state); } + : triggerAtomExpression (KW_AND triggerAtomExpression)* + ; + +triggerAtomExpression +@init { pushMsg("triggerAtomExpression", state); } +@after { popMsg(state); } + : (identifier comparisionOperator triggerLiteral) + | (LPAREN triggerOrExpression RPAREN) + ; + +triggerLiteral +@init { pushMsg("triggerLiteral", state); } +@after { popMsg(state); } + : (Number (KW_HOUR|KW_MINUTE|KW_SECOND)?) + | ByteLengthLiteral + | StringLiteral + ; + +comparisionOperator +@init { pushMsg("comparisionOperator", state); } +@after { popMsg(state); } + : EQUAL | LESSTHAN | LESSTHANOREQUALTO | GREATERTHAN | GREATERTHANOREQUALTO + ; + +triggerActionExpression +@init { pushMsg("triggerActionExpression", state); } +@after { popMsg(state); } + : KW_KILL + | (KW_MOVE^ KW_TO! poolPath) + ; + +createTriggerStatement +@init { pushMsg("create trigger statement", state); } +@after { popMsg(state); } + : KW_CREATE KW_TRIGGER rpName=identifier DOT triggerName=identifier + KW_WHEN triggerExpression KW_DO triggerActionExpression + -> ^(TOK_CREATE_TRIGGER $rpName $triggerName triggerExpression triggerActionExpression) + ; + +alterTriggerStatement +@init { pushMsg("alter trigger statement", state); } +@after { popMsg(state); } + : KW_ALTER KW_TRIGGER rpName=identifier DOT triggerName=identifier + KW_WHEN triggerExpression KW_DO triggerActionExpression + -> ^(TOK_ALTER_TRIGGER $rpName $triggerName triggerExpression triggerActionExpression) + ; + +dropTriggerStatement +@init { pushMsg("drop trigger statement", state); } +@after { popMsg(state); } + : KW_DROP KW_TRIGGER rpName=identifier DOT triggerName=identifier + -> ^(TOK_DROP_TRIGGER $rpName $triggerName) + ; + createDatabaseStatement @init { pushMsg("create database statement", state); } @after { popMsg(state); } diff --git ql/src/java/org/apache/hadoop/hive/ql/parse/SemanticAnalyzerFactory.java ql/src/java/org/apache/hadoop/hive/ql/parse/SemanticAnalyzerFactory.java index e9f6b55c85..e704c73112 100644 --- ql/src/java/org/apache/hadoop/hive/ql/parse/SemanticAnalyzerFactory.java +++ ql/src/java/org/apache/hadoop/hive/ql/parse/SemanticAnalyzerFactory.java @@ -138,6 +138,9 @@ commandType.put(HiveParser.TOK_SHOWRESOURCEPLAN, HiveOperation.SHOW_RESOURCEPLAN); commandType.put(HiveParser.TOK_ALTER_RP, HiveOperation.ALTER_RESOURCEPLAN); commandType.put(HiveParser.TOK_DROP_RP, HiveOperation.DROP_RESOURCEPLAN); + commandType.put(HiveParser.TOK_CREATE_TRIGGER, HiveOperation.CREATE_TRIGGER); + commandType.put(HiveParser.TOK_ALTER_TRIGGER, HiveOperation.ALTER_TRIGGER); + commandType.put(HiveParser.TOK_DROP_TRIGGER, HiveOperation.DROP_TRIGGER); } static { @@ -317,6 +320,9 @@ private static BaseSemanticAnalyzer getInternal(QueryState queryState, ASTNode t case HiveParser.TOK_SHOWRESOURCEPLAN: case HiveParser.TOK_ALTER_RP: case HiveParser.TOK_DROP_RP: + case HiveParser.TOK_CREATE_TRIGGER: + case HiveParser.TOK_ALTER_TRIGGER: + case HiveParser.TOK_DROP_TRIGGER: return new DDLSemanticAnalyzer(queryState); case HiveParser.TOK_CREATEFUNCTION: diff --git ql/src/java/org/apache/hadoop/hive/ql/plan/AlterWMTriggerDesc.java ql/src/java/org/apache/hadoop/hive/ql/plan/AlterWMTriggerDesc.java new file mode 100644 index 0000000000..94414ef1ce --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/plan/AlterWMTriggerDesc.java @@ -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.ql.plan; + +import java.io.Serializable; + +import org.apache.hadoop.hive.ql.plan.Explain.Level; + +@Explain(displayName="Alter WM Trigger", + explainLevels={ Level.USER, Level.DEFAULT, Level.EXTENDED }) +public class AlterWMTriggerDesc extends DDLDesc implements Serializable { + private static final long serialVersionUID = -2105736261687539210L; + + private String rpName; + private String triggerName; + private String triggerExpression; + private String actionExpression; + + public AlterWMTriggerDesc() {} + + public AlterWMTriggerDesc(String rpName, String triggerName, String triggerExpression, + String actionExpression) { + this.rpName = rpName; + this.triggerName = triggerName; + this.triggerExpression = triggerExpression; + this.actionExpression = actionExpression; + } + + @Explain(displayName="resourcePlanName", + explainLevels={ Level.USER, Level.DEFAULT, Level.EXTENDED }) + public String getRpName() { + return rpName; + } + + public void setRpName(String rpName) { + this.rpName = rpName; + } + + @Explain(displayName="triggerName", + explainLevels={ Level.USER, Level.DEFAULT, Level.EXTENDED }) + public String getTriggerName() { + return triggerName; + } + + public void setTriggerName(String triggerName) { + this.triggerName = triggerName; + } + + @Explain(displayName="triggerExpression", + explainLevels={ Level.USER, Level.DEFAULT, Level.EXTENDED }) + public String getTriggerExpression() { + return triggerExpression; + } + + public void setTriggerExpression(String triggerExpression) { + this.triggerExpression = triggerExpression; + } + + @Explain(displayName="actionExpression", + explainLevels={ Level.USER, Level.DEFAULT, Level.EXTENDED }) + public String getActionExpression() { + return actionExpression; + } + + public void setActionExpression(String actionExpression) { + this.actionExpression = actionExpression; + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/plan/CreateWMTriggerDesc.java ql/src/java/org/apache/hadoop/hive/ql/plan/CreateWMTriggerDesc.java new file mode 100644 index 0000000000..92eaefdd6f --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/plan/CreateWMTriggerDesc.java @@ -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.ql.plan; + +import java.io.Serializable; + +import org.apache.hadoop.hive.ql.plan.Explain.Level; + +@Explain(displayName="Create WM Trigger", + explainLevels={ Level.USER, Level.DEFAULT, Level.EXTENDED }) +public class CreateWMTriggerDesc extends DDLDesc implements Serializable { + private static final long serialVersionUID = 1705317739121300923L; + + private String rpName; + private String triggerName; + private String triggerExpression; + private String actionExpression; + + public CreateWMTriggerDesc() {} + + public CreateWMTriggerDesc(String rpName, String triggerName, String triggerExpression, + String actionExpression) { + this.rpName = rpName; + this.triggerName = triggerName; + this.triggerExpression = triggerExpression; + this.actionExpression = actionExpression; + } + + @Explain(displayName="resourcePlanName", + explainLevels={ Level.USER, Level.DEFAULT, Level.EXTENDED }) + public String getRpName() { + return rpName; + } + + public void setRpName(String rpName) { + this.rpName = rpName; + } + + @Explain(displayName="triggerName", + explainLevels={ Level.USER, Level.DEFAULT, Level.EXTENDED }) + public String getTriggerName() { + return triggerName; + } + + public void setTriggerName(String triggerName) { + this.triggerName = triggerName; + } + + @Explain(displayName="triggerExpression", + explainLevels={ Level.USER, Level.DEFAULT, Level.EXTENDED }) + public String getTriggerExpression() { + return triggerExpression; + } + + public void setTriggerExpression(String triggerExpression) { + this.triggerExpression = triggerExpression; + } + + @Explain(displayName="actionExpression", + explainLevels={ Level.USER, Level.DEFAULT, Level.EXTENDED }) + public String getActionExpression() { + return actionExpression; + } + + public void setActionExpression(String actionExpression) { + this.actionExpression = actionExpression; + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/plan/DDLWork.java ql/src/java/org/apache/hadoop/hive/ql/plan/DDLWork.java index cfd2115424..8152cfeb59 100644 --- ql/src/java/org/apache/hadoop/hive/ql/plan/DDLWork.java +++ ql/src/java/org/apache/hadoop/hive/ql/plan/DDLWork.java @@ -48,7 +48,6 @@ private CreateViewDesc createVwDesc; private DropTableDesc dropTblDesc; private AlterTableDesc alterTblDesc; - private AlterIndexDesc alterIdxDesc; private ShowDatabasesDesc showDatabasesDesc; private ShowTablesDesc showTblsDesc; private ShowColumnsDesc showColumnsDesc; @@ -91,6 +90,10 @@ private DropResourcePlanDesc dropResourcePlanDesc; private AlterResourcePlanDesc alterResourcePlanDesc; + private CreateWMTriggerDesc createWMTriggerDesc; + private AlterWMTriggerDesc alterWMTriggerDesc; + private DropWMTriggerDesc dropWMTriggerDesc; + boolean needLock = false; /** @@ -200,9 +203,9 @@ public DDLWork(HashSet inputs, HashSet outputs, * alter index descriptor */ public DDLWork(HashSet inputs, HashSet outputs, - AlterIndexDesc alterIdxDesc) { + AlterIndexDesc alterIndexDesc) { this(inputs, outputs); - this.alterIdxDesc = alterIdxDesc; + this.alterIndexDesc = alterIndexDesc; } /** @@ -576,6 +579,24 @@ public DDLWork(HashSet inputs, HashSet outputs, this.setAlterResourcePlanDesc(alterResourcePlanDesc); } + public DDLWork(HashSet inputs, HashSet outputs, + CreateWMTriggerDesc createWMTriggerDesc) { + this(inputs, outputs); + this.setCreateWMTriggerDesc(createWMTriggerDesc); + } + + public DDLWork(HashSet inputs, HashSet outputs, + AlterWMTriggerDesc alterWMTriggerDesc) { + this(inputs, outputs); + this.setAlterWMTriggerDesc(alterWMTriggerDesc); + } + + public DDLWork(HashSet inputs, HashSet outputs, + DropWMTriggerDesc dropWMTriggerDesc) { + this(inputs, outputs); + this.setDropWMTriggerDesc(dropWMTriggerDesc); + } + /** * @return Create Database descriptor */ @@ -1298,4 +1319,28 @@ public AlterResourcePlanDesc getAlterResourcePlanDesc() { public void setAlterResourcePlanDesc(AlterResourcePlanDesc alterResourcePlanDesc) { this.alterResourcePlanDesc = alterResourcePlanDesc; } + + public CreateWMTriggerDesc getCreateWMTriggerDesc() { + return createWMTriggerDesc; + } + + public void setCreateWMTriggerDesc(CreateWMTriggerDesc createWMTriggerDesc) { + this.createWMTriggerDesc = createWMTriggerDesc; + } + + public AlterWMTriggerDesc getAlterWMTriggerDesc() { + return alterWMTriggerDesc; + } + + public void setAlterWMTriggerDesc(AlterWMTriggerDesc alterWMTriggerDesc) { + this.alterWMTriggerDesc = alterWMTriggerDesc; + } + + public DropWMTriggerDesc getDropWMTriggerDesc() { + return dropWMTriggerDesc; + } + + public void setDropWMTriggerDesc(DropWMTriggerDesc dropWMTriggerDesc) { + this.dropWMTriggerDesc = dropWMTriggerDesc; + } } diff --git ql/src/java/org/apache/hadoop/hive/ql/plan/DropWMTriggerDesc.java ql/src/java/org/apache/hadoop/hive/ql/plan/DropWMTriggerDesc.java new file mode 100644 index 0000000000..eee01eb58b --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/plan/DropWMTriggerDesc.java @@ -0,0 +1,59 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hadoop.hive.ql.plan; + +import java.io.Serializable; + +import org.apache.hadoop.hive.ql.plan.Explain.Level; + +@Explain(displayName="Drop WM Trigger", + explainLevels={ Level.USER, Level.DEFAULT, Level.EXTENDED }) +public class DropWMTriggerDesc extends DDLDesc implements Serializable { + private static final long serialVersionUID = 963803766313787632L; + + private String rpName; + private String triggerName; + + public DropWMTriggerDesc() {} + + public DropWMTriggerDesc(String rpName, String triggerName) { + this.rpName = rpName; + this.triggerName = triggerName; + } + + @Explain(displayName="resourcePlanName", + explainLevels={ Level.USER, Level.DEFAULT, Level.EXTENDED }) + public String getRpName() { + return rpName; + } + + public void setRpName(String rpName) { + this.rpName = rpName; + } + + @Explain(displayName="triggerName", + explainLevels={ Level.USER, Level.DEFAULT, Level.EXTENDED }) + public String getTriggerName() { + return triggerName; + } + + public void setTriggerName(String triggerName) { + this.triggerName = triggerName; + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/plan/HiveOperation.java ql/src/java/org/apache/hadoop/hive/ql/plan/HiveOperation.java index dc4866e53e..1ce1c76f37 100644 --- ql/src/java/org/apache/hadoop/hive/ql/plan/HiveOperation.java +++ ql/src/java/org/apache/hadoop/hive/ql/plan/HiveOperation.java @@ -143,7 +143,10 @@ CREATE_RESOURCEPLAN("CREATE RESOURCEPLAN", null, null, false, false), SHOW_RESOURCEPLAN("SHOW RESOURCEPLAN", null, null, false, false), ALTER_RESOURCEPLAN("ALTER RESOURCEPLAN", null, null, false, false), - DROP_RESOURCEPLAN("DROP RESOURCEPLAN", null, null, false, false); + DROP_RESOURCEPLAN("DROP RESOURCEPLAN", null, null, false, false), + CREATE_TRIGGER("CREATE TRIGGER", null, null, false, false), + ALTER_TRIGGER("ALTER TRIGGER", null, null, false, false), + DROP_TRIGGER("DROP TRIGGER", null, null, false, false); private String operationName; diff --git ql/src/java/org/apache/hadoop/hive/ql/security/authorization/plugin/HiveOperationType.java ql/src/java/org/apache/hadoop/hive/ql/security/authorization/plugin/HiveOperationType.java index b5411c8c9a..ba1d01f3c6 100644 --- ql/src/java/org/apache/hadoop/hive/ql/security/authorization/plugin/HiveOperationType.java +++ ql/src/java/org/apache/hadoop/hive/ql/security/authorization/plugin/HiveOperationType.java @@ -136,6 +136,9 @@ SHOW_RESOURCEPLAN, ALTER_RESOURCEPLAN, DROP_RESOURCEPLAN, + CREATE_TRIGGER, + ALTER_TRIGGER, + DROP_TRIGGER, // ==== Hive command operation types starts here ==== // SET, diff --git ql/src/test/queries/clientpositive/resourceplan.q ql/src/test/queries/clientpositive/resourceplan.q index 586491dc91..f1be695cb8 100644 --- ql/src/test/queries/clientpositive/resourceplan.q +++ ql/src/test/queries/clientpositive/resourceplan.q @@ -104,3 +104,45 @@ DROP RESOURCE PLAN plan_2; -- Success. DROP RESOURCE PLAN plan_3; SELECT * FROM SYS.WM_RESOURCEPLANS; + + +-- +-- Create trigger commands. +-- + +CREATE RESOURCE PLAN plan_1; + +CREATE TRIGGER plan_1.trigger_1 WHEN BYTES_READ > 10k AND BYTES_READ <= 1M OR ELAPSED_TIME > 30 SECOND AND ELAPSED_TIME < 1 MINUTE DO KILL; +SELECT * FROM SYS.WM_TRIGGERS; + +-- Duplicate should fail. +CREATE TRIGGER plan_1.trigger_1 WHEN BYTES_READ = 10G DO KILL; + +CREATE TRIGGER plan_1.trigger_2 WHEN BYTES_READ > 100 DO MOVE TO slow_pool; +SELECT * FROM SYS.WM_TRIGGERS; + +ALTER TRIGGER plan_1.trigger_1 WHEN BYTES_READ = 1000 DO KILL; +SELECT * FROM SYS.WM_TRIGGERS; + +DROP TRIGGER plan_1.trigger_1; +SELECT * FROM SYS.WM_TRIGGERS; + +-- No edit on active resource plan. +CREATE TRIGGER plan_2.trigger_1 WHEN BYTES_READ = 0m DO MOVE TO null_pool; + +-- Cannot drop/change trigger from enabled plan. +ALTER RESOURCE PLAN plan_1 ENABLE; +SELECT * FROM SYS.WM_RESOURCEPLANS; +DROP TRIGGER plan_1.trigger_2; +ALTER TRIGGER plan_1.trigger_2 WHEN BYTES_READ = 1000g DO KILL; + +-- Cannot drop/change trigger from active plan. +ALTER RESOURCE PLAN plan_1 ACTIVATE; +SELECT * FROM SYS.WM_RESOURCEPLANS; +DROP TRIGGER plan_1.trigger_2; +ALTER TRIGGER plan_1.trigger_2 WHEN BYTES_READ = 1000K DO KILL; + +-- Once disabled we should be able to change it. +ALTER RESOURCE PLAN plan_2 DISABLE; +CREATE TRIGGER plan_2.trigger_1 WHEN BYTES_READ = 0 DO MOVE TO null_pool; +SELECT * FROM SYS.WM_TRIGGERS; diff --git ql/src/test/results/clientpositive/llap/resourceplan.q.out ql/src/test/results/clientpositive/llap/resourceplan.q.out index 2231bb566d..5cdfc9de3e 100644 --- ql/src/test/results/clientpositive/llap/resourceplan.q.out +++ ql/src/test/results/clientpositive/llap/resourceplan.q.out @@ -2157,6 +2157,56 @@ FROM POSTHOOK: type: CREATETABLE POSTHOOK: Output: SYS@WM_RESOURCEPLANS POSTHOOK: Output: database:sys +PREHOOK: query: CREATE TABLE IF NOT EXISTS `WM_TRIGGERS` ( + `RP_NAME` string, + `NAME` string, + `TRIGGER_EXPRESSION` string, + `ACTION_EXPRESSION` string +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + r.NAME RP_NAME, + t.NAME NAME, + TRIGGER_EXPRESSION, + ACTION_EXPRESSION +FROM + WM_TRIGGER t +JOIN + WM_RESOURCEPLAN r +ON + t.RP_ID = r.RP_ID" +) +PREHOOK: type: CREATETABLE +PREHOOK: Output: SYS@WM_TRIGGERS +PREHOOK: Output: database:sys +POSTHOOK: query: CREATE TABLE IF NOT EXISTS `WM_TRIGGERS` ( + `RP_NAME` string, + `NAME` string, + `TRIGGER_EXPRESSION` string, + `ACTION_EXPRESSION` string +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + r.NAME RP_NAME, + t.NAME NAME, + TRIGGER_EXPRESSION, + ACTION_EXPRESSION +FROM + WM_TRIGGER t +JOIN + WM_RESOURCEPLAN r +ON + t.RP_ID = r.RP_ID" +) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: SYS@WM_TRIGGERS +POSTHOOK: Output: database:sys PREHOOK: query: DROP DATABASE IF EXISTS INFORMATION_SCHEMA PREHOOK: type: DROPDATABASE POSTHOOK: query: DROP DATABASE IF EXISTS INFORMATION_SCHEMA @@ -2973,7 +3023,7 @@ plan_1 DISABLED NULL plan_2 DISABLED 10 PREHOOK: query: ALTER RESOURCE PLAN plan_1 RENAME TO plan_2 PREHOOK: type: ALTER RESOURCEPLAN -FAILED: Execution Error, return code 1 from org.apache.hadoop.hive.ql.exec.DDLTask. InvalidOperationException(message:Resource plan should be unique) +FAILED: Execution Error, return code 1 from org.apache.hadoop.hive.ql.exec.DDLTask. AlreadyExistsException(message:Resource plan name should be unique: ) PREHOOK: query: SELECT * FROM SYS.WM_RESOURCEPLANS PREHOOK: type: QUERY PREHOOK: Input: sys@wm_resourceplans @@ -3179,3 +3229,125 @@ POSTHOOK: type: QUERY POSTHOOK: Input: sys@wm_resourceplans #### A masked pattern was here #### plan_2 ACTIVE 10 +PREHOOK: query: CREATE RESOURCE PLAN plan_1 +PREHOOK: type: CREATE RESOURCEPLAN +POSTHOOK: query: CREATE RESOURCE PLAN plan_1 +POSTHOOK: type: CREATE RESOURCEPLAN +PREHOOK: query: CREATE TRIGGER plan_1.trigger_1 WHEN BYTES_READ > 10k AND BYTES_READ <= 1M OR ELAPSED_TIME > 30 SECOND AND ELAPSED_TIME < 1 MINUTE DO KILL +PREHOOK: type: CREATE TRIGGER +POSTHOOK: query: CREATE TRIGGER plan_1.trigger_1 WHEN BYTES_READ > 10k AND BYTES_READ <= 1M OR ELAPSED_TIME > 30 SECOND AND ELAPSED_TIME < 1 MINUTE DO KILL +POSTHOOK: type: CREATE TRIGGER +PREHOOK: query: SELECT * FROM SYS.WM_TRIGGERS +PREHOOK: type: QUERY +PREHOOK: Input: sys@wm_triggers +#### A masked pattern was here #### +POSTHOOK: query: SELECT * FROM SYS.WM_TRIGGERS +POSTHOOK: type: QUERY +POSTHOOK: Input: sys@wm_triggers +#### A masked pattern was here #### +plan_1 trigger_1 BYTES_READ > 10k AND BYTES_READ <= 1M OR ELAPSED_TIME > 30 SECOND AND ELAPSED_TIME < 1 MINUTE KILL +PREHOOK: query: CREATE TRIGGER plan_1.trigger_1 WHEN BYTES_READ = 10G DO KILL +PREHOOK: type: CREATE TRIGGER +FAILED: Execution Error, return code 1 from org.apache.hadoop.hive.ql.exec.DDLTask. AlreadyExistsException(message:Trigger already exists, use alter: ) +PREHOOK: query: CREATE TRIGGER plan_1.trigger_2 WHEN BYTES_READ > 100 DO MOVE TO slow_pool +PREHOOK: type: CREATE TRIGGER +POSTHOOK: query: CREATE TRIGGER plan_1.trigger_2 WHEN BYTES_READ > 100 DO MOVE TO slow_pool +POSTHOOK: type: CREATE TRIGGER +PREHOOK: query: SELECT * FROM SYS.WM_TRIGGERS +PREHOOK: type: QUERY +PREHOOK: Input: sys@wm_triggers +#### A masked pattern was here #### +POSTHOOK: query: SELECT * FROM SYS.WM_TRIGGERS +POSTHOOK: type: QUERY +POSTHOOK: Input: sys@wm_triggers +#### A masked pattern was here #### +plan_1 trigger_1 BYTES_READ > 10k AND BYTES_READ <= 1M OR ELAPSED_TIME > 30 SECOND AND ELAPSED_TIME < 1 MINUTE KILL +plan_1 trigger_2 BYTES_READ > 100 MOVE TO slow_pool +PREHOOK: query: ALTER TRIGGER plan_1.trigger_1 WHEN BYTES_READ = 1000 DO KILL +PREHOOK: type: ALTER TRIGGER +POSTHOOK: query: ALTER TRIGGER plan_1.trigger_1 WHEN BYTES_READ = 1000 DO KILL +POSTHOOK: type: ALTER TRIGGER +PREHOOK: query: SELECT * FROM SYS.WM_TRIGGERS +PREHOOK: type: QUERY +PREHOOK: Input: sys@wm_triggers +#### A masked pattern was here #### +POSTHOOK: query: SELECT * FROM SYS.WM_TRIGGERS +POSTHOOK: type: QUERY +POSTHOOK: Input: sys@wm_triggers +#### A masked pattern was here #### +plan_1 trigger_1 BYTES_READ = 1000 KILL +plan_1 trigger_2 BYTES_READ > 100 MOVE TO slow_pool +PREHOOK: query: DROP TRIGGER plan_1.trigger_1 +PREHOOK: type: DROP TRIGGER +POSTHOOK: query: DROP TRIGGER plan_1.trigger_1 +POSTHOOK: type: DROP TRIGGER +PREHOOK: query: SELECT * FROM SYS.WM_TRIGGERS +PREHOOK: type: QUERY +PREHOOK: Input: sys@wm_triggers +#### A masked pattern was here #### +POSTHOOK: query: SELECT * FROM SYS.WM_TRIGGERS +POSTHOOK: type: QUERY +POSTHOOK: Input: sys@wm_triggers +#### A masked pattern was here #### +plan_1 trigger_2 BYTES_READ > 100 MOVE TO slow_pool +PREHOOK: query: CREATE TRIGGER plan_2.trigger_1 WHEN BYTES_READ = 0m DO MOVE TO null_pool +PREHOOK: type: CREATE TRIGGER +FAILED: Execution Error, return code 1 from org.apache.hadoop.hive.ql.exec.DDLTask. InvalidOperationException(message:Resource plan must be disabled to edit it.) +PREHOOK: query: ALTER RESOURCE PLAN plan_1 ENABLE +PREHOOK: type: ALTER RESOURCEPLAN +POSTHOOK: query: ALTER RESOURCE PLAN plan_1 ENABLE +POSTHOOK: type: ALTER RESOURCEPLAN +PREHOOK: query: SELECT * FROM SYS.WM_RESOURCEPLANS +PREHOOK: type: QUERY +PREHOOK: Input: sys@wm_resourceplans +#### A masked pattern was here #### +POSTHOOK: query: SELECT * FROM SYS.WM_RESOURCEPLANS +POSTHOOK: type: QUERY +POSTHOOK: Input: sys@wm_resourceplans +#### A masked pattern was here #### +plan_2 ACTIVE 10 +plan_1 ENABLED NULL +PREHOOK: query: DROP TRIGGER plan_1.trigger_2 +PREHOOK: type: DROP TRIGGER +FAILED: Execution Error, return code 1 from org.apache.hadoop.hive.ql.exec.DDLTask. InvalidOperationException(message:Resource plan must be disabled to edit it.) +PREHOOK: query: ALTER TRIGGER plan_1.trigger_2 WHEN BYTES_READ = 1000g DO KILL +PREHOOK: type: ALTER TRIGGER +FAILED: Execution Error, return code 1 from org.apache.hadoop.hive.ql.exec.DDLTask. InvalidOperationException(message:Resource plan must be disabled to edit it.) +PREHOOK: query: ALTER RESOURCE PLAN plan_1 ACTIVATE +PREHOOK: type: ALTER RESOURCEPLAN +POSTHOOK: query: ALTER RESOURCE PLAN plan_1 ACTIVATE +POSTHOOK: type: ALTER RESOURCEPLAN +PREHOOK: query: SELECT * FROM SYS.WM_RESOURCEPLANS +PREHOOK: type: QUERY +PREHOOK: Input: sys@wm_resourceplans +#### A masked pattern was here #### +POSTHOOK: query: SELECT * FROM SYS.WM_RESOURCEPLANS +POSTHOOK: type: QUERY +POSTHOOK: Input: sys@wm_resourceplans +#### A masked pattern was here #### +plan_2 ENABLED 10 +plan_1 ACTIVE NULL +PREHOOK: query: DROP TRIGGER plan_1.trigger_2 +PREHOOK: type: DROP TRIGGER +FAILED: Execution Error, return code 1 from org.apache.hadoop.hive.ql.exec.DDLTask. InvalidOperationException(message:Resource plan must be disabled to edit it.) +PREHOOK: query: ALTER TRIGGER plan_1.trigger_2 WHEN BYTES_READ = 1000K DO KILL +PREHOOK: type: ALTER TRIGGER +FAILED: Execution Error, return code 1 from org.apache.hadoop.hive.ql.exec.DDLTask. InvalidOperationException(message:Resource plan must be disabled to edit it.) +PREHOOK: query: ALTER RESOURCE PLAN plan_2 DISABLE +PREHOOK: type: ALTER RESOURCEPLAN +POSTHOOK: query: ALTER RESOURCE PLAN plan_2 DISABLE +POSTHOOK: type: ALTER RESOURCEPLAN +PREHOOK: query: CREATE TRIGGER plan_2.trigger_1 WHEN BYTES_READ = 0 DO MOVE TO null_pool +PREHOOK: type: CREATE TRIGGER +POSTHOOK: query: CREATE TRIGGER plan_2.trigger_1 WHEN BYTES_READ = 0 DO MOVE TO null_pool +POSTHOOK: type: CREATE TRIGGER +PREHOOK: query: SELECT * FROM SYS.WM_TRIGGERS +PREHOOK: type: QUERY +PREHOOK: Input: sys@wm_triggers +#### A masked pattern was here #### +POSTHOOK: query: SELECT * FROM SYS.WM_TRIGGERS +POSTHOOK: type: QUERY +POSTHOOK: Input: sys@wm_triggers +#### A masked pattern was here #### +plan_2 trigger_1 BYTES_READ = 0 MOVE TO null_pool +plan_1 trigger_2 BYTES_READ > 100 MOVE TO slow_pool diff --git standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp index bbd0f00971..bf1af88436 100644 --- standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp +++ standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp @@ -1240,14 +1240,14 @@ uint32_t ThriftHiveMetastore_get_databases_result::read(::apache::thrift::protoc if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size934; - ::apache::thrift::protocol::TType _etype937; - xfer += iprot->readListBegin(_etype937, _size934); - this->success.resize(_size934); - uint32_t _i938; - for (_i938 = 0; _i938 < _size934; ++_i938) + uint32_t _size956; + ::apache::thrift::protocol::TType _etype959; + xfer += iprot->readListBegin(_etype959, _size956); + this->success.resize(_size956); + uint32_t _i960; + for (_i960 = 0; _i960 < _size956; ++_i960) { - xfer += iprot->readString(this->success[_i938]); + xfer += iprot->readString(this->success[_i960]); } xfer += iprot->readListEnd(); } @@ -1286,10 +1286,10 @@ uint32_t ThriftHiveMetastore_get_databases_result::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter939; - for (_iter939 = this->success.begin(); _iter939 != this->success.end(); ++_iter939) + std::vector ::const_iterator _iter961; + for (_iter961 = this->success.begin(); _iter961 != this->success.end(); ++_iter961) { - xfer += oprot->writeString((*_iter939)); + xfer += oprot->writeString((*_iter961)); } xfer += oprot->writeListEnd(); } @@ -1334,14 +1334,14 @@ uint32_t ThriftHiveMetastore_get_databases_presult::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size940; - ::apache::thrift::protocol::TType _etype943; - xfer += iprot->readListBegin(_etype943, _size940); - (*(this->success)).resize(_size940); - uint32_t _i944; - for (_i944 = 0; _i944 < _size940; ++_i944) + uint32_t _size962; + ::apache::thrift::protocol::TType _etype965; + xfer += iprot->readListBegin(_etype965, _size962); + (*(this->success)).resize(_size962); + uint32_t _i966; + for (_i966 = 0; _i966 < _size962; ++_i966) { - xfer += iprot->readString((*(this->success))[_i944]); + xfer += iprot->readString((*(this->success))[_i966]); } xfer += iprot->readListEnd(); } @@ -1458,14 +1458,14 @@ uint32_t ThriftHiveMetastore_get_all_databases_result::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size945; - ::apache::thrift::protocol::TType _etype948; - xfer += iprot->readListBegin(_etype948, _size945); - this->success.resize(_size945); - uint32_t _i949; - for (_i949 = 0; _i949 < _size945; ++_i949) + uint32_t _size967; + ::apache::thrift::protocol::TType _etype970; + xfer += iprot->readListBegin(_etype970, _size967); + this->success.resize(_size967); + uint32_t _i971; + for (_i971 = 0; _i971 < _size967; ++_i971) { - xfer += iprot->readString(this->success[_i949]); + xfer += iprot->readString(this->success[_i971]); } xfer += iprot->readListEnd(); } @@ -1504,10 +1504,10 @@ uint32_t ThriftHiveMetastore_get_all_databases_result::write(::apache::thrift::p xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter950; - for (_iter950 = this->success.begin(); _iter950 != this->success.end(); ++_iter950) + std::vector ::const_iterator _iter972; + for (_iter972 = this->success.begin(); _iter972 != this->success.end(); ++_iter972) { - xfer += oprot->writeString((*_iter950)); + xfer += oprot->writeString((*_iter972)); } xfer += oprot->writeListEnd(); } @@ -1552,14 +1552,14 @@ uint32_t ThriftHiveMetastore_get_all_databases_presult::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size951; - ::apache::thrift::protocol::TType _etype954; - xfer += iprot->readListBegin(_etype954, _size951); - (*(this->success)).resize(_size951); - uint32_t _i955; - for (_i955 = 0; _i955 < _size951; ++_i955) + uint32_t _size973; + ::apache::thrift::protocol::TType _etype976; + xfer += iprot->readListBegin(_etype976, _size973); + (*(this->success)).resize(_size973); + uint32_t _i977; + for (_i977 = 0; _i977 < _size973; ++_i977) { - xfer += iprot->readString((*(this->success))[_i955]); + xfer += iprot->readString((*(this->success))[_i977]); } xfer += iprot->readListEnd(); } @@ -2621,17 +2621,17 @@ uint32_t ThriftHiveMetastore_get_type_all_result::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_MAP) { { this->success.clear(); - uint32_t _size956; - ::apache::thrift::protocol::TType _ktype957; - ::apache::thrift::protocol::TType _vtype958; - xfer += iprot->readMapBegin(_ktype957, _vtype958, _size956); - uint32_t _i960; - for (_i960 = 0; _i960 < _size956; ++_i960) + uint32_t _size978; + ::apache::thrift::protocol::TType _ktype979; + ::apache::thrift::protocol::TType _vtype980; + xfer += iprot->readMapBegin(_ktype979, _vtype980, _size978); + uint32_t _i982; + for (_i982 = 0; _i982 < _size978; ++_i982) { - std::string _key961; - xfer += iprot->readString(_key961); - Type& _val962 = this->success[_key961]; - xfer += _val962.read(iprot); + std::string _key983; + xfer += iprot->readString(_key983); + Type& _val984 = this->success[_key983]; + xfer += _val984.read(iprot); } xfer += iprot->readMapEnd(); } @@ -2670,11 +2670,11 @@ uint32_t ThriftHiveMetastore_get_type_all_result::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_MAP, 0); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::map ::const_iterator _iter963; - for (_iter963 = this->success.begin(); _iter963 != this->success.end(); ++_iter963) + std::map ::const_iterator _iter985; + for (_iter985 = this->success.begin(); _iter985 != this->success.end(); ++_iter985) { - xfer += oprot->writeString(_iter963->first); - xfer += _iter963->second.write(oprot); + xfer += oprot->writeString(_iter985->first); + xfer += _iter985->second.write(oprot); } xfer += oprot->writeMapEnd(); } @@ -2719,17 +2719,17 @@ uint32_t ThriftHiveMetastore_get_type_all_presult::read(::apache::thrift::protoc if (ftype == ::apache::thrift::protocol::T_MAP) { { (*(this->success)).clear(); - uint32_t _size964; - ::apache::thrift::protocol::TType _ktype965; - ::apache::thrift::protocol::TType _vtype966; - xfer += iprot->readMapBegin(_ktype965, _vtype966, _size964); - uint32_t _i968; - for (_i968 = 0; _i968 < _size964; ++_i968) + uint32_t _size986; + ::apache::thrift::protocol::TType _ktype987; + ::apache::thrift::protocol::TType _vtype988; + xfer += iprot->readMapBegin(_ktype987, _vtype988, _size986); + uint32_t _i990; + for (_i990 = 0; _i990 < _size986; ++_i990) { - std::string _key969; - xfer += iprot->readString(_key969); - Type& _val970 = (*(this->success))[_key969]; - xfer += _val970.read(iprot); + std::string _key991; + xfer += iprot->readString(_key991); + Type& _val992 = (*(this->success))[_key991]; + xfer += _val992.read(iprot); } xfer += iprot->readMapEnd(); } @@ -2883,14 +2883,14 @@ uint32_t ThriftHiveMetastore_get_fields_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size971; - ::apache::thrift::protocol::TType _etype974; - xfer += iprot->readListBegin(_etype974, _size971); - this->success.resize(_size971); - uint32_t _i975; - for (_i975 = 0; _i975 < _size971; ++_i975) + uint32_t _size993; + ::apache::thrift::protocol::TType _etype996; + xfer += iprot->readListBegin(_etype996, _size993); + this->success.resize(_size993); + uint32_t _i997; + for (_i997 = 0; _i997 < _size993; ++_i997) { - xfer += this->success[_i975].read(iprot); + xfer += this->success[_i997].read(iprot); } xfer += iprot->readListEnd(); } @@ -2945,10 +2945,10 @@ uint32_t ThriftHiveMetastore_get_fields_result::write(::apache::thrift::protocol xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter976; - for (_iter976 = this->success.begin(); _iter976 != this->success.end(); ++_iter976) + std::vector ::const_iterator _iter998; + for (_iter998 = this->success.begin(); _iter998 != this->success.end(); ++_iter998) { - xfer += (*_iter976).write(oprot); + xfer += (*_iter998).write(oprot); } xfer += oprot->writeListEnd(); } @@ -3001,14 +3001,14 @@ uint32_t ThriftHiveMetastore_get_fields_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size977; - ::apache::thrift::protocol::TType _etype980; - xfer += iprot->readListBegin(_etype980, _size977); - (*(this->success)).resize(_size977); - uint32_t _i981; - for (_i981 = 0; _i981 < _size977; ++_i981) + uint32_t _size999; + ::apache::thrift::protocol::TType _etype1002; + xfer += iprot->readListBegin(_etype1002, _size999); + (*(this->success)).resize(_size999); + uint32_t _i1003; + for (_i1003 = 0; _i1003 < _size999; ++_i1003) { - xfer += (*(this->success))[_i981].read(iprot); + xfer += (*(this->success))[_i1003].read(iprot); } xfer += iprot->readListEnd(); } @@ -3194,14 +3194,14 @@ uint32_t ThriftHiveMetastore_get_fields_with_environment_context_result::read(:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size982; - ::apache::thrift::protocol::TType _etype985; - xfer += iprot->readListBegin(_etype985, _size982); - this->success.resize(_size982); - uint32_t _i986; - for (_i986 = 0; _i986 < _size982; ++_i986) + uint32_t _size1004; + ::apache::thrift::protocol::TType _etype1007; + xfer += iprot->readListBegin(_etype1007, _size1004); + this->success.resize(_size1004); + uint32_t _i1008; + for (_i1008 = 0; _i1008 < _size1004; ++_i1008) { - xfer += this->success[_i986].read(iprot); + xfer += this->success[_i1008].read(iprot); } xfer += iprot->readListEnd(); } @@ -3256,10 +3256,10 @@ uint32_t ThriftHiveMetastore_get_fields_with_environment_context_result::write(: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter987; - for (_iter987 = this->success.begin(); _iter987 != this->success.end(); ++_iter987) + std::vector ::const_iterator _iter1009; + for (_iter1009 = this->success.begin(); _iter1009 != this->success.end(); ++_iter1009) { - xfer += (*_iter987).write(oprot); + xfer += (*_iter1009).write(oprot); } xfer += oprot->writeListEnd(); } @@ -3312,14 +3312,14 @@ uint32_t ThriftHiveMetastore_get_fields_with_environment_context_presult::read(: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size988; - ::apache::thrift::protocol::TType _etype991; - xfer += iprot->readListBegin(_etype991, _size988); - (*(this->success)).resize(_size988); - uint32_t _i992; - for (_i992 = 0; _i992 < _size988; ++_i992) + uint32_t _size1010; + ::apache::thrift::protocol::TType _etype1013; + xfer += iprot->readListBegin(_etype1013, _size1010); + (*(this->success)).resize(_size1010); + uint32_t _i1014; + for (_i1014 = 0; _i1014 < _size1010; ++_i1014) { - xfer += (*(this->success))[_i992].read(iprot); + xfer += (*(this->success))[_i1014].read(iprot); } xfer += iprot->readListEnd(); } @@ -3489,14 +3489,14 @@ uint32_t ThriftHiveMetastore_get_schema_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size993; - ::apache::thrift::protocol::TType _etype996; - xfer += iprot->readListBegin(_etype996, _size993); - this->success.resize(_size993); - uint32_t _i997; - for (_i997 = 0; _i997 < _size993; ++_i997) + uint32_t _size1015; + ::apache::thrift::protocol::TType _etype1018; + xfer += iprot->readListBegin(_etype1018, _size1015); + this->success.resize(_size1015); + uint32_t _i1019; + for (_i1019 = 0; _i1019 < _size1015; ++_i1019) { - xfer += this->success[_i997].read(iprot); + xfer += this->success[_i1019].read(iprot); } xfer += iprot->readListEnd(); } @@ -3551,10 +3551,10 @@ uint32_t ThriftHiveMetastore_get_schema_result::write(::apache::thrift::protocol xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter998; - for (_iter998 = this->success.begin(); _iter998 != this->success.end(); ++_iter998) + std::vector ::const_iterator _iter1020; + for (_iter1020 = this->success.begin(); _iter1020 != this->success.end(); ++_iter1020) { - xfer += (*_iter998).write(oprot); + xfer += (*_iter1020).write(oprot); } xfer += oprot->writeListEnd(); } @@ -3607,14 +3607,14 @@ uint32_t ThriftHiveMetastore_get_schema_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size999; - ::apache::thrift::protocol::TType _etype1002; - xfer += iprot->readListBegin(_etype1002, _size999); - (*(this->success)).resize(_size999); - uint32_t _i1003; - for (_i1003 = 0; _i1003 < _size999; ++_i1003) + uint32_t _size1021; + ::apache::thrift::protocol::TType _etype1024; + xfer += iprot->readListBegin(_etype1024, _size1021); + (*(this->success)).resize(_size1021); + uint32_t _i1025; + for (_i1025 = 0; _i1025 < _size1021; ++_i1025) { - xfer += (*(this->success))[_i1003].read(iprot); + xfer += (*(this->success))[_i1025].read(iprot); } xfer += iprot->readListEnd(); } @@ -3800,14 +3800,14 @@ uint32_t ThriftHiveMetastore_get_schema_with_environment_context_result::read(:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1004; - ::apache::thrift::protocol::TType _etype1007; - xfer += iprot->readListBegin(_etype1007, _size1004); - this->success.resize(_size1004); - uint32_t _i1008; - for (_i1008 = 0; _i1008 < _size1004; ++_i1008) + uint32_t _size1026; + ::apache::thrift::protocol::TType _etype1029; + xfer += iprot->readListBegin(_etype1029, _size1026); + this->success.resize(_size1026); + uint32_t _i1030; + for (_i1030 = 0; _i1030 < _size1026; ++_i1030) { - xfer += this->success[_i1008].read(iprot); + xfer += this->success[_i1030].read(iprot); } xfer += iprot->readListEnd(); } @@ -3862,10 +3862,10 @@ uint32_t ThriftHiveMetastore_get_schema_with_environment_context_result::write(: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1009; - for (_iter1009 = this->success.begin(); _iter1009 != this->success.end(); ++_iter1009) + std::vector ::const_iterator _iter1031; + for (_iter1031 = this->success.begin(); _iter1031 != this->success.end(); ++_iter1031) { - xfer += (*_iter1009).write(oprot); + xfer += (*_iter1031).write(oprot); } xfer += oprot->writeListEnd(); } @@ -3918,14 +3918,14 @@ uint32_t ThriftHiveMetastore_get_schema_with_environment_context_presult::read(: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1010; - ::apache::thrift::protocol::TType _etype1013; - xfer += iprot->readListBegin(_etype1013, _size1010); - (*(this->success)).resize(_size1010); - uint32_t _i1014; - for (_i1014 = 0; _i1014 < _size1010; ++_i1014) + uint32_t _size1032; + ::apache::thrift::protocol::TType _etype1035; + xfer += iprot->readListBegin(_etype1035, _size1032); + (*(this->success)).resize(_size1032); + uint32_t _i1036; + for (_i1036 = 0; _i1036 < _size1032; ++_i1036) { - xfer += (*(this->success))[_i1014].read(iprot); + xfer += (*(this->success))[_i1036].read(iprot); } xfer += iprot->readListEnd(); } @@ -4518,14 +4518,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->primaryKeys.clear(); - uint32_t _size1015; - ::apache::thrift::protocol::TType _etype1018; - xfer += iprot->readListBegin(_etype1018, _size1015); - this->primaryKeys.resize(_size1015); - uint32_t _i1019; - for (_i1019 = 0; _i1019 < _size1015; ++_i1019) + uint32_t _size1037; + ::apache::thrift::protocol::TType _etype1040; + xfer += iprot->readListBegin(_etype1040, _size1037); + this->primaryKeys.resize(_size1037); + uint32_t _i1041; + for (_i1041 = 0; _i1041 < _size1037; ++_i1041) { - xfer += this->primaryKeys[_i1019].read(iprot); + xfer += this->primaryKeys[_i1041].read(iprot); } xfer += iprot->readListEnd(); } @@ -4538,14 +4538,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->foreignKeys.clear(); - uint32_t _size1020; - ::apache::thrift::protocol::TType _etype1023; - xfer += iprot->readListBegin(_etype1023, _size1020); - this->foreignKeys.resize(_size1020); - uint32_t _i1024; - for (_i1024 = 0; _i1024 < _size1020; ++_i1024) + uint32_t _size1042; + ::apache::thrift::protocol::TType _etype1045; + xfer += iprot->readListBegin(_etype1045, _size1042); + this->foreignKeys.resize(_size1042); + uint32_t _i1046; + for (_i1046 = 0; _i1046 < _size1042; ++_i1046) { - xfer += this->foreignKeys[_i1024].read(iprot); + xfer += this->foreignKeys[_i1046].read(iprot); } xfer += iprot->readListEnd(); } @@ -4558,14 +4558,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->uniqueConstraints.clear(); - uint32_t _size1025; - ::apache::thrift::protocol::TType _etype1028; - xfer += iprot->readListBegin(_etype1028, _size1025); - this->uniqueConstraints.resize(_size1025); - uint32_t _i1029; - for (_i1029 = 0; _i1029 < _size1025; ++_i1029) + uint32_t _size1047; + ::apache::thrift::protocol::TType _etype1050; + xfer += iprot->readListBegin(_etype1050, _size1047); + this->uniqueConstraints.resize(_size1047); + uint32_t _i1051; + for (_i1051 = 0; _i1051 < _size1047; ++_i1051) { - xfer += this->uniqueConstraints[_i1029].read(iprot); + xfer += this->uniqueConstraints[_i1051].read(iprot); } xfer += iprot->readListEnd(); } @@ -4578,14 +4578,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->notNullConstraints.clear(); - uint32_t _size1030; - ::apache::thrift::protocol::TType _etype1033; - xfer += iprot->readListBegin(_etype1033, _size1030); - this->notNullConstraints.resize(_size1030); - uint32_t _i1034; - for (_i1034 = 0; _i1034 < _size1030; ++_i1034) + uint32_t _size1052; + ::apache::thrift::protocol::TType _etype1055; + xfer += iprot->readListBegin(_etype1055, _size1052); + this->notNullConstraints.resize(_size1052); + uint32_t _i1056; + for (_i1056 = 0; _i1056 < _size1052; ++_i1056) { - xfer += this->notNullConstraints[_i1034].read(iprot); + xfer += this->notNullConstraints[_i1056].read(iprot); } xfer += iprot->readListEnd(); } @@ -4618,10 +4618,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache: xfer += oprot->writeFieldBegin("primaryKeys", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->primaryKeys.size())); - std::vector ::const_iterator _iter1035; - for (_iter1035 = this->primaryKeys.begin(); _iter1035 != this->primaryKeys.end(); ++_iter1035) + std::vector ::const_iterator _iter1057; + for (_iter1057 = this->primaryKeys.begin(); _iter1057 != this->primaryKeys.end(); ++_iter1057) { - xfer += (*_iter1035).write(oprot); + xfer += (*_iter1057).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4630,10 +4630,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache: xfer += oprot->writeFieldBegin("foreignKeys", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->foreignKeys.size())); - std::vector ::const_iterator _iter1036; - for (_iter1036 = this->foreignKeys.begin(); _iter1036 != this->foreignKeys.end(); ++_iter1036) + std::vector ::const_iterator _iter1058; + for (_iter1058 = this->foreignKeys.begin(); _iter1058 != this->foreignKeys.end(); ++_iter1058) { - xfer += (*_iter1036).write(oprot); + xfer += (*_iter1058).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4642,10 +4642,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache: xfer += oprot->writeFieldBegin("uniqueConstraints", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->uniqueConstraints.size())); - std::vector ::const_iterator _iter1037; - for (_iter1037 = this->uniqueConstraints.begin(); _iter1037 != this->uniqueConstraints.end(); ++_iter1037) + std::vector ::const_iterator _iter1059; + for (_iter1059 = this->uniqueConstraints.begin(); _iter1059 != this->uniqueConstraints.end(); ++_iter1059) { - xfer += (*_iter1037).write(oprot); + xfer += (*_iter1059).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4654,10 +4654,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache: xfer += oprot->writeFieldBegin("notNullConstraints", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->notNullConstraints.size())); - std::vector ::const_iterator _iter1038; - for (_iter1038 = this->notNullConstraints.begin(); _iter1038 != this->notNullConstraints.end(); ++_iter1038) + std::vector ::const_iterator _iter1060; + for (_iter1060 = this->notNullConstraints.begin(); _iter1060 != this->notNullConstraints.end(); ++_iter1060) { - xfer += (*_iter1038).write(oprot); + xfer += (*_iter1060).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4685,10 +4685,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache xfer += oprot->writeFieldBegin("primaryKeys", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->primaryKeys)).size())); - std::vector ::const_iterator _iter1039; - for (_iter1039 = (*(this->primaryKeys)).begin(); _iter1039 != (*(this->primaryKeys)).end(); ++_iter1039) + std::vector ::const_iterator _iter1061; + for (_iter1061 = (*(this->primaryKeys)).begin(); _iter1061 != (*(this->primaryKeys)).end(); ++_iter1061) { - xfer += (*_iter1039).write(oprot); + xfer += (*_iter1061).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4697,10 +4697,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache xfer += oprot->writeFieldBegin("foreignKeys", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->foreignKeys)).size())); - std::vector ::const_iterator _iter1040; - for (_iter1040 = (*(this->foreignKeys)).begin(); _iter1040 != (*(this->foreignKeys)).end(); ++_iter1040) + std::vector ::const_iterator _iter1062; + for (_iter1062 = (*(this->foreignKeys)).begin(); _iter1062 != (*(this->foreignKeys)).end(); ++_iter1062) { - xfer += (*_iter1040).write(oprot); + xfer += (*_iter1062).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4709,10 +4709,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache xfer += oprot->writeFieldBegin("uniqueConstraints", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->uniqueConstraints)).size())); - std::vector ::const_iterator _iter1041; - for (_iter1041 = (*(this->uniqueConstraints)).begin(); _iter1041 != (*(this->uniqueConstraints)).end(); ++_iter1041) + std::vector ::const_iterator _iter1063; + for (_iter1063 = (*(this->uniqueConstraints)).begin(); _iter1063 != (*(this->uniqueConstraints)).end(); ++_iter1063) { - xfer += (*_iter1041).write(oprot); + xfer += (*_iter1063).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4721,10 +4721,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache xfer += oprot->writeFieldBegin("notNullConstraints", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->notNullConstraints)).size())); - std::vector ::const_iterator _iter1042; - for (_iter1042 = (*(this->notNullConstraints)).begin(); _iter1042 != (*(this->notNullConstraints)).end(); ++_iter1042) + std::vector ::const_iterator _iter1064; + for (_iter1064 = (*(this->notNullConstraints)).begin(); _iter1064 != (*(this->notNullConstraints)).end(); ++_iter1064) { - xfer += (*_iter1042).write(oprot); + xfer += (*_iter1064).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6478,14 +6478,14 @@ uint32_t ThriftHiveMetastore_truncate_table_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partNames.clear(); - uint32_t _size1043; - ::apache::thrift::protocol::TType _etype1046; - xfer += iprot->readListBegin(_etype1046, _size1043); - this->partNames.resize(_size1043); - uint32_t _i1047; - for (_i1047 = 0; _i1047 < _size1043; ++_i1047) + uint32_t _size1065; + ::apache::thrift::protocol::TType _etype1068; + xfer += iprot->readListBegin(_etype1068, _size1065); + this->partNames.resize(_size1065); + uint32_t _i1069; + for (_i1069 = 0; _i1069 < _size1065; ++_i1069) { - xfer += iprot->readString(this->partNames[_i1047]); + xfer += iprot->readString(this->partNames[_i1069]); } xfer += iprot->readListEnd(); } @@ -6522,10 +6522,10 @@ uint32_t ThriftHiveMetastore_truncate_table_args::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("partNames", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partNames.size())); - std::vector ::const_iterator _iter1048; - for (_iter1048 = this->partNames.begin(); _iter1048 != this->partNames.end(); ++_iter1048) + std::vector ::const_iterator _iter1070; + for (_iter1070 = this->partNames.begin(); _iter1070 != this->partNames.end(); ++_iter1070) { - xfer += oprot->writeString((*_iter1048)); + xfer += oprot->writeString((*_iter1070)); } xfer += oprot->writeListEnd(); } @@ -6557,10 +6557,10 @@ uint32_t ThriftHiveMetastore_truncate_table_pargs::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("partNames", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->partNames)).size())); - std::vector ::const_iterator _iter1049; - for (_iter1049 = (*(this->partNames)).begin(); _iter1049 != (*(this->partNames)).end(); ++_iter1049) + std::vector ::const_iterator _iter1071; + for (_iter1071 = (*(this->partNames)).begin(); _iter1071 != (*(this->partNames)).end(); ++_iter1071) { - xfer += oprot->writeString((*_iter1049)); + xfer += oprot->writeString((*_iter1071)); } xfer += oprot->writeListEnd(); } @@ -6804,14 +6804,14 @@ uint32_t ThriftHiveMetastore_get_tables_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1050; - ::apache::thrift::protocol::TType _etype1053; - xfer += iprot->readListBegin(_etype1053, _size1050); - this->success.resize(_size1050); - uint32_t _i1054; - for (_i1054 = 0; _i1054 < _size1050; ++_i1054) + uint32_t _size1072; + ::apache::thrift::protocol::TType _etype1075; + xfer += iprot->readListBegin(_etype1075, _size1072); + this->success.resize(_size1072); + uint32_t _i1076; + for (_i1076 = 0; _i1076 < _size1072; ++_i1076) { - xfer += iprot->readString(this->success[_i1054]); + xfer += iprot->readString(this->success[_i1076]); } xfer += iprot->readListEnd(); } @@ -6850,10 +6850,10 @@ uint32_t ThriftHiveMetastore_get_tables_result::write(::apache::thrift::protocol xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1055; - for (_iter1055 = this->success.begin(); _iter1055 != this->success.end(); ++_iter1055) + std::vector ::const_iterator _iter1077; + for (_iter1077 = this->success.begin(); _iter1077 != this->success.end(); ++_iter1077) { - xfer += oprot->writeString((*_iter1055)); + xfer += oprot->writeString((*_iter1077)); } xfer += oprot->writeListEnd(); } @@ -6898,14 +6898,14 @@ uint32_t ThriftHiveMetastore_get_tables_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1056; - ::apache::thrift::protocol::TType _etype1059; - xfer += iprot->readListBegin(_etype1059, _size1056); - (*(this->success)).resize(_size1056); - uint32_t _i1060; - for (_i1060 = 0; _i1060 < _size1056; ++_i1060) + uint32_t _size1078; + ::apache::thrift::protocol::TType _etype1081; + xfer += iprot->readListBegin(_etype1081, _size1078); + (*(this->success)).resize(_size1078); + uint32_t _i1082; + for (_i1082 = 0; _i1082 < _size1078; ++_i1082) { - xfer += iprot->readString((*(this->success))[_i1060]); + xfer += iprot->readString((*(this->success))[_i1082]); } xfer += iprot->readListEnd(); } @@ -7075,14 +7075,14 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_result::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1061; - ::apache::thrift::protocol::TType _etype1064; - xfer += iprot->readListBegin(_etype1064, _size1061); - this->success.resize(_size1061); - uint32_t _i1065; - for (_i1065 = 0; _i1065 < _size1061; ++_i1065) + uint32_t _size1083; + ::apache::thrift::protocol::TType _etype1086; + xfer += iprot->readListBegin(_etype1086, _size1083); + this->success.resize(_size1083); + uint32_t _i1087; + for (_i1087 = 0; _i1087 < _size1083; ++_i1087) { - xfer += iprot->readString(this->success[_i1065]); + xfer += iprot->readString(this->success[_i1087]); } xfer += iprot->readListEnd(); } @@ -7121,10 +7121,10 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_result::write(::apache::thrift:: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1066; - for (_iter1066 = this->success.begin(); _iter1066 != this->success.end(); ++_iter1066) + std::vector ::const_iterator _iter1088; + for (_iter1088 = this->success.begin(); _iter1088 != this->success.end(); ++_iter1088) { - xfer += oprot->writeString((*_iter1066)); + xfer += oprot->writeString((*_iter1088)); } xfer += oprot->writeListEnd(); } @@ -7169,14 +7169,14 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_presult::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1067; - ::apache::thrift::protocol::TType _etype1070; - xfer += iprot->readListBegin(_etype1070, _size1067); - (*(this->success)).resize(_size1067); - uint32_t _i1071; - for (_i1071 = 0; _i1071 < _size1067; ++_i1071) + uint32_t _size1089; + ::apache::thrift::protocol::TType _etype1092; + xfer += iprot->readListBegin(_etype1092, _size1089); + (*(this->success)).resize(_size1089); + uint32_t _i1093; + for (_i1093 = 0; _i1093 < _size1089; ++_i1093) { - xfer += iprot->readString((*(this->success))[_i1071]); + xfer += iprot->readString((*(this->success))[_i1093]); } xfer += iprot->readListEnd(); } @@ -7251,14 +7251,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tbl_types.clear(); - uint32_t _size1072; - ::apache::thrift::protocol::TType _etype1075; - xfer += iprot->readListBegin(_etype1075, _size1072); - this->tbl_types.resize(_size1072); - uint32_t _i1076; - for (_i1076 = 0; _i1076 < _size1072; ++_i1076) + uint32_t _size1094; + ::apache::thrift::protocol::TType _etype1097; + xfer += iprot->readListBegin(_etype1097, _size1094); + this->tbl_types.resize(_size1094); + uint32_t _i1098; + for (_i1098 = 0; _i1098 < _size1094; ++_i1098) { - xfer += iprot->readString(this->tbl_types[_i1076]); + xfer += iprot->readString(this->tbl_types[_i1098]); } xfer += iprot->readListEnd(); } @@ -7295,10 +7295,10 @@ uint32_t ThriftHiveMetastore_get_table_meta_args::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("tbl_types", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->tbl_types.size())); - std::vector ::const_iterator _iter1077; - for (_iter1077 = this->tbl_types.begin(); _iter1077 != this->tbl_types.end(); ++_iter1077) + std::vector ::const_iterator _iter1099; + for (_iter1099 = this->tbl_types.begin(); _iter1099 != this->tbl_types.end(); ++_iter1099) { - xfer += oprot->writeString((*_iter1077)); + xfer += oprot->writeString((*_iter1099)); } xfer += oprot->writeListEnd(); } @@ -7330,10 +7330,10 @@ uint32_t ThriftHiveMetastore_get_table_meta_pargs::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("tbl_types", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->tbl_types)).size())); - std::vector ::const_iterator _iter1078; - for (_iter1078 = (*(this->tbl_types)).begin(); _iter1078 != (*(this->tbl_types)).end(); ++_iter1078) + std::vector ::const_iterator _iter1100; + for (_iter1100 = (*(this->tbl_types)).begin(); _iter1100 != (*(this->tbl_types)).end(); ++_iter1100) { - xfer += oprot->writeString((*_iter1078)); + xfer += oprot->writeString((*_iter1100)); } xfer += oprot->writeListEnd(); } @@ -7374,14 +7374,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1079; - ::apache::thrift::protocol::TType _etype1082; - xfer += iprot->readListBegin(_etype1082, _size1079); - this->success.resize(_size1079); - uint32_t _i1083; - for (_i1083 = 0; _i1083 < _size1079; ++_i1083) + uint32_t _size1101; + ::apache::thrift::protocol::TType _etype1104; + xfer += iprot->readListBegin(_etype1104, _size1101); + this->success.resize(_size1101); + uint32_t _i1105; + for (_i1105 = 0; _i1105 < _size1101; ++_i1105) { - xfer += this->success[_i1083].read(iprot); + xfer += this->success[_i1105].read(iprot); } xfer += iprot->readListEnd(); } @@ -7420,10 +7420,10 @@ uint32_t ThriftHiveMetastore_get_table_meta_result::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1084; - for (_iter1084 = this->success.begin(); _iter1084 != this->success.end(); ++_iter1084) + std::vector ::const_iterator _iter1106; + for (_iter1106 = this->success.begin(); _iter1106 != this->success.end(); ++_iter1106) { - xfer += (*_iter1084).write(oprot); + xfer += (*_iter1106).write(oprot); } xfer += oprot->writeListEnd(); } @@ -7468,14 +7468,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1085; - ::apache::thrift::protocol::TType _etype1088; - xfer += iprot->readListBegin(_etype1088, _size1085); - (*(this->success)).resize(_size1085); - uint32_t _i1089; - for (_i1089 = 0; _i1089 < _size1085; ++_i1089) + uint32_t _size1107; + ::apache::thrift::protocol::TType _etype1110; + xfer += iprot->readListBegin(_etype1110, _size1107); + (*(this->success)).resize(_size1107); + uint32_t _i1111; + for (_i1111 = 0; _i1111 < _size1107; ++_i1111) { - xfer += (*(this->success))[_i1089].read(iprot); + xfer += (*(this->success))[_i1111].read(iprot); } xfer += iprot->readListEnd(); } @@ -7613,14 +7613,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1090; - ::apache::thrift::protocol::TType _etype1093; - xfer += iprot->readListBegin(_etype1093, _size1090); - this->success.resize(_size1090); - uint32_t _i1094; - for (_i1094 = 0; _i1094 < _size1090; ++_i1094) + uint32_t _size1112; + ::apache::thrift::protocol::TType _etype1115; + xfer += iprot->readListBegin(_etype1115, _size1112); + this->success.resize(_size1112); + uint32_t _i1116; + for (_i1116 = 0; _i1116 < _size1112; ++_i1116) { - xfer += iprot->readString(this->success[_i1094]); + xfer += iprot->readString(this->success[_i1116]); } xfer += iprot->readListEnd(); } @@ -7659,10 +7659,10 @@ uint32_t ThriftHiveMetastore_get_all_tables_result::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1095; - for (_iter1095 = this->success.begin(); _iter1095 != this->success.end(); ++_iter1095) + std::vector ::const_iterator _iter1117; + for (_iter1117 = this->success.begin(); _iter1117 != this->success.end(); ++_iter1117) { - xfer += oprot->writeString((*_iter1095)); + xfer += oprot->writeString((*_iter1117)); } xfer += oprot->writeListEnd(); } @@ -7707,14 +7707,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1096; - ::apache::thrift::protocol::TType _etype1099; - xfer += iprot->readListBegin(_etype1099, _size1096); - (*(this->success)).resize(_size1096); - uint32_t _i1100; - for (_i1100 = 0; _i1100 < _size1096; ++_i1100) + uint32_t _size1118; + ::apache::thrift::protocol::TType _etype1121; + xfer += iprot->readListBegin(_etype1121, _size1118); + (*(this->success)).resize(_size1118); + uint32_t _i1122; + for (_i1122 = 0; _i1122 < _size1118; ++_i1122) { - xfer += iprot->readString((*(this->success))[_i1100]); + xfer += iprot->readString((*(this->success))[_i1122]); } xfer += iprot->readListEnd(); } @@ -8024,14 +8024,14 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_args::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tbl_names.clear(); - uint32_t _size1101; - ::apache::thrift::protocol::TType _etype1104; - xfer += iprot->readListBegin(_etype1104, _size1101); - this->tbl_names.resize(_size1101); - uint32_t _i1105; - for (_i1105 = 0; _i1105 < _size1101; ++_i1105) + uint32_t _size1123; + ::apache::thrift::protocol::TType _etype1126; + xfer += iprot->readListBegin(_etype1126, _size1123); + this->tbl_names.resize(_size1123); + uint32_t _i1127; + for (_i1127 = 0; _i1127 < _size1123; ++_i1127) { - xfer += iprot->readString(this->tbl_names[_i1105]); + xfer += iprot->readString(this->tbl_names[_i1127]); } xfer += iprot->readListEnd(); } @@ -8064,10 +8064,10 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_args::write(::apache::thr xfer += oprot->writeFieldBegin("tbl_names", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->tbl_names.size())); - std::vector ::const_iterator _iter1106; - for (_iter1106 = this->tbl_names.begin(); _iter1106 != this->tbl_names.end(); ++_iter1106) + std::vector ::const_iterator _iter1128; + for (_iter1128 = this->tbl_names.begin(); _iter1128 != this->tbl_names.end(); ++_iter1128) { - xfer += oprot->writeString((*_iter1106)); + xfer += oprot->writeString((*_iter1128)); } xfer += oprot->writeListEnd(); } @@ -8095,10 +8095,10 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_pargs::write(::apache::th xfer += oprot->writeFieldBegin("tbl_names", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->tbl_names)).size())); - std::vector ::const_iterator _iter1107; - for (_iter1107 = (*(this->tbl_names)).begin(); _iter1107 != (*(this->tbl_names)).end(); ++_iter1107) + std::vector ::const_iterator _iter1129; + for (_iter1129 = (*(this->tbl_names)).begin(); _iter1129 != (*(this->tbl_names)).end(); ++_iter1129) { - xfer += oprot->writeString((*_iter1107)); + xfer += oprot->writeString((*_iter1129)); } xfer += oprot->writeListEnd(); } @@ -8139,14 +8139,14 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_result::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1108; - ::apache::thrift::protocol::TType _etype1111; - xfer += iprot->readListBegin(_etype1111, _size1108); - this->success.resize(_size1108); - uint32_t _i1112; - for (_i1112 = 0; _i1112 < _size1108; ++_i1112) + uint32_t _size1130; + ::apache::thrift::protocol::TType _etype1133; + xfer += iprot->readListBegin(_etype1133, _size1130); + this->success.resize(_size1130); + uint32_t _i1134; + for (_i1134 = 0; _i1134 < _size1130; ++_i1134) { - xfer += this->success[_i1112].read(iprot); + xfer += this->success[_i1134].read(iprot); } xfer += iprot->readListEnd(); } @@ -8177,10 +8177,10 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_result::write(::apache::t xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1113; - for (_iter1113 = this->success.begin(); _iter1113 != this->success.end(); ++_iter1113) + std::vector
::const_iterator _iter1135; + for (_iter1135 = this->success.begin(); _iter1135 != this->success.end(); ++_iter1135) { - xfer += (*_iter1113).write(oprot); + xfer += (*_iter1135).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8221,14 +8221,14 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_presult::read(::apache::t if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1114; - ::apache::thrift::protocol::TType _etype1117; - xfer += iprot->readListBegin(_etype1117, _size1114); - (*(this->success)).resize(_size1114); - uint32_t _i1118; - for (_i1118 = 0; _i1118 < _size1114; ++_i1118) + uint32_t _size1136; + ::apache::thrift::protocol::TType _etype1139; + xfer += iprot->readListBegin(_etype1139, _size1136); + (*(this->success)).resize(_size1136); + uint32_t _i1140; + for (_i1140 = 0; _i1140 < _size1136; ++_i1140) { - xfer += (*(this->success))[_i1118].read(iprot); + xfer += (*(this->success))[_i1140].read(iprot); } xfer += iprot->readListEnd(); } @@ -8864,14 +8864,14 @@ uint32_t ThriftHiveMetastore_get_table_names_by_filter_result::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1119; - ::apache::thrift::protocol::TType _etype1122; - xfer += iprot->readListBegin(_etype1122, _size1119); - this->success.resize(_size1119); - uint32_t _i1123; - for (_i1123 = 0; _i1123 < _size1119; ++_i1123) + uint32_t _size1141; + ::apache::thrift::protocol::TType _etype1144; + xfer += iprot->readListBegin(_etype1144, _size1141); + this->success.resize(_size1141); + uint32_t _i1145; + for (_i1145 = 0; _i1145 < _size1141; ++_i1145) { - xfer += iprot->readString(this->success[_i1123]); + xfer += iprot->readString(this->success[_i1145]); } xfer += iprot->readListEnd(); } @@ -8926,10 +8926,10 @@ uint32_t ThriftHiveMetastore_get_table_names_by_filter_result::write(::apache::t xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1124; - for (_iter1124 = this->success.begin(); _iter1124 != this->success.end(); ++_iter1124) + std::vector ::const_iterator _iter1146; + for (_iter1146 = this->success.begin(); _iter1146 != this->success.end(); ++_iter1146) { - xfer += oprot->writeString((*_iter1124)); + xfer += oprot->writeString((*_iter1146)); } xfer += oprot->writeListEnd(); } @@ -8982,14 +8982,14 @@ uint32_t ThriftHiveMetastore_get_table_names_by_filter_presult::read(::apache::t if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1125; - ::apache::thrift::protocol::TType _etype1128; - xfer += iprot->readListBegin(_etype1128, _size1125); - (*(this->success)).resize(_size1125); - uint32_t _i1129; - for (_i1129 = 0; _i1129 < _size1125; ++_i1129) + uint32_t _size1147; + ::apache::thrift::protocol::TType _etype1150; + xfer += iprot->readListBegin(_etype1150, _size1147); + (*(this->success)).resize(_size1147); + uint32_t _i1151; + for (_i1151 = 0; _i1151 < _size1147; ++_i1151) { - xfer += iprot->readString((*(this->success))[_i1129]); + xfer += iprot->readString((*(this->success))[_i1151]); } xfer += iprot->readListEnd(); } @@ -10323,14 +10323,14 @@ uint32_t ThriftHiveMetastore_add_partitions_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size1130; - ::apache::thrift::protocol::TType _etype1133; - xfer += iprot->readListBegin(_etype1133, _size1130); - this->new_parts.resize(_size1130); - uint32_t _i1134; - for (_i1134 = 0; _i1134 < _size1130; ++_i1134) + uint32_t _size1152; + ::apache::thrift::protocol::TType _etype1155; + xfer += iprot->readListBegin(_etype1155, _size1152); + this->new_parts.resize(_size1152); + uint32_t _i1156; + for (_i1156 = 0; _i1156 < _size1152; ++_i1156) { - xfer += this->new_parts[_i1134].read(iprot); + xfer += this->new_parts[_i1156].read(iprot); } xfer += iprot->readListEnd(); } @@ -10359,10 +10359,10 @@ uint32_t ThriftHiveMetastore_add_partitions_args::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->new_parts.size())); - std::vector ::const_iterator _iter1135; - for (_iter1135 = this->new_parts.begin(); _iter1135 != this->new_parts.end(); ++_iter1135) + std::vector ::const_iterator _iter1157; + for (_iter1157 = this->new_parts.begin(); _iter1157 != this->new_parts.end(); ++_iter1157) { - xfer += (*_iter1135).write(oprot); + xfer += (*_iter1157).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10386,10 +10386,10 @@ uint32_t ThriftHiveMetastore_add_partitions_pargs::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->new_parts)).size())); - std::vector ::const_iterator _iter1136; - for (_iter1136 = (*(this->new_parts)).begin(); _iter1136 != (*(this->new_parts)).end(); ++_iter1136) + std::vector ::const_iterator _iter1158; + for (_iter1158 = (*(this->new_parts)).begin(); _iter1158 != (*(this->new_parts)).end(); ++_iter1158) { - xfer += (*_iter1136).write(oprot); + xfer += (*_iter1158).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10598,14 +10598,14 @@ uint32_t ThriftHiveMetastore_add_partitions_pspec_args::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size1137; - ::apache::thrift::protocol::TType _etype1140; - xfer += iprot->readListBegin(_etype1140, _size1137); - this->new_parts.resize(_size1137); - uint32_t _i1141; - for (_i1141 = 0; _i1141 < _size1137; ++_i1141) + uint32_t _size1159; + ::apache::thrift::protocol::TType _etype1162; + xfer += iprot->readListBegin(_etype1162, _size1159); + this->new_parts.resize(_size1159); + uint32_t _i1163; + for (_i1163 = 0; _i1163 < _size1159; ++_i1163) { - xfer += this->new_parts[_i1141].read(iprot); + xfer += this->new_parts[_i1163].read(iprot); } xfer += iprot->readListEnd(); } @@ -10634,10 +10634,10 @@ uint32_t ThriftHiveMetastore_add_partitions_pspec_args::write(::apache::thrift:: xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->new_parts.size())); - std::vector ::const_iterator _iter1142; - for (_iter1142 = this->new_parts.begin(); _iter1142 != this->new_parts.end(); ++_iter1142) + std::vector ::const_iterator _iter1164; + for (_iter1164 = this->new_parts.begin(); _iter1164 != this->new_parts.end(); ++_iter1164) { - xfer += (*_iter1142).write(oprot); + xfer += (*_iter1164).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10661,10 +10661,10 @@ uint32_t ThriftHiveMetastore_add_partitions_pspec_pargs::write(::apache::thrift: xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->new_parts)).size())); - std::vector ::const_iterator _iter1143; - for (_iter1143 = (*(this->new_parts)).begin(); _iter1143 != (*(this->new_parts)).end(); ++_iter1143) + std::vector ::const_iterator _iter1165; + for (_iter1165 = (*(this->new_parts)).begin(); _iter1165 != (*(this->new_parts)).end(); ++_iter1165) { - xfer += (*_iter1143).write(oprot); + xfer += (*_iter1165).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10889,14 +10889,14 @@ uint32_t ThriftHiveMetastore_append_partition_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1144; - ::apache::thrift::protocol::TType _etype1147; - xfer += iprot->readListBegin(_etype1147, _size1144); - this->part_vals.resize(_size1144); - uint32_t _i1148; - for (_i1148 = 0; _i1148 < _size1144; ++_i1148) + uint32_t _size1166; + ::apache::thrift::protocol::TType _etype1169; + xfer += iprot->readListBegin(_etype1169, _size1166); + this->part_vals.resize(_size1166); + uint32_t _i1170; + for (_i1170 = 0; _i1170 < _size1166; ++_i1170) { - xfer += iprot->readString(this->part_vals[_i1148]); + xfer += iprot->readString(this->part_vals[_i1170]); } xfer += iprot->readListEnd(); } @@ -10933,10 +10933,10 @@ uint32_t ThriftHiveMetastore_append_partition_args::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter1149; - for (_iter1149 = this->part_vals.begin(); _iter1149 != this->part_vals.end(); ++_iter1149) + std::vector ::const_iterator _iter1171; + for (_iter1171 = this->part_vals.begin(); _iter1171 != this->part_vals.end(); ++_iter1171) { - xfer += oprot->writeString((*_iter1149)); + xfer += oprot->writeString((*_iter1171)); } xfer += oprot->writeListEnd(); } @@ -10968,10 +10968,10 @@ uint32_t ThriftHiveMetastore_append_partition_pargs::write(::apache::thrift::pro xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter1150; - for (_iter1150 = (*(this->part_vals)).begin(); _iter1150 != (*(this->part_vals)).end(); ++_iter1150) + std::vector ::const_iterator _iter1172; + for (_iter1172 = (*(this->part_vals)).begin(); _iter1172 != (*(this->part_vals)).end(); ++_iter1172) { - xfer += oprot->writeString((*_iter1150)); + xfer += oprot->writeString((*_iter1172)); } xfer += oprot->writeListEnd(); } @@ -11443,14 +11443,14 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::rea if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1151; - ::apache::thrift::protocol::TType _etype1154; - xfer += iprot->readListBegin(_etype1154, _size1151); - this->part_vals.resize(_size1151); - uint32_t _i1155; - for (_i1155 = 0; _i1155 < _size1151; ++_i1155) + uint32_t _size1173; + ::apache::thrift::protocol::TType _etype1176; + xfer += iprot->readListBegin(_etype1176, _size1173); + this->part_vals.resize(_size1173); + uint32_t _i1177; + for (_i1177 = 0; _i1177 < _size1173; ++_i1177) { - xfer += iprot->readString(this->part_vals[_i1155]); + xfer += iprot->readString(this->part_vals[_i1177]); } xfer += iprot->readListEnd(); } @@ -11495,10 +11495,10 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::wri xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter1156; - for (_iter1156 = this->part_vals.begin(); _iter1156 != this->part_vals.end(); ++_iter1156) + std::vector ::const_iterator _iter1178; + for (_iter1178 = this->part_vals.begin(); _iter1178 != this->part_vals.end(); ++_iter1178) { - xfer += oprot->writeString((*_iter1156)); + xfer += oprot->writeString((*_iter1178)); } xfer += oprot->writeListEnd(); } @@ -11534,10 +11534,10 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_pargs::wr xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter1157; - for (_iter1157 = (*(this->part_vals)).begin(); _iter1157 != (*(this->part_vals)).end(); ++_iter1157) + std::vector ::const_iterator _iter1179; + for (_iter1179 = (*(this->part_vals)).begin(); _iter1179 != (*(this->part_vals)).end(); ++_iter1179) { - xfer += oprot->writeString((*_iter1157)); + xfer += oprot->writeString((*_iter1179)); } xfer += oprot->writeListEnd(); } @@ -12340,14 +12340,14 @@ uint32_t ThriftHiveMetastore_drop_partition_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1158; - ::apache::thrift::protocol::TType _etype1161; - xfer += iprot->readListBegin(_etype1161, _size1158); - this->part_vals.resize(_size1158); - uint32_t _i1162; - for (_i1162 = 0; _i1162 < _size1158; ++_i1162) + uint32_t _size1180; + ::apache::thrift::protocol::TType _etype1183; + xfer += iprot->readListBegin(_etype1183, _size1180); + this->part_vals.resize(_size1180); + uint32_t _i1184; + for (_i1184 = 0; _i1184 < _size1180; ++_i1184) { - xfer += iprot->readString(this->part_vals[_i1162]); + xfer += iprot->readString(this->part_vals[_i1184]); } xfer += iprot->readListEnd(); } @@ -12392,10 +12392,10 @@ uint32_t ThriftHiveMetastore_drop_partition_args::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter1163; - for (_iter1163 = this->part_vals.begin(); _iter1163 != this->part_vals.end(); ++_iter1163) + std::vector ::const_iterator _iter1185; + for (_iter1185 = this->part_vals.begin(); _iter1185 != this->part_vals.end(); ++_iter1185) { - xfer += oprot->writeString((*_iter1163)); + xfer += oprot->writeString((*_iter1185)); } xfer += oprot->writeListEnd(); } @@ -12431,10 +12431,10 @@ uint32_t ThriftHiveMetastore_drop_partition_pargs::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter1164; - for (_iter1164 = (*(this->part_vals)).begin(); _iter1164 != (*(this->part_vals)).end(); ++_iter1164) + std::vector ::const_iterator _iter1186; + for (_iter1186 = (*(this->part_vals)).begin(); _iter1186 != (*(this->part_vals)).end(); ++_iter1186) { - xfer += oprot->writeString((*_iter1164)); + xfer += oprot->writeString((*_iter1186)); } xfer += oprot->writeListEnd(); } @@ -12643,14 +12643,14 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::read( if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1165; - ::apache::thrift::protocol::TType _etype1168; - xfer += iprot->readListBegin(_etype1168, _size1165); - this->part_vals.resize(_size1165); - uint32_t _i1169; - for (_i1169 = 0; _i1169 < _size1165; ++_i1169) + uint32_t _size1187; + ::apache::thrift::protocol::TType _etype1190; + xfer += iprot->readListBegin(_etype1190, _size1187); + this->part_vals.resize(_size1187); + uint32_t _i1191; + for (_i1191 = 0; _i1191 < _size1187; ++_i1191) { - xfer += iprot->readString(this->part_vals[_i1169]); + xfer += iprot->readString(this->part_vals[_i1191]); } xfer += iprot->readListEnd(); } @@ -12703,10 +12703,10 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::write xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter1170; - for (_iter1170 = this->part_vals.begin(); _iter1170 != this->part_vals.end(); ++_iter1170) + std::vector ::const_iterator _iter1192; + for (_iter1192 = this->part_vals.begin(); _iter1192 != this->part_vals.end(); ++_iter1192) { - xfer += oprot->writeString((*_iter1170)); + xfer += oprot->writeString((*_iter1192)); } xfer += oprot->writeListEnd(); } @@ -12746,10 +12746,10 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_pargs::writ xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter1171; - for (_iter1171 = (*(this->part_vals)).begin(); _iter1171 != (*(this->part_vals)).end(); ++_iter1171) + std::vector ::const_iterator _iter1193; + for (_iter1193 = (*(this->part_vals)).begin(); _iter1193 != (*(this->part_vals)).end(); ++_iter1193) { - xfer += oprot->writeString((*_iter1171)); + xfer += oprot->writeString((*_iter1193)); } xfer += oprot->writeListEnd(); } @@ -13755,14 +13755,14 @@ uint32_t ThriftHiveMetastore_get_partition_args::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1172; - ::apache::thrift::protocol::TType _etype1175; - xfer += iprot->readListBegin(_etype1175, _size1172); - this->part_vals.resize(_size1172); - uint32_t _i1176; - for (_i1176 = 0; _i1176 < _size1172; ++_i1176) + uint32_t _size1194; + ::apache::thrift::protocol::TType _etype1197; + xfer += iprot->readListBegin(_etype1197, _size1194); + this->part_vals.resize(_size1194); + uint32_t _i1198; + for (_i1198 = 0; _i1198 < _size1194; ++_i1198) { - xfer += iprot->readString(this->part_vals[_i1176]); + xfer += iprot->readString(this->part_vals[_i1198]); } xfer += iprot->readListEnd(); } @@ -13799,10 +13799,10 @@ uint32_t ThriftHiveMetastore_get_partition_args::write(::apache::thrift::protoco xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter1177; - for (_iter1177 = this->part_vals.begin(); _iter1177 != this->part_vals.end(); ++_iter1177) + std::vector ::const_iterator _iter1199; + for (_iter1199 = this->part_vals.begin(); _iter1199 != this->part_vals.end(); ++_iter1199) { - xfer += oprot->writeString((*_iter1177)); + xfer += oprot->writeString((*_iter1199)); } xfer += oprot->writeListEnd(); } @@ -13834,10 +13834,10 @@ uint32_t ThriftHiveMetastore_get_partition_pargs::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter1178; - for (_iter1178 = (*(this->part_vals)).begin(); _iter1178 != (*(this->part_vals)).end(); ++_iter1178) + std::vector ::const_iterator _iter1200; + for (_iter1200 = (*(this->part_vals)).begin(); _iter1200 != (*(this->part_vals)).end(); ++_iter1200) { - xfer += oprot->writeString((*_iter1178)); + xfer += oprot->writeString((*_iter1200)); } xfer += oprot->writeListEnd(); } @@ -14026,17 +14026,17 @@ uint32_t ThriftHiveMetastore_exchange_partition_args::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size1179; - ::apache::thrift::protocol::TType _ktype1180; - ::apache::thrift::protocol::TType _vtype1181; - xfer += iprot->readMapBegin(_ktype1180, _vtype1181, _size1179); - uint32_t _i1183; - for (_i1183 = 0; _i1183 < _size1179; ++_i1183) + uint32_t _size1201; + ::apache::thrift::protocol::TType _ktype1202; + ::apache::thrift::protocol::TType _vtype1203; + xfer += iprot->readMapBegin(_ktype1202, _vtype1203, _size1201); + uint32_t _i1205; + for (_i1205 = 0; _i1205 < _size1201; ++_i1205) { - std::string _key1184; - xfer += iprot->readString(_key1184); - std::string& _val1185 = this->partitionSpecs[_key1184]; - xfer += iprot->readString(_val1185); + std::string _key1206; + xfer += iprot->readString(_key1206); + std::string& _val1207 = this->partitionSpecs[_key1206]; + xfer += iprot->readString(_val1207); } xfer += iprot->readMapEnd(); } @@ -14097,11 +14097,11 @@ uint32_t ThriftHiveMetastore_exchange_partition_args::write(::apache::thrift::pr xfer += oprot->writeFieldBegin("partitionSpecs", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->partitionSpecs.size())); - std::map ::const_iterator _iter1186; - for (_iter1186 = this->partitionSpecs.begin(); _iter1186 != this->partitionSpecs.end(); ++_iter1186) + std::map ::const_iterator _iter1208; + for (_iter1208 = this->partitionSpecs.begin(); _iter1208 != this->partitionSpecs.end(); ++_iter1208) { - xfer += oprot->writeString(_iter1186->first); - xfer += oprot->writeString(_iter1186->second); + xfer += oprot->writeString(_iter1208->first); + xfer += oprot->writeString(_iter1208->second); } xfer += oprot->writeMapEnd(); } @@ -14141,11 +14141,11 @@ uint32_t ThriftHiveMetastore_exchange_partition_pargs::write(::apache::thrift::p xfer += oprot->writeFieldBegin("partitionSpecs", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast((*(this->partitionSpecs)).size())); - std::map ::const_iterator _iter1187; - for (_iter1187 = (*(this->partitionSpecs)).begin(); _iter1187 != (*(this->partitionSpecs)).end(); ++_iter1187) + std::map ::const_iterator _iter1209; + for (_iter1209 = (*(this->partitionSpecs)).begin(); _iter1209 != (*(this->partitionSpecs)).end(); ++_iter1209) { - xfer += oprot->writeString(_iter1187->first); - xfer += oprot->writeString(_iter1187->second); + xfer += oprot->writeString(_iter1209->first); + xfer += oprot->writeString(_iter1209->second); } xfer += oprot->writeMapEnd(); } @@ -14390,17 +14390,17 @@ uint32_t ThriftHiveMetastore_exchange_partitions_args::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size1188; - ::apache::thrift::protocol::TType _ktype1189; - ::apache::thrift::protocol::TType _vtype1190; - xfer += iprot->readMapBegin(_ktype1189, _vtype1190, _size1188); - uint32_t _i1192; - for (_i1192 = 0; _i1192 < _size1188; ++_i1192) + uint32_t _size1210; + ::apache::thrift::protocol::TType _ktype1211; + ::apache::thrift::protocol::TType _vtype1212; + xfer += iprot->readMapBegin(_ktype1211, _vtype1212, _size1210); + uint32_t _i1214; + for (_i1214 = 0; _i1214 < _size1210; ++_i1214) { - std::string _key1193; - xfer += iprot->readString(_key1193); - std::string& _val1194 = this->partitionSpecs[_key1193]; - xfer += iprot->readString(_val1194); + std::string _key1215; + xfer += iprot->readString(_key1215); + std::string& _val1216 = this->partitionSpecs[_key1215]; + xfer += iprot->readString(_val1216); } xfer += iprot->readMapEnd(); } @@ -14461,11 +14461,11 @@ uint32_t ThriftHiveMetastore_exchange_partitions_args::write(::apache::thrift::p xfer += oprot->writeFieldBegin("partitionSpecs", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->partitionSpecs.size())); - std::map ::const_iterator _iter1195; - for (_iter1195 = this->partitionSpecs.begin(); _iter1195 != this->partitionSpecs.end(); ++_iter1195) + std::map ::const_iterator _iter1217; + for (_iter1217 = this->partitionSpecs.begin(); _iter1217 != this->partitionSpecs.end(); ++_iter1217) { - xfer += oprot->writeString(_iter1195->first); - xfer += oprot->writeString(_iter1195->second); + xfer += oprot->writeString(_iter1217->first); + xfer += oprot->writeString(_iter1217->second); } xfer += oprot->writeMapEnd(); } @@ -14505,11 +14505,11 @@ uint32_t ThriftHiveMetastore_exchange_partitions_pargs::write(::apache::thrift:: xfer += oprot->writeFieldBegin("partitionSpecs", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast((*(this->partitionSpecs)).size())); - std::map ::const_iterator _iter1196; - for (_iter1196 = (*(this->partitionSpecs)).begin(); _iter1196 != (*(this->partitionSpecs)).end(); ++_iter1196) + std::map ::const_iterator _iter1218; + for (_iter1218 = (*(this->partitionSpecs)).begin(); _iter1218 != (*(this->partitionSpecs)).end(); ++_iter1218) { - xfer += oprot->writeString(_iter1196->first); - xfer += oprot->writeString(_iter1196->second); + xfer += oprot->writeString(_iter1218->first); + xfer += oprot->writeString(_iter1218->second); } xfer += oprot->writeMapEnd(); } @@ -14566,14 +14566,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1197; - ::apache::thrift::protocol::TType _etype1200; - xfer += iprot->readListBegin(_etype1200, _size1197); - this->success.resize(_size1197); - uint32_t _i1201; - for (_i1201 = 0; _i1201 < _size1197; ++_i1201) + uint32_t _size1219; + ::apache::thrift::protocol::TType _etype1222; + xfer += iprot->readListBegin(_etype1222, _size1219); + this->success.resize(_size1219); + uint32_t _i1223; + for (_i1223 = 0; _i1223 < _size1219; ++_i1223) { - xfer += this->success[_i1201].read(iprot); + xfer += this->success[_i1223].read(iprot); } xfer += iprot->readListEnd(); } @@ -14636,10 +14636,10 @@ uint32_t ThriftHiveMetastore_exchange_partitions_result::write(::apache::thrift: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1202; - for (_iter1202 = this->success.begin(); _iter1202 != this->success.end(); ++_iter1202) + std::vector ::const_iterator _iter1224; + for (_iter1224 = this->success.begin(); _iter1224 != this->success.end(); ++_iter1224) { - xfer += (*_iter1202).write(oprot); + xfer += (*_iter1224).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14696,14 +14696,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1203; - ::apache::thrift::protocol::TType _etype1206; - xfer += iprot->readListBegin(_etype1206, _size1203); - (*(this->success)).resize(_size1203); - uint32_t _i1207; - for (_i1207 = 0; _i1207 < _size1203; ++_i1207) + uint32_t _size1225; + ::apache::thrift::protocol::TType _etype1228; + xfer += iprot->readListBegin(_etype1228, _size1225); + (*(this->success)).resize(_size1225); + uint32_t _i1229; + for (_i1229 = 0; _i1229 < _size1225; ++_i1229) { - xfer += (*(this->success))[_i1207].read(iprot); + xfer += (*(this->success))[_i1229].read(iprot); } xfer += iprot->readListEnd(); } @@ -14802,14 +14802,14 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_args::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1208; - ::apache::thrift::protocol::TType _etype1211; - xfer += iprot->readListBegin(_etype1211, _size1208); - this->part_vals.resize(_size1208); - uint32_t _i1212; - for (_i1212 = 0; _i1212 < _size1208; ++_i1212) + uint32_t _size1230; + ::apache::thrift::protocol::TType _etype1233; + xfer += iprot->readListBegin(_etype1233, _size1230); + this->part_vals.resize(_size1230); + uint32_t _i1234; + for (_i1234 = 0; _i1234 < _size1230; ++_i1234) { - xfer += iprot->readString(this->part_vals[_i1212]); + xfer += iprot->readString(this->part_vals[_i1234]); } xfer += iprot->readListEnd(); } @@ -14830,14 +14830,14 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_args::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size1213; - ::apache::thrift::protocol::TType _etype1216; - xfer += iprot->readListBegin(_etype1216, _size1213); - this->group_names.resize(_size1213); - uint32_t _i1217; - for (_i1217 = 0; _i1217 < _size1213; ++_i1217) + uint32_t _size1235; + ::apache::thrift::protocol::TType _etype1238; + xfer += iprot->readListBegin(_etype1238, _size1235); + this->group_names.resize(_size1235); + uint32_t _i1239; + for (_i1239 = 0; _i1239 < _size1235; ++_i1239) { - xfer += iprot->readString(this->group_names[_i1217]); + xfer += iprot->readString(this->group_names[_i1239]); } xfer += iprot->readListEnd(); } @@ -14874,10 +14874,10 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_args::write(::apache::thrif xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter1218; - for (_iter1218 = this->part_vals.begin(); _iter1218 != this->part_vals.end(); ++_iter1218) + std::vector ::const_iterator _iter1240; + for (_iter1240 = this->part_vals.begin(); _iter1240 != this->part_vals.end(); ++_iter1240) { - xfer += oprot->writeString((*_iter1218)); + xfer += oprot->writeString((*_iter1240)); } xfer += oprot->writeListEnd(); } @@ -14890,10 +14890,10 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_args::write(::apache::thrif xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->group_names.size())); - std::vector ::const_iterator _iter1219; - for (_iter1219 = this->group_names.begin(); _iter1219 != this->group_names.end(); ++_iter1219) + std::vector ::const_iterator _iter1241; + for (_iter1241 = this->group_names.begin(); _iter1241 != this->group_names.end(); ++_iter1241) { - xfer += oprot->writeString((*_iter1219)); + xfer += oprot->writeString((*_iter1241)); } xfer += oprot->writeListEnd(); } @@ -14925,10 +14925,10 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_pargs::write(::apache::thri xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter1220; - for (_iter1220 = (*(this->part_vals)).begin(); _iter1220 != (*(this->part_vals)).end(); ++_iter1220) + std::vector ::const_iterator _iter1242; + for (_iter1242 = (*(this->part_vals)).begin(); _iter1242 != (*(this->part_vals)).end(); ++_iter1242) { - xfer += oprot->writeString((*_iter1220)); + xfer += oprot->writeString((*_iter1242)); } xfer += oprot->writeListEnd(); } @@ -14941,10 +14941,10 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_pargs::write(::apache::thri xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->group_names)).size())); - std::vector ::const_iterator _iter1221; - for (_iter1221 = (*(this->group_names)).begin(); _iter1221 != (*(this->group_names)).end(); ++_iter1221) + std::vector ::const_iterator _iter1243; + for (_iter1243 = (*(this->group_names)).begin(); _iter1243 != (*(this->group_names)).end(); ++_iter1243) { - xfer += oprot->writeString((*_iter1221)); + xfer += oprot->writeString((*_iter1243)); } xfer += oprot->writeListEnd(); } @@ -15503,14 +15503,14 @@ uint32_t ThriftHiveMetastore_get_partitions_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1222; - ::apache::thrift::protocol::TType _etype1225; - xfer += iprot->readListBegin(_etype1225, _size1222); - this->success.resize(_size1222); - uint32_t _i1226; - for (_i1226 = 0; _i1226 < _size1222; ++_i1226) + uint32_t _size1244; + ::apache::thrift::protocol::TType _etype1247; + xfer += iprot->readListBegin(_etype1247, _size1244); + this->success.resize(_size1244); + uint32_t _i1248; + for (_i1248 = 0; _i1248 < _size1244; ++_i1248) { - xfer += this->success[_i1226].read(iprot); + xfer += this->success[_i1248].read(iprot); } xfer += iprot->readListEnd(); } @@ -15557,10 +15557,10 @@ uint32_t ThriftHiveMetastore_get_partitions_result::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1227; - for (_iter1227 = this->success.begin(); _iter1227 != this->success.end(); ++_iter1227) + std::vector ::const_iterator _iter1249; + for (_iter1249 = this->success.begin(); _iter1249 != this->success.end(); ++_iter1249) { - xfer += (*_iter1227).write(oprot); + xfer += (*_iter1249).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15609,14 +15609,14 @@ uint32_t ThriftHiveMetastore_get_partitions_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1228; - ::apache::thrift::protocol::TType _etype1231; - xfer += iprot->readListBegin(_etype1231, _size1228); - (*(this->success)).resize(_size1228); - uint32_t _i1232; - for (_i1232 = 0; _i1232 < _size1228; ++_i1232) + uint32_t _size1250; + ::apache::thrift::protocol::TType _etype1253; + xfer += iprot->readListBegin(_etype1253, _size1250); + (*(this->success)).resize(_size1250); + uint32_t _i1254; + for (_i1254 = 0; _i1254 < _size1250; ++_i1254) { - xfer += (*(this->success))[_i1232].read(iprot); + xfer += (*(this->success))[_i1254].read(iprot); } xfer += iprot->readListEnd(); } @@ -15715,14 +15715,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_args::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size1233; - ::apache::thrift::protocol::TType _etype1236; - xfer += iprot->readListBegin(_etype1236, _size1233); - this->group_names.resize(_size1233); - uint32_t _i1237; - for (_i1237 = 0; _i1237 < _size1233; ++_i1237) + uint32_t _size1255; + ::apache::thrift::protocol::TType _etype1258; + xfer += iprot->readListBegin(_etype1258, _size1255); + this->group_names.resize(_size1255); + uint32_t _i1259; + for (_i1259 = 0; _i1259 < _size1255; ++_i1259) { - xfer += iprot->readString(this->group_names[_i1237]); + xfer += iprot->readString(this->group_names[_i1259]); } xfer += iprot->readListEnd(); } @@ -15767,10 +15767,10 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_args::write(::apache::thri xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->group_names.size())); - std::vector ::const_iterator _iter1238; - for (_iter1238 = this->group_names.begin(); _iter1238 != this->group_names.end(); ++_iter1238) + std::vector ::const_iterator _iter1260; + for (_iter1260 = this->group_names.begin(); _iter1260 != this->group_names.end(); ++_iter1260) { - xfer += oprot->writeString((*_iter1238)); + xfer += oprot->writeString((*_iter1260)); } xfer += oprot->writeListEnd(); } @@ -15810,10 +15810,10 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_pargs::write(::apache::thr xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->group_names)).size())); - std::vector ::const_iterator _iter1239; - for (_iter1239 = (*(this->group_names)).begin(); _iter1239 != (*(this->group_names)).end(); ++_iter1239) + std::vector ::const_iterator _iter1261; + for (_iter1261 = (*(this->group_names)).begin(); _iter1261 != (*(this->group_names)).end(); ++_iter1261) { - xfer += oprot->writeString((*_iter1239)); + xfer += oprot->writeString((*_iter1261)); } xfer += oprot->writeListEnd(); } @@ -15854,14 +15854,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1240; - ::apache::thrift::protocol::TType _etype1243; - xfer += iprot->readListBegin(_etype1243, _size1240); - this->success.resize(_size1240); - uint32_t _i1244; - for (_i1244 = 0; _i1244 < _size1240; ++_i1244) + uint32_t _size1262; + ::apache::thrift::protocol::TType _etype1265; + xfer += iprot->readListBegin(_etype1265, _size1262); + this->success.resize(_size1262); + uint32_t _i1266; + for (_i1266 = 0; _i1266 < _size1262; ++_i1266) { - xfer += this->success[_i1244].read(iprot); + xfer += this->success[_i1266].read(iprot); } xfer += iprot->readListEnd(); } @@ -15908,10 +15908,10 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_result::write(::apache::th xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1245; - for (_iter1245 = this->success.begin(); _iter1245 != this->success.end(); ++_iter1245) + std::vector ::const_iterator _iter1267; + for (_iter1267 = this->success.begin(); _iter1267 != this->success.end(); ++_iter1267) { - xfer += (*_iter1245).write(oprot); + xfer += (*_iter1267).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15960,14 +15960,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1246; - ::apache::thrift::protocol::TType _etype1249; - xfer += iprot->readListBegin(_etype1249, _size1246); - (*(this->success)).resize(_size1246); - uint32_t _i1250; - for (_i1250 = 0; _i1250 < _size1246; ++_i1250) + uint32_t _size1268; + ::apache::thrift::protocol::TType _etype1271; + xfer += iprot->readListBegin(_etype1271, _size1268); + (*(this->success)).resize(_size1268); + uint32_t _i1272; + for (_i1272 = 0; _i1272 < _size1268; ++_i1272) { - xfer += (*(this->success))[_i1250].read(iprot); + xfer += (*(this->success))[_i1272].read(iprot); } xfer += iprot->readListEnd(); } @@ -16145,14 +16145,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_result::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1251; - ::apache::thrift::protocol::TType _etype1254; - xfer += iprot->readListBegin(_etype1254, _size1251); - this->success.resize(_size1251); - uint32_t _i1255; - for (_i1255 = 0; _i1255 < _size1251; ++_i1255) + uint32_t _size1273; + ::apache::thrift::protocol::TType _etype1276; + xfer += iprot->readListBegin(_etype1276, _size1273); + this->success.resize(_size1273); + uint32_t _i1277; + for (_i1277 = 0; _i1277 < _size1273; ++_i1277) { - xfer += this->success[_i1255].read(iprot); + xfer += this->success[_i1277].read(iprot); } xfer += iprot->readListEnd(); } @@ -16199,10 +16199,10 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_result::write(::apache::thrift xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1256; - for (_iter1256 = this->success.begin(); _iter1256 != this->success.end(); ++_iter1256) + std::vector ::const_iterator _iter1278; + for (_iter1278 = this->success.begin(); _iter1278 != this->success.end(); ++_iter1278) { - xfer += (*_iter1256).write(oprot); + xfer += (*_iter1278).write(oprot); } xfer += oprot->writeListEnd(); } @@ -16251,14 +16251,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_presult::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1257; - ::apache::thrift::protocol::TType _etype1260; - xfer += iprot->readListBegin(_etype1260, _size1257); - (*(this->success)).resize(_size1257); - uint32_t _i1261; - for (_i1261 = 0; _i1261 < _size1257; ++_i1261) + uint32_t _size1279; + ::apache::thrift::protocol::TType _etype1282; + xfer += iprot->readListBegin(_etype1282, _size1279); + (*(this->success)).resize(_size1279); + uint32_t _i1283; + for (_i1283 = 0; _i1283 < _size1279; ++_i1283) { - xfer += (*(this->success))[_i1261].read(iprot); + xfer += (*(this->success))[_i1283].read(iprot); } xfer += iprot->readListEnd(); } @@ -16436,14 +16436,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1262; - ::apache::thrift::protocol::TType _etype1265; - xfer += iprot->readListBegin(_etype1265, _size1262); - this->success.resize(_size1262); - uint32_t _i1266; - for (_i1266 = 0; _i1266 < _size1262; ++_i1266) + uint32_t _size1284; + ::apache::thrift::protocol::TType _etype1287; + xfer += iprot->readListBegin(_etype1287, _size1284); + this->success.resize(_size1284); + uint32_t _i1288; + for (_i1288 = 0; _i1288 < _size1284; ++_i1288) { - xfer += iprot->readString(this->success[_i1266]); + xfer += iprot->readString(this->success[_i1288]); } xfer += iprot->readListEnd(); } @@ -16490,10 +16490,10 @@ uint32_t ThriftHiveMetastore_get_partition_names_result::write(::apache::thrift: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1267; - for (_iter1267 = this->success.begin(); _iter1267 != this->success.end(); ++_iter1267) + std::vector ::const_iterator _iter1289; + for (_iter1289 = this->success.begin(); _iter1289 != this->success.end(); ++_iter1289) { - xfer += oprot->writeString((*_iter1267)); + xfer += oprot->writeString((*_iter1289)); } xfer += oprot->writeListEnd(); } @@ -16542,14 +16542,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1268; - ::apache::thrift::protocol::TType _etype1271; - xfer += iprot->readListBegin(_etype1271, _size1268); - (*(this->success)).resize(_size1268); - uint32_t _i1272; - for (_i1272 = 0; _i1272 < _size1268; ++_i1272) + uint32_t _size1290; + ::apache::thrift::protocol::TType _etype1293; + xfer += iprot->readListBegin(_etype1293, _size1290); + (*(this->success)).resize(_size1290); + uint32_t _i1294; + for (_i1294 = 0; _i1294 < _size1290; ++_i1294) { - xfer += iprot->readString((*(this->success))[_i1272]); + xfer += iprot->readString((*(this->success))[_i1294]); } xfer += iprot->readListEnd(); } @@ -16859,14 +16859,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_args::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1273; - ::apache::thrift::protocol::TType _etype1276; - xfer += iprot->readListBegin(_etype1276, _size1273); - this->part_vals.resize(_size1273); - uint32_t _i1277; - for (_i1277 = 0; _i1277 < _size1273; ++_i1277) + uint32_t _size1295; + ::apache::thrift::protocol::TType _etype1298; + xfer += iprot->readListBegin(_etype1298, _size1295); + this->part_vals.resize(_size1295); + uint32_t _i1299; + for (_i1299 = 0; _i1299 < _size1295; ++_i1299) { - xfer += iprot->readString(this->part_vals[_i1277]); + xfer += iprot->readString(this->part_vals[_i1299]); } xfer += iprot->readListEnd(); } @@ -16911,10 +16911,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_args::write(::apache::thrift::pro xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter1278; - for (_iter1278 = this->part_vals.begin(); _iter1278 != this->part_vals.end(); ++_iter1278) + std::vector ::const_iterator _iter1300; + for (_iter1300 = this->part_vals.begin(); _iter1300 != this->part_vals.end(); ++_iter1300) { - xfer += oprot->writeString((*_iter1278)); + xfer += oprot->writeString((*_iter1300)); } xfer += oprot->writeListEnd(); } @@ -16950,10 +16950,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_pargs::write(::apache::thrift::pr xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter1279; - for (_iter1279 = (*(this->part_vals)).begin(); _iter1279 != (*(this->part_vals)).end(); ++_iter1279) + std::vector ::const_iterator _iter1301; + for (_iter1301 = (*(this->part_vals)).begin(); _iter1301 != (*(this->part_vals)).end(); ++_iter1301) { - xfer += oprot->writeString((*_iter1279)); + xfer += oprot->writeString((*_iter1301)); } xfer += oprot->writeListEnd(); } @@ -16998,14 +16998,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_result::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1280; - ::apache::thrift::protocol::TType _etype1283; - xfer += iprot->readListBegin(_etype1283, _size1280); - this->success.resize(_size1280); - uint32_t _i1284; - for (_i1284 = 0; _i1284 < _size1280; ++_i1284) + uint32_t _size1302; + ::apache::thrift::protocol::TType _etype1305; + xfer += iprot->readListBegin(_etype1305, _size1302); + this->success.resize(_size1302); + uint32_t _i1306; + for (_i1306 = 0; _i1306 < _size1302; ++_i1306) { - xfer += this->success[_i1284].read(iprot); + xfer += this->success[_i1306].read(iprot); } xfer += iprot->readListEnd(); } @@ -17052,10 +17052,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_result::write(::apache::thrift::p xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1285; - for (_iter1285 = this->success.begin(); _iter1285 != this->success.end(); ++_iter1285) + std::vector ::const_iterator _iter1307; + for (_iter1307 = this->success.begin(); _iter1307 != this->success.end(); ++_iter1307) { - xfer += (*_iter1285).write(oprot); + xfer += (*_iter1307).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17104,14 +17104,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_presult::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1286; - ::apache::thrift::protocol::TType _etype1289; - xfer += iprot->readListBegin(_etype1289, _size1286); - (*(this->success)).resize(_size1286); - uint32_t _i1290; - for (_i1290 = 0; _i1290 < _size1286; ++_i1290) + uint32_t _size1308; + ::apache::thrift::protocol::TType _etype1311; + xfer += iprot->readListBegin(_etype1311, _size1308); + (*(this->success)).resize(_size1308); + uint32_t _i1312; + for (_i1312 = 0; _i1312 < _size1308; ++_i1312) { - xfer += (*(this->success))[_i1290].read(iprot); + xfer += (*(this->success))[_i1312].read(iprot); } xfer += iprot->readListEnd(); } @@ -17194,14 +17194,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1291; - ::apache::thrift::protocol::TType _etype1294; - xfer += iprot->readListBegin(_etype1294, _size1291); - this->part_vals.resize(_size1291); - uint32_t _i1295; - for (_i1295 = 0; _i1295 < _size1291; ++_i1295) + uint32_t _size1313; + ::apache::thrift::protocol::TType _etype1316; + xfer += iprot->readListBegin(_etype1316, _size1313); + this->part_vals.resize(_size1313); + uint32_t _i1317; + for (_i1317 = 0; _i1317 < _size1313; ++_i1317) { - xfer += iprot->readString(this->part_vals[_i1295]); + xfer += iprot->readString(this->part_vals[_i1317]); } xfer += iprot->readListEnd(); } @@ -17230,14 +17230,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size1296; - ::apache::thrift::protocol::TType _etype1299; - xfer += iprot->readListBegin(_etype1299, _size1296); - this->group_names.resize(_size1296); - uint32_t _i1300; - for (_i1300 = 0; _i1300 < _size1296; ++_i1300) + uint32_t _size1318; + ::apache::thrift::protocol::TType _etype1321; + xfer += iprot->readListBegin(_etype1321, _size1318); + this->group_names.resize(_size1318); + uint32_t _i1322; + for (_i1322 = 0; _i1322 < _size1318; ++_i1322) { - xfer += iprot->readString(this->group_names[_i1300]); + xfer += iprot->readString(this->group_names[_i1322]); } xfer += iprot->readListEnd(); } @@ -17274,10 +17274,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::write(::apache::t xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter1301; - for (_iter1301 = this->part_vals.begin(); _iter1301 != this->part_vals.end(); ++_iter1301) + std::vector ::const_iterator _iter1323; + for (_iter1323 = this->part_vals.begin(); _iter1323 != this->part_vals.end(); ++_iter1323) { - xfer += oprot->writeString((*_iter1301)); + xfer += oprot->writeString((*_iter1323)); } xfer += oprot->writeListEnd(); } @@ -17294,10 +17294,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::write(::apache::t xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 6); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->group_names.size())); - std::vector ::const_iterator _iter1302; - for (_iter1302 = this->group_names.begin(); _iter1302 != this->group_names.end(); ++_iter1302) + std::vector ::const_iterator _iter1324; + for (_iter1324 = this->group_names.begin(); _iter1324 != this->group_names.end(); ++_iter1324) { - xfer += oprot->writeString((*_iter1302)); + xfer += oprot->writeString((*_iter1324)); } xfer += oprot->writeListEnd(); } @@ -17329,10 +17329,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_pargs::write(::apache:: xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter1303; - for (_iter1303 = (*(this->part_vals)).begin(); _iter1303 != (*(this->part_vals)).end(); ++_iter1303) + std::vector ::const_iterator _iter1325; + for (_iter1325 = (*(this->part_vals)).begin(); _iter1325 != (*(this->part_vals)).end(); ++_iter1325) { - xfer += oprot->writeString((*_iter1303)); + xfer += oprot->writeString((*_iter1325)); } xfer += oprot->writeListEnd(); } @@ -17349,10 +17349,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_pargs::write(::apache:: xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 6); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->group_names)).size())); - std::vector ::const_iterator _iter1304; - for (_iter1304 = (*(this->group_names)).begin(); _iter1304 != (*(this->group_names)).end(); ++_iter1304) + std::vector ::const_iterator _iter1326; + for (_iter1326 = (*(this->group_names)).begin(); _iter1326 != (*(this->group_names)).end(); ++_iter1326) { - xfer += oprot->writeString((*_iter1304)); + xfer += oprot->writeString((*_iter1326)); } xfer += oprot->writeListEnd(); } @@ -17393,14 +17393,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_result::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1305; - ::apache::thrift::protocol::TType _etype1308; - xfer += iprot->readListBegin(_etype1308, _size1305); - this->success.resize(_size1305); - uint32_t _i1309; - for (_i1309 = 0; _i1309 < _size1305; ++_i1309) + uint32_t _size1327; + ::apache::thrift::protocol::TType _etype1330; + xfer += iprot->readListBegin(_etype1330, _size1327); + this->success.resize(_size1327); + uint32_t _i1331; + for (_i1331 = 0; _i1331 < _size1327; ++_i1331) { - xfer += this->success[_i1309].read(iprot); + xfer += this->success[_i1331].read(iprot); } xfer += iprot->readListEnd(); } @@ -17447,10 +17447,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_result::write(::apache: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1310; - for (_iter1310 = this->success.begin(); _iter1310 != this->success.end(); ++_iter1310) + std::vector ::const_iterator _iter1332; + for (_iter1332 = this->success.begin(); _iter1332 != this->success.end(); ++_iter1332) { - xfer += (*_iter1310).write(oprot); + xfer += (*_iter1332).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17499,14 +17499,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_presult::read(::apache: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1311; - ::apache::thrift::protocol::TType _etype1314; - xfer += iprot->readListBegin(_etype1314, _size1311); - (*(this->success)).resize(_size1311); - uint32_t _i1315; - for (_i1315 = 0; _i1315 < _size1311; ++_i1315) + uint32_t _size1333; + ::apache::thrift::protocol::TType _etype1336; + xfer += iprot->readListBegin(_etype1336, _size1333); + (*(this->success)).resize(_size1333); + uint32_t _i1337; + for (_i1337 = 0; _i1337 < _size1333; ++_i1337) { - xfer += (*(this->success))[_i1315].read(iprot); + xfer += (*(this->success))[_i1337].read(iprot); } xfer += iprot->readListEnd(); } @@ -17589,14 +17589,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_args::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1316; - ::apache::thrift::protocol::TType _etype1319; - xfer += iprot->readListBegin(_etype1319, _size1316); - this->part_vals.resize(_size1316); - uint32_t _i1320; - for (_i1320 = 0; _i1320 < _size1316; ++_i1320) + uint32_t _size1338; + ::apache::thrift::protocol::TType _etype1341; + xfer += iprot->readListBegin(_etype1341, _size1338); + this->part_vals.resize(_size1338); + uint32_t _i1342; + for (_i1342 = 0; _i1342 < _size1338; ++_i1342) { - xfer += iprot->readString(this->part_vals[_i1320]); + xfer += iprot->readString(this->part_vals[_i1342]); } xfer += iprot->readListEnd(); } @@ -17641,10 +17641,10 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_args::write(::apache::thrift xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter1321; - for (_iter1321 = this->part_vals.begin(); _iter1321 != this->part_vals.end(); ++_iter1321) + std::vector ::const_iterator _iter1343; + for (_iter1343 = this->part_vals.begin(); _iter1343 != this->part_vals.end(); ++_iter1343) { - xfer += oprot->writeString((*_iter1321)); + xfer += oprot->writeString((*_iter1343)); } xfer += oprot->writeListEnd(); } @@ -17680,10 +17680,10 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_pargs::write(::apache::thrif xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter1322; - for (_iter1322 = (*(this->part_vals)).begin(); _iter1322 != (*(this->part_vals)).end(); ++_iter1322) + std::vector ::const_iterator _iter1344; + for (_iter1344 = (*(this->part_vals)).begin(); _iter1344 != (*(this->part_vals)).end(); ++_iter1344) { - xfer += oprot->writeString((*_iter1322)); + xfer += oprot->writeString((*_iter1344)); } xfer += oprot->writeListEnd(); } @@ -17728,14 +17728,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1323; - ::apache::thrift::protocol::TType _etype1326; - xfer += iprot->readListBegin(_etype1326, _size1323); - this->success.resize(_size1323); - uint32_t _i1327; - for (_i1327 = 0; _i1327 < _size1323; ++_i1327) + uint32_t _size1345; + ::apache::thrift::protocol::TType _etype1348; + xfer += iprot->readListBegin(_etype1348, _size1345); + this->success.resize(_size1345); + uint32_t _i1349; + for (_i1349 = 0; _i1349 < _size1345; ++_i1349) { - xfer += iprot->readString(this->success[_i1327]); + xfer += iprot->readString(this->success[_i1349]); } xfer += iprot->readListEnd(); } @@ -17782,10 +17782,10 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_result::write(::apache::thri xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1328; - for (_iter1328 = this->success.begin(); _iter1328 != this->success.end(); ++_iter1328) + std::vector ::const_iterator _iter1350; + for (_iter1350 = this->success.begin(); _iter1350 != this->success.end(); ++_iter1350) { - xfer += oprot->writeString((*_iter1328)); + xfer += oprot->writeString((*_iter1350)); } xfer += oprot->writeListEnd(); } @@ -17834,14 +17834,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1329; - ::apache::thrift::protocol::TType _etype1332; - xfer += iprot->readListBegin(_etype1332, _size1329); - (*(this->success)).resize(_size1329); - uint32_t _i1333; - for (_i1333 = 0; _i1333 < _size1329; ++_i1333) + uint32_t _size1351; + ::apache::thrift::protocol::TType _etype1354; + xfer += iprot->readListBegin(_etype1354, _size1351); + (*(this->success)).resize(_size1351); + uint32_t _i1355; + for (_i1355 = 0; _i1355 < _size1351; ++_i1355) { - xfer += iprot->readString((*(this->success))[_i1333]); + xfer += iprot->readString((*(this->success))[_i1355]); } xfer += iprot->readListEnd(); } @@ -18035,14 +18035,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1334; - ::apache::thrift::protocol::TType _etype1337; - xfer += iprot->readListBegin(_etype1337, _size1334); - this->success.resize(_size1334); - uint32_t _i1338; - for (_i1338 = 0; _i1338 < _size1334; ++_i1338) + uint32_t _size1356; + ::apache::thrift::protocol::TType _etype1359; + xfer += iprot->readListBegin(_etype1359, _size1356); + this->success.resize(_size1356); + uint32_t _i1360; + for (_i1360 = 0; _i1360 < _size1356; ++_i1360) { - xfer += this->success[_i1338].read(iprot); + xfer += this->success[_i1360].read(iprot); } xfer += iprot->readListEnd(); } @@ -18089,10 +18089,10 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_result::write(::apache::th xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1339; - for (_iter1339 = this->success.begin(); _iter1339 != this->success.end(); ++_iter1339) + std::vector ::const_iterator _iter1361; + for (_iter1361 = this->success.begin(); _iter1361 != this->success.end(); ++_iter1361) { - xfer += (*_iter1339).write(oprot); + xfer += (*_iter1361).write(oprot); } xfer += oprot->writeListEnd(); } @@ -18141,14 +18141,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1340; - ::apache::thrift::protocol::TType _etype1343; - xfer += iprot->readListBegin(_etype1343, _size1340); - (*(this->success)).resize(_size1340); - uint32_t _i1344; - for (_i1344 = 0; _i1344 < _size1340; ++_i1344) + uint32_t _size1362; + ::apache::thrift::protocol::TType _etype1365; + xfer += iprot->readListBegin(_etype1365, _size1362); + (*(this->success)).resize(_size1362); + uint32_t _i1366; + for (_i1366 = 0; _i1366 < _size1362; ++_i1366) { - xfer += (*(this->success))[_i1344].read(iprot); + xfer += (*(this->success))[_i1366].read(iprot); } xfer += iprot->readListEnd(); } @@ -18342,14 +18342,14 @@ uint32_t ThriftHiveMetastore_get_part_specs_by_filter_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1345; - ::apache::thrift::protocol::TType _etype1348; - xfer += iprot->readListBegin(_etype1348, _size1345); - this->success.resize(_size1345); - uint32_t _i1349; - for (_i1349 = 0; _i1349 < _size1345; ++_i1349) + uint32_t _size1367; + ::apache::thrift::protocol::TType _etype1370; + xfer += iprot->readListBegin(_etype1370, _size1367); + this->success.resize(_size1367); + uint32_t _i1371; + for (_i1371 = 0; _i1371 < _size1367; ++_i1371) { - xfer += this->success[_i1349].read(iprot); + xfer += this->success[_i1371].read(iprot); } xfer += iprot->readListEnd(); } @@ -18396,10 +18396,10 @@ uint32_t ThriftHiveMetastore_get_part_specs_by_filter_result::write(::apache::th xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1350; - for (_iter1350 = this->success.begin(); _iter1350 != this->success.end(); ++_iter1350) + std::vector ::const_iterator _iter1372; + for (_iter1372 = this->success.begin(); _iter1372 != this->success.end(); ++_iter1372) { - xfer += (*_iter1350).write(oprot); + xfer += (*_iter1372).write(oprot); } xfer += oprot->writeListEnd(); } @@ -18448,14 +18448,14 @@ uint32_t ThriftHiveMetastore_get_part_specs_by_filter_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1351; - ::apache::thrift::protocol::TType _etype1354; - xfer += iprot->readListBegin(_etype1354, _size1351); - (*(this->success)).resize(_size1351); - uint32_t _i1355; - for (_i1355 = 0; _i1355 < _size1351; ++_i1355) + uint32_t _size1373; + ::apache::thrift::protocol::TType _etype1376; + xfer += iprot->readListBegin(_etype1376, _size1373); + (*(this->success)).resize(_size1373); + uint32_t _i1377; + for (_i1377 = 0; _i1377 < _size1373; ++_i1377) { - xfer += (*(this->success))[_i1355].read(iprot); + xfer += (*(this->success))[_i1377].read(iprot); } xfer += iprot->readListEnd(); } @@ -19024,14 +19024,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_args::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { this->names.clear(); - uint32_t _size1356; - ::apache::thrift::protocol::TType _etype1359; - xfer += iprot->readListBegin(_etype1359, _size1356); - this->names.resize(_size1356); - uint32_t _i1360; - for (_i1360 = 0; _i1360 < _size1356; ++_i1360) + uint32_t _size1378; + ::apache::thrift::protocol::TType _etype1381; + xfer += iprot->readListBegin(_etype1381, _size1378); + this->names.resize(_size1378); + uint32_t _i1382; + for (_i1382 = 0; _i1382 < _size1378; ++_i1382) { - xfer += iprot->readString(this->names[_i1360]); + xfer += iprot->readString(this->names[_i1382]); } xfer += iprot->readListEnd(); } @@ -19068,10 +19068,10 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_args::write(::apache::thrif xfer += oprot->writeFieldBegin("names", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->names.size())); - std::vector ::const_iterator _iter1361; - for (_iter1361 = this->names.begin(); _iter1361 != this->names.end(); ++_iter1361) + std::vector ::const_iterator _iter1383; + for (_iter1383 = this->names.begin(); _iter1383 != this->names.end(); ++_iter1383) { - xfer += oprot->writeString((*_iter1361)); + xfer += oprot->writeString((*_iter1383)); } xfer += oprot->writeListEnd(); } @@ -19103,10 +19103,10 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_pargs::write(::apache::thri xfer += oprot->writeFieldBegin("names", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->names)).size())); - std::vector ::const_iterator _iter1362; - for (_iter1362 = (*(this->names)).begin(); _iter1362 != (*(this->names)).end(); ++_iter1362) + std::vector ::const_iterator _iter1384; + for (_iter1384 = (*(this->names)).begin(); _iter1384 != (*(this->names)).end(); ++_iter1384) { - xfer += oprot->writeString((*_iter1362)); + xfer += oprot->writeString((*_iter1384)); } xfer += oprot->writeListEnd(); } @@ -19147,14 +19147,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_result::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1363; - ::apache::thrift::protocol::TType _etype1366; - xfer += iprot->readListBegin(_etype1366, _size1363); - this->success.resize(_size1363); - uint32_t _i1367; - for (_i1367 = 0; _i1367 < _size1363; ++_i1367) + uint32_t _size1385; + ::apache::thrift::protocol::TType _etype1388; + xfer += iprot->readListBegin(_etype1388, _size1385); + this->success.resize(_size1385); + uint32_t _i1389; + for (_i1389 = 0; _i1389 < _size1385; ++_i1389) { - xfer += this->success[_i1367].read(iprot); + xfer += this->success[_i1389].read(iprot); } xfer += iprot->readListEnd(); } @@ -19201,10 +19201,10 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_result::write(::apache::thr xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1368; - for (_iter1368 = this->success.begin(); _iter1368 != this->success.end(); ++_iter1368) + std::vector ::const_iterator _iter1390; + for (_iter1390 = this->success.begin(); _iter1390 != this->success.end(); ++_iter1390) { - xfer += (*_iter1368).write(oprot); + xfer += (*_iter1390).write(oprot); } xfer += oprot->writeListEnd(); } @@ -19253,14 +19253,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_presult::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1369; - ::apache::thrift::protocol::TType _etype1372; - xfer += iprot->readListBegin(_etype1372, _size1369); - (*(this->success)).resize(_size1369); - uint32_t _i1373; - for (_i1373 = 0; _i1373 < _size1369; ++_i1373) + uint32_t _size1391; + ::apache::thrift::protocol::TType _etype1394; + xfer += iprot->readListBegin(_etype1394, _size1391); + (*(this->success)).resize(_size1391); + uint32_t _i1395; + for (_i1395 = 0; _i1395 < _size1391; ++_i1395) { - xfer += (*(this->success))[_i1373].read(iprot); + xfer += (*(this->success))[_i1395].read(iprot); } xfer += iprot->readListEnd(); } @@ -19582,14 +19582,14 @@ uint32_t ThriftHiveMetastore_alter_partitions_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size1374; - ::apache::thrift::protocol::TType _etype1377; - xfer += iprot->readListBegin(_etype1377, _size1374); - this->new_parts.resize(_size1374); - uint32_t _i1378; - for (_i1378 = 0; _i1378 < _size1374; ++_i1378) + uint32_t _size1396; + ::apache::thrift::protocol::TType _etype1399; + xfer += iprot->readListBegin(_etype1399, _size1396); + this->new_parts.resize(_size1396); + uint32_t _i1400; + for (_i1400 = 0; _i1400 < _size1396; ++_i1400) { - xfer += this->new_parts[_i1378].read(iprot); + xfer += this->new_parts[_i1400].read(iprot); } xfer += iprot->readListEnd(); } @@ -19626,10 +19626,10 @@ uint32_t ThriftHiveMetastore_alter_partitions_args::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->new_parts.size())); - std::vector ::const_iterator _iter1379; - for (_iter1379 = this->new_parts.begin(); _iter1379 != this->new_parts.end(); ++_iter1379) + std::vector ::const_iterator _iter1401; + for (_iter1401 = this->new_parts.begin(); _iter1401 != this->new_parts.end(); ++_iter1401) { - xfer += (*_iter1379).write(oprot); + xfer += (*_iter1401).write(oprot); } xfer += oprot->writeListEnd(); } @@ -19661,10 +19661,10 @@ uint32_t ThriftHiveMetastore_alter_partitions_pargs::write(::apache::thrift::pro xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->new_parts)).size())); - std::vector ::const_iterator _iter1380; - for (_iter1380 = (*(this->new_parts)).begin(); _iter1380 != (*(this->new_parts)).end(); ++_iter1380) + std::vector ::const_iterator _iter1402; + for (_iter1402 = (*(this->new_parts)).begin(); _iter1402 != (*(this->new_parts)).end(); ++_iter1402) { - xfer += (*_iter1380).write(oprot); + xfer += (*_iter1402).write(oprot); } xfer += oprot->writeListEnd(); } @@ -19849,14 +19849,14 @@ uint32_t ThriftHiveMetastore_alter_partitions_with_environment_context_args::rea if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size1381; - ::apache::thrift::protocol::TType _etype1384; - xfer += iprot->readListBegin(_etype1384, _size1381); - this->new_parts.resize(_size1381); - uint32_t _i1385; - for (_i1385 = 0; _i1385 < _size1381; ++_i1385) + uint32_t _size1403; + ::apache::thrift::protocol::TType _etype1406; + xfer += iprot->readListBegin(_etype1406, _size1403); + this->new_parts.resize(_size1403); + uint32_t _i1407; + for (_i1407 = 0; _i1407 < _size1403; ++_i1407) { - xfer += this->new_parts[_i1385].read(iprot); + xfer += this->new_parts[_i1407].read(iprot); } xfer += iprot->readListEnd(); } @@ -19901,10 +19901,10 @@ uint32_t ThriftHiveMetastore_alter_partitions_with_environment_context_args::wri xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->new_parts.size())); - std::vector ::const_iterator _iter1386; - for (_iter1386 = this->new_parts.begin(); _iter1386 != this->new_parts.end(); ++_iter1386) + std::vector ::const_iterator _iter1408; + for (_iter1408 = this->new_parts.begin(); _iter1408 != this->new_parts.end(); ++_iter1408) { - xfer += (*_iter1386).write(oprot); + xfer += (*_iter1408).write(oprot); } xfer += oprot->writeListEnd(); } @@ -19940,10 +19940,10 @@ uint32_t ThriftHiveMetastore_alter_partitions_with_environment_context_pargs::wr xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->new_parts)).size())); - std::vector ::const_iterator _iter1387; - for (_iter1387 = (*(this->new_parts)).begin(); _iter1387 != (*(this->new_parts)).end(); ++_iter1387) + std::vector ::const_iterator _iter1409; + for (_iter1409 = (*(this->new_parts)).begin(); _iter1409 != (*(this->new_parts)).end(); ++_iter1409) { - xfer += (*_iter1387).write(oprot); + xfer += (*_iter1409).write(oprot); } xfer += oprot->writeListEnd(); } @@ -20387,14 +20387,14 @@ uint32_t ThriftHiveMetastore_rename_partition_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1388; - ::apache::thrift::protocol::TType _etype1391; - xfer += iprot->readListBegin(_etype1391, _size1388); - this->part_vals.resize(_size1388); - uint32_t _i1392; - for (_i1392 = 0; _i1392 < _size1388; ++_i1392) + uint32_t _size1410; + ::apache::thrift::protocol::TType _etype1413; + xfer += iprot->readListBegin(_etype1413, _size1410); + this->part_vals.resize(_size1410); + uint32_t _i1414; + for (_i1414 = 0; _i1414 < _size1410; ++_i1414) { - xfer += iprot->readString(this->part_vals[_i1392]); + xfer += iprot->readString(this->part_vals[_i1414]); } xfer += iprot->readListEnd(); } @@ -20439,10 +20439,10 @@ uint32_t ThriftHiveMetastore_rename_partition_args::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter1393; - for (_iter1393 = this->part_vals.begin(); _iter1393 != this->part_vals.end(); ++_iter1393) + std::vector ::const_iterator _iter1415; + for (_iter1415 = this->part_vals.begin(); _iter1415 != this->part_vals.end(); ++_iter1415) { - xfer += oprot->writeString((*_iter1393)); + xfer += oprot->writeString((*_iter1415)); } xfer += oprot->writeListEnd(); } @@ -20478,10 +20478,10 @@ uint32_t ThriftHiveMetastore_rename_partition_pargs::write(::apache::thrift::pro xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter1394; - for (_iter1394 = (*(this->part_vals)).begin(); _iter1394 != (*(this->part_vals)).end(); ++_iter1394) + std::vector ::const_iterator _iter1416; + for (_iter1416 = (*(this->part_vals)).begin(); _iter1416 != (*(this->part_vals)).end(); ++_iter1416) { - xfer += oprot->writeString((*_iter1394)); + xfer += oprot->writeString((*_iter1416)); } xfer += oprot->writeListEnd(); } @@ -20654,14 +20654,14 @@ uint32_t ThriftHiveMetastore_partition_name_has_valid_characters_args::read(::ap if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1395; - ::apache::thrift::protocol::TType _etype1398; - xfer += iprot->readListBegin(_etype1398, _size1395); - this->part_vals.resize(_size1395); - uint32_t _i1399; - for (_i1399 = 0; _i1399 < _size1395; ++_i1399) + uint32_t _size1417; + ::apache::thrift::protocol::TType _etype1420; + xfer += iprot->readListBegin(_etype1420, _size1417); + this->part_vals.resize(_size1417); + uint32_t _i1421; + for (_i1421 = 0; _i1421 < _size1417; ++_i1421) { - xfer += iprot->readString(this->part_vals[_i1399]); + xfer += iprot->readString(this->part_vals[_i1421]); } xfer += iprot->readListEnd(); } @@ -20698,10 +20698,10 @@ uint32_t ThriftHiveMetastore_partition_name_has_valid_characters_args::write(::a xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter1400; - for (_iter1400 = this->part_vals.begin(); _iter1400 != this->part_vals.end(); ++_iter1400) + std::vector ::const_iterator _iter1422; + for (_iter1422 = this->part_vals.begin(); _iter1422 != this->part_vals.end(); ++_iter1422) { - xfer += oprot->writeString((*_iter1400)); + xfer += oprot->writeString((*_iter1422)); } xfer += oprot->writeListEnd(); } @@ -20729,10 +20729,10 @@ uint32_t ThriftHiveMetastore_partition_name_has_valid_characters_pargs::write(:: xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter1401; - for (_iter1401 = (*(this->part_vals)).begin(); _iter1401 != (*(this->part_vals)).end(); ++_iter1401) + std::vector ::const_iterator _iter1423; + for (_iter1423 = (*(this->part_vals)).begin(); _iter1423 != (*(this->part_vals)).end(); ++_iter1423) { - xfer += oprot->writeString((*_iter1401)); + xfer += oprot->writeString((*_iter1423)); } xfer += oprot->writeListEnd(); } @@ -21207,14 +21207,14 @@ uint32_t ThriftHiveMetastore_partition_name_to_vals_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1402; - ::apache::thrift::protocol::TType _etype1405; - xfer += iprot->readListBegin(_etype1405, _size1402); - this->success.resize(_size1402); - uint32_t _i1406; - for (_i1406 = 0; _i1406 < _size1402; ++_i1406) + uint32_t _size1424; + ::apache::thrift::protocol::TType _etype1427; + xfer += iprot->readListBegin(_etype1427, _size1424); + this->success.resize(_size1424); + uint32_t _i1428; + for (_i1428 = 0; _i1428 < _size1424; ++_i1428) { - xfer += iprot->readString(this->success[_i1406]); + xfer += iprot->readString(this->success[_i1428]); } xfer += iprot->readListEnd(); } @@ -21253,10 +21253,10 @@ uint32_t ThriftHiveMetastore_partition_name_to_vals_result::write(::apache::thri xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1407; - for (_iter1407 = this->success.begin(); _iter1407 != this->success.end(); ++_iter1407) + std::vector ::const_iterator _iter1429; + for (_iter1429 = this->success.begin(); _iter1429 != this->success.end(); ++_iter1429) { - xfer += oprot->writeString((*_iter1407)); + xfer += oprot->writeString((*_iter1429)); } xfer += oprot->writeListEnd(); } @@ -21301,14 +21301,14 @@ uint32_t ThriftHiveMetastore_partition_name_to_vals_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1408; - ::apache::thrift::protocol::TType _etype1411; - xfer += iprot->readListBegin(_etype1411, _size1408); - (*(this->success)).resize(_size1408); - uint32_t _i1412; - for (_i1412 = 0; _i1412 < _size1408; ++_i1412) + uint32_t _size1430; + ::apache::thrift::protocol::TType _etype1433; + xfer += iprot->readListBegin(_etype1433, _size1430); + (*(this->success)).resize(_size1430); + uint32_t _i1434; + for (_i1434 = 0; _i1434 < _size1430; ++_i1434) { - xfer += iprot->readString((*(this->success))[_i1412]); + xfer += iprot->readString((*(this->success))[_i1434]); } xfer += iprot->readListEnd(); } @@ -21446,17 +21446,17 @@ uint32_t ThriftHiveMetastore_partition_name_to_spec_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_MAP) { { this->success.clear(); - uint32_t _size1413; - ::apache::thrift::protocol::TType _ktype1414; - ::apache::thrift::protocol::TType _vtype1415; - xfer += iprot->readMapBegin(_ktype1414, _vtype1415, _size1413); - uint32_t _i1417; - for (_i1417 = 0; _i1417 < _size1413; ++_i1417) + uint32_t _size1435; + ::apache::thrift::protocol::TType _ktype1436; + ::apache::thrift::protocol::TType _vtype1437; + xfer += iprot->readMapBegin(_ktype1436, _vtype1437, _size1435); + uint32_t _i1439; + for (_i1439 = 0; _i1439 < _size1435; ++_i1439) { - std::string _key1418; - xfer += iprot->readString(_key1418); - std::string& _val1419 = this->success[_key1418]; - xfer += iprot->readString(_val1419); + std::string _key1440; + xfer += iprot->readString(_key1440); + std::string& _val1441 = this->success[_key1440]; + xfer += iprot->readString(_val1441); } xfer += iprot->readMapEnd(); } @@ -21495,11 +21495,11 @@ uint32_t ThriftHiveMetastore_partition_name_to_spec_result::write(::apache::thri xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_MAP, 0); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::map ::const_iterator _iter1420; - for (_iter1420 = this->success.begin(); _iter1420 != this->success.end(); ++_iter1420) + std::map ::const_iterator _iter1442; + for (_iter1442 = this->success.begin(); _iter1442 != this->success.end(); ++_iter1442) { - xfer += oprot->writeString(_iter1420->first); - xfer += oprot->writeString(_iter1420->second); + xfer += oprot->writeString(_iter1442->first); + xfer += oprot->writeString(_iter1442->second); } xfer += oprot->writeMapEnd(); } @@ -21544,17 +21544,17 @@ uint32_t ThriftHiveMetastore_partition_name_to_spec_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_MAP) { { (*(this->success)).clear(); - uint32_t _size1421; - ::apache::thrift::protocol::TType _ktype1422; - ::apache::thrift::protocol::TType _vtype1423; - xfer += iprot->readMapBegin(_ktype1422, _vtype1423, _size1421); - uint32_t _i1425; - for (_i1425 = 0; _i1425 < _size1421; ++_i1425) + uint32_t _size1443; + ::apache::thrift::protocol::TType _ktype1444; + ::apache::thrift::protocol::TType _vtype1445; + xfer += iprot->readMapBegin(_ktype1444, _vtype1445, _size1443); + uint32_t _i1447; + for (_i1447 = 0; _i1447 < _size1443; ++_i1447) { - std::string _key1426; - xfer += iprot->readString(_key1426); - std::string& _val1427 = (*(this->success))[_key1426]; - xfer += iprot->readString(_val1427); + std::string _key1448; + xfer += iprot->readString(_key1448); + std::string& _val1449 = (*(this->success))[_key1448]; + xfer += iprot->readString(_val1449); } xfer += iprot->readMapEnd(); } @@ -21629,17 +21629,17 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_args::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_MAP) { { this->part_vals.clear(); - uint32_t _size1428; - ::apache::thrift::protocol::TType _ktype1429; - ::apache::thrift::protocol::TType _vtype1430; - xfer += iprot->readMapBegin(_ktype1429, _vtype1430, _size1428); - uint32_t _i1432; - for (_i1432 = 0; _i1432 < _size1428; ++_i1432) + uint32_t _size1450; + ::apache::thrift::protocol::TType _ktype1451; + ::apache::thrift::protocol::TType _vtype1452; + xfer += iprot->readMapBegin(_ktype1451, _vtype1452, _size1450); + uint32_t _i1454; + for (_i1454 = 0; _i1454 < _size1450; ++_i1454) { - std::string _key1433; - xfer += iprot->readString(_key1433); - std::string& _val1434 = this->part_vals[_key1433]; - xfer += iprot->readString(_val1434); + std::string _key1455; + xfer += iprot->readString(_key1455); + std::string& _val1456 = this->part_vals[_key1455]; + xfer += iprot->readString(_val1456); } xfer += iprot->readMapEnd(); } @@ -21650,9 +21650,9 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_args::read(::apache::thrift:: break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1435; - xfer += iprot->readI32(ecast1435); - this->eventType = (PartitionEventType::type)ecast1435; + int32_t ecast1457; + xfer += iprot->readI32(ecast1457); + this->eventType = (PartitionEventType::type)ecast1457; this->__isset.eventType = true; } else { xfer += iprot->skip(ftype); @@ -21686,11 +21686,11 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_args::write(::apache::thrift: xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_MAP, 3); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::map ::const_iterator _iter1436; - for (_iter1436 = this->part_vals.begin(); _iter1436 != this->part_vals.end(); ++_iter1436) + std::map ::const_iterator _iter1458; + for (_iter1458 = this->part_vals.begin(); _iter1458 != this->part_vals.end(); ++_iter1458) { - xfer += oprot->writeString(_iter1436->first); - xfer += oprot->writeString(_iter1436->second); + xfer += oprot->writeString(_iter1458->first); + xfer += oprot->writeString(_iter1458->second); } xfer += oprot->writeMapEnd(); } @@ -21726,11 +21726,11 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_pargs::write(::apache::thrift xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_MAP, 3); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::map ::const_iterator _iter1437; - for (_iter1437 = (*(this->part_vals)).begin(); _iter1437 != (*(this->part_vals)).end(); ++_iter1437) + std::map ::const_iterator _iter1459; + for (_iter1459 = (*(this->part_vals)).begin(); _iter1459 != (*(this->part_vals)).end(); ++_iter1459) { - xfer += oprot->writeString(_iter1437->first); - xfer += oprot->writeString(_iter1437->second); + xfer += oprot->writeString(_iter1459->first); + xfer += oprot->writeString(_iter1459->second); } xfer += oprot->writeMapEnd(); } @@ -21999,17 +21999,17 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_MAP) { { this->part_vals.clear(); - uint32_t _size1438; - ::apache::thrift::protocol::TType _ktype1439; - ::apache::thrift::protocol::TType _vtype1440; - xfer += iprot->readMapBegin(_ktype1439, _vtype1440, _size1438); - uint32_t _i1442; - for (_i1442 = 0; _i1442 < _size1438; ++_i1442) + uint32_t _size1460; + ::apache::thrift::protocol::TType _ktype1461; + ::apache::thrift::protocol::TType _vtype1462; + xfer += iprot->readMapBegin(_ktype1461, _vtype1462, _size1460); + uint32_t _i1464; + for (_i1464 = 0; _i1464 < _size1460; ++_i1464) { - std::string _key1443; - xfer += iprot->readString(_key1443); - std::string& _val1444 = this->part_vals[_key1443]; - xfer += iprot->readString(_val1444); + std::string _key1465; + xfer += iprot->readString(_key1465); + std::string& _val1466 = this->part_vals[_key1465]; + xfer += iprot->readString(_val1466); } xfer += iprot->readMapEnd(); } @@ -22020,9 +22020,9 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::read(::apache::thri break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1445; - xfer += iprot->readI32(ecast1445); - this->eventType = (PartitionEventType::type)ecast1445; + int32_t ecast1467; + xfer += iprot->readI32(ecast1467); + this->eventType = (PartitionEventType::type)ecast1467; this->__isset.eventType = true; } else { xfer += iprot->skip(ftype); @@ -22056,11 +22056,11 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::write(::apache::thr xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_MAP, 3); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::map ::const_iterator _iter1446; - for (_iter1446 = this->part_vals.begin(); _iter1446 != this->part_vals.end(); ++_iter1446) + std::map ::const_iterator _iter1468; + for (_iter1468 = this->part_vals.begin(); _iter1468 != this->part_vals.end(); ++_iter1468) { - xfer += oprot->writeString(_iter1446->first); - xfer += oprot->writeString(_iter1446->second); + xfer += oprot->writeString(_iter1468->first); + xfer += oprot->writeString(_iter1468->second); } xfer += oprot->writeMapEnd(); } @@ -22096,11 +22096,11 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_pargs::write(::apache::th xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_MAP, 3); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::map ::const_iterator _iter1447; - for (_iter1447 = (*(this->part_vals)).begin(); _iter1447 != (*(this->part_vals)).end(); ++_iter1447) + std::map ::const_iterator _iter1469; + for (_iter1469 = (*(this->part_vals)).begin(); _iter1469 != (*(this->part_vals)).end(); ++_iter1469) { - xfer += oprot->writeString(_iter1447->first); - xfer += oprot->writeString(_iter1447->second); + xfer += oprot->writeString(_iter1469->first); + xfer += oprot->writeString(_iter1469->second); } xfer += oprot->writeMapEnd(); } @@ -23536,14 +23536,14 @@ uint32_t ThriftHiveMetastore_get_indexes_result::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1448; - ::apache::thrift::protocol::TType _etype1451; - xfer += iprot->readListBegin(_etype1451, _size1448); - this->success.resize(_size1448); - uint32_t _i1452; - for (_i1452 = 0; _i1452 < _size1448; ++_i1452) + uint32_t _size1470; + ::apache::thrift::protocol::TType _etype1473; + xfer += iprot->readListBegin(_etype1473, _size1470); + this->success.resize(_size1470); + uint32_t _i1474; + for (_i1474 = 0; _i1474 < _size1470; ++_i1474) { - xfer += this->success[_i1452].read(iprot); + xfer += this->success[_i1474].read(iprot); } xfer += iprot->readListEnd(); } @@ -23590,10 +23590,10 @@ uint32_t ThriftHiveMetastore_get_indexes_result::write(::apache::thrift::protoco xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1453; - for (_iter1453 = this->success.begin(); _iter1453 != this->success.end(); ++_iter1453) + std::vector ::const_iterator _iter1475; + for (_iter1475 = this->success.begin(); _iter1475 != this->success.end(); ++_iter1475) { - xfer += (*_iter1453).write(oprot); + xfer += (*_iter1475).write(oprot); } xfer += oprot->writeListEnd(); } @@ -23642,14 +23642,14 @@ uint32_t ThriftHiveMetastore_get_indexes_presult::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1454; - ::apache::thrift::protocol::TType _etype1457; - xfer += iprot->readListBegin(_etype1457, _size1454); - (*(this->success)).resize(_size1454); - uint32_t _i1458; - for (_i1458 = 0; _i1458 < _size1454; ++_i1458) + uint32_t _size1476; + ::apache::thrift::protocol::TType _etype1479; + xfer += iprot->readListBegin(_etype1479, _size1476); + (*(this->success)).resize(_size1476); + uint32_t _i1480; + for (_i1480 = 0; _i1480 < _size1476; ++_i1480) { - xfer += (*(this->success))[_i1458].read(iprot); + xfer += (*(this->success))[_i1480].read(iprot); } xfer += iprot->readListEnd(); } @@ -23827,14 +23827,14 @@ uint32_t ThriftHiveMetastore_get_index_names_result::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1459; - ::apache::thrift::protocol::TType _etype1462; - xfer += iprot->readListBegin(_etype1462, _size1459); - this->success.resize(_size1459); - uint32_t _i1463; - for (_i1463 = 0; _i1463 < _size1459; ++_i1463) + uint32_t _size1481; + ::apache::thrift::protocol::TType _etype1484; + xfer += iprot->readListBegin(_etype1484, _size1481); + this->success.resize(_size1481); + uint32_t _i1485; + for (_i1485 = 0; _i1485 < _size1481; ++_i1485) { - xfer += iprot->readString(this->success[_i1463]); + xfer += iprot->readString(this->success[_i1485]); } xfer += iprot->readListEnd(); } @@ -23873,10 +23873,10 @@ uint32_t ThriftHiveMetastore_get_index_names_result::write(::apache::thrift::pro xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1464; - for (_iter1464 = this->success.begin(); _iter1464 != this->success.end(); ++_iter1464) + std::vector ::const_iterator _iter1486; + for (_iter1486 = this->success.begin(); _iter1486 != this->success.end(); ++_iter1486) { - xfer += oprot->writeString((*_iter1464)); + xfer += oprot->writeString((*_iter1486)); } xfer += oprot->writeListEnd(); } @@ -23921,14 +23921,14 @@ uint32_t ThriftHiveMetastore_get_index_names_presult::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1465; - ::apache::thrift::protocol::TType _etype1468; - xfer += iprot->readListBegin(_etype1468, _size1465); - (*(this->success)).resize(_size1465); - uint32_t _i1469; - for (_i1469 = 0; _i1469 < _size1465; ++_i1469) + uint32_t _size1487; + ::apache::thrift::protocol::TType _etype1490; + xfer += iprot->readListBegin(_etype1490, _size1487); + (*(this->success)).resize(_size1487); + uint32_t _i1491; + for (_i1491 = 0; _i1491 < _size1487; ++_i1491) { - xfer += iprot->readString((*(this->success))[_i1469]); + xfer += iprot->readString((*(this->success))[_i1491]); } xfer += iprot->readListEnd(); } @@ -28409,14 +28409,14 @@ uint32_t ThriftHiveMetastore_get_functions_result::read(::apache::thrift::protoc if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1470; - ::apache::thrift::protocol::TType _etype1473; - xfer += iprot->readListBegin(_etype1473, _size1470); - this->success.resize(_size1470); - uint32_t _i1474; - for (_i1474 = 0; _i1474 < _size1470; ++_i1474) + uint32_t _size1492; + ::apache::thrift::protocol::TType _etype1495; + xfer += iprot->readListBegin(_etype1495, _size1492); + this->success.resize(_size1492); + uint32_t _i1496; + for (_i1496 = 0; _i1496 < _size1492; ++_i1496) { - xfer += iprot->readString(this->success[_i1474]); + xfer += iprot->readString(this->success[_i1496]); } xfer += iprot->readListEnd(); } @@ -28455,10 +28455,10 @@ uint32_t ThriftHiveMetastore_get_functions_result::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1475; - for (_iter1475 = this->success.begin(); _iter1475 != this->success.end(); ++_iter1475) + std::vector ::const_iterator _iter1497; + for (_iter1497 = this->success.begin(); _iter1497 != this->success.end(); ++_iter1497) { - xfer += oprot->writeString((*_iter1475)); + xfer += oprot->writeString((*_iter1497)); } xfer += oprot->writeListEnd(); } @@ -28503,14 +28503,14 @@ uint32_t ThriftHiveMetastore_get_functions_presult::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1476; - ::apache::thrift::protocol::TType _etype1479; - xfer += iprot->readListBegin(_etype1479, _size1476); - (*(this->success)).resize(_size1476); - uint32_t _i1480; - for (_i1480 = 0; _i1480 < _size1476; ++_i1480) + uint32_t _size1498; + ::apache::thrift::protocol::TType _etype1501; + xfer += iprot->readListBegin(_etype1501, _size1498); + (*(this->success)).resize(_size1498); + uint32_t _i1502; + for (_i1502 = 0; _i1502 < _size1498; ++_i1502) { - xfer += iprot->readString((*(this->success))[_i1480]); + xfer += iprot->readString((*(this->success))[_i1502]); } xfer += iprot->readListEnd(); } @@ -29470,14 +29470,14 @@ uint32_t ThriftHiveMetastore_get_role_names_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1481; - ::apache::thrift::protocol::TType _etype1484; - xfer += iprot->readListBegin(_etype1484, _size1481); - this->success.resize(_size1481); - uint32_t _i1485; - for (_i1485 = 0; _i1485 < _size1481; ++_i1485) + uint32_t _size1503; + ::apache::thrift::protocol::TType _etype1506; + xfer += iprot->readListBegin(_etype1506, _size1503); + this->success.resize(_size1503); + uint32_t _i1507; + for (_i1507 = 0; _i1507 < _size1503; ++_i1507) { - xfer += iprot->readString(this->success[_i1485]); + xfer += iprot->readString(this->success[_i1507]); } xfer += iprot->readListEnd(); } @@ -29516,10 +29516,10 @@ uint32_t ThriftHiveMetastore_get_role_names_result::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1486; - for (_iter1486 = this->success.begin(); _iter1486 != this->success.end(); ++_iter1486) + std::vector ::const_iterator _iter1508; + for (_iter1508 = this->success.begin(); _iter1508 != this->success.end(); ++_iter1508) { - xfer += oprot->writeString((*_iter1486)); + xfer += oprot->writeString((*_iter1508)); } xfer += oprot->writeListEnd(); } @@ -29564,14 +29564,14 @@ uint32_t ThriftHiveMetastore_get_role_names_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1487; - ::apache::thrift::protocol::TType _etype1490; - xfer += iprot->readListBegin(_etype1490, _size1487); - (*(this->success)).resize(_size1487); - uint32_t _i1491; - for (_i1491 = 0; _i1491 < _size1487; ++_i1491) + uint32_t _size1509; + ::apache::thrift::protocol::TType _etype1512; + xfer += iprot->readListBegin(_etype1512, _size1509); + (*(this->success)).resize(_size1509); + uint32_t _i1513; + for (_i1513 = 0; _i1513 < _size1509; ++_i1513) { - xfer += iprot->readString((*(this->success))[_i1491]); + xfer += iprot->readString((*(this->success))[_i1513]); } xfer += iprot->readListEnd(); } @@ -29644,9 +29644,9 @@ uint32_t ThriftHiveMetastore_grant_role_args::read(::apache::thrift::protocol::T break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1492; - xfer += iprot->readI32(ecast1492); - this->principal_type = (PrincipalType::type)ecast1492; + int32_t ecast1514; + xfer += iprot->readI32(ecast1514); + this->principal_type = (PrincipalType::type)ecast1514; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -29662,9 +29662,9 @@ uint32_t ThriftHiveMetastore_grant_role_args::read(::apache::thrift::protocol::T break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1493; - xfer += iprot->readI32(ecast1493); - this->grantorType = (PrincipalType::type)ecast1493; + int32_t ecast1515; + xfer += iprot->readI32(ecast1515); + this->grantorType = (PrincipalType::type)ecast1515; this->__isset.grantorType = true; } else { xfer += iprot->skip(ftype); @@ -29817,15 +29817,1134 @@ uint32_t ThriftHiveMetastore_grant_role_result::read(::apache::thrift::protocol: return xfer; } -uint32_t ThriftHiveMetastore_grant_role_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_grant_role_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_grant_role_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(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_grant_role_presult::~ThriftHiveMetastore_grant_role_presult() throw() { +} + + +uint32_t ThriftHiveMetastore_grant_role_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_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; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_revoke_role_args::~ThriftHiveMetastore_revoke_role_args() throw() { +} + + +uint32_t ThriftHiveMetastore_revoke_role_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->role_name); + this->__isset.role_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->principal_name); + this->__isset.principal_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast1516; + xfer += iprot->readI32(ecast1516); + this->principal_type = (PrincipalType::type)ecast1516; + this->__isset.principal_type = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_revoke_role_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_revoke_role_args"); + + xfer += oprot->writeFieldBegin("role_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->role_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("principal_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->principal_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("principal_type", ::apache::thrift::protocol::T_I32, 3); + xfer += oprot->writeI32((int32_t)this->principal_type); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_revoke_role_pargs::~ThriftHiveMetastore_revoke_role_pargs() throw() { +} + + +uint32_t ThriftHiveMetastore_revoke_role_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_revoke_role_pargs"); + + xfer += oprot->writeFieldBegin("role_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->role_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("principal_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->principal_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("principal_type", ::apache::thrift::protocol::T_I32, 3); + xfer += oprot->writeI32((int32_t)(*(this->principal_type))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_revoke_role_result::~ThriftHiveMetastore_revoke_role_result() throw() { +} + + +uint32_t ThriftHiveMetastore_revoke_role_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_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; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_revoke_role_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_revoke_role_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(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_revoke_role_presult::~ThriftHiveMetastore_revoke_role_presult() throw() { +} + + +uint32_t ThriftHiveMetastore_revoke_role_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_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; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_list_roles_args::~ThriftHiveMetastore_list_roles_args() throw() { +} + + +uint32_t ThriftHiveMetastore_list_roles_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->principal_name); + this->__isset.principal_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast1517; + xfer += iprot->readI32(ecast1517); + this->principal_type = (PrincipalType::type)ecast1517; + this->__isset.principal_type = 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_roles_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_list_roles_args"); + + xfer += oprot->writeFieldBegin("principal_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->principal_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("principal_type", ::apache::thrift::protocol::T_I32, 2); + xfer += oprot->writeI32((int32_t)this->principal_type); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_list_roles_pargs::~ThriftHiveMetastore_list_roles_pargs() throw() { +} + + +uint32_t ThriftHiveMetastore_list_roles_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_list_roles_pargs"); + + xfer += oprot->writeFieldBegin("principal_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->principal_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("principal_type", ::apache::thrift::protocol::T_I32, 2); + xfer += oprot->writeI32((int32_t)(*(this->principal_type))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_list_roles_result::~ThriftHiveMetastore_list_roles_result() throw() { +} + + +uint32_t ThriftHiveMetastore_list_roles_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size1518; + ::apache::thrift::protocol::TType _etype1521; + xfer += iprot->readListBegin(_etype1521, _size1518); + this->success.resize(_size1518); + uint32_t _i1522; + for (_i1522 = 0; _i1522 < _size1518; ++_i1522) + { + xfer += this->success[_i1522].read(iprot); + } + xfer += 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_roles_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_list_roles_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 _iter1523; + for (_iter1523 = this->success.begin(); _iter1523 != this->success.end(); ++_iter1523) + { + xfer += (*_iter1523).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; +} + + +ThriftHiveMetastore_list_roles_presult::~ThriftHiveMetastore_list_roles_presult() throw() { +} + + +uint32_t ThriftHiveMetastore_list_roles_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size1524; + ::apache::thrift::protocol::TType _etype1527; + xfer += iprot->readListBegin(_etype1527, _size1524); + (*(this->success)).resize(_size1524); + uint32_t _i1528; + for (_i1528 = 0; _i1528 < _size1524; ++_i1528) + { + xfer += (*(this->success))[_i1528].read(iprot); + } + xfer += 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; +} + + +ThriftHiveMetastore_grant_revoke_role_args::~ThriftHiveMetastore_grant_revoke_role_args() throw() { +} + + +uint32_t ThriftHiveMetastore_grant_revoke_role_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_grant_revoke_role_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_grant_revoke_role_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_grant_revoke_role_pargs::~ThriftHiveMetastore_grant_revoke_role_pargs() throw() { +} + + +uint32_t ThriftHiveMetastore_grant_revoke_role_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_grant_revoke_role_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_grant_revoke_role_result::~ThriftHiveMetastore_grant_revoke_role_result() throw() { +} + + +uint32_t ThriftHiveMetastore_grant_revoke_role_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_grant_revoke_role_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_grant_revoke_role_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(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_grant_revoke_role_presult::~ThriftHiveMetastore_grant_revoke_role_presult() throw() { +} + + +uint32_t ThriftHiveMetastore_grant_revoke_role_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_principals_in_role_args::~ThriftHiveMetastore_get_principals_in_role_args() throw() { +} + + +uint32_t ThriftHiveMetastore_get_principals_in_role_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = 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_principals_in_role_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_principals_in_role_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_principals_in_role_pargs::~ThriftHiveMetastore_get_principals_in_role_pargs() throw() { +} + + +uint32_t ThriftHiveMetastore_get_principals_in_role_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_principals_in_role_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_principals_in_role_result::~ThriftHiveMetastore_get_principals_in_role_result() throw() { +} + + +uint32_t ThriftHiveMetastore_get_principals_in_role_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_principals_in_role_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_principals_in_role_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(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_principals_in_role_presult::~ThriftHiveMetastore_get_principals_in_role_presult() throw() { +} + + +uint32_t ThriftHiveMetastore_get_principals_in_role_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_role_grants_for_principal_args::~ThriftHiveMetastore_get_role_grants_for_principal_args() throw() { +} + + +uint32_t ThriftHiveMetastore_get_role_grants_for_principal_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = 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_role_grants_for_principal_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_role_grants_for_principal_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_role_grants_for_principal_pargs::~ThriftHiveMetastore_get_role_grants_for_principal_pargs() throw() { +} + + +uint32_t ThriftHiveMetastore_get_role_grants_for_principal_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_role_grants_for_principal_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_role_grants_for_principal_result::~ThriftHiveMetastore_get_role_grants_for_principal_result() throw() { +} + + +uint32_t ThriftHiveMetastore_get_role_grants_for_principal_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_role_grants_for_principal_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_grant_role_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_role_grants_for_principal_result"); if (this->__isset.success) { - xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0); - xfer += oprot->writeBool(this->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); @@ -29838,11 +30957,11 @@ uint32_t ThriftHiveMetastore_grant_role_result::write(::apache::thrift::protocol } -ThriftHiveMetastore_grant_role_presult::~ThriftHiveMetastore_grant_role_presult() throw() { +ThriftHiveMetastore_get_role_grants_for_principal_presult::~ThriftHiveMetastore_get_role_grants_for_principal_presult() throw() { } -uint32_t ThriftHiveMetastore_grant_role_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_role_grants_for_principal_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -29864,8 +30983,8 @@ uint32_t ThriftHiveMetastore_grant_role_presult::read(::apache::thrift::protocol switch (fid) { case 0: - if (ftype == ::apache::thrift::protocol::T_BOOL) { - xfer += iprot->readBool((*(this->success))); + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); this->__isset.success = true; } else { xfer += iprot->skip(ftype); @@ -29892,11 +31011,11 @@ uint32_t ThriftHiveMetastore_grant_role_presult::read(::apache::thrift::protocol } -ThriftHiveMetastore_revoke_role_args::~ThriftHiveMetastore_revoke_role_args() throw() { +ThriftHiveMetastore_get_privilege_set_args::~ThriftHiveMetastore_get_privilege_set_args() throw() { } -uint32_t ThriftHiveMetastore_revoke_role_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_privilege_set_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -29918,27 +31037,37 @@ uint32_t ThriftHiveMetastore_revoke_role_args::read(::apache::thrift::protocol:: switch (fid) { case 1: - if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->role_name); - this->__isset.role_name = true; + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->hiveObject.read(iprot); + this->__isset.hiveObject = true; } else { xfer += iprot->skip(ftype); } break; case 2: if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->principal_name); - this->__isset.principal_name = true; + xfer += iprot->readString(this->user_name); + this->__isset.user_name = true; } else { xfer += iprot->skip(ftype); } break; case 3: - if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1494; - xfer += iprot->readI32(ecast1494); - this->principal_type = (PrincipalType::type)ecast1494; - this->__isset.principal_type = true; + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->group_names.clear(); + uint32_t _size1529; + ::apache::thrift::protocol::TType _etype1532; + xfer += iprot->readListBegin(_etype1532, _size1529); + this->group_names.resize(_size1529); + uint32_t _i1533; + for (_i1533 = 0; _i1533 < _size1529; ++_i1533) + { + xfer += iprot->readString(this->group_names[_i1533]); + } + xfer += iprot->readListEnd(); + } + this->__isset.group_names = true; } else { xfer += iprot->skip(ftype); } @@ -29955,21 +31084,29 @@ uint32_t ThriftHiveMetastore_revoke_role_args::read(::apache::thrift::protocol:: return xfer; } -uint32_t ThriftHiveMetastore_revoke_role_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_privilege_set_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_revoke_role_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_privilege_set_args"); - xfer += oprot->writeFieldBegin("role_name", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString(this->role_name); + xfer += oprot->writeFieldBegin("hiveObject", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->hiveObject.write(oprot); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("principal_name", ::apache::thrift::protocol::T_STRING, 2); - xfer += oprot->writeString(this->principal_name); + xfer += oprot->writeFieldBegin("user_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->user_name); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("principal_type", ::apache::thrift::protocol::T_I32, 3); - xfer += oprot->writeI32((int32_t)this->principal_type); + 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 _iter1534; + for (_iter1534 = this->group_names.begin(); _iter1534 != this->group_names.end(); ++_iter1534) + { + xfer += oprot->writeString((*_iter1534)); + } + xfer += oprot->writeListEnd(); + } xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -29978,25 +31115,33 @@ uint32_t ThriftHiveMetastore_revoke_role_args::write(::apache::thrift::protocol: } -ThriftHiveMetastore_revoke_role_pargs::~ThriftHiveMetastore_revoke_role_pargs() throw() { +ThriftHiveMetastore_get_privilege_set_pargs::~ThriftHiveMetastore_get_privilege_set_pargs() throw() { } -uint32_t ThriftHiveMetastore_revoke_role_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_privilege_set_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_revoke_role_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_privilege_set_pargs"); - xfer += oprot->writeFieldBegin("role_name", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString((*(this->role_name))); + xfer += oprot->writeFieldBegin("hiveObject", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->hiveObject)).write(oprot); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("principal_name", ::apache::thrift::protocol::T_STRING, 2); - xfer += oprot->writeString((*(this->principal_name))); + xfer += oprot->writeFieldBegin("user_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->user_name))); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("principal_type", ::apache::thrift::protocol::T_I32, 3); - xfer += oprot->writeI32((int32_t)(*(this->principal_type))); + 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 _iter1535; + for (_iter1535 = (*(this->group_names)).begin(); _iter1535 != (*(this->group_names)).end(); ++_iter1535) + { + xfer += oprot->writeString((*_iter1535)); + } + xfer += oprot->writeListEnd(); + } xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -30005,11 +31150,11 @@ uint32_t ThriftHiveMetastore_revoke_role_pargs::write(::apache::thrift::protocol } -ThriftHiveMetastore_revoke_role_result::~ThriftHiveMetastore_revoke_role_result() throw() { +ThriftHiveMetastore_get_privilege_set_result::~ThriftHiveMetastore_get_privilege_set_result() throw() { } -uint32_t ThriftHiveMetastore_revoke_role_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_privilege_set_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -30031,8 +31176,8 @@ uint32_t ThriftHiveMetastore_revoke_role_result::read(::apache::thrift::protocol switch (fid) { case 0: - if (ftype == ::apache::thrift::protocol::T_BOOL) { - xfer += iprot->readBool(this->success); + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); this->__isset.success = true; } else { xfer += iprot->skip(ftype); @@ -30058,15 +31203,15 @@ uint32_t ThriftHiveMetastore_revoke_role_result::read(::apache::thrift::protocol return xfer; } -uint32_t ThriftHiveMetastore_revoke_role_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_privilege_set_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_revoke_role_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_privilege_set_result"); if (this->__isset.success) { - xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0); - xfer += oprot->writeBool(this->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); @@ -30079,11 +31224,11 @@ uint32_t ThriftHiveMetastore_revoke_role_result::write(::apache::thrift::protoco } -ThriftHiveMetastore_revoke_role_presult::~ThriftHiveMetastore_revoke_role_presult() throw() { +ThriftHiveMetastore_get_privilege_set_presult::~ThriftHiveMetastore_get_privilege_set_presult() throw() { } -uint32_t ThriftHiveMetastore_revoke_role_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_privilege_set_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -30105,8 +31250,8 @@ uint32_t ThriftHiveMetastore_revoke_role_presult::read(::apache::thrift::protoco switch (fid) { case 0: - if (ftype == ::apache::thrift::protocol::T_BOOL) { - xfer += iprot->readBool((*(this->success))); + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); this->__isset.success = true; } else { xfer += iprot->skip(ftype); @@ -30133,11 +31278,11 @@ uint32_t ThriftHiveMetastore_revoke_role_presult::read(::apache::thrift::protoco } -ThriftHiveMetastore_list_roles_args::~ThriftHiveMetastore_list_roles_args() throw() { +ThriftHiveMetastore_list_privileges_args::~ThriftHiveMetastore_list_privileges_args() throw() { } -uint32_t ThriftHiveMetastore_list_roles_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_list_privileges_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -30168,14 +31313,22 @@ uint32_t ThriftHiveMetastore_list_roles_args::read(::apache::thrift::protocol::T break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1495; - xfer += iprot->readI32(ecast1495); - this->principal_type = (PrincipalType::type)ecast1495; + int32_t ecast1536; + xfer += iprot->readI32(ecast1536); + this->principal_type = (PrincipalType::type)ecast1536; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); } break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->hiveObject.read(iprot); + this->__isset.hiveObject = true; + } else { + xfer += iprot->skip(ftype); + } + break; default: xfer += iprot->skip(ftype); break; @@ -30188,10 +31341,10 @@ uint32_t ThriftHiveMetastore_list_roles_args::read(::apache::thrift::protocol::T return xfer; } -uint32_t ThriftHiveMetastore_list_roles_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_list_privileges_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_list_roles_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_list_privileges_args"); xfer += oprot->writeFieldBegin("principal_name", ::apache::thrift::protocol::T_STRING, 1); xfer += oprot->writeString(this->principal_name); @@ -30201,20 +31354,24 @@ uint32_t ThriftHiveMetastore_list_roles_args::write(::apache::thrift::protocol:: xfer += oprot->writeI32((int32_t)this->principal_type); xfer += oprot->writeFieldEnd(); + xfer += oprot->writeFieldBegin("hiveObject", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->hiveObject.write(oprot); + xfer += oprot->writeFieldEnd(); + xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; } -ThriftHiveMetastore_list_roles_pargs::~ThriftHiveMetastore_list_roles_pargs() throw() { +ThriftHiveMetastore_list_privileges_pargs::~ThriftHiveMetastore_list_privileges_pargs() throw() { } -uint32_t ThriftHiveMetastore_list_roles_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_list_privileges_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_list_roles_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_list_privileges_pargs"); xfer += oprot->writeFieldBegin("principal_name", ::apache::thrift::protocol::T_STRING, 1); xfer += oprot->writeString((*(this->principal_name))); @@ -30224,17 +31381,21 @@ uint32_t ThriftHiveMetastore_list_roles_pargs::write(::apache::thrift::protocol: xfer += oprot->writeI32((int32_t)(*(this->principal_type))); xfer += oprot->writeFieldEnd(); + xfer += oprot->writeFieldBegin("hiveObject", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += (*(this->hiveObject)).write(oprot); + xfer += oprot->writeFieldEnd(); + xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; } -ThriftHiveMetastore_list_roles_result::~ThriftHiveMetastore_list_roles_result() throw() { +ThriftHiveMetastore_list_privileges_result::~ThriftHiveMetastore_list_privileges_result() throw() { } -uint32_t ThriftHiveMetastore_list_roles_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_list_privileges_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -30259,14 +31420,14 @@ uint32_t ThriftHiveMetastore_list_roles_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1496; - ::apache::thrift::protocol::TType _etype1499; - xfer += iprot->readListBegin(_etype1499, _size1496); - this->success.resize(_size1496); - uint32_t _i1500; - for (_i1500 = 0; _i1500 < _size1496; ++_i1500) + uint32_t _size1537; + ::apache::thrift::protocol::TType _etype1540; + xfer += iprot->readListBegin(_etype1540, _size1537); + this->success.resize(_size1537); + uint32_t _i1541; + for (_i1541 = 0; _i1541 < _size1537; ++_i1541) { - xfer += this->success[_i1500].read(iprot); + xfer += this->success[_i1541].read(iprot); } xfer += iprot->readListEnd(); } @@ -30295,20 +31456,20 @@ uint32_t ThriftHiveMetastore_list_roles_result::read(::apache::thrift::protocol: return xfer; } -uint32_t ThriftHiveMetastore_list_roles_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_list_privileges_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_list_roles_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_list_privileges_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 _iter1501; - for (_iter1501 = this->success.begin(); _iter1501 != this->success.end(); ++_iter1501) + std::vector ::const_iterator _iter1542; + for (_iter1542 = this->success.begin(); _iter1542 != this->success.end(); ++_iter1542) { - xfer += (*_iter1501).write(oprot); + xfer += (*_iter1542).write(oprot); } xfer += oprot->writeListEnd(); } @@ -30324,11 +31485,11 @@ uint32_t ThriftHiveMetastore_list_roles_result::write(::apache::thrift::protocol } -ThriftHiveMetastore_list_roles_presult::~ThriftHiveMetastore_list_roles_presult() throw() { +ThriftHiveMetastore_list_privileges_presult::~ThriftHiveMetastore_list_privileges_presult() throw() { } -uint32_t ThriftHiveMetastore_list_roles_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_list_privileges_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -30353,14 +31514,14 @@ uint32_t ThriftHiveMetastore_list_roles_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1502; - ::apache::thrift::protocol::TType _etype1505; - xfer += iprot->readListBegin(_etype1505, _size1502); - (*(this->success)).resize(_size1502); - uint32_t _i1506; - for (_i1506 = 0; _i1506 < _size1502; ++_i1506) + uint32_t _size1543; + ::apache::thrift::protocol::TType _etype1546; + xfer += iprot->readListBegin(_etype1546, _size1543); + (*(this->success)).resize(_size1543); + uint32_t _i1547; + for (_i1547 = 0; _i1547 < _size1543; ++_i1547) { - xfer += (*(this->success))[_i1506].read(iprot); + xfer += (*(this->success))[_i1547].read(iprot); } xfer += iprot->readListEnd(); } @@ -30390,11 +31551,11 @@ uint32_t ThriftHiveMetastore_list_roles_presult::read(::apache::thrift::protocol } -ThriftHiveMetastore_grant_revoke_role_args::~ThriftHiveMetastore_grant_revoke_role_args() throw() { +ThriftHiveMetastore_grant_privileges_args::~ThriftHiveMetastore_grant_privileges_args() throw() { } -uint32_t ThriftHiveMetastore_grant_revoke_role_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_grant_privileges_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -30417,8 +31578,8 @@ uint32_t ThriftHiveMetastore_grant_revoke_role_args::read(::apache::thrift::prot { case 1: if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->request.read(iprot); - this->__isset.request = true; + xfer += this->privileges.read(iprot); + this->__isset.privileges = true; } else { xfer += iprot->skip(ftype); } @@ -30435,13 +31596,13 @@ uint32_t ThriftHiveMetastore_grant_revoke_role_args::read(::apache::thrift::prot return xfer; } -uint32_t ThriftHiveMetastore_grant_revoke_role_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_grant_privileges_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_grant_revoke_role_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_grant_privileges_args"); - xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += this->request.write(oprot); + xfer += oprot->writeFieldBegin("privileges", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->privileges.write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -30450,17 +31611,17 @@ uint32_t ThriftHiveMetastore_grant_revoke_role_args::write(::apache::thrift::pro } -ThriftHiveMetastore_grant_revoke_role_pargs::~ThriftHiveMetastore_grant_revoke_role_pargs() throw() { +ThriftHiveMetastore_grant_privileges_pargs::~ThriftHiveMetastore_grant_privileges_pargs() throw() { } -uint32_t ThriftHiveMetastore_grant_revoke_role_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_grant_privileges_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_grant_revoke_role_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_grant_privileges_pargs"); - xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldBegin("privileges", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->privileges)).write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -30469,11 +31630,11 @@ uint32_t ThriftHiveMetastore_grant_revoke_role_pargs::write(::apache::thrift::pr } -ThriftHiveMetastore_grant_revoke_role_result::~ThriftHiveMetastore_grant_revoke_role_result() throw() { +ThriftHiveMetastore_grant_privileges_result::~ThriftHiveMetastore_grant_privileges_result() throw() { } -uint32_t ThriftHiveMetastore_grant_revoke_role_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_grant_privileges_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -30495,8 +31656,8 @@ uint32_t ThriftHiveMetastore_grant_revoke_role_result::read(::apache::thrift::pr switch (fid) { case 0: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->success.read(iprot); + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->success); this->__isset.success = true; } else { xfer += iprot->skip(ftype); @@ -30522,15 +31683,15 @@ uint32_t ThriftHiveMetastore_grant_revoke_role_result::read(::apache::thrift::pr return xfer; } -uint32_t ThriftHiveMetastore_grant_revoke_role_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_grant_privileges_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_grant_revoke_role_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_grant_privileges_result"); if (this->__isset.success) { - xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); - xfer += this->success.write(oprot); + 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); @@ -30543,11 +31704,11 @@ uint32_t ThriftHiveMetastore_grant_revoke_role_result::write(::apache::thrift::p } -ThriftHiveMetastore_grant_revoke_role_presult::~ThriftHiveMetastore_grant_revoke_role_presult() throw() { +ThriftHiveMetastore_grant_privileges_presult::~ThriftHiveMetastore_grant_privileges_presult() throw() { } -uint32_t ThriftHiveMetastore_grant_revoke_role_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_grant_privileges_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -30569,8 +31730,8 @@ uint32_t ThriftHiveMetastore_grant_revoke_role_presult::read(::apache::thrift::p switch (fid) { case 0: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += (*(this->success)).read(iprot); + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool((*(this->success))); this->__isset.success = true; } else { xfer += iprot->skip(ftype); @@ -30597,11 +31758,11 @@ uint32_t ThriftHiveMetastore_grant_revoke_role_presult::read(::apache::thrift::p } -ThriftHiveMetastore_get_principals_in_role_args::~ThriftHiveMetastore_get_principals_in_role_args() throw() { +ThriftHiveMetastore_revoke_privileges_args::~ThriftHiveMetastore_revoke_privileges_args() throw() { } -uint32_t ThriftHiveMetastore_get_principals_in_role_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_revoke_privileges_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -30624,8 +31785,8 @@ uint32_t ThriftHiveMetastore_get_principals_in_role_args::read(::apache::thrift: { case 1: if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->request.read(iprot); - this->__isset.request = true; + xfer += this->privileges.read(iprot); + this->__isset.privileges = true; } else { xfer += iprot->skip(ftype); } @@ -30642,13 +31803,13 @@ uint32_t ThriftHiveMetastore_get_principals_in_role_args::read(::apache::thrift: return xfer; } -uint32_t ThriftHiveMetastore_get_principals_in_role_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_revoke_privileges_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_principals_in_role_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_revoke_privileges_args"); - xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += this->request.write(oprot); + xfer += oprot->writeFieldBegin("privileges", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->privileges.write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -30657,17 +31818,17 @@ uint32_t ThriftHiveMetastore_get_principals_in_role_args::write(::apache::thrift } -ThriftHiveMetastore_get_principals_in_role_pargs::~ThriftHiveMetastore_get_principals_in_role_pargs() throw() { +ThriftHiveMetastore_revoke_privileges_pargs::~ThriftHiveMetastore_revoke_privileges_pargs() throw() { } -uint32_t ThriftHiveMetastore_get_principals_in_role_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_revoke_privileges_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_principals_in_role_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_revoke_privileges_pargs"); - xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldBegin("privileges", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->privileges)).write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -30676,11 +31837,11 @@ uint32_t ThriftHiveMetastore_get_principals_in_role_pargs::write(::apache::thrif } -ThriftHiveMetastore_get_principals_in_role_result::~ThriftHiveMetastore_get_principals_in_role_result() throw() { +ThriftHiveMetastore_revoke_privileges_result::~ThriftHiveMetastore_revoke_privileges_result() throw() { } -uint32_t ThriftHiveMetastore_get_principals_in_role_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_revoke_privileges_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -30702,8 +31863,8 @@ uint32_t ThriftHiveMetastore_get_principals_in_role_result::read(::apache::thrif switch (fid) { case 0: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->success.read(iprot); + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->success); this->__isset.success = true; } else { xfer += iprot->skip(ftype); @@ -30729,15 +31890,15 @@ uint32_t ThriftHiveMetastore_get_principals_in_role_result::read(::apache::thrif return xfer; } -uint32_t ThriftHiveMetastore_get_principals_in_role_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_revoke_privileges_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_principals_in_role_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_revoke_privileges_result"); if (this->__isset.success) { - xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); - xfer += this->success.write(oprot); + 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); @@ -30750,11 +31911,11 @@ uint32_t ThriftHiveMetastore_get_principals_in_role_result::write(::apache::thri } -ThriftHiveMetastore_get_principals_in_role_presult::~ThriftHiveMetastore_get_principals_in_role_presult() throw() { +ThriftHiveMetastore_revoke_privileges_presult::~ThriftHiveMetastore_revoke_privileges_presult() throw() { } -uint32_t ThriftHiveMetastore_get_principals_in_role_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_revoke_privileges_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -30776,8 +31937,8 @@ uint32_t ThriftHiveMetastore_get_principals_in_role_presult::read(::apache::thri switch (fid) { case 0: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += (*(this->success)).read(iprot); + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool((*(this->success))); this->__isset.success = true; } else { xfer += iprot->skip(ftype); @@ -30804,11 +31965,11 @@ uint32_t ThriftHiveMetastore_get_principals_in_role_presult::read(::apache::thri } -ThriftHiveMetastore_get_role_grants_for_principal_args::~ThriftHiveMetastore_get_role_grants_for_principal_args() throw() { +ThriftHiveMetastore_grant_revoke_privileges_args::~ThriftHiveMetastore_grant_revoke_privileges_args() throw() { } -uint32_t ThriftHiveMetastore_get_role_grants_for_principal_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_grant_revoke_privileges_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -30849,10 +32010,10 @@ uint32_t ThriftHiveMetastore_get_role_grants_for_principal_args::read(::apache:: return xfer; } -uint32_t ThriftHiveMetastore_get_role_grants_for_principal_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_grant_revoke_privileges_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_role_grants_for_principal_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_grant_revoke_privileges_args"); xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); xfer += this->request.write(oprot); @@ -30864,14 +32025,14 @@ uint32_t ThriftHiveMetastore_get_role_grants_for_principal_args::write(::apache: } -ThriftHiveMetastore_get_role_grants_for_principal_pargs::~ThriftHiveMetastore_get_role_grants_for_principal_pargs() throw() { +ThriftHiveMetastore_grant_revoke_privileges_pargs::~ThriftHiveMetastore_grant_revoke_privileges_pargs() throw() { } -uint32_t ThriftHiveMetastore_get_role_grants_for_principal_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_grant_revoke_privileges_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_role_grants_for_principal_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_grant_revoke_privileges_pargs"); xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); xfer += (*(this->request)).write(oprot); @@ -30883,11 +32044,11 @@ uint32_t ThriftHiveMetastore_get_role_grants_for_principal_pargs::write(::apache } -ThriftHiveMetastore_get_role_grants_for_principal_result::~ThriftHiveMetastore_get_role_grants_for_principal_result() throw() { +ThriftHiveMetastore_grant_revoke_privileges_result::~ThriftHiveMetastore_grant_revoke_privileges_result() throw() { } -uint32_t ThriftHiveMetastore_get_role_grants_for_principal_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_grant_revoke_privileges_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -30936,11 +32097,11 @@ uint32_t ThriftHiveMetastore_get_role_grants_for_principal_result::read(::apache return xfer; } -uint32_t ThriftHiveMetastore_get_role_grants_for_principal_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_grant_revoke_privileges_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_role_grants_for_principal_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_grant_revoke_privileges_result"); if (this->__isset.success) { xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); @@ -30957,11 +32118,11 @@ uint32_t ThriftHiveMetastore_get_role_grants_for_principal_result::write(::apach } -ThriftHiveMetastore_get_role_grants_for_principal_presult::~ThriftHiveMetastore_get_role_grants_for_principal_presult() throw() { +ThriftHiveMetastore_grant_revoke_privileges_presult::~ThriftHiveMetastore_grant_revoke_privileges_presult() throw() { } -uint32_t ThriftHiveMetastore_get_role_grants_for_principal_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_grant_revoke_privileges_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -31011,11 +32172,11 @@ uint32_t ThriftHiveMetastore_get_role_grants_for_principal_presult::read(::apach } -ThriftHiveMetastore_get_privilege_set_args::~ThriftHiveMetastore_get_privilege_set_args() throw() { +ThriftHiveMetastore_set_ugi_args::~ThriftHiveMetastore_set_ugi_args() throw() { } -uint32_t ThriftHiveMetastore_get_privilege_set_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_set_ugi_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -31037,14 +32198,6 @@ uint32_t ThriftHiveMetastore_get_privilege_set_args::read(::apache::thrift::prot switch (fid) { case 1: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->hiveObject.read(iprot); - this->__isset.hiveObject = true; - } else { - xfer += iprot->skip(ftype); - } - break; - case 2: if (ftype == ::apache::thrift::protocol::T_STRING) { xfer += iprot->readString(this->user_name); this->__isset.user_name = true; @@ -31052,18 +32205,18 @@ uint32_t ThriftHiveMetastore_get_privilege_set_args::read(::apache::thrift::prot xfer += iprot->skip(ftype); } break; - case 3: + case 2: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size1507; - ::apache::thrift::protocol::TType _etype1510; - xfer += iprot->readListBegin(_etype1510, _size1507); - this->group_names.resize(_size1507); - uint32_t _i1511; - for (_i1511 = 0; _i1511 < _size1507; ++_i1511) + uint32_t _size1548; + ::apache::thrift::protocol::TType _etype1551; + xfer += iprot->readListBegin(_etype1551, _size1548); + this->group_names.resize(_size1548); + uint32_t _i1552; + for (_i1552 = 0; _i1552 < _size1548; ++_i1552) { - xfer += iprot->readString(this->group_names[_i1511]); + xfer += iprot->readString(this->group_names[_i1552]); } xfer += iprot->readListEnd(); } @@ -31084,26 +32237,22 @@ uint32_t ThriftHiveMetastore_get_privilege_set_args::read(::apache::thrift::prot return xfer; } -uint32_t ThriftHiveMetastore_get_privilege_set_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_set_ugi_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_privilege_set_args"); - - xfer += oprot->writeFieldBegin("hiveObject", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += this->hiveObject.write(oprot); - xfer += oprot->writeFieldEnd(); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_set_ugi_args"); - xfer += oprot->writeFieldBegin("user_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeFieldBegin("user_name", ::apache::thrift::protocol::T_STRING, 1); xfer += oprot->writeString(this->user_name); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 3); + 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 _iter1512; - for (_iter1512 = this->group_names.begin(); _iter1512 != this->group_names.end(); ++_iter1512) + std::vector ::const_iterator _iter1553; + for (_iter1553 = this->group_names.begin(); _iter1553 != this->group_names.end(); ++_iter1553) { - xfer += oprot->writeString((*_iter1512)); + xfer += oprot->writeString((*_iter1553)); } xfer += oprot->writeListEnd(); } @@ -31115,30 +32264,26 @@ uint32_t ThriftHiveMetastore_get_privilege_set_args::write(::apache::thrift::pro } -ThriftHiveMetastore_get_privilege_set_pargs::~ThriftHiveMetastore_get_privilege_set_pargs() throw() { +ThriftHiveMetastore_set_ugi_pargs::~ThriftHiveMetastore_set_ugi_pargs() throw() { } -uint32_t ThriftHiveMetastore_get_privilege_set_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_set_ugi_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_privilege_set_pargs"); - - xfer += oprot->writeFieldBegin("hiveObject", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += (*(this->hiveObject)).write(oprot); - xfer += oprot->writeFieldEnd(); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_set_ugi_pargs"); - xfer += oprot->writeFieldBegin("user_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeFieldBegin("user_name", ::apache::thrift::protocol::T_STRING, 1); xfer += oprot->writeString((*(this->user_name))); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 3); + 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 _iter1513; - for (_iter1513 = (*(this->group_names)).begin(); _iter1513 != (*(this->group_names)).end(); ++_iter1513) + std::vector ::const_iterator _iter1554; + for (_iter1554 = (*(this->group_names)).begin(); _iter1554 != (*(this->group_names)).end(); ++_iter1554) { - xfer += oprot->writeString((*_iter1513)); + xfer += oprot->writeString((*_iter1554)); } xfer += oprot->writeListEnd(); } @@ -31150,11 +32295,11 @@ uint32_t ThriftHiveMetastore_get_privilege_set_pargs::write(::apache::thrift::pr } -ThriftHiveMetastore_get_privilege_set_result::~ThriftHiveMetastore_get_privilege_set_result() throw() { +ThriftHiveMetastore_set_ugi_result::~ThriftHiveMetastore_set_ugi_result() throw() { } -uint32_t ThriftHiveMetastore_get_privilege_set_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_set_ugi_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -31176,8 +32321,20 @@ uint32_t ThriftHiveMetastore_get_privilege_set_result::read(::apache::thrift::pr switch (fid) { case 0: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->success.read(iprot); + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size1555; + ::apache::thrift::protocol::TType _etype1558; + xfer += iprot->readListBegin(_etype1558, _size1555); + this->success.resize(_size1555); + uint32_t _i1559; + for (_i1559 = 0; _i1559 < _size1555; ++_i1559) + { + xfer += iprot->readString(this->success[_i1559]); + } + xfer += iprot->readListEnd(); + } this->__isset.success = true; } else { xfer += iprot->skip(ftype); @@ -31203,15 +32360,23 @@ uint32_t ThriftHiveMetastore_get_privilege_set_result::read(::apache::thrift::pr return xfer; } -uint32_t ThriftHiveMetastore_get_privilege_set_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_set_ugi_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_privilege_set_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_set_ugi_result"); if (this->__isset.success) { - xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); - xfer += this->success.write(oprot); + 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 _iter1560; + for (_iter1560 = this->success.begin(); _iter1560 != this->success.end(); ++_iter1560) + { + xfer += oprot->writeString((*_iter1560)); + } + xfer += oprot->writeListEnd(); + } xfer += oprot->writeFieldEnd(); } else if (this->__isset.o1) { xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); @@ -31224,11 +32389,11 @@ uint32_t ThriftHiveMetastore_get_privilege_set_result::write(::apache::thrift::p } -ThriftHiveMetastore_get_privilege_set_presult::~ThriftHiveMetastore_get_privilege_set_presult() throw() { +ThriftHiveMetastore_set_ugi_presult::~ThriftHiveMetastore_set_ugi_presult() throw() { } -uint32_t ThriftHiveMetastore_get_privilege_set_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_set_ugi_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -31250,8 +32415,20 @@ uint32_t ThriftHiveMetastore_get_privilege_set_presult::read(::apache::thrift::p switch (fid) { case 0: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += (*(this->success)).read(iprot); + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size1561; + ::apache::thrift::protocol::TType _etype1564; + xfer += iprot->readListBegin(_etype1564, _size1561); + (*(this->success)).resize(_size1561); + uint32_t _i1565; + for (_i1565 = 0; _i1565 < _size1561; ++_i1565) + { + xfer += iprot->readString((*(this->success))[_i1565]); + } + xfer += iprot->readListEnd(); + } this->__isset.success = true; } else { xfer += iprot->skip(ftype); @@ -31278,11 +32455,11 @@ uint32_t ThriftHiveMetastore_get_privilege_set_presult::read(::apache::thrift::p } -ThriftHiveMetastore_list_privileges_args::~ThriftHiveMetastore_list_privileges_args() throw() { +ThriftHiveMetastore_get_delegation_token_args::~ThriftHiveMetastore_get_delegation_token_args() throw() { } -uint32_t ThriftHiveMetastore_list_privileges_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_delegation_token_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -31305,26 +32482,16 @@ uint32_t ThriftHiveMetastore_list_privileges_args::read(::apache::thrift::protoc { case 1: if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->principal_name); - this->__isset.principal_name = true; + xfer += iprot->readString(this->token_owner); + this->__isset.token_owner = true; } else { xfer += iprot->skip(ftype); } break; case 2: - if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1514; - xfer += iprot->readI32(ecast1514); - this->principal_type = (PrincipalType::type)ecast1514; - this->__isset.principal_type = true; - } else { - xfer += iprot->skip(ftype); - } - break; - case 3: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->hiveObject.read(iprot); - this->__isset.hiveObject = true; + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->renewer_kerberos_principal_name); + this->__isset.renewer_kerberos_principal_name = true; } else { xfer += iprot->skip(ftype); } @@ -31341,21 +32508,17 @@ uint32_t ThriftHiveMetastore_list_privileges_args::read(::apache::thrift::protoc return xfer; } -uint32_t ThriftHiveMetastore_list_privileges_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_delegation_token_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_list_privileges_args"); - - xfer += oprot->writeFieldBegin("principal_name", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString(this->principal_name); - xfer += oprot->writeFieldEnd(); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_delegation_token_args"); - xfer += oprot->writeFieldBegin("principal_type", ::apache::thrift::protocol::T_I32, 2); - xfer += oprot->writeI32((int32_t)this->principal_type); + xfer += oprot->writeFieldBegin("token_owner", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->token_owner); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("hiveObject", ::apache::thrift::protocol::T_STRUCT, 3); - xfer += this->hiveObject.write(oprot); + xfer += oprot->writeFieldBegin("renewer_kerberos_principal_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->renewer_kerberos_principal_name); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -31364,25 +32527,21 @@ uint32_t ThriftHiveMetastore_list_privileges_args::write(::apache::thrift::proto } -ThriftHiveMetastore_list_privileges_pargs::~ThriftHiveMetastore_list_privileges_pargs() throw() { +ThriftHiveMetastore_get_delegation_token_pargs::~ThriftHiveMetastore_get_delegation_token_pargs() throw() { } -uint32_t ThriftHiveMetastore_list_privileges_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_delegation_token_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_list_privileges_pargs"); - - xfer += oprot->writeFieldBegin("principal_name", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString((*(this->principal_name))); - xfer += oprot->writeFieldEnd(); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_delegation_token_pargs"); - xfer += oprot->writeFieldBegin("principal_type", ::apache::thrift::protocol::T_I32, 2); - xfer += oprot->writeI32((int32_t)(*(this->principal_type))); + xfer += oprot->writeFieldBegin("token_owner", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->token_owner))); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("hiveObject", ::apache::thrift::protocol::T_STRUCT, 3); - xfer += (*(this->hiveObject)).write(oprot); + xfer += oprot->writeFieldBegin("renewer_kerberos_principal_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->renewer_kerberos_principal_name))); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -31391,11 +32550,11 @@ uint32_t ThriftHiveMetastore_list_privileges_pargs::write(::apache::thrift::prot } -ThriftHiveMetastore_list_privileges_result::~ThriftHiveMetastore_list_privileges_result() throw() { +ThriftHiveMetastore_get_delegation_token_result::~ThriftHiveMetastore_get_delegation_token_result() throw() { } -uint32_t ThriftHiveMetastore_list_privileges_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_delegation_token_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -31417,20 +32576,8 @@ uint32_t ThriftHiveMetastore_list_privileges_result::read(::apache::thrift::prot switch (fid) { case 0: - if (ftype == ::apache::thrift::protocol::T_LIST) { - { - this->success.clear(); - uint32_t _size1515; - ::apache::thrift::protocol::TType _etype1518; - xfer += iprot->readListBegin(_etype1518, _size1515); - this->success.resize(_size1515); - uint32_t _i1519; - for (_i1519 = 0; _i1519 < _size1515; ++_i1519) - { - xfer += this->success[_i1519].read(iprot); - } - xfer += iprot->readListEnd(); - } + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->success); this->__isset.success = true; } else { xfer += iprot->skip(ftype); @@ -31456,23 +32603,15 @@ uint32_t ThriftHiveMetastore_list_privileges_result::read(::apache::thrift::prot return xfer; } -uint32_t ThriftHiveMetastore_list_privileges_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_delegation_token_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_list_privileges_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_delegation_token_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 _iter1520; - for (_iter1520 = this->success.begin(); _iter1520 != this->success.end(); ++_iter1520) - { - xfer += (*_iter1520).write(oprot); - } - xfer += oprot->writeListEnd(); - } + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0); + xfer += oprot->writeString(this->success); xfer += oprot->writeFieldEnd(); } else if (this->__isset.o1) { xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); @@ -31485,11 +32624,11 @@ uint32_t ThriftHiveMetastore_list_privileges_result::write(::apache::thrift::pro } -ThriftHiveMetastore_list_privileges_presult::~ThriftHiveMetastore_list_privileges_presult() throw() { +ThriftHiveMetastore_get_delegation_token_presult::~ThriftHiveMetastore_get_delegation_token_presult() throw() { } -uint32_t ThriftHiveMetastore_list_privileges_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_delegation_token_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -31511,20 +32650,8 @@ uint32_t ThriftHiveMetastore_list_privileges_presult::read(::apache::thrift::pro switch (fid) { case 0: - if (ftype == ::apache::thrift::protocol::T_LIST) { - { - (*(this->success)).clear(); - uint32_t _size1521; - ::apache::thrift::protocol::TType _etype1524; - xfer += iprot->readListBegin(_etype1524, _size1521); - (*(this->success)).resize(_size1521); - uint32_t _i1525; - for (_i1525 = 0; _i1525 < _size1521; ++_i1525) - { - xfer += (*(this->success))[_i1525].read(iprot); - } - xfer += iprot->readListEnd(); - } + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString((*(this->success))); this->__isset.success = true; } else { xfer += iprot->skip(ftype); @@ -31551,11 +32678,11 @@ uint32_t ThriftHiveMetastore_list_privileges_presult::read(::apache::thrift::pro } -ThriftHiveMetastore_grant_privileges_args::~ThriftHiveMetastore_grant_privileges_args() throw() { +ThriftHiveMetastore_renew_delegation_token_args::~ThriftHiveMetastore_renew_delegation_token_args() throw() { } -uint32_t ThriftHiveMetastore_grant_privileges_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_renew_delegation_token_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -31577,9 +32704,9 @@ uint32_t ThriftHiveMetastore_grant_privileges_args::read(::apache::thrift::proto switch (fid) { case 1: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->privileges.read(iprot); - this->__isset.privileges = true; + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->token_str_form); + this->__isset.token_str_form = true; } else { xfer += iprot->skip(ftype); } @@ -31596,13 +32723,13 @@ uint32_t ThriftHiveMetastore_grant_privileges_args::read(::apache::thrift::proto return xfer; } -uint32_t ThriftHiveMetastore_grant_privileges_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_renew_delegation_token_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_grant_privileges_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_renew_delegation_token_args"); - xfer += oprot->writeFieldBegin("privileges", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += this->privileges.write(oprot); + xfer += oprot->writeFieldBegin("token_str_form", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->token_str_form); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -31611,17 +32738,17 @@ uint32_t ThriftHiveMetastore_grant_privileges_args::write(::apache::thrift::prot } -ThriftHiveMetastore_grant_privileges_pargs::~ThriftHiveMetastore_grant_privileges_pargs() throw() { +ThriftHiveMetastore_renew_delegation_token_pargs::~ThriftHiveMetastore_renew_delegation_token_pargs() throw() { } -uint32_t ThriftHiveMetastore_grant_privileges_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_renew_delegation_token_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_grant_privileges_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_renew_delegation_token_pargs"); - xfer += oprot->writeFieldBegin("privileges", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += (*(this->privileges)).write(oprot); + xfer += oprot->writeFieldBegin("token_str_form", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->token_str_form))); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -31630,11 +32757,11 @@ uint32_t ThriftHiveMetastore_grant_privileges_pargs::write(::apache::thrift::pro } -ThriftHiveMetastore_grant_privileges_result::~ThriftHiveMetastore_grant_privileges_result() throw() { +ThriftHiveMetastore_renew_delegation_token_result::~ThriftHiveMetastore_renew_delegation_token_result() throw() { } -uint32_t ThriftHiveMetastore_grant_privileges_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_renew_delegation_token_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -31656,8 +32783,8 @@ uint32_t ThriftHiveMetastore_grant_privileges_result::read(::apache::thrift::pro switch (fid) { case 0: - if (ftype == ::apache::thrift::protocol::T_BOOL) { - xfer += iprot->readBool(this->success); + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->success); this->__isset.success = true; } else { xfer += iprot->skip(ftype); @@ -31683,15 +32810,15 @@ uint32_t ThriftHiveMetastore_grant_privileges_result::read(::apache::thrift::pro return xfer; } -uint32_t ThriftHiveMetastore_grant_privileges_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_renew_delegation_token_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_grant_privileges_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_renew_delegation_token_result"); if (this->__isset.success) { - xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0); - xfer += oprot->writeBool(this->success); + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I64, 0); + xfer += oprot->writeI64(this->success); xfer += oprot->writeFieldEnd(); } else if (this->__isset.o1) { xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); @@ -31704,11 +32831,11 @@ uint32_t ThriftHiveMetastore_grant_privileges_result::write(::apache::thrift::pr } -ThriftHiveMetastore_grant_privileges_presult::~ThriftHiveMetastore_grant_privileges_presult() throw() { +ThriftHiveMetastore_renew_delegation_token_presult::~ThriftHiveMetastore_renew_delegation_token_presult() throw() { } -uint32_t ThriftHiveMetastore_grant_privileges_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_renew_delegation_token_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -31730,8 +32857,8 @@ uint32_t ThriftHiveMetastore_grant_privileges_presult::read(::apache::thrift::pr switch (fid) { case 0: - if (ftype == ::apache::thrift::protocol::T_BOOL) { - xfer += iprot->readBool((*(this->success))); + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64((*(this->success))); this->__isset.success = true; } else { xfer += iprot->skip(ftype); @@ -31758,11 +32885,11 @@ uint32_t ThriftHiveMetastore_grant_privileges_presult::read(::apache::thrift::pr } -ThriftHiveMetastore_revoke_privileges_args::~ThriftHiveMetastore_revoke_privileges_args() throw() { +ThriftHiveMetastore_cancel_delegation_token_args::~ThriftHiveMetastore_cancel_delegation_token_args() throw() { } -uint32_t ThriftHiveMetastore_revoke_privileges_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_cancel_delegation_token_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -31784,9 +32911,9 @@ uint32_t ThriftHiveMetastore_revoke_privileges_args::read(::apache::thrift::prot switch (fid) { case 1: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->privileges.read(iprot); - this->__isset.privileges = true; + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->token_str_form); + this->__isset.token_str_form = true; } else { xfer += iprot->skip(ftype); } @@ -31803,13 +32930,13 @@ uint32_t ThriftHiveMetastore_revoke_privileges_args::read(::apache::thrift::prot return xfer; } -uint32_t ThriftHiveMetastore_revoke_privileges_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_cancel_delegation_token_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_revoke_privileges_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_cancel_delegation_token_args"); - xfer += oprot->writeFieldBegin("privileges", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += this->privileges.write(oprot); + xfer += oprot->writeFieldBegin("token_str_form", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->token_str_form); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -31818,17 +32945,17 @@ uint32_t ThriftHiveMetastore_revoke_privileges_args::write(::apache::thrift::pro } -ThriftHiveMetastore_revoke_privileges_pargs::~ThriftHiveMetastore_revoke_privileges_pargs() throw() { +ThriftHiveMetastore_cancel_delegation_token_pargs::~ThriftHiveMetastore_cancel_delegation_token_pargs() throw() { } -uint32_t ThriftHiveMetastore_revoke_privileges_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_cancel_delegation_token_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_revoke_privileges_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_cancel_delegation_token_pargs"); - xfer += oprot->writeFieldBegin("privileges", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += (*(this->privileges)).write(oprot); + xfer += oprot->writeFieldBegin("token_str_form", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->token_str_form))); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -31837,11 +32964,11 @@ uint32_t ThriftHiveMetastore_revoke_privileges_pargs::write(::apache::thrift::pr } -ThriftHiveMetastore_revoke_privileges_result::~ThriftHiveMetastore_revoke_privileges_result() throw() { +ThriftHiveMetastore_cancel_delegation_token_result::~ThriftHiveMetastore_cancel_delegation_token_result() throw() { } -uint32_t ThriftHiveMetastore_revoke_privileges_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_cancel_delegation_token_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -31862,14 +32989,6 @@ uint32_t ThriftHiveMetastore_revoke_privileges_result::read(::apache::thrift::pr } 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); @@ -31890,17 +33009,13 @@ uint32_t ThriftHiveMetastore_revoke_privileges_result::read(::apache::thrift::pr return xfer; } -uint32_t ThriftHiveMetastore_revoke_privileges_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_cancel_delegation_token_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_revoke_privileges_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_cancel_delegation_token_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) { + if (this->__isset.o1) { xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); xfer += this->o1.write(oprot); xfer += oprot->writeFieldEnd(); @@ -31911,11 +33026,11 @@ uint32_t ThriftHiveMetastore_revoke_privileges_result::write(::apache::thrift::p } -ThriftHiveMetastore_revoke_privileges_presult::~ThriftHiveMetastore_revoke_privileges_presult() throw() { +ThriftHiveMetastore_cancel_delegation_token_presult::~ThriftHiveMetastore_cancel_delegation_token_presult() throw() { } -uint32_t ThriftHiveMetastore_revoke_privileges_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_cancel_delegation_token_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -31936,14 +33051,6 @@ uint32_t ThriftHiveMetastore_revoke_privileges_presult::read(::apache::thrift::p } 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); @@ -31965,11 +33072,11 @@ uint32_t ThriftHiveMetastore_revoke_privileges_presult::read(::apache::thrift::p } -ThriftHiveMetastore_grant_revoke_privileges_args::~ThriftHiveMetastore_grant_revoke_privileges_args() throw() { +ThriftHiveMetastore_add_token_args::~ThriftHiveMetastore_add_token_args() throw() { } -uint32_t ThriftHiveMetastore_grant_revoke_privileges_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_add_token_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -31991,9 +33098,17 @@ uint32_t ThriftHiveMetastore_grant_revoke_privileges_args::read(::apache::thrift switch (fid) { case 1: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->request.read(iprot); - this->__isset.request = true; + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->token_identifier); + this->__isset.token_identifier = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->delegation_token); + this->__isset.delegation_token = true; } else { xfer += iprot->skip(ftype); } @@ -32010,13 +33125,17 @@ uint32_t ThriftHiveMetastore_grant_revoke_privileges_args::read(::apache::thrift return xfer; } -uint32_t ThriftHiveMetastore_grant_revoke_privileges_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_add_token_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_grant_revoke_privileges_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_token_args"); - xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += this->request.write(oprot); + xfer += oprot->writeFieldBegin("token_identifier", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->token_identifier); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("delegation_token", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->delegation_token); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -32025,17 +33144,21 @@ uint32_t ThriftHiveMetastore_grant_revoke_privileges_args::write(::apache::thrif } -ThriftHiveMetastore_grant_revoke_privileges_pargs::~ThriftHiveMetastore_grant_revoke_privileges_pargs() throw() { +ThriftHiveMetastore_add_token_pargs::~ThriftHiveMetastore_add_token_pargs() throw() { } -uint32_t ThriftHiveMetastore_grant_revoke_privileges_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_add_token_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_grant_revoke_privileges_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_token_pargs"); - xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldBegin("token_identifier", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->token_identifier))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("delegation_token", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->delegation_token))); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -32044,11 +33167,11 @@ uint32_t ThriftHiveMetastore_grant_revoke_privileges_pargs::write(::apache::thri } -ThriftHiveMetastore_grant_revoke_privileges_result::~ThriftHiveMetastore_grant_revoke_privileges_result() throw() { +ThriftHiveMetastore_add_token_result::~ThriftHiveMetastore_add_token_result() throw() { } -uint32_t ThriftHiveMetastore_grant_revoke_privileges_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_add_token_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -32070,21 +33193,13 @@ uint32_t ThriftHiveMetastore_grant_revoke_privileges_result::read(::apache::thri switch (fid) { case 0: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->success.read(iprot); + 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; default: xfer += iprot->skip(ftype); break; @@ -32097,19 +33212,15 @@ uint32_t ThriftHiveMetastore_grant_revoke_privileges_result::read(::apache::thri return xfer; } -uint32_t ThriftHiveMetastore_grant_revoke_privileges_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_add_token_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_grant_revoke_privileges_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_token_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->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0); + xfer += oprot->writeBool(this->success); xfer += oprot->writeFieldEnd(); } xfer += oprot->writeFieldStop(); @@ -32118,11 +33229,11 @@ uint32_t ThriftHiveMetastore_grant_revoke_privileges_result::write(::apache::thr } -ThriftHiveMetastore_grant_revoke_privileges_presult::~ThriftHiveMetastore_grant_revoke_privileges_presult() throw() { +ThriftHiveMetastore_add_token_presult::~ThriftHiveMetastore_add_token_presult() throw() { } -uint32_t ThriftHiveMetastore_grant_revoke_privileges_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_add_token_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -32144,21 +33255,13 @@ uint32_t ThriftHiveMetastore_grant_revoke_privileges_presult::read(::apache::thr switch (fid) { case 0: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += (*(this->success)).read(iprot); + 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; default: xfer += iprot->skip(ftype); break; @@ -32172,11 +33275,11 @@ uint32_t ThriftHiveMetastore_grant_revoke_privileges_presult::read(::apache::thr } -ThriftHiveMetastore_set_ugi_args::~ThriftHiveMetastore_set_ugi_args() throw() { +ThriftHiveMetastore_remove_token_args::~ThriftHiveMetastore_remove_token_args() throw() { } -uint32_t ThriftHiveMetastore_set_ugi_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_remove_token_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -32199,28 +33302,8 @@ uint32_t ThriftHiveMetastore_set_ugi_args::read(::apache::thrift::protocol::TPro { case 1: if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->user_name); - this->__isset.user_name = true; - } else { - xfer += iprot->skip(ftype); - } - break; - case 2: - if (ftype == ::apache::thrift::protocol::T_LIST) { - { - this->group_names.clear(); - uint32_t _size1526; - ::apache::thrift::protocol::TType _etype1529; - xfer += iprot->readListBegin(_etype1529, _size1526); - this->group_names.resize(_size1526); - uint32_t _i1530; - for (_i1530 = 0; _i1530 < _size1526; ++_i1530) - { - xfer += iprot->readString(this->group_names[_i1530]); - } - xfer += iprot->readListEnd(); - } - this->__isset.group_names = true; + xfer += iprot->readString(this->token_identifier); + this->__isset.token_identifier = true; } else { xfer += iprot->skip(ftype); } @@ -32237,25 +33320,13 @@ uint32_t ThriftHiveMetastore_set_ugi_args::read(::apache::thrift::protocol::TPro return xfer; } -uint32_t ThriftHiveMetastore_set_ugi_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_remove_token_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_set_ugi_args"); - - xfer += oprot->writeFieldBegin("user_name", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString(this->user_name); - xfer += oprot->writeFieldEnd(); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_remove_token_args"); - 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 _iter1531; - for (_iter1531 = this->group_names.begin(); _iter1531 != this->group_names.end(); ++_iter1531) - { - xfer += oprot->writeString((*_iter1531)); - } - xfer += oprot->writeListEnd(); - } + xfer += oprot->writeFieldBegin("token_identifier", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->token_identifier); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -32264,29 +33335,17 @@ uint32_t ThriftHiveMetastore_set_ugi_args::write(::apache::thrift::protocol::TPr } -ThriftHiveMetastore_set_ugi_pargs::~ThriftHiveMetastore_set_ugi_pargs() throw() { +ThriftHiveMetastore_remove_token_pargs::~ThriftHiveMetastore_remove_token_pargs() throw() { } -uint32_t ThriftHiveMetastore_set_ugi_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_remove_token_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_set_ugi_pargs"); - - xfer += oprot->writeFieldBegin("user_name", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString((*(this->user_name))); - xfer += oprot->writeFieldEnd(); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_remove_token_pargs"); - 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 _iter1532; - for (_iter1532 = (*(this->group_names)).begin(); _iter1532 != (*(this->group_names)).end(); ++_iter1532) - { - xfer += oprot->writeString((*_iter1532)); - } - xfer += oprot->writeListEnd(); - } + xfer += oprot->writeFieldBegin("token_identifier", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->token_identifier))); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -32295,11 +33354,11 @@ uint32_t ThriftHiveMetastore_set_ugi_pargs::write(::apache::thrift::protocol::TP } -ThriftHiveMetastore_set_ugi_result::~ThriftHiveMetastore_set_ugi_result() throw() { +ThriftHiveMetastore_remove_token_result::~ThriftHiveMetastore_remove_token_result() throw() { } -uint32_t ThriftHiveMetastore_set_ugi_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_remove_token_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -32321,33 +33380,13 @@ uint32_t ThriftHiveMetastore_set_ugi_result::read(::apache::thrift::protocol::TP switch (fid) { case 0: - if (ftype == ::apache::thrift::protocol::T_LIST) { - { - this->success.clear(); - uint32_t _size1533; - ::apache::thrift::protocol::TType _etype1536; - xfer += iprot->readListBegin(_etype1536, _size1533); - this->success.resize(_size1533); - uint32_t _i1537; - for (_i1537 = 0; _i1537 < _size1533; ++_i1537) - { - xfer += iprot->readString(this->success[_i1537]); - } - xfer += iprot->readListEnd(); - } + 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; default: xfer += iprot->skip(ftype); break; @@ -32360,27 +33399,15 @@ uint32_t ThriftHiveMetastore_set_ugi_result::read(::apache::thrift::protocol::TP return xfer; } -uint32_t ThriftHiveMetastore_set_ugi_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_remove_token_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_set_ugi_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_remove_token_result"); if (this->__isset.success) { - 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 _iter1538; - for (_iter1538 = this->success.begin(); _iter1538 != this->success.end(); ++_iter1538) - { - xfer += oprot->writeString((*_iter1538)); - } - 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->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0); + xfer += oprot->writeBool(this->success); xfer += oprot->writeFieldEnd(); } xfer += oprot->writeFieldStop(); @@ -32389,11 +33416,11 @@ uint32_t ThriftHiveMetastore_set_ugi_result::write(::apache::thrift::protocol::T } -ThriftHiveMetastore_set_ugi_presult::~ThriftHiveMetastore_set_ugi_presult() throw() { +ThriftHiveMetastore_remove_token_presult::~ThriftHiveMetastore_remove_token_presult() throw() { } -uint32_t ThriftHiveMetastore_set_ugi_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_remove_token_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -32415,33 +33442,13 @@ uint32_t ThriftHiveMetastore_set_ugi_presult::read(::apache::thrift::protocol::T switch (fid) { case 0: - if (ftype == ::apache::thrift::protocol::T_LIST) { - { - (*(this->success)).clear(); - uint32_t _size1539; - ::apache::thrift::protocol::TType _etype1542; - xfer += iprot->readListBegin(_etype1542, _size1539); - (*(this->success)).resize(_size1539); - uint32_t _i1543; - for (_i1543 = 0; _i1543 < _size1539; ++_i1543) - { - xfer += iprot->readString((*(this->success))[_i1543]); - } - xfer += iprot->readListEnd(); - } + 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; default: xfer += iprot->skip(ftype); break; @@ -32455,11 +33462,11 @@ uint32_t ThriftHiveMetastore_set_ugi_presult::read(::apache::thrift::protocol::T } -ThriftHiveMetastore_get_delegation_token_args::~ThriftHiveMetastore_get_delegation_token_args() throw() { +ThriftHiveMetastore_get_token_args::~ThriftHiveMetastore_get_token_args() throw() { } -uint32_t ThriftHiveMetastore_get_delegation_token_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_token_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -32482,16 +33489,8 @@ uint32_t ThriftHiveMetastore_get_delegation_token_args::read(::apache::thrift::p { case 1: if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->token_owner); - this->__isset.token_owner = true; - } else { - xfer += iprot->skip(ftype); - } - break; - case 2: - if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->renewer_kerberos_principal_name); - this->__isset.renewer_kerberos_principal_name = true; + xfer += iprot->readString(this->token_identifier); + this->__isset.token_identifier = true; } else { xfer += iprot->skip(ftype); } @@ -32508,17 +33507,13 @@ uint32_t ThriftHiveMetastore_get_delegation_token_args::read(::apache::thrift::p return xfer; } -uint32_t ThriftHiveMetastore_get_delegation_token_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_token_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_delegation_token_args"); - - xfer += oprot->writeFieldBegin("token_owner", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString(this->token_owner); - xfer += oprot->writeFieldEnd(); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_token_args"); - xfer += oprot->writeFieldBegin("renewer_kerberos_principal_name", ::apache::thrift::protocol::T_STRING, 2); - xfer += oprot->writeString(this->renewer_kerberos_principal_name); + xfer += oprot->writeFieldBegin("token_identifier", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->token_identifier); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -32527,21 +33522,17 @@ uint32_t ThriftHiveMetastore_get_delegation_token_args::write(::apache::thrift:: } -ThriftHiveMetastore_get_delegation_token_pargs::~ThriftHiveMetastore_get_delegation_token_pargs() throw() { +ThriftHiveMetastore_get_token_pargs::~ThriftHiveMetastore_get_token_pargs() throw() { } -uint32_t ThriftHiveMetastore_get_delegation_token_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_token_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_delegation_token_pargs"); - - xfer += oprot->writeFieldBegin("token_owner", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString((*(this->token_owner))); - xfer += oprot->writeFieldEnd(); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_token_pargs"); - xfer += oprot->writeFieldBegin("renewer_kerberos_principal_name", ::apache::thrift::protocol::T_STRING, 2); - xfer += oprot->writeString((*(this->renewer_kerberos_principal_name))); + xfer += oprot->writeFieldBegin("token_identifier", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->token_identifier))); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -32550,11 +33541,11 @@ uint32_t ThriftHiveMetastore_get_delegation_token_pargs::write(::apache::thrift: } -ThriftHiveMetastore_get_delegation_token_result::~ThriftHiveMetastore_get_delegation_token_result() throw() { +ThriftHiveMetastore_get_token_result::~ThriftHiveMetastore_get_token_result() throw() { } -uint32_t ThriftHiveMetastore_get_delegation_token_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_token_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -32583,14 +33574,6 @@ uint32_t ThriftHiveMetastore_get_delegation_token_result::read(::apache::thrift: 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; @@ -32603,20 +33586,16 @@ uint32_t ThriftHiveMetastore_get_delegation_token_result::read(::apache::thrift: return xfer; } -uint32_t ThriftHiveMetastore_get_delegation_token_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_token_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_delegation_token_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_token_result"); if (this->__isset.success) { xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0); xfer += oprot->writeString(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(); } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); @@ -32624,11 +33603,11 @@ uint32_t ThriftHiveMetastore_get_delegation_token_result::write(::apache::thrift } -ThriftHiveMetastore_get_delegation_token_presult::~ThriftHiveMetastore_get_delegation_token_presult() throw() { +ThriftHiveMetastore_get_token_presult::~ThriftHiveMetastore_get_token_presult() throw() { } -uint32_t ThriftHiveMetastore_get_delegation_token_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_token_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -32657,14 +33636,6 @@ uint32_t ThriftHiveMetastore_get_delegation_token_presult::read(::apache::thrift 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; @@ -32678,11 +33649,11 @@ uint32_t ThriftHiveMetastore_get_delegation_token_presult::read(::apache::thrift } -ThriftHiveMetastore_renew_delegation_token_args::~ThriftHiveMetastore_renew_delegation_token_args() throw() { +ThriftHiveMetastore_get_all_token_identifiers_args::~ThriftHiveMetastore_get_all_token_identifiers_args() throw() { } -uint32_t ThriftHiveMetastore_renew_delegation_token_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_all_token_identifiers_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -32701,20 +33672,7 @@ uint32_t ThriftHiveMetastore_renew_delegation_token_args::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_STOP) { break; } - switch (fid) - { - case 1: - if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->token_str_form); - this->__isset.token_str_form = true; - } else { - xfer += iprot->skip(ftype); - } - break; - default: - xfer += iprot->skip(ftype); - break; - } + xfer += iprot->skip(ftype); xfer += iprot->readFieldEnd(); } @@ -32723,14 +33681,10 @@ uint32_t ThriftHiveMetastore_renew_delegation_token_args::read(::apache::thrift: return xfer; } -uint32_t ThriftHiveMetastore_renew_delegation_token_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_all_token_identifiers_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_renew_delegation_token_args"); - - xfer += oprot->writeFieldBegin("token_str_form", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString(this->token_str_form); - xfer += oprot->writeFieldEnd(); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_token_identifiers_args"); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); @@ -32738,18 +33692,14 @@ uint32_t ThriftHiveMetastore_renew_delegation_token_args::write(::apache::thrift } -ThriftHiveMetastore_renew_delegation_token_pargs::~ThriftHiveMetastore_renew_delegation_token_pargs() throw() { +ThriftHiveMetastore_get_all_token_identifiers_pargs::~ThriftHiveMetastore_get_all_token_identifiers_pargs() throw() { } -uint32_t ThriftHiveMetastore_renew_delegation_token_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_all_token_identifiers_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_renew_delegation_token_pargs"); - - xfer += oprot->writeFieldBegin("token_str_form", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString((*(this->token_str_form))); - xfer += oprot->writeFieldEnd(); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_token_identifiers_pargs"); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); @@ -32757,11 +33707,11 @@ uint32_t ThriftHiveMetastore_renew_delegation_token_pargs::write(::apache::thrif } -ThriftHiveMetastore_renew_delegation_token_result::~ThriftHiveMetastore_renew_delegation_token_result() throw() { +ThriftHiveMetastore_get_all_token_identifiers_result::~ThriftHiveMetastore_get_all_token_identifiers_result() throw() { } -uint32_t ThriftHiveMetastore_renew_delegation_token_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_all_token_identifiers_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -32783,21 +33733,25 @@ uint32_t ThriftHiveMetastore_renew_delegation_token_result::read(::apache::thrif switch (fid) { case 0: - if (ftype == ::apache::thrift::protocol::T_I64) { - xfer += iprot->readI64(this->success); + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size1566; + ::apache::thrift::protocol::TType _etype1569; + xfer += iprot->readListBegin(_etype1569, _size1566); + this->success.resize(_size1566); + uint32_t _i1570; + for (_i1570 = 0; _i1570 < _size1566; ++_i1570) + { + xfer += iprot->readString(this->success[_i1570]); + } + xfer += 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; @@ -32810,19 +33764,23 @@ uint32_t ThriftHiveMetastore_renew_delegation_token_result::read(::apache::thrif return xfer; } -uint32_t ThriftHiveMetastore_renew_delegation_token_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_all_token_identifiers_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_renew_delegation_token_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_token_identifiers_result"); if (this->__isset.success) { - xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I64, 0); - xfer += oprot->writeI64(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->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 _iter1571; + for (_iter1571 = this->success.begin(); _iter1571 != this->success.end(); ++_iter1571) + { + xfer += oprot->writeString((*_iter1571)); + } + xfer += oprot->writeListEnd(); + } xfer += oprot->writeFieldEnd(); } xfer += oprot->writeFieldStop(); @@ -32831,11 +33789,11 @@ uint32_t ThriftHiveMetastore_renew_delegation_token_result::write(::apache::thri } -ThriftHiveMetastore_renew_delegation_token_presult::~ThriftHiveMetastore_renew_delegation_token_presult() throw() { +ThriftHiveMetastore_get_all_token_identifiers_presult::~ThriftHiveMetastore_get_all_token_identifiers_presult() throw() { } -uint32_t ThriftHiveMetastore_renew_delegation_token_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_all_token_identifiers_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -32857,17 +33815,67 @@ uint32_t ThriftHiveMetastore_renew_delegation_token_presult::read(::apache::thri switch (fid) { case 0: - if (ftype == ::apache::thrift::protocol::T_I64) { - xfer += iprot->readI64((*(this->success))); + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size1572; + ::apache::thrift::protocol::TType _etype1575; + xfer += iprot->readListBegin(_etype1575, _size1572); + (*(this->success)).resize(_size1572); + uint32_t _i1576; + for (_i1576 = 0; _i1576 < _size1572; ++_i1576) + { + xfer += iprot->readString((*(this->success))[_i1576]); + } + xfer += iprot->readListEnd(); + } this->__isset.success = true; } else { xfer += iprot->skip(ftype); } break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_add_master_key_args::~ThriftHiveMetastore_add_master_key_args() throw() { +} + + +uint32_t ThriftHiveMetastore_add_master_key_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { case 1: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->o1.read(iprot); - this->__isset.o1 = true; + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->key); + this->__isset.key = true; } else { xfer += iprot->skip(ftype); } @@ -32884,12 +33892,45 @@ uint32_t ThriftHiveMetastore_renew_delegation_token_presult::read(::apache::thri return xfer; } +uint32_t ThriftHiveMetastore_add_master_key_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_master_key_args"); -ThriftHiveMetastore_cancel_delegation_token_args::~ThriftHiveMetastore_cancel_delegation_token_args() throw() { + xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->key); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; } -uint32_t ThriftHiveMetastore_cancel_delegation_token_args::read(::apache::thrift::protocol::TProtocol* iprot) { +ThriftHiveMetastore_add_master_key_pargs::~ThriftHiveMetastore_add_master_key_pargs() throw() { +} + + +uint32_t ThriftHiveMetastore_add_master_key_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_master_key_pargs"); + + xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->key))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_master_key_result::~ThriftHiveMetastore_add_master_key_result() throw() { +} + + +uint32_t ThriftHiveMetastore_add_master_key_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -32910,85 +33951,14 @@ uint32_t ThriftHiveMetastore_cancel_delegation_token_args::read(::apache::thrift } switch (fid) { - case 1: - if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->token_str_form); - this->__isset.token_str_form = true; + case 0: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->success); + this->__isset.success = true; } else { xfer += iprot->skip(ftype); } break; - default: - xfer += iprot->skip(ftype); - break; - } - xfer += iprot->readFieldEnd(); - } - - xfer += iprot->readStructEnd(); - - return xfer; -} - -uint32_t ThriftHiveMetastore_cancel_delegation_token_args::write(::apache::thrift::protocol::TProtocol* oprot) const { - uint32_t xfer = 0; - apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_cancel_delegation_token_args"); - - xfer += oprot->writeFieldBegin("token_str_form", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString(this->token_str_form); - xfer += oprot->writeFieldEnd(); - - xfer += oprot->writeFieldStop(); - xfer += oprot->writeStructEnd(); - return xfer; -} - - -ThriftHiveMetastore_cancel_delegation_token_pargs::~ThriftHiveMetastore_cancel_delegation_token_pargs() throw() { -} - - -uint32_t ThriftHiveMetastore_cancel_delegation_token_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { - uint32_t xfer = 0; - apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_cancel_delegation_token_pargs"); - - xfer += oprot->writeFieldBegin("token_str_form", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString((*(this->token_str_form))); - xfer += oprot->writeFieldEnd(); - - xfer += oprot->writeFieldStop(); - xfer += oprot->writeStructEnd(); - return xfer; -} - - -ThriftHiveMetastore_cancel_delegation_token_result::~ThriftHiveMetastore_cancel_delegation_token_result() throw() { -} - - -uint32_t ThriftHiveMetastore_cancel_delegation_token_result::read(::apache::thrift::protocol::TProtocol* iprot) { - - apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); - uint32_t xfer = 0; - std::string fname; - ::apache::thrift::protocol::TType ftype; - int16_t fid; - - xfer += iprot->readStructBegin(fname); - - using ::apache::thrift::protocol::TProtocolException; - - - while (true) - { - xfer += iprot->readFieldBegin(fname, ftype, fid); - if (ftype == ::apache::thrift::protocol::T_STOP) { - break; - } - switch (fid) - { case 1: if (ftype == ::apache::thrift::protocol::T_STRUCT) { xfer += this->o1.read(iprot); @@ -33009,13 +33979,17 @@ uint32_t ThriftHiveMetastore_cancel_delegation_token_result::read(::apache::thri return xfer; } -uint32_t ThriftHiveMetastore_cancel_delegation_token_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_add_master_key_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_cancel_delegation_token_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_master_key_result"); - if (this->__isset.o1) { + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I32, 0); + xfer += oprot->writeI32(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(); @@ -33026,11 +34000,11 @@ uint32_t ThriftHiveMetastore_cancel_delegation_token_result::write(::apache::thr } -ThriftHiveMetastore_cancel_delegation_token_presult::~ThriftHiveMetastore_cancel_delegation_token_presult() throw() { +ThriftHiveMetastore_add_master_key_presult::~ThriftHiveMetastore_add_master_key_presult() throw() { } -uint32_t ThriftHiveMetastore_cancel_delegation_token_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_add_master_key_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -33051,6 +34025,14 @@ uint32_t ThriftHiveMetastore_cancel_delegation_token_presult::read(::apache::thr } switch (fid) { + case 0: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32((*(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); @@ -33072,11 +34054,11 @@ uint32_t ThriftHiveMetastore_cancel_delegation_token_presult::read(::apache::thr } -ThriftHiveMetastore_add_token_args::~ThriftHiveMetastore_add_token_args() throw() { +ThriftHiveMetastore_update_master_key_args::~ThriftHiveMetastore_update_master_key_args() throw() { } -uint32_t ThriftHiveMetastore_add_token_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_update_master_key_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -33098,17 +34080,17 @@ uint32_t ThriftHiveMetastore_add_token_args::read(::apache::thrift::protocol::TP switch (fid) { case 1: - if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->token_identifier); - this->__isset.token_identifier = true; + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->seq_number); + this->__isset.seq_number = true; } else { xfer += iprot->skip(ftype); } break; case 2: if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->delegation_token); - this->__isset.delegation_token = true; + xfer += iprot->readString(this->key); + this->__isset.key = true; } else { xfer += iprot->skip(ftype); } @@ -33125,17 +34107,17 @@ uint32_t ThriftHiveMetastore_add_token_args::read(::apache::thrift::protocol::TP return xfer; } -uint32_t ThriftHiveMetastore_add_token_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_update_master_key_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_token_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_update_master_key_args"); - xfer += oprot->writeFieldBegin("token_identifier", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString(this->token_identifier); + xfer += oprot->writeFieldBegin("seq_number", ::apache::thrift::protocol::T_I32, 1); + xfer += oprot->writeI32(this->seq_number); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("delegation_token", ::apache::thrift::protocol::T_STRING, 2); - xfer += oprot->writeString(this->delegation_token); + xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->key); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -33144,21 +34126,21 @@ uint32_t ThriftHiveMetastore_add_token_args::write(::apache::thrift::protocol::T } -ThriftHiveMetastore_add_token_pargs::~ThriftHiveMetastore_add_token_pargs() throw() { +ThriftHiveMetastore_update_master_key_pargs::~ThriftHiveMetastore_update_master_key_pargs() throw() { } -uint32_t ThriftHiveMetastore_add_token_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_update_master_key_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_token_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_update_master_key_pargs"); - xfer += oprot->writeFieldBegin("token_identifier", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString((*(this->token_identifier))); + xfer += oprot->writeFieldBegin("seq_number", ::apache::thrift::protocol::T_I32, 1); + xfer += oprot->writeI32((*(this->seq_number))); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("delegation_token", ::apache::thrift::protocol::T_STRING, 2); - xfer += oprot->writeString((*(this->delegation_token))); + xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->key))); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -33167,11 +34149,11 @@ uint32_t ThriftHiveMetastore_add_token_pargs::write(::apache::thrift::protocol:: } -ThriftHiveMetastore_add_token_result::~ThriftHiveMetastore_add_token_result() throw() { +ThriftHiveMetastore_update_master_key_result::~ThriftHiveMetastore_update_master_key_result() throw() { } -uint32_t ThriftHiveMetastore_add_token_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_update_master_key_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -33192,10 +34174,18 @@ uint32_t ThriftHiveMetastore_add_token_result::read(::apache::thrift::protocol:: } switch (fid) { - case 0: - if (ftype == ::apache::thrift::protocol::T_BOOL) { - xfer += iprot->readBool(this->success); - this->__isset.success = true; + 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); } @@ -33212,15 +34202,19 @@ uint32_t ThriftHiveMetastore_add_token_result::read(::apache::thrift::protocol:: return xfer; } -uint32_t ThriftHiveMetastore_add_token_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_update_master_key_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_token_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_update_master_key_result"); - if (this->__isset.success) { - xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0); - xfer += oprot->writeBool(this->success); + 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(); @@ -33229,11 +34223,11 @@ uint32_t ThriftHiveMetastore_add_token_result::write(::apache::thrift::protocol: } -ThriftHiveMetastore_add_token_presult::~ThriftHiveMetastore_add_token_presult() throw() { +ThriftHiveMetastore_update_master_key_presult::~ThriftHiveMetastore_update_master_key_presult() throw() { } -uint32_t ThriftHiveMetastore_add_token_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_update_master_key_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -33254,10 +34248,18 @@ uint32_t ThriftHiveMetastore_add_token_presult::read(::apache::thrift::protocol: } switch (fid) { - case 0: - if (ftype == ::apache::thrift::protocol::T_BOOL) { - xfer += iprot->readBool((*(this->success))); - this->__isset.success = true; + 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); } @@ -33275,11 +34277,11 @@ uint32_t ThriftHiveMetastore_add_token_presult::read(::apache::thrift::protocol: } -ThriftHiveMetastore_remove_token_args::~ThriftHiveMetastore_remove_token_args() throw() { +ThriftHiveMetastore_remove_master_key_args::~ThriftHiveMetastore_remove_master_key_args() throw() { } -uint32_t ThriftHiveMetastore_remove_token_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_remove_master_key_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -33301,9 +34303,9 @@ uint32_t ThriftHiveMetastore_remove_token_args::read(::apache::thrift::protocol: switch (fid) { case 1: - if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->token_identifier); - this->__isset.token_identifier = true; + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->key_seq); + this->__isset.key_seq = true; } else { xfer += iprot->skip(ftype); } @@ -33320,13 +34322,13 @@ uint32_t ThriftHiveMetastore_remove_token_args::read(::apache::thrift::protocol: return xfer; } -uint32_t ThriftHiveMetastore_remove_token_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_remove_master_key_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_remove_token_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_remove_master_key_args"); - xfer += oprot->writeFieldBegin("token_identifier", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString(this->token_identifier); + xfer += oprot->writeFieldBegin("key_seq", ::apache::thrift::protocol::T_I32, 1); + xfer += oprot->writeI32(this->key_seq); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -33335,17 +34337,17 @@ uint32_t ThriftHiveMetastore_remove_token_args::write(::apache::thrift::protocol } -ThriftHiveMetastore_remove_token_pargs::~ThriftHiveMetastore_remove_token_pargs() throw() { +ThriftHiveMetastore_remove_master_key_pargs::~ThriftHiveMetastore_remove_master_key_pargs() throw() { } -uint32_t ThriftHiveMetastore_remove_token_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_remove_master_key_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_remove_token_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_remove_master_key_pargs"); - xfer += oprot->writeFieldBegin("token_identifier", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString((*(this->token_identifier))); + xfer += oprot->writeFieldBegin("key_seq", ::apache::thrift::protocol::T_I32, 1); + xfer += oprot->writeI32((*(this->key_seq))); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -33354,11 +34356,11 @@ uint32_t ThriftHiveMetastore_remove_token_pargs::write(::apache::thrift::protoco } -ThriftHiveMetastore_remove_token_result::~ThriftHiveMetastore_remove_token_result() throw() { +ThriftHiveMetastore_remove_master_key_result::~ThriftHiveMetastore_remove_master_key_result() throw() { } -uint32_t ThriftHiveMetastore_remove_token_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_remove_master_key_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -33399,11 +34401,11 @@ uint32_t ThriftHiveMetastore_remove_token_result::read(::apache::thrift::protoco return xfer; } -uint32_t ThriftHiveMetastore_remove_token_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_remove_master_key_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_remove_token_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_remove_master_key_result"); if (this->__isset.success) { xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0); @@ -33416,11 +34418,11 @@ uint32_t ThriftHiveMetastore_remove_token_result::write(::apache::thrift::protoc } -ThriftHiveMetastore_remove_token_presult::~ThriftHiveMetastore_remove_token_presult() throw() { +ThriftHiveMetastore_remove_master_key_presult::~ThriftHiveMetastore_remove_master_key_presult() throw() { } -uint32_t ThriftHiveMetastore_remove_token_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_remove_master_key_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -33462,11 +34464,11 @@ uint32_t ThriftHiveMetastore_remove_token_presult::read(::apache::thrift::protoc } -ThriftHiveMetastore_get_token_args::~ThriftHiveMetastore_get_token_args() throw() { +ThriftHiveMetastore_get_master_keys_args::~ThriftHiveMetastore_get_master_keys_args() throw() { } -uint32_t ThriftHiveMetastore_get_token_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_master_keys_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -33485,20 +34487,7 @@ uint32_t ThriftHiveMetastore_get_token_args::read(::apache::thrift::protocol::TP if (ftype == ::apache::thrift::protocol::T_STOP) { break; } - switch (fid) - { - case 1: - if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->token_identifier); - this->__isset.token_identifier = true; - } else { - xfer += iprot->skip(ftype); - } - break; - default: - xfer += iprot->skip(ftype); - break; - } + xfer += iprot->skip(ftype); xfer += iprot->readFieldEnd(); } @@ -33507,14 +34496,10 @@ uint32_t ThriftHiveMetastore_get_token_args::read(::apache::thrift::protocol::TP return xfer; } -uint32_t ThriftHiveMetastore_get_token_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_master_keys_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_token_args"); - - xfer += oprot->writeFieldBegin("token_identifier", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString(this->token_identifier); - xfer += oprot->writeFieldEnd(); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_master_keys_args"); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); @@ -33522,18 +34507,14 @@ uint32_t ThriftHiveMetastore_get_token_args::write(::apache::thrift::protocol::T } -ThriftHiveMetastore_get_token_pargs::~ThriftHiveMetastore_get_token_pargs() throw() { +ThriftHiveMetastore_get_master_keys_pargs::~ThriftHiveMetastore_get_master_keys_pargs() throw() { } -uint32_t ThriftHiveMetastore_get_token_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_master_keys_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_token_pargs"); - - xfer += oprot->writeFieldBegin("token_identifier", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString((*(this->token_identifier))); - xfer += oprot->writeFieldEnd(); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_master_keys_pargs"); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); @@ -33541,11 +34522,11 @@ uint32_t ThriftHiveMetastore_get_token_pargs::write(::apache::thrift::protocol:: } -ThriftHiveMetastore_get_token_result::~ThriftHiveMetastore_get_token_result() throw() { +ThriftHiveMetastore_get_master_keys_result::~ThriftHiveMetastore_get_master_keys_result() throw() { } -uint32_t ThriftHiveMetastore_get_token_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_master_keys_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -33567,8 +34548,20 @@ uint32_t ThriftHiveMetastore_get_token_result::read(::apache::thrift::protocol:: switch (fid) { case 0: - if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->success); + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size1577; + ::apache::thrift::protocol::TType _etype1580; + xfer += iprot->readListBegin(_etype1580, _size1577); + this->success.resize(_size1577); + uint32_t _i1581; + for (_i1581 = 0; _i1581 < _size1577; ++_i1581) + { + xfer += iprot->readString(this->success[_i1581]); + } + xfer += iprot->readListEnd(); + } this->__isset.success = true; } else { xfer += iprot->skip(ftype); @@ -33586,15 +34579,23 @@ uint32_t ThriftHiveMetastore_get_token_result::read(::apache::thrift::protocol:: return xfer; } -uint32_t ThriftHiveMetastore_get_token_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_master_keys_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_token_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_master_keys_result"); if (this->__isset.success) { - xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0); - xfer += oprot->writeString(this->success); + 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 _iter1582; + for (_iter1582 = this->success.begin(); _iter1582 != this->success.end(); ++_iter1582) + { + xfer += oprot->writeString((*_iter1582)); + } + xfer += oprot->writeListEnd(); + } xfer += oprot->writeFieldEnd(); } xfer += oprot->writeFieldStop(); @@ -33603,11 +34604,11 @@ uint32_t ThriftHiveMetastore_get_token_result::write(::apache::thrift::protocol: } -ThriftHiveMetastore_get_token_presult::~ThriftHiveMetastore_get_token_presult() throw() { +ThriftHiveMetastore_get_master_keys_presult::~ThriftHiveMetastore_get_master_keys_presult() throw() { } -uint32_t ThriftHiveMetastore_get_token_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_master_keys_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -33629,8 +34630,20 @@ uint32_t ThriftHiveMetastore_get_token_presult::read(::apache::thrift::protocol: switch (fid) { case 0: - if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString((*(this->success))); + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size1583; + ::apache::thrift::protocol::TType _etype1586; + xfer += iprot->readListBegin(_etype1586, _size1583); + (*(this->success)).resize(_size1583); + uint32_t _i1587; + for (_i1587 = 0; _i1587 < _size1583; ++_i1587) + { + xfer += iprot->readString((*(this->success))[_i1587]); + } + xfer += iprot->readListEnd(); + } this->__isset.success = true; } else { xfer += iprot->skip(ftype); @@ -33649,11 +34662,11 @@ uint32_t ThriftHiveMetastore_get_token_presult::read(::apache::thrift::protocol: } -ThriftHiveMetastore_get_all_token_identifiers_args::~ThriftHiveMetastore_get_all_token_identifiers_args() throw() { +ThriftHiveMetastore_get_open_txns_args::~ThriftHiveMetastore_get_open_txns_args() throw() { } -uint32_t ThriftHiveMetastore_get_all_token_identifiers_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_open_txns_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -33681,10 +34694,10 @@ uint32_t ThriftHiveMetastore_get_all_token_identifiers_args::read(::apache::thri return xfer; } -uint32_t ThriftHiveMetastore_get_all_token_identifiers_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_open_txns_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_token_identifiers_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_open_txns_args"); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); @@ -33692,14 +34705,14 @@ uint32_t ThriftHiveMetastore_get_all_token_identifiers_args::write(::apache::thr } -ThriftHiveMetastore_get_all_token_identifiers_pargs::~ThriftHiveMetastore_get_all_token_identifiers_pargs() throw() { +ThriftHiveMetastore_get_open_txns_pargs::~ThriftHiveMetastore_get_open_txns_pargs() throw() { } -uint32_t ThriftHiveMetastore_get_all_token_identifiers_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_open_txns_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_token_identifiers_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_open_txns_pargs"); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); @@ -33707,11 +34720,11 @@ uint32_t ThriftHiveMetastore_get_all_token_identifiers_pargs::write(::apache::th } -ThriftHiveMetastore_get_all_token_identifiers_result::~ThriftHiveMetastore_get_all_token_identifiers_result() throw() { +ThriftHiveMetastore_get_open_txns_result::~ThriftHiveMetastore_get_open_txns_result() throw() { } -uint32_t ThriftHiveMetastore_get_all_token_identifiers_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_open_txns_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -33733,20 +34746,8 @@ uint32_t ThriftHiveMetastore_get_all_token_identifiers_result::read(::apache::th switch (fid) { case 0: - if (ftype == ::apache::thrift::protocol::T_LIST) { - { - this->success.clear(); - uint32_t _size1544; - ::apache::thrift::protocol::TType _etype1547; - xfer += iprot->readListBegin(_etype1547, _size1544); - this->success.resize(_size1544); - uint32_t _i1548; - for (_i1548 = 0; _i1548 < _size1544; ++_i1548) - { - xfer += iprot->readString(this->success[_i1548]); - } - xfer += iprot->readListEnd(); - } + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); this->__isset.success = true; } else { xfer += iprot->skip(ftype); @@ -33764,23 +34765,15 @@ uint32_t ThriftHiveMetastore_get_all_token_identifiers_result::read(::apache::th return xfer; } -uint32_t ThriftHiveMetastore_get_all_token_identifiers_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_open_txns_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_token_identifiers_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_open_txns_result"); if (this->__isset.success) { - 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 _iter1549; - for (_iter1549 = this->success.begin(); _iter1549 != this->success.end(); ++_iter1549) - { - xfer += oprot->writeString((*_iter1549)); - } - xfer += oprot->writeListEnd(); - } + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); xfer += oprot->writeFieldEnd(); } xfer += oprot->writeFieldStop(); @@ -33789,11 +34782,11 @@ uint32_t ThriftHiveMetastore_get_all_token_identifiers_result::write(::apache::t } -ThriftHiveMetastore_get_all_token_identifiers_presult::~ThriftHiveMetastore_get_all_token_identifiers_presult() throw() { +ThriftHiveMetastore_get_open_txns_presult::~ThriftHiveMetastore_get_open_txns_presult() throw() { } -uint32_t ThriftHiveMetastore_get_all_token_identifiers_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_open_txns_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -33815,20 +34808,8 @@ uint32_t ThriftHiveMetastore_get_all_token_identifiers_presult::read(::apache::t switch (fid) { case 0: - if (ftype == ::apache::thrift::protocol::T_LIST) { - { - (*(this->success)).clear(); - uint32_t _size1550; - ::apache::thrift::protocol::TType _etype1553; - xfer += iprot->readListBegin(_etype1553, _size1550); - (*(this->success)).resize(_size1550); - uint32_t _i1554; - for (_i1554 = 0; _i1554 < _size1550; ++_i1554) - { - xfer += iprot->readString((*(this->success))[_i1554]); - } - xfer += iprot->readListEnd(); - } + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); this->__isset.success = true; } else { xfer += iprot->skip(ftype); @@ -33847,11 +34828,11 @@ uint32_t ThriftHiveMetastore_get_all_token_identifiers_presult::read(::apache::t } -ThriftHiveMetastore_add_master_key_args::~ThriftHiveMetastore_add_master_key_args() throw() { +ThriftHiveMetastore_get_open_txns_info_args::~ThriftHiveMetastore_get_open_txns_info_args() throw() { } -uint32_t ThriftHiveMetastore_add_master_key_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_open_txns_info_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -33870,20 +34851,7 @@ uint32_t ThriftHiveMetastore_add_master_key_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_STOP) { break; } - switch (fid) - { - case 1: - if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->key); - this->__isset.key = true; - } else { - xfer += iprot->skip(ftype); - } - break; - default: - xfer += iprot->skip(ftype); - break; - } + xfer += iprot->skip(ftype); xfer += iprot->readFieldEnd(); } @@ -33892,14 +34860,10 @@ uint32_t ThriftHiveMetastore_add_master_key_args::read(::apache::thrift::protoco return xfer; } -uint32_t ThriftHiveMetastore_add_master_key_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_open_txns_info_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_master_key_args"); - - xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString(this->key); - xfer += oprot->writeFieldEnd(); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_open_txns_info_args"); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); @@ -33907,18 +34871,14 @@ uint32_t ThriftHiveMetastore_add_master_key_args::write(::apache::thrift::protoc } -ThriftHiveMetastore_add_master_key_pargs::~ThriftHiveMetastore_add_master_key_pargs() throw() { +ThriftHiveMetastore_get_open_txns_info_pargs::~ThriftHiveMetastore_get_open_txns_info_pargs() throw() { } -uint32_t ThriftHiveMetastore_add_master_key_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_open_txns_info_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_master_key_pargs"); - - xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString((*(this->key))); - xfer += oprot->writeFieldEnd(); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_open_txns_info_pargs"); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); @@ -33926,11 +34886,11 @@ uint32_t ThriftHiveMetastore_add_master_key_pargs::write(::apache::thrift::proto } -ThriftHiveMetastore_add_master_key_result::~ThriftHiveMetastore_add_master_key_result() throw() { +ThriftHiveMetastore_get_open_txns_info_result::~ThriftHiveMetastore_get_open_txns_info_result() throw() { } -uint32_t ThriftHiveMetastore_add_master_key_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_open_txns_info_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -33952,17 +34912,9 @@ uint32_t ThriftHiveMetastore_add_master_key_result::read(::apache::thrift::proto switch (fid) { case 0: - if (ftype == ::apache::thrift::protocol::T_I32) { - xfer += iprot->readI32(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; + xfer += this->success.read(iprot); + this->__isset.success = true; } else { xfer += iprot->skip(ftype); } @@ -33979,19 +34931,15 @@ uint32_t ThriftHiveMetastore_add_master_key_result::read(::apache::thrift::proto return xfer; } -uint32_t ThriftHiveMetastore_add_master_key_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_open_txns_info_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_master_key_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_open_txns_info_result"); if (this->__isset.success) { - xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I32, 0); - xfer += oprot->writeI32(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->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); xfer += oprot->writeFieldEnd(); } xfer += oprot->writeFieldStop(); @@ -34000,11 +34948,11 @@ uint32_t ThriftHiveMetastore_add_master_key_result::write(::apache::thrift::prot } -ThriftHiveMetastore_add_master_key_presult::~ThriftHiveMetastore_add_master_key_presult() throw() { +ThriftHiveMetastore_get_open_txns_info_presult::~ThriftHiveMetastore_get_open_txns_info_presult() throw() { } -uint32_t ThriftHiveMetastore_add_master_key_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_open_txns_info_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -34026,17 +34974,9 @@ uint32_t ThriftHiveMetastore_add_master_key_presult::read(::apache::thrift::prot switch (fid) { case 0: - if (ftype == ::apache::thrift::protocol::T_I32) { - xfer += iprot->readI32((*(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; + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; } else { xfer += iprot->skip(ftype); } @@ -34054,11 +34994,11 @@ uint32_t ThriftHiveMetastore_add_master_key_presult::read(::apache::thrift::prot } -ThriftHiveMetastore_update_master_key_args::~ThriftHiveMetastore_update_master_key_args() throw() { +ThriftHiveMetastore_open_txns_args::~ThriftHiveMetastore_open_txns_args() throw() { } -uint32_t ThriftHiveMetastore_update_master_key_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_open_txns_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -34080,17 +35020,9 @@ uint32_t ThriftHiveMetastore_update_master_key_args::read(::apache::thrift::prot switch (fid) { case 1: - if (ftype == ::apache::thrift::protocol::T_I32) { - xfer += iprot->readI32(this->seq_number); - this->__isset.seq_number = true; - } else { - xfer += iprot->skip(ftype); - } - break; - case 2: - if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->key); - this->__isset.key = true; + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->rqst.read(iprot); + this->__isset.rqst = true; } else { xfer += iprot->skip(ftype); } @@ -34107,17 +35039,13 @@ uint32_t ThriftHiveMetastore_update_master_key_args::read(::apache::thrift::prot return xfer; } -uint32_t ThriftHiveMetastore_update_master_key_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_open_txns_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_update_master_key_args"); - - xfer += oprot->writeFieldBegin("seq_number", ::apache::thrift::protocol::T_I32, 1); - xfer += oprot->writeI32(this->seq_number); - xfer += oprot->writeFieldEnd(); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_open_txns_args"); - xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 2); - xfer += oprot->writeString(this->key); + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->rqst.write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -34126,21 +35054,17 @@ uint32_t ThriftHiveMetastore_update_master_key_args::write(::apache::thrift::pro } -ThriftHiveMetastore_update_master_key_pargs::~ThriftHiveMetastore_update_master_key_pargs() throw() { +ThriftHiveMetastore_open_txns_pargs::~ThriftHiveMetastore_open_txns_pargs() throw() { } -uint32_t ThriftHiveMetastore_update_master_key_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_open_txns_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_update_master_key_pargs"); - - xfer += oprot->writeFieldBegin("seq_number", ::apache::thrift::protocol::T_I32, 1); - xfer += oprot->writeI32((*(this->seq_number))); - xfer += oprot->writeFieldEnd(); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_open_txns_pargs"); - xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 2); - xfer += oprot->writeString((*(this->key))); + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->rqst)).write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -34149,11 +35073,11 @@ uint32_t ThriftHiveMetastore_update_master_key_pargs::write(::apache::thrift::pr } -ThriftHiveMetastore_update_master_key_result::~ThriftHiveMetastore_update_master_key_result() throw() { +ThriftHiveMetastore_open_txns_result::~ThriftHiveMetastore_open_txns_result() throw() { } -uint32_t ThriftHiveMetastore_update_master_key_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_open_txns_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -34174,18 +35098,10 @@ uint32_t ThriftHiveMetastore_update_master_key_result::read(::apache::thrift::pr } 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: + case 0: if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->o2.read(iprot); - this->__isset.o2 = true; + xfer += this->success.read(iprot); + this->__isset.success = true; } else { xfer += iprot->skip(ftype); } @@ -34202,19 +35118,15 @@ uint32_t ThriftHiveMetastore_update_master_key_result::read(::apache::thrift::pr return xfer; } -uint32_t ThriftHiveMetastore_update_master_key_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_open_txns_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_update_master_key_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_open_txns_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); + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); xfer += oprot->writeFieldEnd(); } xfer += oprot->writeFieldStop(); @@ -34223,11 +35135,11 @@ uint32_t ThriftHiveMetastore_update_master_key_result::write(::apache::thrift::p } -ThriftHiveMetastore_update_master_key_presult::~ThriftHiveMetastore_update_master_key_presult() throw() { +ThriftHiveMetastore_open_txns_presult::~ThriftHiveMetastore_open_txns_presult() throw() { } -uint32_t ThriftHiveMetastore_update_master_key_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_open_txns_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -34248,18 +35160,10 @@ uint32_t ThriftHiveMetastore_update_master_key_presult::read(::apache::thrift::p } 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: + case 0: if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->o2.read(iprot); - this->__isset.o2 = true; + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; } else { xfer += iprot->skip(ftype); } @@ -34277,11 +35181,11 @@ uint32_t ThriftHiveMetastore_update_master_key_presult::read(::apache::thrift::p } -ThriftHiveMetastore_remove_master_key_args::~ThriftHiveMetastore_remove_master_key_args() throw() { +ThriftHiveMetastore_abort_txn_args::~ThriftHiveMetastore_abort_txn_args() throw() { } -uint32_t ThriftHiveMetastore_remove_master_key_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_abort_txn_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -34303,9 +35207,9 @@ uint32_t ThriftHiveMetastore_remove_master_key_args::read(::apache::thrift::prot switch (fid) { case 1: - if (ftype == ::apache::thrift::protocol::T_I32) { - xfer += iprot->readI32(this->key_seq); - this->__isset.key_seq = true; + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->rqst.read(iprot); + this->__isset.rqst = true; } else { xfer += iprot->skip(ftype); } @@ -34322,13 +35226,13 @@ uint32_t ThriftHiveMetastore_remove_master_key_args::read(::apache::thrift::prot return xfer; } -uint32_t ThriftHiveMetastore_remove_master_key_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_abort_txn_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_remove_master_key_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_abort_txn_args"); - xfer += oprot->writeFieldBegin("key_seq", ::apache::thrift::protocol::T_I32, 1); - xfer += oprot->writeI32(this->key_seq); + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->rqst.write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -34337,17 +35241,17 @@ uint32_t ThriftHiveMetastore_remove_master_key_args::write(::apache::thrift::pro } -ThriftHiveMetastore_remove_master_key_pargs::~ThriftHiveMetastore_remove_master_key_pargs() throw() { +ThriftHiveMetastore_abort_txn_pargs::~ThriftHiveMetastore_abort_txn_pargs() throw() { } -uint32_t ThriftHiveMetastore_remove_master_key_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_abort_txn_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_remove_master_key_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_abort_txn_pargs"); - xfer += oprot->writeFieldBegin("key_seq", ::apache::thrift::protocol::T_I32, 1); - xfer += oprot->writeI32((*(this->key_seq))); + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->rqst)).write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -34356,11 +35260,11 @@ uint32_t ThriftHiveMetastore_remove_master_key_pargs::write(::apache::thrift::pr } -ThriftHiveMetastore_remove_master_key_result::~ThriftHiveMetastore_remove_master_key_result() throw() { +ThriftHiveMetastore_abort_txn_result::~ThriftHiveMetastore_abort_txn_result() throw() { } -uint32_t ThriftHiveMetastore_remove_master_key_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_abort_txn_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -34381,10 +35285,10 @@ uint32_t ThriftHiveMetastore_remove_master_key_result::read(::apache::thrift::pr } switch (fid) { - case 0: - if (ftype == ::apache::thrift::protocol::T_BOOL) { - xfer += iprot->readBool(this->success); - this->__isset.success = true; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; } else { xfer += iprot->skip(ftype); } @@ -34401,15 +35305,15 @@ uint32_t ThriftHiveMetastore_remove_master_key_result::read(::apache::thrift::pr return xfer; } -uint32_t ThriftHiveMetastore_remove_master_key_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_abort_txn_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_remove_master_key_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_abort_txn_result"); - if (this->__isset.success) { - xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0); - xfer += oprot->writeBool(this->success); + 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(); @@ -34418,11 +35322,11 @@ uint32_t ThriftHiveMetastore_remove_master_key_result::write(::apache::thrift::p } -ThriftHiveMetastore_remove_master_key_presult::~ThriftHiveMetastore_remove_master_key_presult() throw() { +ThriftHiveMetastore_abort_txn_presult::~ThriftHiveMetastore_abort_txn_presult() throw() { } -uint32_t ThriftHiveMetastore_remove_master_key_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_abort_txn_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -34443,10 +35347,10 @@ uint32_t ThriftHiveMetastore_remove_master_key_presult::read(::apache::thrift::p } switch (fid) { - case 0: - if (ftype == ::apache::thrift::protocol::T_BOOL) { - xfer += iprot->readBool((*(this->success))); - this->__isset.success = true; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; } else { xfer += iprot->skip(ftype); } @@ -34464,11 +35368,11 @@ uint32_t ThriftHiveMetastore_remove_master_key_presult::read(::apache::thrift::p } -ThriftHiveMetastore_get_master_keys_args::~ThriftHiveMetastore_get_master_keys_args() throw() { +ThriftHiveMetastore_abort_txns_args::~ThriftHiveMetastore_abort_txns_args() throw() { } -uint32_t ThriftHiveMetastore_get_master_keys_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_abort_txns_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -34487,7 +35391,20 @@ uint32_t ThriftHiveMetastore_get_master_keys_args::read(::apache::thrift::protoc if (ftype == ::apache::thrift::protocol::T_STOP) { break; } - xfer += iprot->skip(ftype); + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->rqst.read(iprot); + this->__isset.rqst = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } xfer += iprot->readFieldEnd(); } @@ -34496,10 +35413,14 @@ uint32_t ThriftHiveMetastore_get_master_keys_args::read(::apache::thrift::protoc return xfer; } -uint32_t ThriftHiveMetastore_get_master_keys_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_abort_txns_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_master_keys_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_abort_txns_args"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->rqst.write(oprot); + xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); @@ -34507,14 +35428,18 @@ uint32_t ThriftHiveMetastore_get_master_keys_args::write(::apache::thrift::proto } -ThriftHiveMetastore_get_master_keys_pargs::~ThriftHiveMetastore_get_master_keys_pargs() throw() { +ThriftHiveMetastore_abort_txns_pargs::~ThriftHiveMetastore_abort_txns_pargs() throw() { } -uint32_t ThriftHiveMetastore_get_master_keys_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_abort_txns_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_master_keys_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_abort_txns_pargs"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->rqst)).write(oprot); + xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); @@ -34522,11 +35447,11 @@ uint32_t ThriftHiveMetastore_get_master_keys_pargs::write(::apache::thrift::prot } -ThriftHiveMetastore_get_master_keys_result::~ThriftHiveMetastore_get_master_keys_result() throw() { +ThriftHiveMetastore_abort_txns_result::~ThriftHiveMetastore_abort_txns_result() throw() { } -uint32_t ThriftHiveMetastore_get_master_keys_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_abort_txns_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -34547,22 +35472,10 @@ uint32_t ThriftHiveMetastore_get_master_keys_result::read(::apache::thrift::prot } switch (fid) { - case 0: - if (ftype == ::apache::thrift::protocol::T_LIST) { - { - this->success.clear(); - uint32_t _size1555; - ::apache::thrift::protocol::TType _etype1558; - xfer += iprot->readListBegin(_etype1558, _size1555); - this->success.resize(_size1555); - uint32_t _i1559; - for (_i1559 = 0; _i1559 < _size1555; ++_i1559) - { - xfer += iprot->readString(this->success[_i1559]); - } - xfer += iprot->readListEnd(); - } - this->__isset.success = true; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; } else { xfer += iprot->skip(ftype); } @@ -34579,23 +35492,15 @@ uint32_t ThriftHiveMetastore_get_master_keys_result::read(::apache::thrift::prot return xfer; } -uint32_t ThriftHiveMetastore_get_master_keys_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_abort_txns_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_master_keys_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_abort_txns_result"); - if (this->__isset.success) { - 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 _iter1560; - for (_iter1560 = this->success.begin(); _iter1560 != this->success.end(); ++_iter1560) - { - xfer += oprot->writeString((*_iter1560)); - } - xfer += oprot->writeListEnd(); - } + 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(); @@ -34604,11 +35509,11 @@ uint32_t ThriftHiveMetastore_get_master_keys_result::write(::apache::thrift::pro } -ThriftHiveMetastore_get_master_keys_presult::~ThriftHiveMetastore_get_master_keys_presult() throw() { +ThriftHiveMetastore_abort_txns_presult::~ThriftHiveMetastore_abort_txns_presult() throw() { } -uint32_t ThriftHiveMetastore_get_master_keys_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_abort_txns_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -34629,22 +35534,10 @@ uint32_t ThriftHiveMetastore_get_master_keys_presult::read(::apache::thrift::pro } switch (fid) { - case 0: - if (ftype == ::apache::thrift::protocol::T_LIST) { - { - (*(this->success)).clear(); - uint32_t _size1561; - ::apache::thrift::protocol::TType _etype1564; - xfer += iprot->readListBegin(_etype1564, _size1561); - (*(this->success)).resize(_size1561); - uint32_t _i1565; - for (_i1565 = 0; _i1565 < _size1561; ++_i1565) - { - xfer += iprot->readString((*(this->success))[_i1565]); - } - xfer += iprot->readListEnd(); - } - this->__isset.success = true; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; } else { xfer += iprot->skip(ftype); } @@ -34662,11 +35555,11 @@ uint32_t ThriftHiveMetastore_get_master_keys_presult::read(::apache::thrift::pro } -ThriftHiveMetastore_get_open_txns_args::~ThriftHiveMetastore_get_open_txns_args() throw() { +ThriftHiveMetastore_commit_txn_args::~ThriftHiveMetastore_commit_txn_args() throw() { } -uint32_t ThriftHiveMetastore_get_open_txns_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_commit_txn_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -34685,7 +35578,20 @@ uint32_t ThriftHiveMetastore_get_open_txns_args::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_STOP) { break; } - xfer += iprot->skip(ftype); + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->rqst.read(iprot); + this->__isset.rqst = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } xfer += iprot->readFieldEnd(); } @@ -34694,10 +35600,14 @@ uint32_t ThriftHiveMetastore_get_open_txns_args::read(::apache::thrift::protocol return xfer; } -uint32_t ThriftHiveMetastore_get_open_txns_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_commit_txn_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_open_txns_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_commit_txn_args"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->rqst.write(oprot); + xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); @@ -34705,14 +35615,18 @@ uint32_t ThriftHiveMetastore_get_open_txns_args::write(::apache::thrift::protoco } -ThriftHiveMetastore_get_open_txns_pargs::~ThriftHiveMetastore_get_open_txns_pargs() throw() { +ThriftHiveMetastore_commit_txn_pargs::~ThriftHiveMetastore_commit_txn_pargs() throw() { } -uint32_t ThriftHiveMetastore_get_open_txns_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_commit_txn_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_open_txns_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_commit_txn_pargs"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->rqst)).write(oprot); + xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); @@ -34720,11 +35634,11 @@ uint32_t ThriftHiveMetastore_get_open_txns_pargs::write(::apache::thrift::protoc } -ThriftHiveMetastore_get_open_txns_result::~ThriftHiveMetastore_get_open_txns_result() throw() { +ThriftHiveMetastore_commit_txn_result::~ThriftHiveMetastore_commit_txn_result() throw() { } -uint32_t ThriftHiveMetastore_get_open_txns_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_commit_txn_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -34745,10 +35659,18 @@ uint32_t ThriftHiveMetastore_get_open_txns_result::read(::apache::thrift::protoc } switch (fid) { - case 0: + case 1: if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->success.read(iprot); - this->__isset.success = true; + 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); } @@ -34765,15 +35687,19 @@ uint32_t ThriftHiveMetastore_get_open_txns_result::read(::apache::thrift::protoc return xfer; } -uint32_t ThriftHiveMetastore_get_open_txns_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_commit_txn_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_open_txns_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_commit_txn_result"); - if (this->__isset.success) { - xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); - xfer += this->success.write(oprot); + 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(); @@ -34782,11 +35708,11 @@ uint32_t ThriftHiveMetastore_get_open_txns_result::write(::apache::thrift::proto } -ThriftHiveMetastore_get_open_txns_presult::~ThriftHiveMetastore_get_open_txns_presult() throw() { +ThriftHiveMetastore_commit_txn_presult::~ThriftHiveMetastore_commit_txn_presult() throw() { } -uint32_t ThriftHiveMetastore_get_open_txns_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_commit_txn_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -34807,10 +35733,18 @@ uint32_t ThriftHiveMetastore_get_open_txns_presult::read(::apache::thrift::proto } switch (fid) { - case 0: + case 1: if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += (*(this->success)).read(iprot); - this->__isset.success = true; + 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); } @@ -34828,11 +35762,11 @@ uint32_t ThriftHiveMetastore_get_open_txns_presult::read(::apache::thrift::proto } -ThriftHiveMetastore_get_open_txns_info_args::~ThriftHiveMetastore_get_open_txns_info_args() throw() { +ThriftHiveMetastore_lock_args::~ThriftHiveMetastore_lock_args() throw() { } -uint32_t ThriftHiveMetastore_get_open_txns_info_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_lock_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -34851,7 +35785,20 @@ uint32_t ThriftHiveMetastore_get_open_txns_info_args::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_STOP) { break; } - xfer += iprot->skip(ftype); + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->rqst.read(iprot); + this->__isset.rqst = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } xfer += iprot->readFieldEnd(); } @@ -34860,10 +35807,14 @@ uint32_t ThriftHiveMetastore_get_open_txns_info_args::read(::apache::thrift::pro return xfer; } -uint32_t ThriftHiveMetastore_get_open_txns_info_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_lock_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_open_txns_info_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_lock_args"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->rqst.write(oprot); + xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); @@ -34871,14 +35822,18 @@ uint32_t ThriftHiveMetastore_get_open_txns_info_args::write(::apache::thrift::pr } -ThriftHiveMetastore_get_open_txns_info_pargs::~ThriftHiveMetastore_get_open_txns_info_pargs() throw() { +ThriftHiveMetastore_lock_pargs::~ThriftHiveMetastore_lock_pargs() throw() { } -uint32_t ThriftHiveMetastore_get_open_txns_info_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_lock_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_open_txns_info_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_lock_pargs"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->rqst)).write(oprot); + xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); @@ -34886,11 +35841,11 @@ uint32_t ThriftHiveMetastore_get_open_txns_info_pargs::write(::apache::thrift::p } -ThriftHiveMetastore_get_open_txns_info_result::~ThriftHiveMetastore_get_open_txns_info_result() throw() { +ThriftHiveMetastore_lock_result::~ThriftHiveMetastore_lock_result() throw() { } -uint32_t ThriftHiveMetastore_get_open_txns_info_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_lock_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -34919,6 +35874,22 @@ uint32_t ThriftHiveMetastore_get_open_txns_info_result::read(::apache::thrift::p 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; @@ -34931,16 +35902,24 @@ uint32_t ThriftHiveMetastore_get_open_txns_info_result::read(::apache::thrift::p return xfer; } -uint32_t ThriftHiveMetastore_get_open_txns_info_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_lock_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_open_txns_info_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_lock_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(); @@ -34948,11 +35927,11 @@ uint32_t ThriftHiveMetastore_get_open_txns_info_result::write(::apache::thrift:: } -ThriftHiveMetastore_get_open_txns_info_presult::~ThriftHiveMetastore_get_open_txns_info_presult() throw() { +ThriftHiveMetastore_lock_presult::~ThriftHiveMetastore_lock_presult() throw() { } -uint32_t ThriftHiveMetastore_get_open_txns_info_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_lock_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -34981,6 +35960,22 @@ uint32_t ThriftHiveMetastore_get_open_txns_info_presult::read(::apache::thrift:: 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; @@ -34994,11 +35989,11 @@ uint32_t ThriftHiveMetastore_get_open_txns_info_presult::read(::apache::thrift:: } -ThriftHiveMetastore_open_txns_args::~ThriftHiveMetastore_open_txns_args() throw() { +ThriftHiveMetastore_check_lock_args::~ThriftHiveMetastore_check_lock_args() throw() { } -uint32_t ThriftHiveMetastore_open_txns_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_check_lock_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -35039,10 +36034,10 @@ uint32_t ThriftHiveMetastore_open_txns_args::read(::apache::thrift::protocol::TP return xfer; } -uint32_t ThriftHiveMetastore_open_txns_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_check_lock_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_open_txns_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_check_lock_args"); xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); xfer += this->rqst.write(oprot); @@ -35054,14 +36049,14 @@ uint32_t ThriftHiveMetastore_open_txns_args::write(::apache::thrift::protocol::T } -ThriftHiveMetastore_open_txns_pargs::~ThriftHiveMetastore_open_txns_pargs() throw() { +ThriftHiveMetastore_check_lock_pargs::~ThriftHiveMetastore_check_lock_pargs() throw() { } -uint32_t ThriftHiveMetastore_open_txns_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_check_lock_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_open_txns_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_check_lock_pargs"); xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); xfer += (*(this->rqst)).write(oprot); @@ -35073,11 +36068,11 @@ uint32_t ThriftHiveMetastore_open_txns_pargs::write(::apache::thrift::protocol:: } -ThriftHiveMetastore_open_txns_result::~ThriftHiveMetastore_open_txns_result() throw() { +ThriftHiveMetastore_check_lock_result::~ThriftHiveMetastore_check_lock_result() throw() { } -uint32_t ThriftHiveMetastore_open_txns_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_check_lock_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -35106,6 +36101,30 @@ uint32_t ThriftHiveMetastore_open_txns_result::read(::apache::thrift::protocol:: 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; @@ -35118,16 +36137,28 @@ uint32_t ThriftHiveMetastore_open_txns_result::read(::apache::thrift::protocol:: return xfer; } -uint32_t ThriftHiveMetastore_open_txns_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_check_lock_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_open_txns_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_check_lock_result"); if (this->__isset.success) { xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); xfer += this->success.write(oprot); xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); @@ -35135,11 +36166,11 @@ uint32_t ThriftHiveMetastore_open_txns_result::write(::apache::thrift::protocol: } -ThriftHiveMetastore_open_txns_presult::~ThriftHiveMetastore_open_txns_presult() throw() { +ThriftHiveMetastore_check_lock_presult::~ThriftHiveMetastore_check_lock_presult() throw() { } -uint32_t ThriftHiveMetastore_open_txns_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_check_lock_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -35168,6 +36199,30 @@ uint32_t ThriftHiveMetastore_open_txns_presult::read(::apache::thrift::protocol: 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; @@ -35181,11 +36236,11 @@ uint32_t ThriftHiveMetastore_open_txns_presult::read(::apache::thrift::protocol: } -ThriftHiveMetastore_abort_txn_args::~ThriftHiveMetastore_abort_txn_args() throw() { +ThriftHiveMetastore_unlock_args::~ThriftHiveMetastore_unlock_args() throw() { } -uint32_t ThriftHiveMetastore_abort_txn_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_unlock_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -35226,10 +36281,10 @@ uint32_t ThriftHiveMetastore_abort_txn_args::read(::apache::thrift::protocol::TP return xfer; } -uint32_t ThriftHiveMetastore_abort_txn_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_unlock_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_abort_txn_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_unlock_args"); xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); xfer += this->rqst.write(oprot); @@ -35241,14 +36296,14 @@ uint32_t ThriftHiveMetastore_abort_txn_args::write(::apache::thrift::protocol::T } -ThriftHiveMetastore_abort_txn_pargs::~ThriftHiveMetastore_abort_txn_pargs() throw() { +ThriftHiveMetastore_unlock_pargs::~ThriftHiveMetastore_unlock_pargs() throw() { } -uint32_t ThriftHiveMetastore_abort_txn_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_unlock_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_abort_txn_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_unlock_pargs"); xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); xfer += (*(this->rqst)).write(oprot); @@ -35260,11 +36315,11 @@ uint32_t ThriftHiveMetastore_abort_txn_pargs::write(::apache::thrift::protocol:: } -ThriftHiveMetastore_abort_txn_result::~ThriftHiveMetastore_abort_txn_result() throw() { +ThriftHiveMetastore_unlock_result::~ThriftHiveMetastore_unlock_result() throw() { } -uint32_t ThriftHiveMetastore_abort_txn_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_unlock_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -35293,6 +36348,14 @@ uint32_t ThriftHiveMetastore_abort_txn_result::read(::apache::thrift::protocol:: 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; @@ -35305,16 +36368,20 @@ uint32_t ThriftHiveMetastore_abort_txn_result::read(::apache::thrift::protocol:: return xfer; } -uint32_t ThriftHiveMetastore_abort_txn_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_unlock_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_abort_txn_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_unlock_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(); } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); @@ -35322,11 +36389,11 @@ uint32_t ThriftHiveMetastore_abort_txn_result::write(::apache::thrift::protocol: } -ThriftHiveMetastore_abort_txn_presult::~ThriftHiveMetastore_abort_txn_presult() throw() { +ThriftHiveMetastore_unlock_presult::~ThriftHiveMetastore_unlock_presult() throw() { } -uint32_t ThriftHiveMetastore_abort_txn_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_unlock_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -35355,6 +36422,14 @@ uint32_t ThriftHiveMetastore_abort_txn_presult::read(::apache::thrift::protocol: 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; @@ -35368,11 +36443,11 @@ uint32_t ThriftHiveMetastore_abort_txn_presult::read(::apache::thrift::protocol: } -ThriftHiveMetastore_abort_txns_args::~ThriftHiveMetastore_abort_txns_args() throw() { +ThriftHiveMetastore_show_locks_args::~ThriftHiveMetastore_show_locks_args() throw() { } -uint32_t ThriftHiveMetastore_abort_txns_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_show_locks_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -35413,10 +36488,10 @@ uint32_t ThriftHiveMetastore_abort_txns_args::read(::apache::thrift::protocol::T return xfer; } -uint32_t ThriftHiveMetastore_abort_txns_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_show_locks_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_abort_txns_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_show_locks_args"); xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); xfer += this->rqst.write(oprot); @@ -35428,14 +36503,14 @@ uint32_t ThriftHiveMetastore_abort_txns_args::write(::apache::thrift::protocol:: } -ThriftHiveMetastore_abort_txns_pargs::~ThriftHiveMetastore_abort_txns_pargs() throw() { +ThriftHiveMetastore_show_locks_pargs::~ThriftHiveMetastore_show_locks_pargs() throw() { } -uint32_t ThriftHiveMetastore_abort_txns_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_show_locks_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_abort_txns_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_show_locks_pargs"); xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); xfer += (*(this->rqst)).write(oprot); @@ -35447,11 +36522,11 @@ uint32_t ThriftHiveMetastore_abort_txns_pargs::write(::apache::thrift::protocol: } -ThriftHiveMetastore_abort_txns_result::~ThriftHiveMetastore_abort_txns_result() throw() { +ThriftHiveMetastore_show_locks_result::~ThriftHiveMetastore_show_locks_result() throw() { } -uint32_t ThriftHiveMetastore_abort_txns_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_show_locks_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -35472,10 +36547,10 @@ uint32_t ThriftHiveMetastore_abort_txns_result::read(::apache::thrift::protocol: } switch (fid) { - case 1: + case 0: if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->o1.read(iprot); - this->__isset.o1 = true; + xfer += this->success.read(iprot); + this->__isset.success = true; } else { xfer += iprot->skip(ftype); } @@ -35492,15 +36567,15 @@ uint32_t ThriftHiveMetastore_abort_txns_result::read(::apache::thrift::protocol: return xfer; } -uint32_t ThriftHiveMetastore_abort_txns_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_show_locks_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_abort_txns_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_show_locks_result"); - if (this->__isset.o1) { - xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += this->o1.write(oprot); + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); xfer += oprot->writeFieldEnd(); } xfer += oprot->writeFieldStop(); @@ -35509,11 +36584,11 @@ uint32_t ThriftHiveMetastore_abort_txns_result::write(::apache::thrift::protocol } -ThriftHiveMetastore_abort_txns_presult::~ThriftHiveMetastore_abort_txns_presult() throw() { +ThriftHiveMetastore_show_locks_presult::~ThriftHiveMetastore_show_locks_presult() throw() { } -uint32_t ThriftHiveMetastore_abort_txns_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_show_locks_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -35534,10 +36609,10 @@ uint32_t ThriftHiveMetastore_abort_txns_presult::read(::apache::thrift::protocol } switch (fid) { - case 1: + case 0: if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->o1.read(iprot); - this->__isset.o1 = true; + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; } else { xfer += iprot->skip(ftype); } @@ -35555,11 +36630,11 @@ uint32_t ThriftHiveMetastore_abort_txns_presult::read(::apache::thrift::protocol } -ThriftHiveMetastore_commit_txn_args::~ThriftHiveMetastore_commit_txn_args() throw() { +ThriftHiveMetastore_heartbeat_args::~ThriftHiveMetastore_heartbeat_args() throw() { } -uint32_t ThriftHiveMetastore_commit_txn_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_heartbeat_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -35582,8 +36657,8 @@ uint32_t ThriftHiveMetastore_commit_txn_args::read(::apache::thrift::protocol::T { case 1: if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->rqst.read(iprot); - this->__isset.rqst = true; + xfer += this->ids.read(iprot); + this->__isset.ids = true; } else { xfer += iprot->skip(ftype); } @@ -35600,13 +36675,13 @@ uint32_t ThriftHiveMetastore_commit_txn_args::read(::apache::thrift::protocol::T return xfer; } -uint32_t ThriftHiveMetastore_commit_txn_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_heartbeat_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_commit_txn_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_heartbeat_args"); - xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += this->rqst.write(oprot); + xfer += oprot->writeFieldBegin("ids", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->ids.write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -35615,17 +36690,17 @@ uint32_t ThriftHiveMetastore_commit_txn_args::write(::apache::thrift::protocol:: } -ThriftHiveMetastore_commit_txn_pargs::~ThriftHiveMetastore_commit_txn_pargs() throw() { +ThriftHiveMetastore_heartbeat_pargs::~ThriftHiveMetastore_heartbeat_pargs() throw() { } -uint32_t ThriftHiveMetastore_commit_txn_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_heartbeat_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_commit_txn_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_heartbeat_pargs"); - xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += (*(this->rqst)).write(oprot); + xfer += oprot->writeFieldBegin("ids", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->ids)).write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -35634,11 +36709,11 @@ uint32_t ThriftHiveMetastore_commit_txn_pargs::write(::apache::thrift::protocol: } -ThriftHiveMetastore_commit_txn_result::~ThriftHiveMetastore_commit_txn_result() throw() { +ThriftHiveMetastore_heartbeat_result::~ThriftHiveMetastore_heartbeat_result() throw() { } -uint32_t ThriftHiveMetastore_commit_txn_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_heartbeat_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -35675,6 +36750,14 @@ uint32_t ThriftHiveMetastore_commit_txn_result::read(::apache::thrift::protocol: 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; @@ -35687,11 +36770,11 @@ uint32_t ThriftHiveMetastore_commit_txn_result::read(::apache::thrift::protocol: return xfer; } -uint32_t ThriftHiveMetastore_commit_txn_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_heartbeat_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_commit_txn_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_heartbeat_result"); if (this->__isset.o1) { xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); @@ -35701,6 +36784,10 @@ uint32_t ThriftHiveMetastore_commit_txn_result::write(::apache::thrift::protocol 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(); @@ -35708,11 +36795,11 @@ uint32_t ThriftHiveMetastore_commit_txn_result::write(::apache::thrift::protocol } -ThriftHiveMetastore_commit_txn_presult::~ThriftHiveMetastore_commit_txn_presult() throw() { +ThriftHiveMetastore_heartbeat_presult::~ThriftHiveMetastore_heartbeat_presult() throw() { } -uint32_t ThriftHiveMetastore_commit_txn_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_heartbeat_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -35749,6 +36836,14 @@ uint32_t ThriftHiveMetastore_commit_txn_presult::read(::apache::thrift::protocol 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; @@ -35762,11 +36857,11 @@ uint32_t ThriftHiveMetastore_commit_txn_presult::read(::apache::thrift::protocol } -ThriftHiveMetastore_lock_args::~ThriftHiveMetastore_lock_args() throw() { +ThriftHiveMetastore_heartbeat_txn_range_args::~ThriftHiveMetastore_heartbeat_txn_range_args() throw() { } -uint32_t ThriftHiveMetastore_lock_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_heartbeat_txn_range_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -35789,8 +36884,8 @@ uint32_t ThriftHiveMetastore_lock_args::read(::apache::thrift::protocol::TProtoc { case 1: if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->rqst.read(iprot); - this->__isset.rqst = true; + xfer += this->txns.read(iprot); + this->__isset.txns = true; } else { xfer += iprot->skip(ftype); } @@ -35807,13 +36902,13 @@ uint32_t ThriftHiveMetastore_lock_args::read(::apache::thrift::protocol::TProtoc return xfer; } -uint32_t ThriftHiveMetastore_lock_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_heartbeat_txn_range_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_lock_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_heartbeat_txn_range_args"); - xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += this->rqst.write(oprot); + xfer += oprot->writeFieldBegin("txns", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->txns.write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -35822,17 +36917,17 @@ uint32_t ThriftHiveMetastore_lock_args::write(::apache::thrift::protocol::TProto } -ThriftHiveMetastore_lock_pargs::~ThriftHiveMetastore_lock_pargs() throw() { +ThriftHiveMetastore_heartbeat_txn_range_pargs::~ThriftHiveMetastore_heartbeat_txn_range_pargs() throw() { } -uint32_t ThriftHiveMetastore_lock_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_heartbeat_txn_range_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_lock_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_heartbeat_txn_range_pargs"); - xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += (*(this->rqst)).write(oprot); + xfer += oprot->writeFieldBegin("txns", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->txns)).write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -35841,11 +36936,11 @@ uint32_t ThriftHiveMetastore_lock_pargs::write(::apache::thrift::protocol::TProt } -ThriftHiveMetastore_lock_result::~ThriftHiveMetastore_lock_result() throw() { +ThriftHiveMetastore_heartbeat_txn_range_result::~ThriftHiveMetastore_heartbeat_txn_range_result() throw() { } -uint32_t ThriftHiveMetastore_lock_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_heartbeat_txn_range_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -35874,22 +36969,6 @@ uint32_t ThriftHiveMetastore_lock_result::read(::apache::thrift::protocol::TProt 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; @@ -35902,24 +36981,16 @@ uint32_t ThriftHiveMetastore_lock_result::read(::apache::thrift::protocol::TProt return xfer; } -uint32_t ThriftHiveMetastore_lock_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_heartbeat_txn_range_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_lock_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_heartbeat_txn_range_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(); @@ -35927,11 +36998,11 @@ uint32_t ThriftHiveMetastore_lock_result::write(::apache::thrift::protocol::TPro } -ThriftHiveMetastore_lock_presult::~ThriftHiveMetastore_lock_presult() throw() { +ThriftHiveMetastore_heartbeat_txn_range_presult::~ThriftHiveMetastore_heartbeat_txn_range_presult() throw() { } -uint32_t ThriftHiveMetastore_lock_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_heartbeat_txn_range_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -35960,22 +37031,6 @@ uint32_t ThriftHiveMetastore_lock_presult::read(::apache::thrift::protocol::TPro 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; @@ -35989,11 +37044,11 @@ uint32_t ThriftHiveMetastore_lock_presult::read(::apache::thrift::protocol::TPro } -ThriftHiveMetastore_check_lock_args::~ThriftHiveMetastore_check_lock_args() throw() { +ThriftHiveMetastore_compact_args::~ThriftHiveMetastore_compact_args() throw() { } -uint32_t ThriftHiveMetastore_check_lock_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_compact_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -36034,10 +37089,10 @@ uint32_t ThriftHiveMetastore_check_lock_args::read(::apache::thrift::protocol::T return xfer; } -uint32_t ThriftHiveMetastore_check_lock_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_compact_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_check_lock_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_compact_args"); xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); xfer += this->rqst.write(oprot); @@ -36049,14 +37104,14 @@ uint32_t ThriftHiveMetastore_check_lock_args::write(::apache::thrift::protocol:: } -ThriftHiveMetastore_check_lock_pargs::~ThriftHiveMetastore_check_lock_pargs() throw() { +ThriftHiveMetastore_compact_pargs::~ThriftHiveMetastore_compact_pargs() throw() { } -uint32_t ThriftHiveMetastore_check_lock_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_compact_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_check_lock_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_compact_pargs"); xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); xfer += (*(this->rqst)).write(oprot); @@ -36068,11 +37123,11 @@ uint32_t ThriftHiveMetastore_check_lock_pargs::write(::apache::thrift::protocol: } -ThriftHiveMetastore_check_lock_result::~ThriftHiveMetastore_check_lock_result() throw() { +ThriftHiveMetastore_compact_result::~ThriftHiveMetastore_compact_result() throw() { } -uint32_t ThriftHiveMetastore_check_lock_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_compact_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -36091,44 +37146,7 @@ uint32_t ThriftHiveMetastore_check_lock_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_STOP) { break; } - switch (fid) - { - case 0: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->success.read(iprot); - this->__isset.success = true; - } else { - xfer += iprot->skip(ftype); - } - break; - case 1: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->o1.read(iprot); - this->__isset.o1 = true; - } else { - xfer += iprot->skip(ftype); - } - break; - case 2: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->o2.read(iprot); - this->__isset.o2 = true; - } else { - xfer += iprot->skip(ftype); - } - break; - case 3: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->o3.read(iprot); - this->__isset.o3 = true; - } else { - xfer += iprot->skip(ftype); - } - break; - default: - xfer += iprot->skip(ftype); - break; - } + xfer += iprot->skip(ftype); xfer += iprot->readFieldEnd(); } @@ -36137,40 +37155,23 @@ uint32_t ThriftHiveMetastore_check_lock_result::read(::apache::thrift::protocol: return xfer; } -uint32_t ThriftHiveMetastore_check_lock_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_compact_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_check_lock_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_compact_result"); - if (this->__isset.success) { - xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); - xfer += this->success.write(oprot); - xfer += oprot->writeFieldEnd(); - } else if (this->__isset.o1) { - xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += this->o1.write(oprot); - xfer += oprot->writeFieldEnd(); - } else if (this->__isset.o2) { - xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); - xfer += this->o2.write(oprot); - xfer += oprot->writeFieldEnd(); - } else if (this->__isset.o3) { - xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); - xfer += this->o3.write(oprot); - xfer += oprot->writeFieldEnd(); - } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; } -ThriftHiveMetastore_check_lock_presult::~ThriftHiveMetastore_check_lock_presult() throw() { +ThriftHiveMetastore_compact_presult::~ThriftHiveMetastore_compact_presult() throw() { } -uint32_t ThriftHiveMetastore_check_lock_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_compact_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -36189,44 +37190,7 @@ uint32_t ThriftHiveMetastore_check_lock_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_STOP) { break; } - switch (fid) - { - case 0: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += (*(this->success)).read(iprot); - this->__isset.success = true; - } else { - xfer += iprot->skip(ftype); - } - break; - case 1: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->o1.read(iprot); - this->__isset.o1 = true; - } else { - xfer += iprot->skip(ftype); - } - break; - case 2: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->o2.read(iprot); - this->__isset.o2 = true; - } else { - xfer += iprot->skip(ftype); - } - break; - case 3: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->o3.read(iprot); - this->__isset.o3 = true; - } else { - xfer += iprot->skip(ftype); - } - break; - default: - xfer += iprot->skip(ftype); - break; - } + xfer += iprot->skip(ftype); xfer += iprot->readFieldEnd(); } @@ -36236,11 +37200,11 @@ uint32_t ThriftHiveMetastore_check_lock_presult::read(::apache::thrift::protocol } -ThriftHiveMetastore_unlock_args::~ThriftHiveMetastore_unlock_args() throw() { +ThriftHiveMetastore_compact2_args::~ThriftHiveMetastore_compact2_args() throw() { } -uint32_t ThriftHiveMetastore_unlock_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_compact2_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -36281,10 +37245,10 @@ uint32_t ThriftHiveMetastore_unlock_args::read(::apache::thrift::protocol::TProt return xfer; } -uint32_t ThriftHiveMetastore_unlock_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_compact2_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_unlock_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_compact2_args"); xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); xfer += this->rqst.write(oprot); @@ -36296,14 +37260,14 @@ uint32_t ThriftHiveMetastore_unlock_args::write(::apache::thrift::protocol::TPro } -ThriftHiveMetastore_unlock_pargs::~ThriftHiveMetastore_unlock_pargs() throw() { +ThriftHiveMetastore_compact2_pargs::~ThriftHiveMetastore_compact2_pargs() throw() { } -uint32_t ThriftHiveMetastore_unlock_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_compact2_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_unlock_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_compact2_pargs"); xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); xfer += (*(this->rqst)).write(oprot); @@ -36315,11 +37279,11 @@ uint32_t ThriftHiveMetastore_unlock_pargs::write(::apache::thrift::protocol::TPr } -ThriftHiveMetastore_unlock_result::~ThriftHiveMetastore_unlock_result() throw() { +ThriftHiveMetastore_compact2_result::~ThriftHiveMetastore_compact2_result() throw() { } -uint32_t ThriftHiveMetastore_unlock_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_compact2_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -36340,18 +37304,10 @@ uint32_t ThriftHiveMetastore_unlock_result::read(::apache::thrift::protocol::TPr } 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: + case 0: if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->o2.read(iprot); - this->__isset.o2 = true; + xfer += this->success.read(iprot); + this->__isset.success = true; } else { xfer += iprot->skip(ftype); } @@ -36368,19 +37324,15 @@ uint32_t ThriftHiveMetastore_unlock_result::read(::apache::thrift::protocol::TPr return xfer; } -uint32_t ThriftHiveMetastore_unlock_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_compact2_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_unlock_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_compact2_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); + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); xfer += oprot->writeFieldEnd(); } xfer += oprot->writeFieldStop(); @@ -36389,11 +37341,11 @@ uint32_t ThriftHiveMetastore_unlock_result::write(::apache::thrift::protocol::TP } -ThriftHiveMetastore_unlock_presult::~ThriftHiveMetastore_unlock_presult() throw() { +ThriftHiveMetastore_compact2_presult::~ThriftHiveMetastore_compact2_presult() throw() { } -uint32_t ThriftHiveMetastore_unlock_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_compact2_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -36414,18 +37366,10 @@ uint32_t ThriftHiveMetastore_unlock_presult::read(::apache::thrift::protocol::TP } 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: + case 0: if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->o2.read(iprot); - this->__isset.o2 = true; + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; } else { xfer += iprot->skip(ftype); } @@ -36443,11 +37387,11 @@ uint32_t ThriftHiveMetastore_unlock_presult::read(::apache::thrift::protocol::TP } -ThriftHiveMetastore_show_locks_args::~ThriftHiveMetastore_show_locks_args() throw() { +ThriftHiveMetastore_show_compact_args::~ThriftHiveMetastore_show_compact_args() throw() { } -uint32_t ThriftHiveMetastore_show_locks_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_show_compact_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -36488,10 +37432,10 @@ uint32_t ThriftHiveMetastore_show_locks_args::read(::apache::thrift::protocol::T return xfer; } -uint32_t ThriftHiveMetastore_show_locks_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_show_compact_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_show_locks_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_show_compact_args"); xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); xfer += this->rqst.write(oprot); @@ -36503,14 +37447,14 @@ uint32_t ThriftHiveMetastore_show_locks_args::write(::apache::thrift::protocol:: } -ThriftHiveMetastore_show_locks_pargs::~ThriftHiveMetastore_show_locks_pargs() throw() { +ThriftHiveMetastore_show_compact_pargs::~ThriftHiveMetastore_show_compact_pargs() throw() { } -uint32_t ThriftHiveMetastore_show_locks_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_show_compact_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_show_locks_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_show_compact_pargs"); xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); xfer += (*(this->rqst)).write(oprot); @@ -36522,11 +37466,11 @@ uint32_t ThriftHiveMetastore_show_locks_pargs::write(::apache::thrift::protocol: } -ThriftHiveMetastore_show_locks_result::~ThriftHiveMetastore_show_locks_result() throw() { +ThriftHiveMetastore_show_compact_result::~ThriftHiveMetastore_show_compact_result() throw() { } -uint32_t ThriftHiveMetastore_show_locks_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_show_compact_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -36567,11 +37511,11 @@ uint32_t ThriftHiveMetastore_show_locks_result::read(::apache::thrift::protocol: return xfer; } -uint32_t ThriftHiveMetastore_show_locks_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_show_compact_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_show_locks_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_show_compact_result"); if (this->__isset.success) { xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); @@ -36584,11 +37528,11 @@ uint32_t ThriftHiveMetastore_show_locks_result::write(::apache::thrift::protocol } -ThriftHiveMetastore_show_locks_presult::~ThriftHiveMetastore_show_locks_presult() throw() { +ThriftHiveMetastore_show_compact_presult::~ThriftHiveMetastore_show_compact_presult() throw() { } -uint32_t ThriftHiveMetastore_show_locks_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_show_compact_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -36630,11 +37574,11 @@ uint32_t ThriftHiveMetastore_show_locks_presult::read(::apache::thrift::protocol } -ThriftHiveMetastore_heartbeat_args::~ThriftHiveMetastore_heartbeat_args() throw() { +ThriftHiveMetastore_add_dynamic_partitions_args::~ThriftHiveMetastore_add_dynamic_partitions_args() throw() { } -uint32_t ThriftHiveMetastore_heartbeat_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_add_dynamic_partitions_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -36657,8 +37601,8 @@ uint32_t ThriftHiveMetastore_heartbeat_args::read(::apache::thrift::protocol::TP { case 1: if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->ids.read(iprot); - this->__isset.ids = true; + xfer += this->rqst.read(iprot); + this->__isset.rqst = true; } else { xfer += iprot->skip(ftype); } @@ -36675,13 +37619,13 @@ uint32_t ThriftHiveMetastore_heartbeat_args::read(::apache::thrift::protocol::TP return xfer; } -uint32_t ThriftHiveMetastore_heartbeat_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_add_dynamic_partitions_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_heartbeat_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_dynamic_partitions_args"); - xfer += oprot->writeFieldBegin("ids", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += this->ids.write(oprot); + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->rqst.write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -36690,17 +37634,17 @@ uint32_t ThriftHiveMetastore_heartbeat_args::write(::apache::thrift::protocol::T } -ThriftHiveMetastore_heartbeat_pargs::~ThriftHiveMetastore_heartbeat_pargs() throw() { +ThriftHiveMetastore_add_dynamic_partitions_pargs::~ThriftHiveMetastore_add_dynamic_partitions_pargs() throw() { } -uint32_t ThriftHiveMetastore_heartbeat_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_add_dynamic_partitions_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_heartbeat_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_dynamic_partitions_pargs"); - xfer += oprot->writeFieldBegin("ids", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += (*(this->ids)).write(oprot); + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->rqst)).write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -36709,11 +37653,11 @@ uint32_t ThriftHiveMetastore_heartbeat_pargs::write(::apache::thrift::protocol:: } -ThriftHiveMetastore_heartbeat_result::~ThriftHiveMetastore_heartbeat_result() throw() { +ThriftHiveMetastore_add_dynamic_partitions_result::~ThriftHiveMetastore_add_dynamic_partitions_result() throw() { } -uint32_t ThriftHiveMetastore_heartbeat_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_add_dynamic_partitions_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -36750,14 +37694,6 @@ uint32_t ThriftHiveMetastore_heartbeat_result::read(::apache::thrift::protocol:: 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; @@ -36770,11 +37706,11 @@ uint32_t ThriftHiveMetastore_heartbeat_result::read(::apache::thrift::protocol:: return xfer; } -uint32_t ThriftHiveMetastore_heartbeat_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_add_dynamic_partitions_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_heartbeat_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_dynamic_partitions_result"); if (this->__isset.o1) { xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); @@ -36784,10 +37720,6 @@ uint32_t ThriftHiveMetastore_heartbeat_result::write(::apache::thrift::protocol: 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(); @@ -36795,11 +37727,11 @@ uint32_t ThriftHiveMetastore_heartbeat_result::write(::apache::thrift::protocol: } -ThriftHiveMetastore_heartbeat_presult::~ThriftHiveMetastore_heartbeat_presult() throw() { +ThriftHiveMetastore_add_dynamic_partitions_presult::~ThriftHiveMetastore_add_dynamic_partitions_presult() throw() { } -uint32_t ThriftHiveMetastore_heartbeat_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_add_dynamic_partitions_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -36836,14 +37768,6 @@ uint32_t ThriftHiveMetastore_heartbeat_presult::read(::apache::thrift::protocol: 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; @@ -36857,11 +37781,11 @@ uint32_t ThriftHiveMetastore_heartbeat_presult::read(::apache::thrift::protocol: } -ThriftHiveMetastore_heartbeat_txn_range_args::~ThriftHiveMetastore_heartbeat_txn_range_args() throw() { +ThriftHiveMetastore_get_next_notification_args::~ThriftHiveMetastore_get_next_notification_args() throw() { } -uint32_t ThriftHiveMetastore_heartbeat_txn_range_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_next_notification_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -36884,8 +37808,8 @@ uint32_t ThriftHiveMetastore_heartbeat_txn_range_args::read(::apache::thrift::pr { case 1: if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->txns.read(iprot); - this->__isset.txns = true; + xfer += this->rqst.read(iprot); + this->__isset.rqst = true; } else { xfer += iprot->skip(ftype); } @@ -36902,13 +37826,13 @@ uint32_t ThriftHiveMetastore_heartbeat_txn_range_args::read(::apache::thrift::pr return xfer; } -uint32_t ThriftHiveMetastore_heartbeat_txn_range_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_next_notification_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_heartbeat_txn_range_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_next_notification_args"); - xfer += oprot->writeFieldBegin("txns", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += this->txns.write(oprot); + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->rqst.write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -36917,17 +37841,17 @@ uint32_t ThriftHiveMetastore_heartbeat_txn_range_args::write(::apache::thrift::p } -ThriftHiveMetastore_heartbeat_txn_range_pargs::~ThriftHiveMetastore_heartbeat_txn_range_pargs() throw() { +ThriftHiveMetastore_get_next_notification_pargs::~ThriftHiveMetastore_get_next_notification_pargs() throw() { } -uint32_t ThriftHiveMetastore_heartbeat_txn_range_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_next_notification_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_heartbeat_txn_range_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_next_notification_pargs"); - xfer += oprot->writeFieldBegin("txns", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += (*(this->txns)).write(oprot); + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->rqst)).write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -36936,11 +37860,11 @@ uint32_t ThriftHiveMetastore_heartbeat_txn_range_pargs::write(::apache::thrift:: } -ThriftHiveMetastore_heartbeat_txn_range_result::~ThriftHiveMetastore_heartbeat_txn_range_result() throw() { +ThriftHiveMetastore_get_next_notification_result::~ThriftHiveMetastore_get_next_notification_result() throw() { } -uint32_t ThriftHiveMetastore_heartbeat_txn_range_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_next_notification_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -36981,11 +37905,11 @@ uint32_t ThriftHiveMetastore_heartbeat_txn_range_result::read(::apache::thrift:: return xfer; } -uint32_t ThriftHiveMetastore_heartbeat_txn_range_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_next_notification_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_heartbeat_txn_range_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_next_notification_result"); if (this->__isset.success) { xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); @@ -36998,11 +37922,11 @@ uint32_t ThriftHiveMetastore_heartbeat_txn_range_result::write(::apache::thrift: } -ThriftHiveMetastore_heartbeat_txn_range_presult::~ThriftHiveMetastore_heartbeat_txn_range_presult() throw() { +ThriftHiveMetastore_get_next_notification_presult::~ThriftHiveMetastore_get_next_notification_presult() throw() { } -uint32_t ThriftHiveMetastore_heartbeat_txn_range_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_next_notification_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -37044,11 +37968,11 @@ uint32_t ThriftHiveMetastore_heartbeat_txn_range_presult::read(::apache::thrift: } -ThriftHiveMetastore_compact_args::~ThriftHiveMetastore_compact_args() throw() { +ThriftHiveMetastore_get_current_notificationEventId_args::~ThriftHiveMetastore_get_current_notificationEventId_args() throw() { } -uint32_t ThriftHiveMetastore_compact_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_current_notificationEventId_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -37067,20 +37991,7 @@ uint32_t ThriftHiveMetastore_compact_args::read(::apache::thrift::protocol::TPro if (ftype == ::apache::thrift::protocol::T_STOP) { break; } - switch (fid) - { - case 1: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->rqst.read(iprot); - this->__isset.rqst = true; - } else { - xfer += iprot->skip(ftype); - } - break; - default: - xfer += iprot->skip(ftype); - break; - } + xfer += iprot->skip(ftype); xfer += iprot->readFieldEnd(); } @@ -37089,14 +38000,10 @@ uint32_t ThriftHiveMetastore_compact_args::read(::apache::thrift::protocol::TPro return xfer; } -uint32_t ThriftHiveMetastore_compact_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_current_notificationEventId_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_compact_args"); - - xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += this->rqst.write(oprot); - xfer += oprot->writeFieldEnd(); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_current_notificationEventId_args"); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); @@ -37104,18 +38011,14 @@ uint32_t ThriftHiveMetastore_compact_args::write(::apache::thrift::protocol::TPr } -ThriftHiveMetastore_compact_pargs::~ThriftHiveMetastore_compact_pargs() throw() { +ThriftHiveMetastore_get_current_notificationEventId_pargs::~ThriftHiveMetastore_get_current_notificationEventId_pargs() throw() { } -uint32_t ThriftHiveMetastore_compact_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_current_notificationEventId_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_compact_pargs"); - - xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += (*(this->rqst)).write(oprot); - xfer += oprot->writeFieldEnd(); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_current_notificationEventId_pargs"); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); @@ -37123,11 +38026,11 @@ uint32_t ThriftHiveMetastore_compact_pargs::write(::apache::thrift::protocol::TP } -ThriftHiveMetastore_compact_result::~ThriftHiveMetastore_compact_result() throw() { +ThriftHiveMetastore_get_current_notificationEventId_result::~ThriftHiveMetastore_get_current_notificationEventId_result() throw() { } -uint32_t ThriftHiveMetastore_compact_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_current_notificationEventId_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -37146,7 +38049,20 @@ uint32_t ThriftHiveMetastore_compact_result::read(::apache::thrift::protocol::TP if (ftype == ::apache::thrift::protocol::T_STOP) { break; } - xfer += iprot->skip(ftype); + 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; + default: + xfer += iprot->skip(ftype); + break; + } xfer += iprot->readFieldEnd(); } @@ -37155,23 +38071,28 @@ uint32_t ThriftHiveMetastore_compact_result::read(::apache::thrift::protocol::TP return xfer; } -uint32_t ThriftHiveMetastore_compact_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_current_notificationEventId_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_compact_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_current_notificationEventId_result"); + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; } -ThriftHiveMetastore_compact_presult::~ThriftHiveMetastore_compact_presult() throw() { +ThriftHiveMetastore_get_current_notificationEventId_presult::~ThriftHiveMetastore_get_current_notificationEventId_presult() throw() { } -uint32_t ThriftHiveMetastore_compact_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_current_notificationEventId_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -37190,7 +38111,20 @@ uint32_t ThriftHiveMetastore_compact_presult::read(::apache::thrift::protocol::T if (ftype == ::apache::thrift::protocol::T_STOP) { break; } - xfer += iprot->skip(ftype); + 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; + default: + xfer += iprot->skip(ftype); + break; + } xfer += iprot->readFieldEnd(); } @@ -37200,11 +38134,11 @@ uint32_t ThriftHiveMetastore_compact_presult::read(::apache::thrift::protocol::T } -ThriftHiveMetastore_compact2_args::~ThriftHiveMetastore_compact2_args() throw() { +ThriftHiveMetastore_get_notification_events_count_args::~ThriftHiveMetastore_get_notification_events_count_args() throw() { } -uint32_t ThriftHiveMetastore_compact2_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_notification_events_count_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -37225,7 +38159,7 @@ uint32_t ThriftHiveMetastore_compact2_args::read(::apache::thrift::protocol::TPr } switch (fid) { - case 1: + case -1: if (ftype == ::apache::thrift::protocol::T_STRUCT) { xfer += this->rqst.read(iprot); this->__isset.rqst = true; @@ -37245,12 +38179,12 @@ uint32_t ThriftHiveMetastore_compact2_args::read(::apache::thrift::protocol::TPr return xfer; } -uint32_t ThriftHiveMetastore_compact2_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_notification_events_count_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_compact2_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_notification_events_count_args"); - xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, -1); xfer += this->rqst.write(oprot); xfer += oprot->writeFieldEnd(); @@ -37260,16 +38194,16 @@ uint32_t ThriftHiveMetastore_compact2_args::write(::apache::thrift::protocol::TP } -ThriftHiveMetastore_compact2_pargs::~ThriftHiveMetastore_compact2_pargs() throw() { +ThriftHiveMetastore_get_notification_events_count_pargs::~ThriftHiveMetastore_get_notification_events_count_pargs() throw() { } -uint32_t ThriftHiveMetastore_compact2_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_notification_events_count_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_compact2_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_notification_events_count_pargs"); - xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, -1); xfer += (*(this->rqst)).write(oprot); xfer += oprot->writeFieldEnd(); @@ -37279,11 +38213,11 @@ uint32_t ThriftHiveMetastore_compact2_pargs::write(::apache::thrift::protocol::T } -ThriftHiveMetastore_compact2_result::~ThriftHiveMetastore_compact2_result() throw() { +ThriftHiveMetastore_get_notification_events_count_result::~ThriftHiveMetastore_get_notification_events_count_result() throw() { } -uint32_t ThriftHiveMetastore_compact2_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_notification_events_count_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -37324,11 +38258,11 @@ uint32_t ThriftHiveMetastore_compact2_result::read(::apache::thrift::protocol::T return xfer; } -uint32_t ThriftHiveMetastore_compact2_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_notification_events_count_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_compact2_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_notification_events_count_result"); if (this->__isset.success) { xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); @@ -37341,11 +38275,11 @@ uint32_t ThriftHiveMetastore_compact2_result::write(::apache::thrift::protocol:: } -ThriftHiveMetastore_compact2_presult::~ThriftHiveMetastore_compact2_presult() throw() { +ThriftHiveMetastore_get_notification_events_count_presult::~ThriftHiveMetastore_get_notification_events_count_presult() throw() { } -uint32_t ThriftHiveMetastore_compact2_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_notification_events_count_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -37387,11 +38321,11 @@ uint32_t ThriftHiveMetastore_compact2_presult::read(::apache::thrift::protocol:: } -ThriftHiveMetastore_show_compact_args::~ThriftHiveMetastore_show_compact_args() throw() { +ThriftHiveMetastore_fire_listener_event_args::~ThriftHiveMetastore_fire_listener_event_args() throw() { } -uint32_t ThriftHiveMetastore_show_compact_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_fire_listener_event_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -37432,10 +38366,10 @@ uint32_t ThriftHiveMetastore_show_compact_args::read(::apache::thrift::protocol: return xfer; } -uint32_t ThriftHiveMetastore_show_compact_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_fire_listener_event_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_show_compact_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_fire_listener_event_args"); xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); xfer += this->rqst.write(oprot); @@ -37447,14 +38381,14 @@ uint32_t ThriftHiveMetastore_show_compact_args::write(::apache::thrift::protocol } -ThriftHiveMetastore_show_compact_pargs::~ThriftHiveMetastore_show_compact_pargs() throw() { +ThriftHiveMetastore_fire_listener_event_pargs::~ThriftHiveMetastore_fire_listener_event_pargs() throw() { } -uint32_t ThriftHiveMetastore_show_compact_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_fire_listener_event_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_show_compact_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_fire_listener_event_pargs"); xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); xfer += (*(this->rqst)).write(oprot); @@ -37466,11 +38400,11 @@ uint32_t ThriftHiveMetastore_show_compact_pargs::write(::apache::thrift::protoco } -ThriftHiveMetastore_show_compact_result::~ThriftHiveMetastore_show_compact_result() throw() { +ThriftHiveMetastore_fire_listener_event_result::~ThriftHiveMetastore_fire_listener_event_result() throw() { } -uint32_t ThriftHiveMetastore_show_compact_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_fire_listener_event_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -37511,11 +38445,11 @@ uint32_t ThriftHiveMetastore_show_compact_result::read(::apache::thrift::protoco return xfer; } -uint32_t ThriftHiveMetastore_show_compact_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_fire_listener_event_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_show_compact_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_fire_listener_event_result"); if (this->__isset.success) { xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); @@ -37528,11 +38462,11 @@ uint32_t ThriftHiveMetastore_show_compact_result::write(::apache::thrift::protoc } -ThriftHiveMetastore_show_compact_presult::~ThriftHiveMetastore_show_compact_presult() throw() { +ThriftHiveMetastore_fire_listener_event_presult::~ThriftHiveMetastore_fire_listener_event_presult() throw() { } -uint32_t ThriftHiveMetastore_show_compact_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_fire_listener_event_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -37574,11 +38508,11 @@ uint32_t ThriftHiveMetastore_show_compact_presult::read(::apache::thrift::protoc } -ThriftHiveMetastore_add_dynamic_partitions_args::~ThriftHiveMetastore_add_dynamic_partitions_args() throw() { +ThriftHiveMetastore_flushCache_args::~ThriftHiveMetastore_flushCache_args() throw() { } -uint32_t ThriftHiveMetastore_add_dynamic_partitions_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_flushCache_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -37597,20 +38531,7 @@ uint32_t ThriftHiveMetastore_add_dynamic_partitions_args::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_STOP) { break; } - switch (fid) - { - case 1: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->rqst.read(iprot); - this->__isset.rqst = true; - } else { - xfer += iprot->skip(ftype); - } - break; - default: - xfer += iprot->skip(ftype); - break; - } + xfer += iprot->skip(ftype); xfer += iprot->readFieldEnd(); } @@ -37619,14 +38540,10 @@ uint32_t ThriftHiveMetastore_add_dynamic_partitions_args::read(::apache::thrift: return xfer; } -uint32_t ThriftHiveMetastore_add_dynamic_partitions_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_flushCache_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_dynamic_partitions_args"); - - xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += this->rqst.write(oprot); - xfer += oprot->writeFieldEnd(); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_flushCache_args"); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); @@ -37634,18 +38551,14 @@ uint32_t ThriftHiveMetastore_add_dynamic_partitions_args::write(::apache::thrift } -ThriftHiveMetastore_add_dynamic_partitions_pargs::~ThriftHiveMetastore_add_dynamic_partitions_pargs() throw() { +ThriftHiveMetastore_flushCache_pargs::~ThriftHiveMetastore_flushCache_pargs() throw() { } -uint32_t ThriftHiveMetastore_add_dynamic_partitions_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_flushCache_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_dynamic_partitions_pargs"); - - xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += (*(this->rqst)).write(oprot); - xfer += oprot->writeFieldEnd(); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_flushCache_pargs"); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); @@ -37653,11 +38566,11 @@ uint32_t ThriftHiveMetastore_add_dynamic_partitions_pargs::write(::apache::thrif } -ThriftHiveMetastore_add_dynamic_partitions_result::~ThriftHiveMetastore_add_dynamic_partitions_result() throw() { +ThriftHiveMetastore_flushCache_result::~ThriftHiveMetastore_flushCache_result() throw() { } -uint32_t ThriftHiveMetastore_add_dynamic_partitions_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_flushCache_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -37676,28 +38589,7 @@ uint32_t ThriftHiveMetastore_add_dynamic_partitions_result::read(::apache::thrif 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; - default: - xfer += iprot->skip(ftype); - break; - } + xfer += iprot->skip(ftype); xfer += iprot->readFieldEnd(); } @@ -37706,32 +38598,23 @@ uint32_t ThriftHiveMetastore_add_dynamic_partitions_result::read(::apache::thrif return xfer; } -uint32_t ThriftHiveMetastore_add_dynamic_partitions_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_flushCache_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_dynamic_partitions_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_flushCache_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(); - } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; } -ThriftHiveMetastore_add_dynamic_partitions_presult::~ThriftHiveMetastore_add_dynamic_partitions_presult() throw() { +ThriftHiveMetastore_flushCache_presult::~ThriftHiveMetastore_flushCache_presult() throw() { } -uint32_t ThriftHiveMetastore_add_dynamic_partitions_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_flushCache_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -37750,28 +38633,7 @@ uint32_t ThriftHiveMetastore_add_dynamic_partitions_presult::read(::apache::thri 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; - default: - xfer += iprot->skip(ftype); - break; - } + xfer += iprot->skip(ftype); xfer += iprot->readFieldEnd(); } @@ -37781,11 +38643,11 @@ uint32_t ThriftHiveMetastore_add_dynamic_partitions_presult::read(::apache::thri } -ThriftHiveMetastore_get_next_notification_args::~ThriftHiveMetastore_get_next_notification_args() throw() { +ThriftHiveMetastore_cm_recycle_args::~ThriftHiveMetastore_cm_recycle_args() throw() { } -uint32_t ThriftHiveMetastore_get_next_notification_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_cm_recycle_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -37808,8 +38670,8 @@ uint32_t ThriftHiveMetastore_get_next_notification_args::read(::apache::thrift:: { case 1: if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->rqst.read(iprot); - this->__isset.rqst = true; + xfer += this->request.read(iprot); + this->__isset.request = true; } else { xfer += iprot->skip(ftype); } @@ -37826,13 +38688,13 @@ uint32_t ThriftHiveMetastore_get_next_notification_args::read(::apache::thrift:: return xfer; } -uint32_t ThriftHiveMetastore_get_next_notification_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_cm_recycle_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_next_notification_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_cm_recycle_args"); - xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += this->rqst.write(oprot); + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -37841,17 +38703,17 @@ uint32_t ThriftHiveMetastore_get_next_notification_args::write(::apache::thrift: } -ThriftHiveMetastore_get_next_notification_pargs::~ThriftHiveMetastore_get_next_notification_pargs() throw() { +ThriftHiveMetastore_cm_recycle_pargs::~ThriftHiveMetastore_cm_recycle_pargs() throw() { } -uint32_t ThriftHiveMetastore_get_next_notification_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_cm_recycle_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_next_notification_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_cm_recycle_pargs"); - xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += (*(this->rqst)).write(oprot); + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -37860,11 +38722,11 @@ uint32_t ThriftHiveMetastore_get_next_notification_pargs::write(::apache::thrift } -ThriftHiveMetastore_get_next_notification_result::~ThriftHiveMetastore_get_next_notification_result() throw() { +ThriftHiveMetastore_cm_recycle_result::~ThriftHiveMetastore_cm_recycle_result() throw() { } -uint32_t ThriftHiveMetastore_get_next_notification_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_cm_recycle_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -37893,6 +38755,14 @@ uint32_t ThriftHiveMetastore_get_next_notification_result::read(::apache::thrift 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; @@ -37905,16 +38775,20 @@ uint32_t ThriftHiveMetastore_get_next_notification_result::read(::apache::thrift return xfer; } -uint32_t ThriftHiveMetastore_get_next_notification_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_cm_recycle_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_next_notification_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_cm_recycle_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(); } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); @@ -37922,11 +38796,11 @@ uint32_t ThriftHiveMetastore_get_next_notification_result::write(::apache::thrif } -ThriftHiveMetastore_get_next_notification_presult::~ThriftHiveMetastore_get_next_notification_presult() throw() { +ThriftHiveMetastore_cm_recycle_presult::~ThriftHiveMetastore_cm_recycle_presult() throw() { } -uint32_t ThriftHiveMetastore_get_next_notification_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_cm_recycle_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -37955,6 +38829,14 @@ uint32_t ThriftHiveMetastore_get_next_notification_presult::read(::apache::thrif 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; @@ -37968,11 +38850,11 @@ uint32_t ThriftHiveMetastore_get_next_notification_presult::read(::apache::thrif } -ThriftHiveMetastore_get_current_notificationEventId_args::~ThriftHiveMetastore_get_current_notificationEventId_args() throw() { +ThriftHiveMetastore_get_file_metadata_by_expr_args::~ThriftHiveMetastore_get_file_metadata_by_expr_args() throw() { } -uint32_t ThriftHiveMetastore_get_current_notificationEventId_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_file_metadata_by_expr_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -37991,7 +38873,20 @@ uint32_t ThriftHiveMetastore_get_current_notificationEventId_args::read(::apache if (ftype == ::apache::thrift::protocol::T_STOP) { break; } - xfer += iprot->skip(ftype); + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->req.read(iprot); + this->__isset.req = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } xfer += iprot->readFieldEnd(); } @@ -38000,10 +38895,14 @@ uint32_t ThriftHiveMetastore_get_current_notificationEventId_args::read(::apache return xfer; } -uint32_t ThriftHiveMetastore_get_current_notificationEventId_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_file_metadata_by_expr_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_current_notificationEventId_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_file_metadata_by_expr_args"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->req.write(oprot); + xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); @@ -38011,14 +38910,18 @@ uint32_t ThriftHiveMetastore_get_current_notificationEventId_args::write(::apach } -ThriftHiveMetastore_get_current_notificationEventId_pargs::~ThriftHiveMetastore_get_current_notificationEventId_pargs() throw() { +ThriftHiveMetastore_get_file_metadata_by_expr_pargs::~ThriftHiveMetastore_get_file_metadata_by_expr_pargs() throw() { } -uint32_t ThriftHiveMetastore_get_current_notificationEventId_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_file_metadata_by_expr_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_current_notificationEventId_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_file_metadata_by_expr_pargs"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->req)).write(oprot); + xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); @@ -38026,11 +38929,11 @@ uint32_t ThriftHiveMetastore_get_current_notificationEventId_pargs::write(::apac } -ThriftHiveMetastore_get_current_notificationEventId_result::~ThriftHiveMetastore_get_current_notificationEventId_result() throw() { +ThriftHiveMetastore_get_file_metadata_by_expr_result::~ThriftHiveMetastore_get_file_metadata_by_expr_result() throw() { } -uint32_t ThriftHiveMetastore_get_current_notificationEventId_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_file_metadata_by_expr_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -38071,11 +38974,11 @@ uint32_t ThriftHiveMetastore_get_current_notificationEventId_result::read(::apac return xfer; } -uint32_t ThriftHiveMetastore_get_current_notificationEventId_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_file_metadata_by_expr_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_current_notificationEventId_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_file_metadata_by_expr_result"); if (this->__isset.success) { xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); @@ -38088,11 +38991,11 @@ uint32_t ThriftHiveMetastore_get_current_notificationEventId_result::write(::apa } -ThriftHiveMetastore_get_current_notificationEventId_presult::~ThriftHiveMetastore_get_current_notificationEventId_presult() throw() { +ThriftHiveMetastore_get_file_metadata_by_expr_presult::~ThriftHiveMetastore_get_file_metadata_by_expr_presult() throw() { } -uint32_t ThriftHiveMetastore_get_current_notificationEventId_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_file_metadata_by_expr_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -38134,11 +39037,11 @@ uint32_t ThriftHiveMetastore_get_current_notificationEventId_presult::read(::apa } -ThriftHiveMetastore_get_notification_events_count_args::~ThriftHiveMetastore_get_notification_events_count_args() throw() { +ThriftHiveMetastore_get_file_metadata_args::~ThriftHiveMetastore_get_file_metadata_args() throw() { } -uint32_t ThriftHiveMetastore_get_notification_events_count_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_file_metadata_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -38159,10 +39062,10 @@ uint32_t ThriftHiveMetastore_get_notification_events_count_args::read(::apache:: } switch (fid) { - case -1: + case 1: if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->rqst.read(iprot); - this->__isset.rqst = true; + xfer += this->req.read(iprot); + this->__isset.req = true; } else { xfer += iprot->skip(ftype); } @@ -38179,13 +39082,13 @@ uint32_t ThriftHiveMetastore_get_notification_events_count_args::read(::apache:: return xfer; } -uint32_t ThriftHiveMetastore_get_notification_events_count_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_file_metadata_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_notification_events_count_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_file_metadata_args"); - xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, -1); - xfer += this->rqst.write(oprot); + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->req.write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -38194,17 +39097,17 @@ uint32_t ThriftHiveMetastore_get_notification_events_count_args::write(::apache: } -ThriftHiveMetastore_get_notification_events_count_pargs::~ThriftHiveMetastore_get_notification_events_count_pargs() throw() { +ThriftHiveMetastore_get_file_metadata_pargs::~ThriftHiveMetastore_get_file_metadata_pargs() throw() { } -uint32_t ThriftHiveMetastore_get_notification_events_count_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_file_metadata_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_notification_events_count_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_file_metadata_pargs"); - xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, -1); - xfer += (*(this->rqst)).write(oprot); + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->req)).write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -38213,11 +39116,11 @@ uint32_t ThriftHiveMetastore_get_notification_events_count_pargs::write(::apache } -ThriftHiveMetastore_get_notification_events_count_result::~ThriftHiveMetastore_get_notification_events_count_result() throw() { +ThriftHiveMetastore_get_file_metadata_result::~ThriftHiveMetastore_get_file_metadata_result() throw() { } -uint32_t ThriftHiveMetastore_get_notification_events_count_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_file_metadata_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -38258,11 +39161,11 @@ uint32_t ThriftHiveMetastore_get_notification_events_count_result::read(::apache return xfer; } -uint32_t ThriftHiveMetastore_get_notification_events_count_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_file_metadata_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_notification_events_count_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_file_metadata_result"); if (this->__isset.success) { xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); @@ -38275,11 +39178,11 @@ uint32_t ThriftHiveMetastore_get_notification_events_count_result::write(::apach } -ThriftHiveMetastore_get_notification_events_count_presult::~ThriftHiveMetastore_get_notification_events_count_presult() throw() { +ThriftHiveMetastore_get_file_metadata_presult::~ThriftHiveMetastore_get_file_metadata_presult() throw() { } -uint32_t ThriftHiveMetastore_get_notification_events_count_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_file_metadata_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -38321,11 +39224,11 @@ uint32_t ThriftHiveMetastore_get_notification_events_count_presult::read(::apach } -ThriftHiveMetastore_fire_listener_event_args::~ThriftHiveMetastore_fire_listener_event_args() throw() { +ThriftHiveMetastore_put_file_metadata_args::~ThriftHiveMetastore_put_file_metadata_args() throw() { } -uint32_t ThriftHiveMetastore_fire_listener_event_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_put_file_metadata_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -38348,8 +39251,8 @@ uint32_t ThriftHiveMetastore_fire_listener_event_args::read(::apache::thrift::pr { case 1: if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->rqst.read(iprot); - this->__isset.rqst = true; + xfer += this->req.read(iprot); + this->__isset.req = true; } else { xfer += iprot->skip(ftype); } @@ -38366,13 +39269,13 @@ uint32_t ThriftHiveMetastore_fire_listener_event_args::read(::apache::thrift::pr return xfer; } -uint32_t ThriftHiveMetastore_fire_listener_event_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_put_file_metadata_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_fire_listener_event_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_put_file_metadata_args"); - xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += this->rqst.write(oprot); + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->req.write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -38381,17 +39284,17 @@ uint32_t ThriftHiveMetastore_fire_listener_event_args::write(::apache::thrift::p } -ThriftHiveMetastore_fire_listener_event_pargs::~ThriftHiveMetastore_fire_listener_event_pargs() throw() { +ThriftHiveMetastore_put_file_metadata_pargs::~ThriftHiveMetastore_put_file_metadata_pargs() throw() { } -uint32_t ThriftHiveMetastore_fire_listener_event_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_put_file_metadata_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_fire_listener_event_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_put_file_metadata_pargs"); - xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += (*(this->rqst)).write(oprot); + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->req)).write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -38400,11 +39303,11 @@ uint32_t ThriftHiveMetastore_fire_listener_event_pargs::write(::apache::thrift:: } -ThriftHiveMetastore_fire_listener_event_result::~ThriftHiveMetastore_fire_listener_event_result() throw() { +ThriftHiveMetastore_put_file_metadata_result::~ThriftHiveMetastore_put_file_metadata_result() throw() { } -uint32_t ThriftHiveMetastore_fire_listener_event_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_put_file_metadata_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -38445,11 +39348,11 @@ uint32_t ThriftHiveMetastore_fire_listener_event_result::read(::apache::thrift:: return xfer; } -uint32_t ThriftHiveMetastore_fire_listener_event_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_put_file_metadata_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_fire_listener_event_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_put_file_metadata_result"); if (this->__isset.success) { xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); @@ -38462,11 +39365,11 @@ uint32_t ThriftHiveMetastore_fire_listener_event_result::write(::apache::thrift: } -ThriftHiveMetastore_fire_listener_event_presult::~ThriftHiveMetastore_fire_listener_event_presult() throw() { +ThriftHiveMetastore_put_file_metadata_presult::~ThriftHiveMetastore_put_file_metadata_presult() throw() { } -uint32_t ThriftHiveMetastore_fire_listener_event_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_put_file_metadata_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -38508,146 +39411,11 @@ uint32_t ThriftHiveMetastore_fire_listener_event_presult::read(::apache::thrift: } -ThriftHiveMetastore_flushCache_args::~ThriftHiveMetastore_flushCache_args() throw() { -} - - -uint32_t ThriftHiveMetastore_flushCache_args::read(::apache::thrift::protocol::TProtocol* iprot) { - - apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); - uint32_t xfer = 0; - std::string fname; - ::apache::thrift::protocol::TType ftype; - int16_t fid; - - xfer += iprot->readStructBegin(fname); - - using ::apache::thrift::protocol::TProtocolException; - - - while (true) - { - xfer += iprot->readFieldBegin(fname, ftype, fid); - if (ftype == ::apache::thrift::protocol::T_STOP) { - break; - } - xfer += iprot->skip(ftype); - xfer += iprot->readFieldEnd(); - } - - xfer += iprot->readStructEnd(); - - return xfer; -} - -uint32_t ThriftHiveMetastore_flushCache_args::write(::apache::thrift::protocol::TProtocol* oprot) const { - uint32_t xfer = 0; - apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_flushCache_args"); - - xfer += oprot->writeFieldStop(); - xfer += oprot->writeStructEnd(); - return xfer; -} - - -ThriftHiveMetastore_flushCache_pargs::~ThriftHiveMetastore_flushCache_pargs() throw() { -} - - -uint32_t ThriftHiveMetastore_flushCache_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { - uint32_t xfer = 0; - apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_flushCache_pargs"); - - xfer += oprot->writeFieldStop(); - xfer += oprot->writeStructEnd(); - return xfer; -} - - -ThriftHiveMetastore_flushCache_result::~ThriftHiveMetastore_flushCache_result() throw() { -} - - -uint32_t ThriftHiveMetastore_flushCache_result::read(::apache::thrift::protocol::TProtocol* iprot) { - - apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); - uint32_t xfer = 0; - std::string fname; - ::apache::thrift::protocol::TType ftype; - int16_t fid; - - xfer += iprot->readStructBegin(fname); - - using ::apache::thrift::protocol::TProtocolException; - - - while (true) - { - xfer += iprot->readFieldBegin(fname, ftype, fid); - if (ftype == ::apache::thrift::protocol::T_STOP) { - break; - } - xfer += iprot->skip(ftype); - xfer += iprot->readFieldEnd(); - } - - xfer += iprot->readStructEnd(); - - return xfer; -} - -uint32_t ThriftHiveMetastore_flushCache_result::write(::apache::thrift::protocol::TProtocol* oprot) const { - - uint32_t xfer = 0; - - xfer += oprot->writeStructBegin("ThriftHiveMetastore_flushCache_result"); - - xfer += oprot->writeFieldStop(); - xfer += oprot->writeStructEnd(); - return xfer; -} - - -ThriftHiveMetastore_flushCache_presult::~ThriftHiveMetastore_flushCache_presult() throw() { -} - - -uint32_t ThriftHiveMetastore_flushCache_presult::read(::apache::thrift::protocol::TProtocol* iprot) { - - apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); - uint32_t xfer = 0; - std::string fname; - ::apache::thrift::protocol::TType ftype; - int16_t fid; - - xfer += iprot->readStructBegin(fname); - - using ::apache::thrift::protocol::TProtocolException; - - - while (true) - { - xfer += iprot->readFieldBegin(fname, ftype, fid); - if (ftype == ::apache::thrift::protocol::T_STOP) { - break; - } - xfer += iprot->skip(ftype); - xfer += iprot->readFieldEnd(); - } - - xfer += iprot->readStructEnd(); - - return xfer; -} - - -ThriftHiveMetastore_cm_recycle_args::~ThriftHiveMetastore_cm_recycle_args() throw() { +ThriftHiveMetastore_clear_file_metadata_args::~ThriftHiveMetastore_clear_file_metadata_args() throw() { } -uint32_t ThriftHiveMetastore_cm_recycle_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_clear_file_metadata_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -38670,8 +39438,8 @@ uint32_t ThriftHiveMetastore_cm_recycle_args::read(::apache::thrift::protocol::T { case 1: if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->request.read(iprot); - this->__isset.request = true; + xfer += this->req.read(iprot); + this->__isset.req = true; } else { xfer += iprot->skip(ftype); } @@ -38688,13 +39456,13 @@ uint32_t ThriftHiveMetastore_cm_recycle_args::read(::apache::thrift::protocol::T return xfer; } -uint32_t ThriftHiveMetastore_cm_recycle_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_clear_file_metadata_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_cm_recycle_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_clear_file_metadata_args"); - xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += this->request.write(oprot); + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->req.write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -38703,17 +39471,17 @@ uint32_t ThriftHiveMetastore_cm_recycle_args::write(::apache::thrift::protocol:: } -ThriftHiveMetastore_cm_recycle_pargs::~ThriftHiveMetastore_cm_recycle_pargs() throw() { +ThriftHiveMetastore_clear_file_metadata_pargs::~ThriftHiveMetastore_clear_file_metadata_pargs() throw() { } -uint32_t ThriftHiveMetastore_cm_recycle_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_clear_file_metadata_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_cm_recycle_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_clear_file_metadata_pargs"); - xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->req)).write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -38722,11 +39490,11 @@ uint32_t ThriftHiveMetastore_cm_recycle_pargs::write(::apache::thrift::protocol: } -ThriftHiveMetastore_cm_recycle_result::~ThriftHiveMetastore_cm_recycle_result() throw() { +ThriftHiveMetastore_clear_file_metadata_result::~ThriftHiveMetastore_clear_file_metadata_result() throw() { } -uint32_t ThriftHiveMetastore_cm_recycle_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_clear_file_metadata_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -38755,14 +39523,6 @@ uint32_t ThriftHiveMetastore_cm_recycle_result::read(::apache::thrift::protocol: 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; @@ -38775,20 +39535,16 @@ uint32_t ThriftHiveMetastore_cm_recycle_result::read(::apache::thrift::protocol: return xfer; } -uint32_t ThriftHiveMetastore_cm_recycle_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_clear_file_metadata_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_cm_recycle_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_clear_file_metadata_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(); } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); @@ -38796,11 +39552,11 @@ uint32_t ThriftHiveMetastore_cm_recycle_result::write(::apache::thrift::protocol } -ThriftHiveMetastore_cm_recycle_presult::~ThriftHiveMetastore_cm_recycle_presult() throw() { +ThriftHiveMetastore_clear_file_metadata_presult::~ThriftHiveMetastore_clear_file_metadata_presult() throw() { } -uint32_t ThriftHiveMetastore_cm_recycle_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_clear_file_metadata_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -38829,14 +39585,6 @@ uint32_t ThriftHiveMetastore_cm_recycle_presult::read(::apache::thrift::protocol 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; @@ -38850,11 +39598,11 @@ uint32_t ThriftHiveMetastore_cm_recycle_presult::read(::apache::thrift::protocol } -ThriftHiveMetastore_get_file_metadata_by_expr_args::~ThriftHiveMetastore_get_file_metadata_by_expr_args() throw() { +ThriftHiveMetastore_cache_file_metadata_args::~ThriftHiveMetastore_cache_file_metadata_args() throw() { } -uint32_t ThriftHiveMetastore_get_file_metadata_by_expr_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_cache_file_metadata_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -38895,10 +39643,10 @@ uint32_t ThriftHiveMetastore_get_file_metadata_by_expr_args::read(::apache::thri return xfer; } -uint32_t ThriftHiveMetastore_get_file_metadata_by_expr_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_cache_file_metadata_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_file_metadata_by_expr_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_cache_file_metadata_args"); xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); xfer += this->req.write(oprot); @@ -38910,14 +39658,14 @@ uint32_t ThriftHiveMetastore_get_file_metadata_by_expr_args::write(::apache::thr } -ThriftHiveMetastore_get_file_metadata_by_expr_pargs::~ThriftHiveMetastore_get_file_metadata_by_expr_pargs() throw() { +ThriftHiveMetastore_cache_file_metadata_pargs::~ThriftHiveMetastore_cache_file_metadata_pargs() throw() { } -uint32_t ThriftHiveMetastore_get_file_metadata_by_expr_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_cache_file_metadata_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_file_metadata_by_expr_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_cache_file_metadata_pargs"); xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); xfer += (*(this->req)).write(oprot); @@ -38929,11 +39677,11 @@ uint32_t ThriftHiveMetastore_get_file_metadata_by_expr_pargs::write(::apache::th } -ThriftHiveMetastore_get_file_metadata_by_expr_result::~ThriftHiveMetastore_get_file_metadata_by_expr_result() throw() { +ThriftHiveMetastore_cache_file_metadata_result::~ThriftHiveMetastore_cache_file_metadata_result() throw() { } -uint32_t ThriftHiveMetastore_get_file_metadata_by_expr_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_cache_file_metadata_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -38974,11 +39722,11 @@ uint32_t ThriftHiveMetastore_get_file_metadata_by_expr_result::read(::apache::th return xfer; } -uint32_t ThriftHiveMetastore_get_file_metadata_by_expr_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_cache_file_metadata_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_file_metadata_by_expr_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_cache_file_metadata_result"); if (this->__isset.success) { xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); @@ -38991,11 +39739,11 @@ uint32_t ThriftHiveMetastore_get_file_metadata_by_expr_result::write(::apache::t } -ThriftHiveMetastore_get_file_metadata_by_expr_presult::~ThriftHiveMetastore_get_file_metadata_by_expr_presult() throw() { +ThriftHiveMetastore_cache_file_metadata_presult::~ThriftHiveMetastore_cache_file_metadata_presult() throw() { } -uint32_t ThriftHiveMetastore_get_file_metadata_by_expr_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_cache_file_metadata_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -39037,11 +39785,11 @@ uint32_t ThriftHiveMetastore_get_file_metadata_by_expr_presult::read(::apache::t } -ThriftHiveMetastore_get_file_metadata_args::~ThriftHiveMetastore_get_file_metadata_args() throw() { +ThriftHiveMetastore_get_metastore_db_uuid_args::~ThriftHiveMetastore_get_metastore_db_uuid_args() throw() { } -uint32_t ThriftHiveMetastore_get_file_metadata_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_metastore_db_uuid_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -39060,20 +39808,7 @@ uint32_t ThriftHiveMetastore_get_file_metadata_args::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_STOP) { break; } - switch (fid) - { - case 1: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->req.read(iprot); - this->__isset.req = true; - } else { - xfer += iprot->skip(ftype); - } - break; - default: - xfer += iprot->skip(ftype); - break; - } + xfer += iprot->skip(ftype); xfer += iprot->readFieldEnd(); } @@ -39082,14 +39817,10 @@ uint32_t ThriftHiveMetastore_get_file_metadata_args::read(::apache::thrift::prot return xfer; } -uint32_t ThriftHiveMetastore_get_file_metadata_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_metastore_db_uuid_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_file_metadata_args"); - - xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += this->req.write(oprot); - xfer += oprot->writeFieldEnd(); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_metastore_db_uuid_args"); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); @@ -39097,18 +39828,14 @@ uint32_t ThriftHiveMetastore_get_file_metadata_args::write(::apache::thrift::pro } -ThriftHiveMetastore_get_file_metadata_pargs::~ThriftHiveMetastore_get_file_metadata_pargs() throw() { +ThriftHiveMetastore_get_metastore_db_uuid_pargs::~ThriftHiveMetastore_get_metastore_db_uuid_pargs() throw() { } -uint32_t ThriftHiveMetastore_get_file_metadata_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_metastore_db_uuid_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_file_metadata_pargs"); - - xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += (*(this->req)).write(oprot); - xfer += oprot->writeFieldEnd(); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_metastore_db_uuid_pargs"); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); @@ -39116,11 +39843,11 @@ uint32_t ThriftHiveMetastore_get_file_metadata_pargs::write(::apache::thrift::pr } -ThriftHiveMetastore_get_file_metadata_result::~ThriftHiveMetastore_get_file_metadata_result() throw() { +ThriftHiveMetastore_get_metastore_db_uuid_result::~ThriftHiveMetastore_get_metastore_db_uuid_result() throw() { } -uint32_t ThriftHiveMetastore_get_file_metadata_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_metastore_db_uuid_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -39142,13 +39869,21 @@ uint32_t ThriftHiveMetastore_get_file_metadata_result::read(::apache::thrift::pr switch (fid) { case 0: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->success.read(iprot); + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(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; default: xfer += iprot->skip(ftype); break; @@ -39161,15 +39896,19 @@ uint32_t ThriftHiveMetastore_get_file_metadata_result::read(::apache::thrift::pr return xfer; } -uint32_t ThriftHiveMetastore_get_file_metadata_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_metastore_db_uuid_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_file_metadata_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_metastore_db_uuid_result"); if (this->__isset.success) { - xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); - xfer += this->success.write(oprot); + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0); + xfer += oprot->writeString(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(); } xfer += oprot->writeFieldStop(); @@ -39178,11 +39917,11 @@ uint32_t ThriftHiveMetastore_get_file_metadata_result::write(::apache::thrift::p } -ThriftHiveMetastore_get_file_metadata_presult::~ThriftHiveMetastore_get_file_metadata_presult() throw() { +ThriftHiveMetastore_get_metastore_db_uuid_presult::~ThriftHiveMetastore_get_metastore_db_uuid_presult() throw() { } -uint32_t ThriftHiveMetastore_get_file_metadata_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_metastore_db_uuid_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -39204,13 +39943,21 @@ uint32_t ThriftHiveMetastore_get_file_metadata_presult::read(::apache::thrift::p switch (fid) { case 0: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += (*(this->success)).read(iprot); + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString((*(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; default: xfer += iprot->skip(ftype); break; @@ -39224,11 +39971,11 @@ uint32_t ThriftHiveMetastore_get_file_metadata_presult::read(::apache::thrift::p } -ThriftHiveMetastore_put_file_metadata_args::~ThriftHiveMetastore_put_file_metadata_args() throw() { +ThriftHiveMetastore_create_resource_plan_args::~ThriftHiveMetastore_create_resource_plan_args() throw() { } -uint32_t ThriftHiveMetastore_put_file_metadata_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_create_resource_plan_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -39251,8 +39998,8 @@ uint32_t ThriftHiveMetastore_put_file_metadata_args::read(::apache::thrift::prot { case 1: if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->req.read(iprot); - this->__isset.req = true; + xfer += this->request.read(iprot); + this->__isset.request = true; } else { xfer += iprot->skip(ftype); } @@ -39269,13 +40016,13 @@ uint32_t ThriftHiveMetastore_put_file_metadata_args::read(::apache::thrift::prot return xfer; } -uint32_t ThriftHiveMetastore_put_file_metadata_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_create_resource_plan_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_put_file_metadata_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_resource_plan_args"); - xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += this->req.write(oprot); + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -39284,17 +40031,17 @@ uint32_t ThriftHiveMetastore_put_file_metadata_args::write(::apache::thrift::pro } -ThriftHiveMetastore_put_file_metadata_pargs::~ThriftHiveMetastore_put_file_metadata_pargs() throw() { +ThriftHiveMetastore_create_resource_plan_pargs::~ThriftHiveMetastore_create_resource_plan_pargs() throw() { } -uint32_t ThriftHiveMetastore_put_file_metadata_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_create_resource_plan_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_put_file_metadata_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_resource_plan_pargs"); - xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += (*(this->req)).write(oprot); + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -39303,11 +40050,11 @@ uint32_t ThriftHiveMetastore_put_file_metadata_pargs::write(::apache::thrift::pr } -ThriftHiveMetastore_put_file_metadata_result::~ThriftHiveMetastore_put_file_metadata_result() throw() { +ThriftHiveMetastore_create_resource_plan_result::~ThriftHiveMetastore_create_resource_plan_result() throw() { } -uint32_t ThriftHiveMetastore_put_file_metadata_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_create_resource_plan_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -39336,6 +40083,30 @@ uint32_t ThriftHiveMetastore_put_file_metadata_result::read(::apache::thrift::pr 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; @@ -39348,16 +40119,28 @@ uint32_t ThriftHiveMetastore_put_file_metadata_result::read(::apache::thrift::pr return xfer; } -uint32_t ThriftHiveMetastore_put_file_metadata_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_create_resource_plan_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_put_file_metadata_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_resource_plan_result"); if (this->__isset.success) { xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); xfer += this->success.write(oprot); xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); @@ -39365,11 +40148,11 @@ uint32_t ThriftHiveMetastore_put_file_metadata_result::write(::apache::thrift::p } -ThriftHiveMetastore_put_file_metadata_presult::~ThriftHiveMetastore_put_file_metadata_presult() throw() { +ThriftHiveMetastore_create_resource_plan_presult::~ThriftHiveMetastore_create_resource_plan_presult() throw() { } -uint32_t ThriftHiveMetastore_put_file_metadata_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_create_resource_plan_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -39398,6 +40181,30 @@ uint32_t ThriftHiveMetastore_put_file_metadata_presult::read(::apache::thrift::p 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; @@ -39411,11 +40218,11 @@ uint32_t ThriftHiveMetastore_put_file_metadata_presult::read(::apache::thrift::p } -ThriftHiveMetastore_clear_file_metadata_args::~ThriftHiveMetastore_clear_file_metadata_args() throw() { +ThriftHiveMetastore_get_resource_plan_args::~ThriftHiveMetastore_get_resource_plan_args() throw() { } -uint32_t ThriftHiveMetastore_clear_file_metadata_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_resource_plan_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -39438,8 +40245,8 @@ uint32_t ThriftHiveMetastore_clear_file_metadata_args::read(::apache::thrift::pr { case 1: if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->req.read(iprot); - this->__isset.req = true; + xfer += this->request.read(iprot); + this->__isset.request = true; } else { xfer += iprot->skip(ftype); } @@ -39456,13 +40263,13 @@ uint32_t ThriftHiveMetastore_clear_file_metadata_args::read(::apache::thrift::pr return xfer; } -uint32_t ThriftHiveMetastore_clear_file_metadata_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_resource_plan_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_clear_file_metadata_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_resource_plan_args"); - xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += this->req.write(oprot); + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -39471,17 +40278,17 @@ uint32_t ThriftHiveMetastore_clear_file_metadata_args::write(::apache::thrift::p } -ThriftHiveMetastore_clear_file_metadata_pargs::~ThriftHiveMetastore_clear_file_metadata_pargs() throw() { +ThriftHiveMetastore_get_resource_plan_pargs::~ThriftHiveMetastore_get_resource_plan_pargs() throw() { } -uint32_t ThriftHiveMetastore_clear_file_metadata_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_resource_plan_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_clear_file_metadata_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_resource_plan_pargs"); - xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += (*(this->req)).write(oprot); + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -39490,11 +40297,11 @@ uint32_t ThriftHiveMetastore_clear_file_metadata_pargs::write(::apache::thrift:: } -ThriftHiveMetastore_clear_file_metadata_result::~ThriftHiveMetastore_clear_file_metadata_result() throw() { +ThriftHiveMetastore_get_resource_plan_result::~ThriftHiveMetastore_get_resource_plan_result() throw() { } -uint32_t ThriftHiveMetastore_clear_file_metadata_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_resource_plan_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -39523,6 +40330,22 @@ uint32_t ThriftHiveMetastore_clear_file_metadata_result::read(::apache::thrift:: 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; @@ -39535,16 +40358,24 @@ uint32_t ThriftHiveMetastore_clear_file_metadata_result::read(::apache::thrift:: return xfer; } -uint32_t ThriftHiveMetastore_clear_file_metadata_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_resource_plan_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_clear_file_metadata_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_resource_plan_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(); @@ -39552,11 +40383,11 @@ uint32_t ThriftHiveMetastore_clear_file_metadata_result::write(::apache::thrift: } -ThriftHiveMetastore_clear_file_metadata_presult::~ThriftHiveMetastore_clear_file_metadata_presult() throw() { +ThriftHiveMetastore_get_resource_plan_presult::~ThriftHiveMetastore_get_resource_plan_presult() throw() { } -uint32_t ThriftHiveMetastore_clear_file_metadata_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_resource_plan_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -39585,6 +40416,22 @@ uint32_t ThriftHiveMetastore_clear_file_metadata_presult::read(::apache::thrift: 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; @@ -39598,11 +40445,11 @@ uint32_t ThriftHiveMetastore_clear_file_metadata_presult::read(::apache::thrift: } -ThriftHiveMetastore_cache_file_metadata_args::~ThriftHiveMetastore_cache_file_metadata_args() throw() { +ThriftHiveMetastore_get_all_resource_plans_args::~ThriftHiveMetastore_get_all_resource_plans_args() throw() { } -uint32_t ThriftHiveMetastore_cache_file_metadata_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_all_resource_plans_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -39625,8 +40472,8 @@ uint32_t ThriftHiveMetastore_cache_file_metadata_args::read(::apache::thrift::pr { case 1: if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->req.read(iprot); - this->__isset.req = true; + xfer += this->request.read(iprot); + this->__isset.request = true; } else { xfer += iprot->skip(ftype); } @@ -39643,13 +40490,13 @@ uint32_t ThriftHiveMetastore_cache_file_metadata_args::read(::apache::thrift::pr return xfer; } -uint32_t ThriftHiveMetastore_cache_file_metadata_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_all_resource_plans_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_cache_file_metadata_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_resource_plans_args"); - xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += this->req.write(oprot); + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -39658,17 +40505,17 @@ uint32_t ThriftHiveMetastore_cache_file_metadata_args::write(::apache::thrift::p } -ThriftHiveMetastore_cache_file_metadata_pargs::~ThriftHiveMetastore_cache_file_metadata_pargs() throw() { +ThriftHiveMetastore_get_all_resource_plans_pargs::~ThriftHiveMetastore_get_all_resource_plans_pargs() throw() { } -uint32_t ThriftHiveMetastore_cache_file_metadata_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_all_resource_plans_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_cache_file_metadata_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_resource_plans_pargs"); - xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += (*(this->req)).write(oprot); + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -39677,11 +40524,11 @@ uint32_t ThriftHiveMetastore_cache_file_metadata_pargs::write(::apache::thrift:: } -ThriftHiveMetastore_cache_file_metadata_result::~ThriftHiveMetastore_cache_file_metadata_result() throw() { +ThriftHiveMetastore_get_all_resource_plans_result::~ThriftHiveMetastore_get_all_resource_plans_result() throw() { } -uint32_t ThriftHiveMetastore_cache_file_metadata_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_all_resource_plans_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -39710,6 +40557,14 @@ uint32_t ThriftHiveMetastore_cache_file_metadata_result::read(::apache::thrift:: 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; @@ -39722,16 +40577,20 @@ uint32_t ThriftHiveMetastore_cache_file_metadata_result::read(::apache::thrift:: return xfer; } -uint32_t ThriftHiveMetastore_cache_file_metadata_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_all_resource_plans_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_cache_file_metadata_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_resource_plans_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(); } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); @@ -39739,11 +40598,11 @@ uint32_t ThriftHiveMetastore_cache_file_metadata_result::write(::apache::thrift: } -ThriftHiveMetastore_cache_file_metadata_presult::~ThriftHiveMetastore_cache_file_metadata_presult() throw() { +ThriftHiveMetastore_get_all_resource_plans_presult::~ThriftHiveMetastore_get_all_resource_plans_presult() throw() { } -uint32_t ThriftHiveMetastore_cache_file_metadata_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_all_resource_plans_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -39772,6 +40631,14 @@ uint32_t ThriftHiveMetastore_cache_file_metadata_presult::read(::apache::thrift: 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; @@ -39785,11 +40652,11 @@ uint32_t ThriftHiveMetastore_cache_file_metadata_presult::read(::apache::thrift: } -ThriftHiveMetastore_get_metastore_db_uuid_args::~ThriftHiveMetastore_get_metastore_db_uuid_args() throw() { +ThriftHiveMetastore_alter_resource_plan_args::~ThriftHiveMetastore_alter_resource_plan_args() throw() { } -uint32_t ThriftHiveMetastore_get_metastore_db_uuid_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_alter_resource_plan_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -39808,7 +40675,20 @@ uint32_t ThriftHiveMetastore_get_metastore_db_uuid_args::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_STOP) { break; } - xfer += iprot->skip(ftype); + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } xfer += iprot->readFieldEnd(); } @@ -39817,10 +40697,14 @@ uint32_t ThriftHiveMetastore_get_metastore_db_uuid_args::read(::apache::thrift:: return xfer; } -uint32_t ThriftHiveMetastore_get_metastore_db_uuid_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_alter_resource_plan_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_metastore_db_uuid_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_resource_plan_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); @@ -39828,14 +40712,18 @@ uint32_t ThriftHiveMetastore_get_metastore_db_uuid_args::write(::apache::thrift: } -ThriftHiveMetastore_get_metastore_db_uuid_pargs::~ThriftHiveMetastore_get_metastore_db_uuid_pargs() throw() { +ThriftHiveMetastore_alter_resource_plan_pargs::~ThriftHiveMetastore_alter_resource_plan_pargs() throw() { } -uint32_t ThriftHiveMetastore_get_metastore_db_uuid_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_alter_resource_plan_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_metastore_db_uuid_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_resource_plan_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); @@ -39843,11 +40731,11 @@ uint32_t ThriftHiveMetastore_get_metastore_db_uuid_pargs::write(::apache::thrift } -ThriftHiveMetastore_get_metastore_db_uuid_result::~ThriftHiveMetastore_get_metastore_db_uuid_result() throw() { +ThriftHiveMetastore_alter_resource_plan_result::~ThriftHiveMetastore_alter_resource_plan_result() throw() { } -uint32_t ThriftHiveMetastore_get_metastore_db_uuid_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_alter_resource_plan_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -39869,8 +40757,8 @@ uint32_t ThriftHiveMetastore_get_metastore_db_uuid_result::read(::apache::thrift switch (fid) { case 0: - if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->success); + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); this->__isset.success = true; } else { xfer += iprot->skip(ftype); @@ -39884,6 +40772,22 @@ uint32_t ThriftHiveMetastore_get_metastore_db_uuid_result::read(::apache::thrift 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; @@ -39896,20 +40800,28 @@ uint32_t ThriftHiveMetastore_get_metastore_db_uuid_result::read(::apache::thrift return xfer; } -uint32_t ThriftHiveMetastore_get_metastore_db_uuid_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_alter_resource_plan_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_metastore_db_uuid_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_resource_plan_result"); if (this->__isset.success) { - xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0); - xfer += oprot->writeString(this->success); + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); xfer += oprot->writeFieldEnd(); } else if (this->__isset.o1) { xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); xfer += this->o1.write(oprot); xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); @@ -39917,11 +40829,11 @@ uint32_t ThriftHiveMetastore_get_metastore_db_uuid_result::write(::apache::thrif } -ThriftHiveMetastore_get_metastore_db_uuid_presult::~ThriftHiveMetastore_get_metastore_db_uuid_presult() throw() { +ThriftHiveMetastore_alter_resource_plan_presult::~ThriftHiveMetastore_alter_resource_plan_presult() throw() { } -uint32_t ThriftHiveMetastore_get_metastore_db_uuid_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_alter_resource_plan_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -39943,8 +40855,8 @@ uint32_t ThriftHiveMetastore_get_metastore_db_uuid_presult::read(::apache::thrif switch (fid) { case 0: - if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString((*(this->success))); + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); this->__isset.success = true; } else { xfer += iprot->skip(ftype); @@ -39958,6 +40870,22 @@ uint32_t ThriftHiveMetastore_get_metastore_db_uuid_presult::read(::apache::thrif 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; @@ -39971,11 +40899,11 @@ uint32_t ThriftHiveMetastore_get_metastore_db_uuid_presult::read(::apache::thrif } -ThriftHiveMetastore_create_resource_plan_args::~ThriftHiveMetastore_create_resource_plan_args() throw() { +ThriftHiveMetastore_validate_resource_plan_args::~ThriftHiveMetastore_validate_resource_plan_args() throw() { } -uint32_t ThriftHiveMetastore_create_resource_plan_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_validate_resource_plan_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -40016,10 +40944,10 @@ uint32_t ThriftHiveMetastore_create_resource_plan_args::read(::apache::thrift::p return xfer; } -uint32_t ThriftHiveMetastore_create_resource_plan_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_validate_resource_plan_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_resource_plan_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_validate_resource_plan_args"); xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); xfer += this->request.write(oprot); @@ -40031,14 +40959,14 @@ uint32_t ThriftHiveMetastore_create_resource_plan_args::write(::apache::thrift:: } -ThriftHiveMetastore_create_resource_plan_pargs::~ThriftHiveMetastore_create_resource_plan_pargs() throw() { +ThriftHiveMetastore_validate_resource_plan_pargs::~ThriftHiveMetastore_validate_resource_plan_pargs() throw() { } -uint32_t ThriftHiveMetastore_create_resource_plan_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_validate_resource_plan_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_resource_plan_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_validate_resource_plan_pargs"); xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); xfer += (*(this->request)).write(oprot); @@ -40050,11 +40978,11 @@ uint32_t ThriftHiveMetastore_create_resource_plan_pargs::write(::apache::thrift: } -ThriftHiveMetastore_create_resource_plan_result::~ThriftHiveMetastore_create_resource_plan_result() throw() { +ThriftHiveMetastore_validate_resource_plan_result::~ThriftHiveMetastore_validate_resource_plan_result() throw() { } -uint32_t ThriftHiveMetastore_create_resource_plan_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_validate_resource_plan_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -40099,14 +41027,6 @@ uint32_t ThriftHiveMetastore_create_resource_plan_result::read(::apache::thrift: 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; @@ -40119,11 +41039,11 @@ uint32_t ThriftHiveMetastore_create_resource_plan_result::read(::apache::thrift: return xfer; } -uint32_t ThriftHiveMetastore_create_resource_plan_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_validate_resource_plan_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_resource_plan_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_validate_resource_plan_result"); if (this->__isset.success) { xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); @@ -40137,10 +41057,6 @@ uint32_t ThriftHiveMetastore_create_resource_plan_result::write(::apache::thrift 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(); @@ -40148,11 +41064,11 @@ uint32_t ThriftHiveMetastore_create_resource_plan_result::write(::apache::thrift } -ThriftHiveMetastore_create_resource_plan_presult::~ThriftHiveMetastore_create_resource_plan_presult() throw() { +ThriftHiveMetastore_validate_resource_plan_presult::~ThriftHiveMetastore_validate_resource_plan_presult() throw() { } -uint32_t ThriftHiveMetastore_create_resource_plan_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_validate_resource_plan_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -40197,14 +41113,6 @@ uint32_t ThriftHiveMetastore_create_resource_plan_presult::read(::apache::thrift 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; @@ -40218,11 +41126,11 @@ uint32_t ThriftHiveMetastore_create_resource_plan_presult::read(::apache::thrift } -ThriftHiveMetastore_get_resource_plan_args::~ThriftHiveMetastore_get_resource_plan_args() throw() { +ThriftHiveMetastore_drop_resource_plan_args::~ThriftHiveMetastore_drop_resource_plan_args() throw() { } -uint32_t ThriftHiveMetastore_get_resource_plan_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_drop_resource_plan_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -40263,10 +41171,10 @@ uint32_t ThriftHiveMetastore_get_resource_plan_args::read(::apache::thrift::prot return xfer; } -uint32_t ThriftHiveMetastore_get_resource_plan_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_drop_resource_plan_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_resource_plan_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_resource_plan_args"); xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); xfer += this->request.write(oprot); @@ -40278,14 +41186,14 @@ uint32_t ThriftHiveMetastore_get_resource_plan_args::write(::apache::thrift::pro } -ThriftHiveMetastore_get_resource_plan_pargs::~ThriftHiveMetastore_get_resource_plan_pargs() throw() { +ThriftHiveMetastore_drop_resource_plan_pargs::~ThriftHiveMetastore_drop_resource_plan_pargs() throw() { } -uint32_t ThriftHiveMetastore_get_resource_plan_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_drop_resource_plan_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_resource_plan_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_resource_plan_pargs"); xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); xfer += (*(this->request)).write(oprot); @@ -40297,97 +41205,109 @@ uint32_t ThriftHiveMetastore_get_resource_plan_pargs::write(::apache::thrift::pr } -ThriftHiveMetastore_get_resource_plan_result::~ThriftHiveMetastore_get_resource_plan_result() throw() { -} - - -uint32_t ThriftHiveMetastore_get_resource_plan_result::read(::apache::thrift::protocol::TProtocol* iprot) { - - apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); - uint32_t xfer = 0; - std::string fname; - ::apache::thrift::protocol::TType ftype; - int16_t fid; - - xfer += iprot->readStructBegin(fname); - - using ::apache::thrift::protocol::TProtocolException; - - - while (true) - { - xfer += iprot->readFieldBegin(fname, ftype, fid); - if (ftype == ::apache::thrift::protocol::T_STOP) { - break; - } - switch (fid) - { - case 0: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->success.read(iprot); - this->__isset.success = true; - } else { - xfer += iprot->skip(ftype); - } - break; - case 1: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->o1.read(iprot); - this->__isset.o1 = true; - } else { - xfer += iprot->skip(ftype); - } - break; - case 2: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->o2.read(iprot); - this->__isset.o2 = true; - } else { - xfer += iprot->skip(ftype); - } - break; - default: - xfer += iprot->skip(ftype); - break; - } - xfer += iprot->readFieldEnd(); - } - - xfer += iprot->readStructEnd(); - - return xfer; -} - -uint32_t ThriftHiveMetastore_get_resource_plan_result::write(::apache::thrift::protocol::TProtocol* oprot) const { - - uint32_t xfer = 0; - - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_resource_plan_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; -} - - -ThriftHiveMetastore_get_resource_plan_presult::~ThriftHiveMetastore_get_resource_plan_presult() throw() { +ThriftHiveMetastore_drop_resource_plan_result::~ThriftHiveMetastore_drop_resource_plan_result() throw() { } -uint32_t ThriftHiveMetastore_get_resource_plan_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_drop_resource_plan_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_resource_plan_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_resource_plan_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_resource_plan_presult::~ThriftHiveMetastore_drop_resource_plan_presult() throw() { +} + + +uint32_t ThriftHiveMetastore_drop_resource_plan_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -40432,6 +41352,14 @@ uint32_t ThriftHiveMetastore_get_resource_plan_presult::read(::apache::thrift::p 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; @@ -40445,11 +41373,11 @@ uint32_t ThriftHiveMetastore_get_resource_plan_presult::read(::apache::thrift::p } -ThriftHiveMetastore_get_all_resource_plans_args::~ThriftHiveMetastore_get_all_resource_plans_args() throw() { +ThriftHiveMetastore_create_wm_trigger_args::~ThriftHiveMetastore_create_wm_trigger_args() throw() { } -uint32_t ThriftHiveMetastore_get_all_resource_plans_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_create_wm_trigger_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -40490,10 +41418,10 @@ uint32_t ThriftHiveMetastore_get_all_resource_plans_args::read(::apache::thrift: return xfer; } -uint32_t ThriftHiveMetastore_get_all_resource_plans_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_create_wm_trigger_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_resource_plans_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_wm_trigger_args"); xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); xfer += this->request.write(oprot); @@ -40505,14 +41433,14 @@ uint32_t ThriftHiveMetastore_get_all_resource_plans_args::write(::apache::thrift } -ThriftHiveMetastore_get_all_resource_plans_pargs::~ThriftHiveMetastore_get_all_resource_plans_pargs() throw() { +ThriftHiveMetastore_create_wm_trigger_pargs::~ThriftHiveMetastore_create_wm_trigger_pargs() throw() { } -uint32_t ThriftHiveMetastore_get_all_resource_plans_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_create_wm_trigger_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_resource_plans_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_wm_trigger_pargs"); xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); xfer += (*(this->request)).write(oprot); @@ -40524,11 +41452,11 @@ uint32_t ThriftHiveMetastore_get_all_resource_plans_pargs::write(::apache::thrif } -ThriftHiveMetastore_get_all_resource_plans_result::~ThriftHiveMetastore_get_all_resource_plans_result() throw() { +ThriftHiveMetastore_create_wm_trigger_result::~ThriftHiveMetastore_create_wm_trigger_result() throw() { } -uint32_t ThriftHiveMetastore_get_all_resource_plans_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_create_wm_trigger_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -40565,6 +41493,30 @@ uint32_t ThriftHiveMetastore_get_all_resource_plans_result::read(::apache::thrif 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; @@ -40577,11 +41529,11 @@ uint32_t ThriftHiveMetastore_get_all_resource_plans_result::read(::apache::thrif return xfer; } -uint32_t ThriftHiveMetastore_get_all_resource_plans_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_create_wm_trigger_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_resource_plans_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_wm_trigger_result"); if (this->__isset.success) { xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); @@ -40591,6 +41543,18 @@ uint32_t ThriftHiveMetastore_get_all_resource_plans_result::write(::apache::thri 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(); @@ -40598,11 +41562,11 @@ uint32_t ThriftHiveMetastore_get_all_resource_plans_result::write(::apache::thri } -ThriftHiveMetastore_get_all_resource_plans_presult::~ThriftHiveMetastore_get_all_resource_plans_presult() throw() { +ThriftHiveMetastore_create_wm_trigger_presult::~ThriftHiveMetastore_create_wm_trigger_presult() throw() { } -uint32_t ThriftHiveMetastore_get_all_resource_plans_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_create_wm_trigger_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -40639,6 +41603,30 @@ uint32_t ThriftHiveMetastore_get_all_resource_plans_presult::read(::apache::thri 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; @@ -40652,11 +41640,11 @@ uint32_t ThriftHiveMetastore_get_all_resource_plans_presult::read(::apache::thri } -ThriftHiveMetastore_alter_resource_plan_args::~ThriftHiveMetastore_alter_resource_plan_args() throw() { +ThriftHiveMetastore_alter_wm_trigger_args::~ThriftHiveMetastore_alter_wm_trigger_args() throw() { } -uint32_t ThriftHiveMetastore_alter_resource_plan_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_alter_wm_trigger_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -40697,10 +41685,10 @@ uint32_t ThriftHiveMetastore_alter_resource_plan_args::read(::apache::thrift::pr return xfer; } -uint32_t ThriftHiveMetastore_alter_resource_plan_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_alter_wm_trigger_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_resource_plan_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_wm_trigger_args"); xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); xfer += this->request.write(oprot); @@ -40712,14 +41700,14 @@ uint32_t ThriftHiveMetastore_alter_resource_plan_args::write(::apache::thrift::p } -ThriftHiveMetastore_alter_resource_plan_pargs::~ThriftHiveMetastore_alter_resource_plan_pargs() throw() { +ThriftHiveMetastore_alter_wm_trigger_pargs::~ThriftHiveMetastore_alter_wm_trigger_pargs() throw() { } -uint32_t ThriftHiveMetastore_alter_resource_plan_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_alter_wm_trigger_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_resource_plan_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_wm_trigger_pargs"); xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); xfer += (*(this->request)).write(oprot); @@ -40731,11 +41719,11 @@ uint32_t ThriftHiveMetastore_alter_resource_plan_pargs::write(::apache::thrift:: } -ThriftHiveMetastore_alter_resource_plan_result::~ThriftHiveMetastore_alter_resource_plan_result() throw() { +ThriftHiveMetastore_alter_wm_trigger_result::~ThriftHiveMetastore_alter_wm_trigger_result() throw() { } -uint32_t ThriftHiveMetastore_alter_resource_plan_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_alter_wm_trigger_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -40800,11 +41788,11 @@ uint32_t ThriftHiveMetastore_alter_resource_plan_result::read(::apache::thrift:: return xfer; } -uint32_t ThriftHiveMetastore_alter_resource_plan_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_alter_wm_trigger_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_resource_plan_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_wm_trigger_result"); if (this->__isset.success) { xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); @@ -40829,11 +41817,11 @@ uint32_t ThriftHiveMetastore_alter_resource_plan_result::write(::apache::thrift: } -ThriftHiveMetastore_alter_resource_plan_presult::~ThriftHiveMetastore_alter_resource_plan_presult() throw() { +ThriftHiveMetastore_alter_wm_trigger_presult::~ThriftHiveMetastore_alter_wm_trigger_presult() throw() { } -uint32_t ThriftHiveMetastore_alter_resource_plan_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_alter_wm_trigger_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -40899,11 +41887,11 @@ uint32_t ThriftHiveMetastore_alter_resource_plan_presult::read(::apache::thrift: } -ThriftHiveMetastore_validate_resource_plan_args::~ThriftHiveMetastore_validate_resource_plan_args() throw() { +ThriftHiveMetastore_drop_wm_trigger_args::~ThriftHiveMetastore_drop_wm_trigger_args() throw() { } -uint32_t ThriftHiveMetastore_validate_resource_plan_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_drop_wm_trigger_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -40944,10 +41932,10 @@ uint32_t ThriftHiveMetastore_validate_resource_plan_args::read(::apache::thrift: return xfer; } -uint32_t ThriftHiveMetastore_validate_resource_plan_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_drop_wm_trigger_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_validate_resource_plan_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_wm_trigger_args"); xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); xfer += this->request.write(oprot); @@ -40959,14 +41947,14 @@ uint32_t ThriftHiveMetastore_validate_resource_plan_args::write(::apache::thrift } -ThriftHiveMetastore_validate_resource_plan_pargs::~ThriftHiveMetastore_validate_resource_plan_pargs() throw() { +ThriftHiveMetastore_drop_wm_trigger_pargs::~ThriftHiveMetastore_drop_wm_trigger_pargs() throw() { } -uint32_t ThriftHiveMetastore_validate_resource_plan_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_drop_wm_trigger_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_validate_resource_plan_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_wm_trigger_pargs"); xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); xfer += (*(this->request)).write(oprot); @@ -40978,11 +41966,11 @@ uint32_t ThriftHiveMetastore_validate_resource_plan_pargs::write(::apache::thrif } -ThriftHiveMetastore_validate_resource_plan_result::~ThriftHiveMetastore_validate_resource_plan_result() throw() { +ThriftHiveMetastore_drop_wm_trigger_result::~ThriftHiveMetastore_drop_wm_trigger_result() throw() { } -uint32_t ThriftHiveMetastore_validate_resource_plan_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_drop_wm_trigger_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -41027,6 +42015,14 @@ uint32_t ThriftHiveMetastore_validate_resource_plan_result::read(::apache::thrif 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; @@ -41039,11 +42035,11 @@ uint32_t ThriftHiveMetastore_validate_resource_plan_result::read(::apache::thrif return xfer; } -uint32_t ThriftHiveMetastore_validate_resource_plan_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_drop_wm_trigger_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_validate_resource_plan_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_wm_trigger_result"); if (this->__isset.success) { xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); @@ -41057,6 +42053,10 @@ uint32_t ThriftHiveMetastore_validate_resource_plan_result::write(::apache::thri 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(); @@ -41064,11 +42064,11 @@ uint32_t ThriftHiveMetastore_validate_resource_plan_result::write(::apache::thri } -ThriftHiveMetastore_validate_resource_plan_presult::~ThriftHiveMetastore_validate_resource_plan_presult() throw() { +ThriftHiveMetastore_drop_wm_trigger_presult::~ThriftHiveMetastore_drop_wm_trigger_presult() throw() { } -uint32_t ThriftHiveMetastore_validate_resource_plan_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_drop_wm_trigger_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -41113,6 +42113,14 @@ uint32_t ThriftHiveMetastore_validate_resource_plan_presult::read(::apache::thri 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; @@ -41126,11 +42134,11 @@ uint32_t ThriftHiveMetastore_validate_resource_plan_presult::read(::apache::thri } -ThriftHiveMetastore_drop_resource_plan_args::~ThriftHiveMetastore_drop_resource_plan_args() throw() { +ThriftHiveMetastore_get_triggers_for_resourceplan_args::~ThriftHiveMetastore_get_triggers_for_resourceplan_args() throw() { } -uint32_t ThriftHiveMetastore_drop_resource_plan_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_triggers_for_resourceplan_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -41171,10 +42179,10 @@ uint32_t ThriftHiveMetastore_drop_resource_plan_args::read(::apache::thrift::pro return xfer; } -uint32_t ThriftHiveMetastore_drop_resource_plan_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_triggers_for_resourceplan_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_resource_plan_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_triggers_for_resourceplan_args"); xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); xfer += this->request.write(oprot); @@ -41186,14 +42194,14 @@ uint32_t ThriftHiveMetastore_drop_resource_plan_args::write(::apache::thrift::pr } -ThriftHiveMetastore_drop_resource_plan_pargs::~ThriftHiveMetastore_drop_resource_plan_pargs() throw() { +ThriftHiveMetastore_get_triggers_for_resourceplan_pargs::~ThriftHiveMetastore_get_triggers_for_resourceplan_pargs() throw() { } -uint32_t ThriftHiveMetastore_drop_resource_plan_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_triggers_for_resourceplan_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_resource_plan_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_triggers_for_resourceplan_pargs"); xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); xfer += (*(this->request)).write(oprot); @@ -41205,11 +42213,11 @@ uint32_t ThriftHiveMetastore_drop_resource_plan_pargs::write(::apache::thrift::p } -ThriftHiveMetastore_drop_resource_plan_result::~ThriftHiveMetastore_drop_resource_plan_result() throw() { +ThriftHiveMetastore_get_triggers_for_resourceplan_result::~ThriftHiveMetastore_get_triggers_for_resourceplan_result() throw() { } -uint32_t ThriftHiveMetastore_drop_resource_plan_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_triggers_for_resourceplan_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -41254,14 +42262,6 @@ uint32_t ThriftHiveMetastore_drop_resource_plan_result::read(::apache::thrift::p 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; @@ -41274,11 +42274,11 @@ uint32_t ThriftHiveMetastore_drop_resource_plan_result::read(::apache::thrift::p return xfer; } -uint32_t ThriftHiveMetastore_drop_resource_plan_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_triggers_for_resourceplan_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_resource_plan_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_triggers_for_resourceplan_result"); if (this->__isset.success) { xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); @@ -41292,10 +42292,6 @@ uint32_t ThriftHiveMetastore_drop_resource_plan_result::write(::apache::thrift:: 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(); @@ -41303,11 +42299,11 @@ uint32_t ThriftHiveMetastore_drop_resource_plan_result::write(::apache::thrift:: } -ThriftHiveMetastore_drop_resource_plan_presult::~ThriftHiveMetastore_drop_resource_plan_presult() throw() { +ThriftHiveMetastore_get_triggers_for_resourceplan_presult::~ThriftHiveMetastore_get_triggers_for_resourceplan_presult() throw() { } -uint32_t ThriftHiveMetastore_drop_resource_plan_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_triggers_for_resourceplan_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -41352,14 +42348,6 @@ uint32_t ThriftHiveMetastore_drop_resource_plan_presult::read(::apache::thrift:: 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; @@ -52001,6 +52989,274 @@ void ThriftHiveMetastoreClient::recv_drop_resource_plan(WMDropResourcePlanRespon throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "drop_resource_plan failed: unknown result"); } +void ThriftHiveMetastoreClient::create_wm_trigger(WMCreateTriggerResponse& _return, const WMCreateTriggerRequest& request) +{ + send_create_wm_trigger(request); + recv_create_wm_trigger(_return); +} + +void ThriftHiveMetastoreClient::send_create_wm_trigger(const WMCreateTriggerRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("create_wm_trigger", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_create_wm_trigger_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_create_wm_trigger(WMCreateTriggerResponse& _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("create_wm_trigger") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_create_wm_trigger_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; + } + if (result.__isset.o3) { + throw result.o3; + } + if (result.__isset.o4) { + throw result.o4; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "create_wm_trigger failed: unknown result"); +} + +void ThriftHiveMetastoreClient::alter_wm_trigger(WMAlterTriggerResponse& _return, const WMAlterTriggerRequest& request) +{ + send_alter_wm_trigger(request); + recv_alter_wm_trigger(_return); +} + +void ThriftHiveMetastoreClient::send_alter_wm_trigger(const WMAlterTriggerRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("alter_wm_trigger", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_alter_wm_trigger_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_alter_wm_trigger(WMAlterTriggerResponse& _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("alter_wm_trigger") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_alter_wm_trigger_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; + } + if (result.__isset.o3) { + throw result.o3; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "alter_wm_trigger failed: unknown result"); +} + +void ThriftHiveMetastoreClient::drop_wm_trigger(WMDropTriggerResponse& _return, const WMDropTriggerRequest& request) +{ + send_drop_wm_trigger(request); + recv_drop_wm_trigger(_return); +} + +void ThriftHiveMetastoreClient::send_drop_wm_trigger(const WMDropTriggerRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("drop_wm_trigger", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_wm_trigger_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_drop_wm_trigger(WMDropTriggerResponse& _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("drop_wm_trigger") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_drop_wm_trigger_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; + } + if (result.__isset.o3) { + throw result.o3; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "drop_wm_trigger failed: unknown result"); +} + +void ThriftHiveMetastoreClient::get_triggers_for_resourceplan(WMGetTriggersForResourePlanResponse& _return, const WMGetTriggersForResourePlanRequest& request) +{ + send_get_triggers_for_resourceplan(request); + recv_get_triggers_for_resourceplan(_return); +} + +void ThriftHiveMetastoreClient::send_get_triggers_for_resourceplan(const WMGetTriggersForResourePlanRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_triggers_for_resourceplan", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_triggers_for_resourceplan_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_triggers_for_resourceplan(WMGetTriggersForResourePlanResponse& _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_triggers_for_resourceplan") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_triggers_for_resourceplan_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_triggers_for_resourceplan failed: unknown result"); +} + bool ThriftHiveMetastoreProcessor::dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext) { ProcessMap::iterator pfn; pfn = processMap_.find(fname); @@ -61954,6 +63210,258 @@ void ThriftHiveMetastoreProcessor::process_drop_resource_plan(int32_t seqid, ::a } } +void ThriftHiveMetastoreProcessor::process_create_wm_trigger(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = NULL; + if (this->eventHandler_.get() != NULL) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.create_wm_trigger", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.create_wm_trigger"); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.create_wm_trigger"); + } + + ThriftHiveMetastore_create_wm_trigger_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.create_wm_trigger", bytes); + } + + ThriftHiveMetastore_create_wm_trigger_result result; + try { + iface_->create_wm_trigger(result.success, args.request); + result.__isset.success = true; + } catch (AlreadyExistsException &o1) { + result.o1 = o1; + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = o2; + result.__isset.o2 = true; + } catch (InvalidObjectException &o3) { + result.o3 = o3; + result.__isset.o3 = true; + } catch (MetaException &o4) { + result.o4 = o4; + result.__isset.o4 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.create_wm_trigger"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("create_wm_trigger", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.create_wm_trigger"); + } + + oprot->writeMessageBegin("create_wm_trigger", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.create_wm_trigger", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_alter_wm_trigger(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = NULL; + if (this->eventHandler_.get() != NULL) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.alter_wm_trigger", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.alter_wm_trigger"); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.alter_wm_trigger"); + } + + ThriftHiveMetastore_alter_wm_trigger_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.alter_wm_trigger", bytes); + } + + ThriftHiveMetastore_alter_wm_trigger_result result; + try { + iface_->alter_wm_trigger(result.success, args.request); + result.__isset.success = true; + } catch (NoSuchObjectException &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 (this->eventHandler_.get() != NULL) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.alter_wm_trigger"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("alter_wm_trigger", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.alter_wm_trigger"); + } + + oprot->writeMessageBegin("alter_wm_trigger", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.alter_wm_trigger", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_drop_wm_trigger(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = NULL; + if (this->eventHandler_.get() != NULL) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.drop_wm_trigger", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.drop_wm_trigger"); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.drop_wm_trigger"); + } + + ThriftHiveMetastore_drop_wm_trigger_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.drop_wm_trigger", bytes); + } + + ThriftHiveMetastore_drop_wm_trigger_result result; + try { + iface_->drop_wm_trigger(result.success, args.request); + result.__isset.success = true; + } 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 (this->eventHandler_.get() != NULL) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.drop_wm_trigger"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("drop_wm_trigger", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.drop_wm_trigger"); + } + + oprot->writeMessageBegin("drop_wm_trigger", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.drop_wm_trigger", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_get_triggers_for_resourceplan(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = NULL; + if (this->eventHandler_.get() != NULL) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_triggers_for_resourceplan", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_triggers_for_resourceplan"); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_triggers_for_resourceplan"); + } + + ThriftHiveMetastore_get_triggers_for_resourceplan_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_triggers_for_resourceplan", bytes); + } + + ThriftHiveMetastore_get_triggers_for_resourceplan_result result; + try { + iface_->get_triggers_for_resourceplan(result.success, args.request); + 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 (const std::exception& e) { + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_triggers_for_resourceplan"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_triggers_for_resourceplan", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_triggers_for_resourceplan"); + } + + oprot->writeMessageBegin("get_triggers_for_resourceplan", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_triggers_for_resourceplan", bytes); + } +} + ::boost::shared_ptr< ::apache::thrift::TProcessor > ThriftHiveMetastoreProcessorFactory::getProcessor(const ::apache::thrift::TConnectionInfo& connInfo) { ::apache::thrift::ReleaseHandler< ThriftHiveMetastoreIfFactory > cleanup(handlerFactory_); ::boost::shared_ptr< ThriftHiveMetastoreIf > handler(handlerFactory_->getHandler(connInfo), cleanup); @@ -75119,7 +76627,265 @@ void ThriftHiveMetastoreConcurrentClient::recv_show_locks(ShowLocksResponse& _re iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("show_locks") != 0) { + if (fname.compare("show_locks") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_show_locks_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "show_locks failed: unknown result"); + } + // seqid != rseqid + this->sync_.updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_.waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::heartbeat(const HeartbeatRequest& ids) +{ + int32_t seqid = send_heartbeat(ids); + recv_heartbeat(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_heartbeat(const HeartbeatRequest& ids) +{ + int32_t cseqid = this->sync_.generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); + oprot_->writeMessageBegin("heartbeat", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_heartbeat_pargs args; + args.ids = &ids; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_heartbeat(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(&this->sync_, seqid); + + while(true) { + if(!this->sync_.getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("heartbeat") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_heartbeat_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_.updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_.waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::heartbeat_txn_range(HeartbeatTxnRangeResponse& _return, const HeartbeatTxnRangeRequest& txns) +{ + int32_t seqid = send_heartbeat_txn_range(txns); + recv_heartbeat_txn_range(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_heartbeat_txn_range(const HeartbeatTxnRangeRequest& txns) +{ + int32_t cseqid = this->sync_.generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); + oprot_->writeMessageBegin("heartbeat_txn_range", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_heartbeat_txn_range_pargs args; + args.txns = &txns; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_heartbeat_txn_range(HeartbeatTxnRangeResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(&this->sync_, seqid); + + while(true) { + if(!this->sync_.getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("heartbeat_txn_range") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_heartbeat_txn_range_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "heartbeat_txn_range failed: unknown result"); + } + // seqid != rseqid + this->sync_.updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_.waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::compact(const CompactionRequest& rqst) +{ + int32_t seqid = send_compact(rqst); + recv_compact(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_compact(const CompactionRequest& rqst) +{ + int32_t cseqid = this->sync_.generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); + oprot_->writeMessageBegin("compact", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_compact_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_compact(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(&this->sync_, seqid); + + while(true) { + if(!this->sync_.getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("compact") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -75128,19 +76894,13 @@ void ThriftHiveMetastoreConcurrentClient::recv_show_locks(ShowLocksResponse& _re using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_show_locks_presult result; - result.success = &_return; + ThriftHiveMetastore_compact_presult result; result.read(iprot_); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); - if (result.__isset.success) { - // _return pointer has now been filled - sentry.commit(); - return; - } - // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "show_locks failed: unknown result"); + sentry.commit(); + return; } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -75150,20 +76910,20 @@ void ThriftHiveMetastoreConcurrentClient::recv_show_locks(ShowLocksResponse& _re } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::heartbeat(const HeartbeatRequest& ids) +void ThriftHiveMetastoreConcurrentClient::compact2(CompactionResponse& _return, const CompactionRequest& rqst) { - int32_t seqid = send_heartbeat(ids); - recv_heartbeat(seqid); + int32_t seqid = send_compact2(rqst); + recv_compact2(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_heartbeat(const HeartbeatRequest& ids) +int32_t ThriftHiveMetastoreConcurrentClient::send_compact2(const CompactionRequest& rqst) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("heartbeat", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("compact2", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_heartbeat_pargs args; - args.ids = &ids; + ThriftHiveMetastore_compact2_pargs args; + args.rqst = &rqst; args.write(oprot_); oprot_->writeMessageEnd(); @@ -75174,7 +76934,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_heartbeat(const HeartbeatReque return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_heartbeat(const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_compact2(CompactionResponse& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -75203,7 +76963,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_heartbeat(const int32_t seqid) iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("heartbeat") != 0) { + if (fname.compare("compact2") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -75212,25 +76972,19 @@ void ThriftHiveMetastoreConcurrentClient::recv_heartbeat(const int32_t seqid) using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_heartbeat_presult result; + ThriftHiveMetastore_compact2_presult result; + result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); - if (result.__isset.o1) { - sentry.commit(); - throw result.o1; - } - if (result.__isset.o2) { - sentry.commit(); - throw result.o2; - } - if (result.__isset.o3) { + if (result.__isset.success) { + // _return pointer has now been filled sentry.commit(); - throw result.o3; + return; } - sentry.commit(); - return; + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "compact2 failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -75240,20 +76994,20 @@ void ThriftHiveMetastoreConcurrentClient::recv_heartbeat(const int32_t seqid) } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::heartbeat_txn_range(HeartbeatTxnRangeResponse& _return, const HeartbeatTxnRangeRequest& txns) +void ThriftHiveMetastoreConcurrentClient::show_compact(ShowCompactResponse& _return, const ShowCompactRequest& rqst) { - int32_t seqid = send_heartbeat_txn_range(txns); - recv_heartbeat_txn_range(_return, seqid); + int32_t seqid = send_show_compact(rqst); + recv_show_compact(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_heartbeat_txn_range(const HeartbeatTxnRangeRequest& txns) +int32_t ThriftHiveMetastoreConcurrentClient::send_show_compact(const ShowCompactRequest& rqst) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("heartbeat_txn_range", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("show_compact", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_heartbeat_txn_range_pargs args; - args.txns = &txns; + ThriftHiveMetastore_show_compact_pargs args; + args.rqst = &rqst; args.write(oprot_); oprot_->writeMessageEnd(); @@ -75264,7 +77018,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_heartbeat_txn_range(const Hear return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_heartbeat_txn_range(HeartbeatTxnRangeResponse& _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_show_compact(ShowCompactResponse& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -75293,7 +77047,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_heartbeat_txn_range(HeartbeatTxnR iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("heartbeat_txn_range") != 0) { + if (fname.compare("show_compact") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -75302,7 +77056,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_heartbeat_txn_range(HeartbeatTxnR using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_heartbeat_txn_range_presult result; + ThriftHiveMetastore_show_compact_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -75314,7 +77068,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_heartbeat_txn_range(HeartbeatTxnR return; } // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "heartbeat_txn_range failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "show_compact failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -75324,19 +77078,19 @@ void ThriftHiveMetastoreConcurrentClient::recv_heartbeat_txn_range(HeartbeatTxnR } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::compact(const CompactionRequest& rqst) +void ThriftHiveMetastoreConcurrentClient::add_dynamic_partitions(const AddDynamicPartitions& rqst) { - int32_t seqid = send_compact(rqst); - recv_compact(seqid); + int32_t seqid = send_add_dynamic_partitions(rqst); + recv_add_dynamic_partitions(seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_compact(const CompactionRequest& rqst) +int32_t ThriftHiveMetastoreConcurrentClient::send_add_dynamic_partitions(const AddDynamicPartitions& rqst) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("compact", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("add_dynamic_partitions", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_compact_pargs args; + ThriftHiveMetastore_add_dynamic_partitions_pargs args; args.rqst = &rqst; args.write(oprot_); @@ -75348,7 +77102,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_compact(const CompactionReques return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_compact(const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_add_dynamic_partitions(const int32_t seqid) { int32_t rseqid = 0; @@ -75377,7 +77131,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_compact(const int32_t seqid) iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("compact") != 0) { + if (fname.compare("add_dynamic_partitions") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -75386,11 +77140,19 @@ void ThriftHiveMetastoreConcurrentClient::recv_compact(const int32_t seqid) using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_compact_presult result; + ThriftHiveMetastore_add_dynamic_partitions_presult result; result.read(iprot_); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } sentry.commit(); return; } @@ -75402,19 +77164,19 @@ void ThriftHiveMetastoreConcurrentClient::recv_compact(const int32_t seqid) } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::compact2(CompactionResponse& _return, const CompactionRequest& rqst) +void ThriftHiveMetastoreConcurrentClient::get_next_notification(NotificationEventResponse& _return, const NotificationEventRequest& rqst) { - int32_t seqid = send_compact2(rqst); - recv_compact2(_return, seqid); + int32_t seqid = send_get_next_notification(rqst); + recv_get_next_notification(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_compact2(const CompactionRequest& rqst) +int32_t ThriftHiveMetastoreConcurrentClient::send_get_next_notification(const NotificationEventRequest& rqst) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("compact2", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("get_next_notification", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_compact2_pargs args; + ThriftHiveMetastore_get_next_notification_pargs args; args.rqst = &rqst; args.write(oprot_); @@ -75426,7 +77188,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_compact2(const CompactionReque return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_compact2(CompactionResponse& _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_get_next_notification(NotificationEventResponse& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -75455,7 +77217,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_compact2(CompactionResponse& _ret iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("compact2") != 0) { + if (fname.compare("get_next_notification") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -75464,7 +77226,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_compact2(CompactionResponse& _ret using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_compact2_presult result; + ThriftHiveMetastore_get_next_notification_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -75476,7 +77238,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_compact2(CompactionResponse& _ret return; } // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "compact2 failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_next_notification failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -75486,20 +77248,19 @@ void ThriftHiveMetastoreConcurrentClient::recv_compact2(CompactionResponse& _ret } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::show_compact(ShowCompactResponse& _return, const ShowCompactRequest& rqst) +void ThriftHiveMetastoreConcurrentClient::get_current_notificationEventId(CurrentNotificationEventId& _return) { - int32_t seqid = send_show_compact(rqst); - recv_show_compact(_return, seqid); + int32_t seqid = send_get_current_notificationEventId(); + recv_get_current_notificationEventId(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_show_compact(const ShowCompactRequest& rqst) +int32_t ThriftHiveMetastoreConcurrentClient::send_get_current_notificationEventId() { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("show_compact", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("get_current_notificationEventId", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_show_compact_pargs args; - args.rqst = &rqst; + ThriftHiveMetastore_get_current_notificationEventId_pargs args; args.write(oprot_); oprot_->writeMessageEnd(); @@ -75510,7 +77271,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_show_compact(const ShowCompact return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_show_compact(ShowCompactResponse& _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_get_current_notificationEventId(CurrentNotificationEventId& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -75539,7 +77300,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_show_compact(ShowCompactResponse& iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("show_compact") != 0) { + if (fname.compare("get_current_notificationEventId") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -75548,7 +77309,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_show_compact(ShowCompactResponse& using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_show_compact_presult result; + ThriftHiveMetastore_get_current_notificationEventId_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -75560,7 +77321,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_show_compact(ShowCompactResponse& return; } // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "show_compact failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_current_notificationEventId failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -75570,19 +77331,19 @@ void ThriftHiveMetastoreConcurrentClient::recv_show_compact(ShowCompactResponse& } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::add_dynamic_partitions(const AddDynamicPartitions& rqst) +void ThriftHiveMetastoreConcurrentClient::get_notification_events_count(NotificationEventsCountResponse& _return, const NotificationEventsCountRequest& rqst) { - int32_t seqid = send_add_dynamic_partitions(rqst); - recv_add_dynamic_partitions(seqid); + int32_t seqid = send_get_notification_events_count(rqst); + recv_get_notification_events_count(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_add_dynamic_partitions(const AddDynamicPartitions& rqst) +int32_t ThriftHiveMetastoreConcurrentClient::send_get_notification_events_count(const NotificationEventsCountRequest& rqst) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("add_dynamic_partitions", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("get_notification_events_count", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_add_dynamic_partitions_pargs args; + ThriftHiveMetastore_get_notification_events_count_pargs args; args.rqst = &rqst; args.write(oprot_); @@ -75594,7 +77355,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_add_dynamic_partitions(const A return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_add_dynamic_partitions(const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_get_notification_events_count(NotificationEventsCountResponse& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -75623,7 +77384,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_add_dynamic_partitions(const int3 iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("add_dynamic_partitions") != 0) { + if (fname.compare("get_notification_events_count") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -75632,21 +77393,103 @@ void ThriftHiveMetastoreConcurrentClient::recv_add_dynamic_partitions(const int3 using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_add_dynamic_partitions_presult result; + ThriftHiveMetastore_get_notification_events_count_presult result; + result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); - if (result.__isset.o1) { + if (result.__isset.success) { + // _return pointer has now been filled sentry.commit(); - throw result.o1; + return; } - if (result.__isset.o2) { + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_notification_events_count failed: unknown result"); + } + // seqid != rseqid + this->sync_.updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_.waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::fire_listener_event(FireEventResponse& _return, const FireEventRequest& rqst) +{ + int32_t seqid = send_fire_listener_event(rqst); + recv_fire_listener_event(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_fire_listener_event(const FireEventRequest& rqst) +{ + int32_t cseqid = this->sync_.generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); + oprot_->writeMessageBegin("fire_listener_event", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_fire_listener_event_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_fire_listener_event(FireEventResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(&this->sync_, seqid); + + while(true) { + if(!this->sync_.getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); sentry.commit(); - throw result.o2; + throw x; } - sentry.commit(); - return; + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("fire_listener_event") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_fire_listener_event_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "fire_listener_event failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -75656,20 +77499,19 @@ void ThriftHiveMetastoreConcurrentClient::recv_add_dynamic_partitions(const int3 } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::get_next_notification(NotificationEventResponse& _return, const NotificationEventRequest& rqst) +void ThriftHiveMetastoreConcurrentClient::flushCache() { - int32_t seqid = send_get_next_notification(rqst); - recv_get_next_notification(_return, seqid); + int32_t seqid = send_flushCache(); + recv_flushCache(seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_get_next_notification(const NotificationEventRequest& rqst) +int32_t ThriftHiveMetastoreConcurrentClient::send_flushCache() { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("get_next_notification", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("flushCache", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_get_next_notification_pargs args; - args.rqst = &rqst; + ThriftHiveMetastore_flushCache_pargs args; args.write(oprot_); oprot_->writeMessageEnd(); @@ -75680,7 +77522,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_get_next_notification(const No return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_get_next_notification(NotificationEventResponse& _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_flushCache(const int32_t seqid) { int32_t rseqid = 0; @@ -75709,7 +77551,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_next_notification(Notificatio iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("get_next_notification") != 0) { + if (fname.compare("flushCache") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -75718,19 +77560,13 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_next_notification(Notificatio using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_get_next_notification_presult result; - result.success = &_return; + ThriftHiveMetastore_flushCache_presult result; result.read(iprot_); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); - if (result.__isset.success) { - // _return pointer has now been filled - sentry.commit(); - return; - } - // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_next_notification failed: unknown result"); + sentry.commit(); + return; } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -75740,19 +77576,20 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_next_notification(Notificatio } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::get_current_notificationEventId(CurrentNotificationEventId& _return) +void ThriftHiveMetastoreConcurrentClient::cm_recycle(CmRecycleResponse& _return, const CmRecycleRequest& request) { - int32_t seqid = send_get_current_notificationEventId(); - recv_get_current_notificationEventId(_return, seqid); + int32_t seqid = send_cm_recycle(request); + recv_cm_recycle(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_get_current_notificationEventId() +int32_t ThriftHiveMetastoreConcurrentClient::send_cm_recycle(const CmRecycleRequest& request) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("get_current_notificationEventId", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("cm_recycle", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_get_current_notificationEventId_pargs args; + ThriftHiveMetastore_cm_recycle_pargs args; + args.request = &request; args.write(oprot_); oprot_->writeMessageEnd(); @@ -75763,7 +77600,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_get_current_notificationEventI return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_get_current_notificationEventId(CurrentNotificationEventId& _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_cm_recycle(CmRecycleResponse& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -75792,7 +77629,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_current_notificationEventId(C iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("get_current_notificationEventId") != 0) { + if (fname.compare("cm_recycle") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -75801,7 +77638,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_current_notificationEventId(C using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_get_current_notificationEventId_presult result; + ThriftHiveMetastore_cm_recycle_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -75812,8 +77649,12 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_current_notificationEventId(C sentry.commit(); return; } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_current_notificationEventId failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "cm_recycle failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -75823,20 +77664,20 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_current_notificationEventId(C } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::get_notification_events_count(NotificationEventsCountResponse& _return, const NotificationEventsCountRequest& rqst) +void ThriftHiveMetastoreConcurrentClient::get_file_metadata_by_expr(GetFileMetadataByExprResult& _return, const GetFileMetadataByExprRequest& req) { - int32_t seqid = send_get_notification_events_count(rqst); - recv_get_notification_events_count(_return, seqid); + int32_t seqid = send_get_file_metadata_by_expr(req); + recv_get_file_metadata_by_expr(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_get_notification_events_count(const NotificationEventsCountRequest& rqst) +int32_t ThriftHiveMetastoreConcurrentClient::send_get_file_metadata_by_expr(const GetFileMetadataByExprRequest& req) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("get_notification_events_count", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("get_file_metadata_by_expr", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_get_notification_events_count_pargs args; - args.rqst = &rqst; + ThriftHiveMetastore_get_file_metadata_by_expr_pargs args; + args.req = &req; args.write(oprot_); oprot_->writeMessageEnd(); @@ -75847,7 +77688,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_get_notification_events_count( return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_get_notification_events_count(NotificationEventsCountResponse& _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_get_file_metadata_by_expr(GetFileMetadataByExprResult& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -75876,7 +77717,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_notification_events_count(Not iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("get_notification_events_count") != 0) { + if (fname.compare("get_file_metadata_by_expr") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -75885,7 +77726,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_notification_events_count(Not using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_get_notification_events_count_presult result; + ThriftHiveMetastore_get_file_metadata_by_expr_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -75897,7 +77738,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_notification_events_count(Not return; } // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_notification_events_count failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_file_metadata_by_expr failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -75907,20 +77748,20 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_notification_events_count(Not } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::fire_listener_event(FireEventResponse& _return, const FireEventRequest& rqst) +void ThriftHiveMetastoreConcurrentClient::get_file_metadata(GetFileMetadataResult& _return, const GetFileMetadataRequest& req) { - int32_t seqid = send_fire_listener_event(rqst); - recv_fire_listener_event(_return, seqid); + int32_t seqid = send_get_file_metadata(req); + recv_get_file_metadata(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_fire_listener_event(const FireEventRequest& rqst) +int32_t ThriftHiveMetastoreConcurrentClient::send_get_file_metadata(const GetFileMetadataRequest& req) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("fire_listener_event", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("get_file_metadata", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_fire_listener_event_pargs args; - args.rqst = &rqst; + ThriftHiveMetastore_get_file_metadata_pargs args; + args.req = &req; args.write(oprot_); oprot_->writeMessageEnd(); @@ -75931,7 +77772,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_fire_listener_event(const Fire return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_fire_listener_event(FireEventResponse& _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_get_file_metadata(GetFileMetadataResult& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -75960,7 +77801,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_fire_listener_event(FireEventResp iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("fire_listener_event") != 0) { + if (fname.compare("get_file_metadata") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -75969,7 +77810,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_fire_listener_event(FireEventResp using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_fire_listener_event_presult result; + ThriftHiveMetastore_get_file_metadata_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -75981,84 +77822,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_fire_listener_event(FireEventResp return; } // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "fire_listener_event failed: unknown result"); - } - // seqid != rseqid - this->sync_.updatePending(fname, mtype, rseqid); - - // this will temporarily unlock the readMutex, and let other clients get work done - this->sync_.waitForWork(seqid); - } // end while(true) -} - -void ThriftHiveMetastoreConcurrentClient::flushCache() -{ - int32_t seqid = send_flushCache(); - recv_flushCache(seqid); -} - -int32_t ThriftHiveMetastoreConcurrentClient::send_flushCache() -{ - int32_t cseqid = this->sync_.generateSeqId(); - ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("flushCache", ::apache::thrift::protocol::T_CALL, cseqid); - - ThriftHiveMetastore_flushCache_pargs args; - args.write(oprot_); - - oprot_->writeMessageEnd(); - oprot_->getTransport()->writeEnd(); - oprot_->getTransport()->flush(); - - sentry.commit(); - return cseqid; -} - -void ThriftHiveMetastoreConcurrentClient::recv_flushCache(const int32_t seqid) -{ - - int32_t rseqid = 0; - std::string fname; - ::apache::thrift::protocol::TMessageType mtype; - - // the read mutex gets dropped and reacquired as part of waitForWork() - // The destructor of this sentry wakes up other clients - ::apache::thrift::async::TConcurrentRecvSentry sentry(&this->sync_, seqid); - - while(true) { - if(!this->sync_.getPending(fname, mtype, rseqid)) { - iprot_->readMessageBegin(fname, mtype, rseqid); - } - if(seqid == rseqid) { - if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { - ::apache::thrift::TApplicationException x; - x.read(iprot_); - iprot_->readMessageEnd(); - iprot_->getTransport()->readEnd(); - sentry.commit(); - throw x; - } - if (mtype != ::apache::thrift::protocol::T_REPLY) { - iprot_->skip(::apache::thrift::protocol::T_STRUCT); - iprot_->readMessageEnd(); - iprot_->getTransport()->readEnd(); - } - if (fname.compare("flushCache") != 0) { - iprot_->skip(::apache::thrift::protocol::T_STRUCT); - iprot_->readMessageEnd(); - iprot_->getTransport()->readEnd(); - - // in a bad state, don't commit - using ::apache::thrift::protocol::TProtocolException; - throw TProtocolException(TProtocolException::INVALID_DATA); - } - ThriftHiveMetastore_flushCache_presult result; - result.read(iprot_); - iprot_->readMessageEnd(); - iprot_->getTransport()->readEnd(); - - sentry.commit(); - return; + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_file_metadata failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -76068,20 +77832,20 @@ void ThriftHiveMetastoreConcurrentClient::recv_flushCache(const int32_t seqid) } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::cm_recycle(CmRecycleResponse& _return, const CmRecycleRequest& request) +void ThriftHiveMetastoreConcurrentClient::put_file_metadata(PutFileMetadataResult& _return, const PutFileMetadataRequest& req) { - int32_t seqid = send_cm_recycle(request); - recv_cm_recycle(_return, seqid); + int32_t seqid = send_put_file_metadata(req); + recv_put_file_metadata(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_cm_recycle(const CmRecycleRequest& request) +int32_t ThriftHiveMetastoreConcurrentClient::send_put_file_metadata(const PutFileMetadataRequest& req) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("cm_recycle", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("put_file_metadata", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_cm_recycle_pargs args; - args.request = &request; + ThriftHiveMetastore_put_file_metadata_pargs args; + args.req = &req; args.write(oprot_); oprot_->writeMessageEnd(); @@ -76092,7 +77856,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_cm_recycle(const CmRecycleRequ return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_cm_recycle(CmRecycleResponse& _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_put_file_metadata(PutFileMetadataResult& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -76121,7 +77885,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_cm_recycle(CmRecycleResponse& _re iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("cm_recycle") != 0) { + if (fname.compare("put_file_metadata") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -76130,7 +77894,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_cm_recycle(CmRecycleResponse& _re using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_cm_recycle_presult result; + ThriftHiveMetastore_put_file_metadata_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -76141,12 +77905,8 @@ void ThriftHiveMetastoreConcurrentClient::recv_cm_recycle(CmRecycleResponse& _re sentry.commit(); return; } - if (result.__isset.o1) { - sentry.commit(); - throw result.o1; - } // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "cm_recycle failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "put_file_metadata failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -76156,19 +77916,19 @@ void ThriftHiveMetastoreConcurrentClient::recv_cm_recycle(CmRecycleResponse& _re } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::get_file_metadata_by_expr(GetFileMetadataByExprResult& _return, const GetFileMetadataByExprRequest& req) +void ThriftHiveMetastoreConcurrentClient::clear_file_metadata(ClearFileMetadataResult& _return, const ClearFileMetadataRequest& req) { - int32_t seqid = send_get_file_metadata_by_expr(req); - recv_get_file_metadata_by_expr(_return, seqid); + int32_t seqid = send_clear_file_metadata(req); + recv_clear_file_metadata(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_get_file_metadata_by_expr(const GetFileMetadataByExprRequest& req) +int32_t ThriftHiveMetastoreConcurrentClient::send_clear_file_metadata(const ClearFileMetadataRequest& req) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("get_file_metadata_by_expr", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("clear_file_metadata", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_get_file_metadata_by_expr_pargs args; + ThriftHiveMetastore_clear_file_metadata_pargs args; args.req = &req; args.write(oprot_); @@ -76180,7 +77940,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_get_file_metadata_by_expr(cons return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_get_file_metadata_by_expr(GetFileMetadataByExprResult& _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_clear_file_metadata(ClearFileMetadataResult& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -76209,7 +77969,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_file_metadata_by_expr(GetFile iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("get_file_metadata_by_expr") != 0) { + if (fname.compare("clear_file_metadata") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -76218,7 +77978,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_file_metadata_by_expr(GetFile using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_get_file_metadata_by_expr_presult result; + ThriftHiveMetastore_clear_file_metadata_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -76230,7 +77990,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_file_metadata_by_expr(GetFile return; } // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_file_metadata_by_expr failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "clear_file_metadata failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -76240,19 +78000,19 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_file_metadata_by_expr(GetFile } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::get_file_metadata(GetFileMetadataResult& _return, const GetFileMetadataRequest& req) +void ThriftHiveMetastoreConcurrentClient::cache_file_metadata(CacheFileMetadataResult& _return, const CacheFileMetadataRequest& req) { - int32_t seqid = send_get_file_metadata(req); - recv_get_file_metadata(_return, seqid); + int32_t seqid = send_cache_file_metadata(req); + recv_cache_file_metadata(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_get_file_metadata(const GetFileMetadataRequest& req) +int32_t ThriftHiveMetastoreConcurrentClient::send_cache_file_metadata(const CacheFileMetadataRequest& req) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("get_file_metadata", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("cache_file_metadata", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_get_file_metadata_pargs args; + ThriftHiveMetastore_cache_file_metadata_pargs args; args.req = &req; args.write(oprot_); @@ -76264,7 +78024,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_get_file_metadata(const GetFil return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_get_file_metadata(GetFileMetadataResult& _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_cache_file_metadata(CacheFileMetadataResult& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -76293,7 +78053,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_file_metadata(GetFileMetadata iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("get_file_metadata") != 0) { + if (fname.compare("cache_file_metadata") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -76302,7 +78062,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_file_metadata(GetFileMetadata using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_get_file_metadata_presult result; + ThriftHiveMetastore_cache_file_metadata_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -76314,7 +78074,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_file_metadata(GetFileMetadata return; } // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_file_metadata failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "cache_file_metadata failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -76324,20 +78084,19 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_file_metadata(GetFileMetadata } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::put_file_metadata(PutFileMetadataResult& _return, const PutFileMetadataRequest& req) +void ThriftHiveMetastoreConcurrentClient::get_metastore_db_uuid(std::string& _return) { - int32_t seqid = send_put_file_metadata(req); - recv_put_file_metadata(_return, seqid); + int32_t seqid = send_get_metastore_db_uuid(); + recv_get_metastore_db_uuid(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_put_file_metadata(const PutFileMetadataRequest& req) +int32_t ThriftHiveMetastoreConcurrentClient::send_get_metastore_db_uuid() { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("put_file_metadata", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("get_metastore_db_uuid", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_put_file_metadata_pargs args; - args.req = &req; + ThriftHiveMetastore_get_metastore_db_uuid_pargs args; args.write(oprot_); oprot_->writeMessageEnd(); @@ -76348,7 +78107,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_put_file_metadata(const PutFil return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_put_file_metadata(PutFileMetadataResult& _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_get_metastore_db_uuid(std::string& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -76377,7 +78136,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_put_file_metadata(PutFileMetadata iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("put_file_metadata") != 0) { + if (fname.compare("get_metastore_db_uuid") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -76386,7 +78145,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_put_file_metadata(PutFileMetadata using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_put_file_metadata_presult result; + ThriftHiveMetastore_get_metastore_db_uuid_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -76397,8 +78156,12 @@ void ThriftHiveMetastoreConcurrentClient::recv_put_file_metadata(PutFileMetadata sentry.commit(); return; } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "put_file_metadata failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_metastore_db_uuid failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -76408,20 +78171,20 @@ void ThriftHiveMetastoreConcurrentClient::recv_put_file_metadata(PutFileMetadata } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::clear_file_metadata(ClearFileMetadataResult& _return, const ClearFileMetadataRequest& req) +void ThriftHiveMetastoreConcurrentClient::create_resource_plan(WMCreateResourcePlanResponse& _return, const WMCreateResourcePlanRequest& request) { - int32_t seqid = send_clear_file_metadata(req); - recv_clear_file_metadata(_return, seqid); + int32_t seqid = send_create_resource_plan(request); + recv_create_resource_plan(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_clear_file_metadata(const ClearFileMetadataRequest& req) +int32_t ThriftHiveMetastoreConcurrentClient::send_create_resource_plan(const WMCreateResourcePlanRequest& request) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("clear_file_metadata", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("create_resource_plan", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_clear_file_metadata_pargs args; - args.req = &req; + ThriftHiveMetastore_create_resource_plan_pargs args; + args.request = &request; args.write(oprot_); oprot_->writeMessageEnd(); @@ -76432,7 +78195,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_clear_file_metadata(const Clea return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_clear_file_metadata(ClearFileMetadataResult& _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_create_resource_plan(WMCreateResourcePlanResponse& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -76461,7 +78224,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_clear_file_metadata(ClearFileMeta iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("clear_file_metadata") != 0) { + if (fname.compare("create_resource_plan") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -76470,7 +78233,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_clear_file_metadata(ClearFileMeta using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_clear_file_metadata_presult result; + ThriftHiveMetastore_create_resource_plan_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -76481,8 +78244,20 @@ void ThriftHiveMetastoreConcurrentClient::recv_clear_file_metadata(ClearFileMeta sentry.commit(); return; } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "clear_file_metadata failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "create_resource_plan failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -76492,20 +78267,20 @@ void ThriftHiveMetastoreConcurrentClient::recv_clear_file_metadata(ClearFileMeta } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::cache_file_metadata(CacheFileMetadataResult& _return, const CacheFileMetadataRequest& req) +void ThriftHiveMetastoreConcurrentClient::get_resource_plan(WMGetResourcePlanResponse& _return, const WMGetResourcePlanRequest& request) { - int32_t seqid = send_cache_file_metadata(req); - recv_cache_file_metadata(_return, seqid); + int32_t seqid = send_get_resource_plan(request); + recv_get_resource_plan(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_cache_file_metadata(const CacheFileMetadataRequest& req) +int32_t ThriftHiveMetastoreConcurrentClient::send_get_resource_plan(const WMGetResourcePlanRequest& request) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("cache_file_metadata", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("get_resource_plan", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_cache_file_metadata_pargs args; - args.req = &req; + ThriftHiveMetastore_get_resource_plan_pargs args; + args.request = &request; args.write(oprot_); oprot_->writeMessageEnd(); @@ -76516,7 +78291,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_cache_file_metadata(const Cach return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_cache_file_metadata(CacheFileMetadataResult& _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_get_resource_plan(WMGetResourcePlanResponse& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -76545,7 +78320,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_cache_file_metadata(CacheFileMeta iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("cache_file_metadata") != 0) { + if (fname.compare("get_resource_plan") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -76554,7 +78329,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_cache_file_metadata(CacheFileMeta using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_cache_file_metadata_presult result; + ThriftHiveMetastore_get_resource_plan_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -76565,8 +78340,16 @@ void ThriftHiveMetastoreConcurrentClient::recv_cache_file_metadata(CacheFileMeta sentry.commit(); return; } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "cache_file_metadata failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_resource_plan failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -76576,19 +78359,20 @@ void ThriftHiveMetastoreConcurrentClient::recv_cache_file_metadata(CacheFileMeta } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::get_metastore_db_uuid(std::string& _return) +void ThriftHiveMetastoreConcurrentClient::get_all_resource_plans(WMGetAllResourcePlanResponse& _return, const WMGetAllResourcePlanRequest& request) { - int32_t seqid = send_get_metastore_db_uuid(); - recv_get_metastore_db_uuid(_return, seqid); + int32_t seqid = send_get_all_resource_plans(request); + recv_get_all_resource_plans(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_get_metastore_db_uuid() +int32_t ThriftHiveMetastoreConcurrentClient::send_get_all_resource_plans(const WMGetAllResourcePlanRequest& request) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("get_metastore_db_uuid", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("get_all_resource_plans", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_get_metastore_db_uuid_pargs args; + ThriftHiveMetastore_get_all_resource_plans_pargs args; + args.request = &request; args.write(oprot_); oprot_->writeMessageEnd(); @@ -76599,7 +78383,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_get_metastore_db_uuid() return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_get_metastore_db_uuid(std::string& _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_get_all_resource_plans(WMGetAllResourcePlanResponse& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -76628,7 +78412,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_metastore_db_uuid(std::string iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("get_metastore_db_uuid") != 0) { + if (fname.compare("get_all_resource_plans") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -76637,7 +78421,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_metastore_db_uuid(std::string using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_get_metastore_db_uuid_presult result; + ThriftHiveMetastore_get_all_resource_plans_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -76653,7 +78437,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_metastore_db_uuid(std::string throw result.o1; } // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_metastore_db_uuid failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_all_resource_plans failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -76663,19 +78447,19 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_metastore_db_uuid(std::string } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::create_resource_plan(WMCreateResourcePlanResponse& _return, const WMCreateResourcePlanRequest& request) +void ThriftHiveMetastoreConcurrentClient::alter_resource_plan(WMAlterResourcePlanResponse& _return, const WMAlterResourcePlanRequest& request) { - int32_t seqid = send_create_resource_plan(request); - recv_create_resource_plan(_return, seqid); + int32_t seqid = send_alter_resource_plan(request); + recv_alter_resource_plan(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_create_resource_plan(const WMCreateResourcePlanRequest& request) +int32_t ThriftHiveMetastoreConcurrentClient::send_alter_resource_plan(const WMAlterResourcePlanRequest& request) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("create_resource_plan", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("alter_resource_plan", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_create_resource_plan_pargs args; + ThriftHiveMetastore_alter_resource_plan_pargs args; args.request = &request; args.write(oprot_); @@ -76687,7 +78471,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_create_resource_plan(const WMC return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_create_resource_plan(WMCreateResourcePlanResponse& _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_alter_resource_plan(WMAlterResourcePlanResponse& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -76716,7 +78500,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_create_resource_plan(WMCreateReso iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("create_resource_plan") != 0) { + if (fname.compare("alter_resource_plan") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -76725,7 +78509,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_create_resource_plan(WMCreateReso using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_create_resource_plan_presult result; + ThriftHiveMetastore_alter_resource_plan_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -76749,7 +78533,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_create_resource_plan(WMCreateReso throw result.o3; } // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "create_resource_plan failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "alter_resource_plan failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -76759,19 +78543,19 @@ void ThriftHiveMetastoreConcurrentClient::recv_create_resource_plan(WMCreateReso } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::get_resource_plan(WMGetResourcePlanResponse& _return, const WMGetResourcePlanRequest& request) +void ThriftHiveMetastoreConcurrentClient::validate_resource_plan(WMValidateResourcePlanResponse& _return, const WMValidateResourcePlanRequest& request) { - int32_t seqid = send_get_resource_plan(request); - recv_get_resource_plan(_return, seqid); + int32_t seqid = send_validate_resource_plan(request); + recv_validate_resource_plan(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_get_resource_plan(const WMGetResourcePlanRequest& request) +int32_t ThriftHiveMetastoreConcurrentClient::send_validate_resource_plan(const WMValidateResourcePlanRequest& request) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("get_resource_plan", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("validate_resource_plan", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_get_resource_plan_pargs args; + ThriftHiveMetastore_validate_resource_plan_pargs args; args.request = &request; args.write(oprot_); @@ -76783,7 +78567,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_get_resource_plan(const WMGetR return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_get_resource_plan(WMGetResourcePlanResponse& _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_validate_resource_plan(WMValidateResourcePlanResponse& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -76812,7 +78596,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_resource_plan(WMGetResourcePl iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("get_resource_plan") != 0) { + if (fname.compare("validate_resource_plan") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -76821,7 +78605,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_resource_plan(WMGetResourcePl using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_get_resource_plan_presult result; + ThriftHiveMetastore_validate_resource_plan_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -76841,7 +78625,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_resource_plan(WMGetResourcePl throw result.o2; } // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_resource_plan failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "validate_resource_plan failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -76851,19 +78635,19 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_resource_plan(WMGetResourcePl } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::get_all_resource_plans(WMGetAllResourcePlanResponse& _return, const WMGetAllResourcePlanRequest& request) +void ThriftHiveMetastoreConcurrentClient::drop_resource_plan(WMDropResourcePlanResponse& _return, const WMDropResourcePlanRequest& request) { - int32_t seqid = send_get_all_resource_plans(request); - recv_get_all_resource_plans(_return, seqid); + int32_t seqid = send_drop_resource_plan(request); + recv_drop_resource_plan(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_get_all_resource_plans(const WMGetAllResourcePlanRequest& request) +int32_t ThriftHiveMetastoreConcurrentClient::send_drop_resource_plan(const WMDropResourcePlanRequest& request) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("get_all_resource_plans", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("drop_resource_plan", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_get_all_resource_plans_pargs args; + ThriftHiveMetastore_drop_resource_plan_pargs args; args.request = &request; args.write(oprot_); @@ -76875,7 +78659,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_get_all_resource_plans(const W return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_get_all_resource_plans(WMGetAllResourcePlanResponse& _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_drop_resource_plan(WMDropResourcePlanResponse& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -76904,7 +78688,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_all_resource_plans(WMGetAllRe iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("get_all_resource_plans") != 0) { + if (fname.compare("drop_resource_plan") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -76913,7 +78697,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_all_resource_plans(WMGetAllRe using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_get_all_resource_plans_presult result; + ThriftHiveMetastore_drop_resource_plan_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -76928,8 +78712,16 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_all_resource_plans(WMGetAllRe sentry.commit(); throw result.o1; } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_all_resource_plans failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "drop_resource_plan failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -76939,19 +78731,19 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_all_resource_plans(WMGetAllRe } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::alter_resource_plan(WMAlterResourcePlanResponse& _return, const WMAlterResourcePlanRequest& request) +void ThriftHiveMetastoreConcurrentClient::create_wm_trigger(WMCreateTriggerResponse& _return, const WMCreateTriggerRequest& request) { - int32_t seqid = send_alter_resource_plan(request); - recv_alter_resource_plan(_return, seqid); + int32_t seqid = send_create_wm_trigger(request); + recv_create_wm_trigger(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_alter_resource_plan(const WMAlterResourcePlanRequest& request) +int32_t ThriftHiveMetastoreConcurrentClient::send_create_wm_trigger(const WMCreateTriggerRequest& request) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("alter_resource_plan", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("create_wm_trigger", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_alter_resource_plan_pargs args; + ThriftHiveMetastore_create_wm_trigger_pargs args; args.request = &request; args.write(oprot_); @@ -76963,7 +78755,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_alter_resource_plan(const WMAl return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_alter_resource_plan(WMAlterResourcePlanResponse& _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_create_wm_trigger(WMCreateTriggerResponse& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -76992,7 +78784,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_alter_resource_plan(WMAlterResour iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("alter_resource_plan") != 0) { + if (fname.compare("create_wm_trigger") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -77001,7 +78793,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_alter_resource_plan(WMAlterResour using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_alter_resource_plan_presult result; + ThriftHiveMetastore_create_wm_trigger_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -77024,8 +78816,12 @@ void ThriftHiveMetastoreConcurrentClient::recv_alter_resource_plan(WMAlterResour sentry.commit(); throw result.o3; } + if (result.__isset.o4) { + sentry.commit(); + throw result.o4; + } // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "alter_resource_plan failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "create_wm_trigger failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -77035,19 +78831,19 @@ void ThriftHiveMetastoreConcurrentClient::recv_alter_resource_plan(WMAlterResour } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::validate_resource_plan(WMValidateResourcePlanResponse& _return, const WMValidateResourcePlanRequest& request) +void ThriftHiveMetastoreConcurrentClient::alter_wm_trigger(WMAlterTriggerResponse& _return, const WMAlterTriggerRequest& request) { - int32_t seqid = send_validate_resource_plan(request); - recv_validate_resource_plan(_return, seqid); + int32_t seqid = send_alter_wm_trigger(request); + recv_alter_wm_trigger(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_validate_resource_plan(const WMValidateResourcePlanRequest& request) +int32_t ThriftHiveMetastoreConcurrentClient::send_alter_wm_trigger(const WMAlterTriggerRequest& request) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("validate_resource_plan", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("alter_wm_trigger", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_validate_resource_plan_pargs args; + ThriftHiveMetastore_alter_wm_trigger_pargs args; args.request = &request; args.write(oprot_); @@ -77059,7 +78855,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_validate_resource_plan(const W return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_validate_resource_plan(WMValidateResourcePlanResponse& _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_alter_wm_trigger(WMAlterTriggerResponse& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -77088,7 +78884,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_validate_resource_plan(WMValidate iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("validate_resource_plan") != 0) { + if (fname.compare("alter_wm_trigger") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -77097,7 +78893,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_validate_resource_plan(WMValidate using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_validate_resource_plan_presult result; + ThriftHiveMetastore_alter_wm_trigger_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -77116,8 +78912,12 @@ void ThriftHiveMetastoreConcurrentClient::recv_validate_resource_plan(WMValidate sentry.commit(); throw result.o2; } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "validate_resource_plan failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "alter_wm_trigger failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -77127,19 +78927,19 @@ void ThriftHiveMetastoreConcurrentClient::recv_validate_resource_plan(WMValidate } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::drop_resource_plan(WMDropResourcePlanResponse& _return, const WMDropResourcePlanRequest& request) +void ThriftHiveMetastoreConcurrentClient::drop_wm_trigger(WMDropTriggerResponse& _return, const WMDropTriggerRequest& request) { - int32_t seqid = send_drop_resource_plan(request); - recv_drop_resource_plan(_return, seqid); + int32_t seqid = send_drop_wm_trigger(request); + recv_drop_wm_trigger(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_drop_resource_plan(const WMDropResourcePlanRequest& request) +int32_t ThriftHiveMetastoreConcurrentClient::send_drop_wm_trigger(const WMDropTriggerRequest& request) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("drop_resource_plan", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("drop_wm_trigger", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_drop_resource_plan_pargs args; + ThriftHiveMetastore_drop_wm_trigger_pargs args; args.request = &request; args.write(oprot_); @@ -77151,7 +78951,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_drop_resource_plan(const WMDro return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_drop_resource_plan(WMDropResourcePlanResponse& _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_drop_wm_trigger(WMDropTriggerResponse& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -77180,7 +78980,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_drop_resource_plan(WMDropResource iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("drop_resource_plan") != 0) { + if (fname.compare("drop_wm_trigger") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -77189,7 +78989,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_drop_resource_plan(WMDropResource using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_drop_resource_plan_presult result; + ThriftHiveMetastore_drop_wm_trigger_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -77213,7 +79013,99 @@ void ThriftHiveMetastoreConcurrentClient::recv_drop_resource_plan(WMDropResource throw result.o3; } // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "drop_resource_plan failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "drop_wm_trigger failed: unknown result"); + } + // seqid != rseqid + this->sync_.updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_.waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_triggers_for_resourceplan(WMGetTriggersForResourePlanResponse& _return, const WMGetTriggersForResourePlanRequest& request) +{ + int32_t seqid = send_get_triggers_for_resourceplan(request); + recv_get_triggers_for_resourceplan(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_triggers_for_resourceplan(const WMGetTriggersForResourePlanRequest& request) +{ + int32_t cseqid = this->sync_.generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); + oprot_->writeMessageBegin("get_triggers_for_resourceplan", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_triggers_for_resourceplan_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_triggers_for_resourceplan(WMGetTriggersForResourePlanResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(&this->sync_, seqid); + + while(true) { + if(!this->sync_.getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_triggers_for_resourceplan") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_triggers_for_resourceplan_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_triggers_for_resourceplan failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); diff --git standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h index 78f405f05a..bea7b4b907 100644 --- standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h +++ standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h @@ -190,6 +190,10 @@ class ThriftHiveMetastoreIf : virtual public ::facebook::fb303::FacebookService virtual void alter_resource_plan(WMAlterResourcePlanResponse& _return, const WMAlterResourcePlanRequest& request) = 0; virtual void validate_resource_plan(WMValidateResourcePlanResponse& _return, const WMValidateResourcePlanRequest& request) = 0; virtual void drop_resource_plan(WMDropResourcePlanResponse& _return, const WMDropResourcePlanRequest& request) = 0; + virtual void create_wm_trigger(WMCreateTriggerResponse& _return, const WMCreateTriggerRequest& request) = 0; + virtual void alter_wm_trigger(WMAlterTriggerResponse& _return, const WMAlterTriggerRequest& request) = 0; + virtual void drop_wm_trigger(WMDropTriggerResponse& _return, const WMDropTriggerRequest& request) = 0; + virtual void get_triggers_for_resourceplan(WMGetTriggersForResourePlanResponse& _return, const WMGetTriggersForResourePlanRequest& request) = 0; }; class ThriftHiveMetastoreIfFactory : virtual public ::facebook::fb303::FacebookServiceIfFactory { @@ -751,6 +755,18 @@ class ThriftHiveMetastoreNull : virtual public ThriftHiveMetastoreIf , virtual p void drop_resource_plan(WMDropResourcePlanResponse& /* _return */, const WMDropResourcePlanRequest& /* request */) { return; } + void create_wm_trigger(WMCreateTriggerResponse& /* _return */, const WMCreateTriggerRequest& /* request */) { + return; + } + void alter_wm_trigger(WMAlterTriggerResponse& /* _return */, const WMAlterTriggerRequest& /* request */) { + return; + } + void drop_wm_trigger(WMDropTriggerResponse& /* _return */, const WMDropTriggerRequest& /* request */) { + return; + } + void get_triggers_for_resourceplan(WMGetTriggersForResourePlanResponse& /* _return */, const WMGetTriggersForResourePlanRequest& /* request */) { + return; + } }; typedef struct _ThriftHiveMetastore_getMetaConf_args__isset { @@ -21437,6 +21453,518 @@ class ThriftHiveMetastore_drop_resource_plan_presult { }; +typedef struct _ThriftHiveMetastore_create_wm_trigger_args__isset { + _ThriftHiveMetastore_create_wm_trigger_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_create_wm_trigger_args__isset; + +class ThriftHiveMetastore_create_wm_trigger_args { + public: + + ThriftHiveMetastore_create_wm_trigger_args(const ThriftHiveMetastore_create_wm_trigger_args&); + ThriftHiveMetastore_create_wm_trigger_args& operator=(const ThriftHiveMetastore_create_wm_trigger_args&); + ThriftHiveMetastore_create_wm_trigger_args() { + } + + virtual ~ThriftHiveMetastore_create_wm_trigger_args() throw(); + WMCreateTriggerRequest request; + + _ThriftHiveMetastore_create_wm_trigger_args__isset __isset; + + void __set_request(const WMCreateTriggerRequest& val); + + bool operator == (const ThriftHiveMetastore_create_wm_trigger_args & rhs) const + { + if (!(request == rhs.request)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_create_wm_trigger_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_create_wm_trigger_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_create_wm_trigger_pargs { + public: + + + virtual ~ThriftHiveMetastore_create_wm_trigger_pargs() throw(); + const WMCreateTriggerRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_create_wm_trigger_result__isset { + _ThriftHiveMetastore_create_wm_trigger_result__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_create_wm_trigger_result__isset; + +class ThriftHiveMetastore_create_wm_trigger_result { + public: + + ThriftHiveMetastore_create_wm_trigger_result(const ThriftHiveMetastore_create_wm_trigger_result&); + ThriftHiveMetastore_create_wm_trigger_result& operator=(const ThriftHiveMetastore_create_wm_trigger_result&); + ThriftHiveMetastore_create_wm_trigger_result() { + } + + virtual ~ThriftHiveMetastore_create_wm_trigger_result() throw(); + WMCreateTriggerResponse success; + AlreadyExistsException o1; + NoSuchObjectException o2; + InvalidObjectException o3; + MetaException o4; + + _ThriftHiveMetastore_create_wm_trigger_result__isset __isset; + + void __set_success(const WMCreateTriggerResponse& val); + + void __set_o1(const AlreadyExistsException& val); + + void __set_o2(const NoSuchObjectException& val); + + void __set_o3(const InvalidObjectException& val); + + void __set_o4(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_create_wm_trigger_result & rhs) const + { + if (!(success == rhs.success)) + return false; + if (!(o1 == rhs.o1)) + return false; + if (!(o2 == rhs.o2)) + return false; + if (!(o3 == rhs.o3)) + return false; + if (!(o4 == rhs.o4)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_create_wm_trigger_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_create_wm_trigger_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_create_wm_trigger_presult__isset { + _ThriftHiveMetastore_create_wm_trigger_presult__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_create_wm_trigger_presult__isset; + +class ThriftHiveMetastore_create_wm_trigger_presult { + public: + + + virtual ~ThriftHiveMetastore_create_wm_trigger_presult() throw(); + WMCreateTriggerResponse* success; + AlreadyExistsException o1; + NoSuchObjectException o2; + InvalidObjectException o3; + MetaException o4; + + _ThriftHiveMetastore_create_wm_trigger_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_alter_wm_trigger_args__isset { + _ThriftHiveMetastore_alter_wm_trigger_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_alter_wm_trigger_args__isset; + +class ThriftHiveMetastore_alter_wm_trigger_args { + public: + + ThriftHiveMetastore_alter_wm_trigger_args(const ThriftHiveMetastore_alter_wm_trigger_args&); + ThriftHiveMetastore_alter_wm_trigger_args& operator=(const ThriftHiveMetastore_alter_wm_trigger_args&); + ThriftHiveMetastore_alter_wm_trigger_args() { + } + + virtual ~ThriftHiveMetastore_alter_wm_trigger_args() throw(); + WMAlterTriggerRequest request; + + _ThriftHiveMetastore_alter_wm_trigger_args__isset __isset; + + void __set_request(const WMAlterTriggerRequest& val); + + bool operator == (const ThriftHiveMetastore_alter_wm_trigger_args & rhs) const + { + if (!(request == rhs.request)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_alter_wm_trigger_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_alter_wm_trigger_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_alter_wm_trigger_pargs { + public: + + + virtual ~ThriftHiveMetastore_alter_wm_trigger_pargs() throw(); + const WMAlterTriggerRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_alter_wm_trigger_result__isset { + _ThriftHiveMetastore_alter_wm_trigger_result__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_alter_wm_trigger_result__isset; + +class ThriftHiveMetastore_alter_wm_trigger_result { + public: + + ThriftHiveMetastore_alter_wm_trigger_result(const ThriftHiveMetastore_alter_wm_trigger_result&); + ThriftHiveMetastore_alter_wm_trigger_result& operator=(const ThriftHiveMetastore_alter_wm_trigger_result&); + ThriftHiveMetastore_alter_wm_trigger_result() { + } + + virtual ~ThriftHiveMetastore_alter_wm_trigger_result() throw(); + WMAlterTriggerResponse success; + NoSuchObjectException o1; + InvalidObjectException o2; + MetaException o3; + + _ThriftHiveMetastore_alter_wm_trigger_result__isset __isset; + + void __set_success(const WMAlterTriggerResponse& val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const InvalidObjectException& val); + + void __set_o3(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_alter_wm_trigger_result & rhs) const + { + if (!(success == rhs.success)) + return false; + if (!(o1 == rhs.o1)) + return false; + if (!(o2 == rhs.o2)) + return false; + if (!(o3 == rhs.o3)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_alter_wm_trigger_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_alter_wm_trigger_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_alter_wm_trigger_presult__isset { + _ThriftHiveMetastore_alter_wm_trigger_presult__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_alter_wm_trigger_presult__isset; + +class ThriftHiveMetastore_alter_wm_trigger_presult { + public: + + + virtual ~ThriftHiveMetastore_alter_wm_trigger_presult() throw(); + WMAlterTriggerResponse* success; + NoSuchObjectException o1; + InvalidObjectException o2; + MetaException o3; + + _ThriftHiveMetastore_alter_wm_trigger_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_drop_wm_trigger_args__isset { + _ThriftHiveMetastore_drop_wm_trigger_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_drop_wm_trigger_args__isset; + +class ThriftHiveMetastore_drop_wm_trigger_args { + public: + + ThriftHiveMetastore_drop_wm_trigger_args(const ThriftHiveMetastore_drop_wm_trigger_args&); + ThriftHiveMetastore_drop_wm_trigger_args& operator=(const ThriftHiveMetastore_drop_wm_trigger_args&); + ThriftHiveMetastore_drop_wm_trigger_args() { + } + + virtual ~ThriftHiveMetastore_drop_wm_trigger_args() throw(); + WMDropTriggerRequest request; + + _ThriftHiveMetastore_drop_wm_trigger_args__isset __isset; + + void __set_request(const WMDropTriggerRequest& val); + + bool operator == (const ThriftHiveMetastore_drop_wm_trigger_args & rhs) const + { + if (!(request == rhs.request)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_drop_wm_trigger_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_wm_trigger_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_drop_wm_trigger_pargs { + public: + + + virtual ~ThriftHiveMetastore_drop_wm_trigger_pargs() throw(); + const WMDropTriggerRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_wm_trigger_result__isset { + _ThriftHiveMetastore_drop_wm_trigger_result__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_drop_wm_trigger_result__isset; + +class ThriftHiveMetastore_drop_wm_trigger_result { + public: + + ThriftHiveMetastore_drop_wm_trigger_result(const ThriftHiveMetastore_drop_wm_trigger_result&); + ThriftHiveMetastore_drop_wm_trigger_result& operator=(const ThriftHiveMetastore_drop_wm_trigger_result&); + ThriftHiveMetastore_drop_wm_trigger_result() { + } + + virtual ~ThriftHiveMetastore_drop_wm_trigger_result() throw(); + WMDropTriggerResponse success; + NoSuchObjectException o1; + InvalidOperationException o2; + MetaException o3; + + _ThriftHiveMetastore_drop_wm_trigger_result__isset __isset; + + void __set_success(const WMDropTriggerResponse& val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const InvalidOperationException& val); + + void __set_o3(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_drop_wm_trigger_result & rhs) const + { + if (!(success == rhs.success)) + return false; + if (!(o1 == rhs.o1)) + return false; + if (!(o2 == rhs.o2)) + return false; + if (!(o3 == rhs.o3)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_drop_wm_trigger_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_wm_trigger_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_wm_trigger_presult__isset { + _ThriftHiveMetastore_drop_wm_trigger_presult__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_drop_wm_trigger_presult__isset; + +class ThriftHiveMetastore_drop_wm_trigger_presult { + public: + + + virtual ~ThriftHiveMetastore_drop_wm_trigger_presult() throw(); + WMDropTriggerResponse* success; + NoSuchObjectException o1; + InvalidOperationException o2; + MetaException o3; + + _ThriftHiveMetastore_drop_wm_trigger_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_get_triggers_for_resourceplan_args__isset { + _ThriftHiveMetastore_get_triggers_for_resourceplan_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_get_triggers_for_resourceplan_args__isset; + +class ThriftHiveMetastore_get_triggers_for_resourceplan_args { + public: + + ThriftHiveMetastore_get_triggers_for_resourceplan_args(const ThriftHiveMetastore_get_triggers_for_resourceplan_args&); + ThriftHiveMetastore_get_triggers_for_resourceplan_args& operator=(const ThriftHiveMetastore_get_triggers_for_resourceplan_args&); + ThriftHiveMetastore_get_triggers_for_resourceplan_args() { + } + + virtual ~ThriftHiveMetastore_get_triggers_for_resourceplan_args() throw(); + WMGetTriggersForResourePlanRequest request; + + _ThriftHiveMetastore_get_triggers_for_resourceplan_args__isset __isset; + + void __set_request(const WMGetTriggersForResourePlanRequest& val); + + bool operator == (const ThriftHiveMetastore_get_triggers_for_resourceplan_args & rhs) const + { + if (!(request == rhs.request)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_get_triggers_for_resourceplan_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_triggers_for_resourceplan_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_triggers_for_resourceplan_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_triggers_for_resourceplan_pargs() throw(); + const WMGetTriggersForResourePlanRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_triggers_for_resourceplan_result__isset { + _ThriftHiveMetastore_get_triggers_for_resourceplan_result__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_triggers_for_resourceplan_result__isset; + +class ThriftHiveMetastore_get_triggers_for_resourceplan_result { + public: + + ThriftHiveMetastore_get_triggers_for_resourceplan_result(const ThriftHiveMetastore_get_triggers_for_resourceplan_result&); + ThriftHiveMetastore_get_triggers_for_resourceplan_result& operator=(const ThriftHiveMetastore_get_triggers_for_resourceplan_result&); + ThriftHiveMetastore_get_triggers_for_resourceplan_result() { + } + + virtual ~ThriftHiveMetastore_get_triggers_for_resourceplan_result() throw(); + WMGetTriggersForResourePlanResponse success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_get_triggers_for_resourceplan_result__isset __isset; + + void __set_success(const WMGetTriggersForResourePlanResponse& val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_triggers_for_resourceplan_result & rhs) const + { + if (!(success == rhs.success)) + return false; + if (!(o1 == rhs.o1)) + return false; + if (!(o2 == rhs.o2)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_get_triggers_for_resourceplan_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_triggers_for_resourceplan_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_triggers_for_resourceplan_presult__isset { + _ThriftHiveMetastore_get_triggers_for_resourceplan_presult__isset() : success(false), o1(false), o2(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; +} _ThriftHiveMetastore_get_triggers_for_resourceplan_presult__isset; + +class ThriftHiveMetastore_get_triggers_for_resourceplan_presult { + public: + + + virtual ~ThriftHiveMetastore_get_triggers_for_resourceplan_presult() throw(); + WMGetTriggersForResourePlanResponse* success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_get_triggers_for_resourceplan_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + class ThriftHiveMetastoreClient : virtual public ThriftHiveMetastoreIf, public ::facebook::fb303::FacebookServiceClient { public: ThriftHiveMetastoreClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) : @@ -21952,6 +22480,18 @@ class ThriftHiveMetastoreClient : virtual public ThriftHiveMetastoreIf, public void drop_resource_plan(WMDropResourcePlanResponse& _return, const WMDropResourcePlanRequest& request); void send_drop_resource_plan(const WMDropResourcePlanRequest& request); void recv_drop_resource_plan(WMDropResourcePlanResponse& _return); + void create_wm_trigger(WMCreateTriggerResponse& _return, const WMCreateTriggerRequest& request); + void send_create_wm_trigger(const WMCreateTriggerRequest& request); + void recv_create_wm_trigger(WMCreateTriggerResponse& _return); + void alter_wm_trigger(WMAlterTriggerResponse& _return, const WMAlterTriggerRequest& request); + void send_alter_wm_trigger(const WMAlterTriggerRequest& request); + void recv_alter_wm_trigger(WMAlterTriggerResponse& _return); + void drop_wm_trigger(WMDropTriggerResponse& _return, const WMDropTriggerRequest& request); + void send_drop_wm_trigger(const WMDropTriggerRequest& request); + void recv_drop_wm_trigger(WMDropTriggerResponse& _return); + void get_triggers_for_resourceplan(WMGetTriggersForResourePlanResponse& _return, const WMGetTriggersForResourePlanRequest& request); + void send_get_triggers_for_resourceplan(const WMGetTriggersForResourePlanRequest& request); + void recv_get_triggers_for_resourceplan(WMGetTriggersForResourePlanResponse& _return); }; class ThriftHiveMetastoreProcessor : public ::facebook::fb303::FacebookServiceProcessor { @@ -22130,6 +22670,10 @@ class ThriftHiveMetastoreProcessor : public ::facebook::fb303::FacebookServiceP void process_alter_resource_plan(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_validate_resource_plan(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_drop_resource_plan(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_create_wm_trigger(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_alter_wm_trigger(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_drop_wm_trigger(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_triggers_for_resourceplan(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); public: ThriftHiveMetastoreProcessor(boost::shared_ptr iface) : ::facebook::fb303::FacebookServiceProcessor(iface), @@ -22302,6 +22846,10 @@ class ThriftHiveMetastoreProcessor : public ::facebook::fb303::FacebookServiceP processMap_["alter_resource_plan"] = &ThriftHiveMetastoreProcessor::process_alter_resource_plan; processMap_["validate_resource_plan"] = &ThriftHiveMetastoreProcessor::process_validate_resource_plan; processMap_["drop_resource_plan"] = &ThriftHiveMetastoreProcessor::process_drop_resource_plan; + processMap_["create_wm_trigger"] = &ThriftHiveMetastoreProcessor::process_create_wm_trigger; + processMap_["alter_wm_trigger"] = &ThriftHiveMetastoreProcessor::process_alter_wm_trigger; + processMap_["drop_wm_trigger"] = &ThriftHiveMetastoreProcessor::process_drop_wm_trigger; + processMap_["get_triggers_for_resourceplan"] = &ThriftHiveMetastoreProcessor::process_get_triggers_for_resourceplan; } virtual ~ThriftHiveMetastoreProcessor() {} @@ -23949,6 +24497,46 @@ class ThriftHiveMetastoreMultiface : virtual public ThriftHiveMetastoreIf, publi return; } + void create_wm_trigger(WMCreateTriggerResponse& _return, const WMCreateTriggerRequest& request) { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->create_wm_trigger(_return, request); + } + ifaces_[i]->create_wm_trigger(_return, request); + return; + } + + void alter_wm_trigger(WMAlterTriggerResponse& _return, const WMAlterTriggerRequest& request) { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->alter_wm_trigger(_return, request); + } + ifaces_[i]->alter_wm_trigger(_return, request); + return; + } + + void drop_wm_trigger(WMDropTriggerResponse& _return, const WMDropTriggerRequest& request) { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->drop_wm_trigger(_return, request); + } + ifaces_[i]->drop_wm_trigger(_return, request); + return; + } + + void get_triggers_for_resourceplan(WMGetTriggersForResourePlanResponse& _return, const WMGetTriggersForResourePlanRequest& request) { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_triggers_for_resourceplan(_return, request); + } + ifaces_[i]->get_triggers_for_resourceplan(_return, request); + return; + } + }; // The 'concurrent' client is a thread safe client that correctly handles @@ -24469,6 +25057,18 @@ class ThriftHiveMetastoreConcurrentClient : virtual public ThriftHiveMetastoreIf void drop_resource_plan(WMDropResourcePlanResponse& _return, const WMDropResourcePlanRequest& request); int32_t send_drop_resource_plan(const WMDropResourcePlanRequest& request); void recv_drop_resource_plan(WMDropResourcePlanResponse& _return, const int32_t seqid); + void create_wm_trigger(WMCreateTriggerResponse& _return, const WMCreateTriggerRequest& request); + int32_t send_create_wm_trigger(const WMCreateTriggerRequest& request); + void recv_create_wm_trigger(WMCreateTriggerResponse& _return, const int32_t seqid); + void alter_wm_trigger(WMAlterTriggerResponse& _return, const WMAlterTriggerRequest& request); + int32_t send_alter_wm_trigger(const WMAlterTriggerRequest& request); + void recv_alter_wm_trigger(WMAlterTriggerResponse& _return, const int32_t seqid); + void drop_wm_trigger(WMDropTriggerResponse& _return, const WMDropTriggerRequest& request); + int32_t send_drop_wm_trigger(const WMDropTriggerRequest& request); + void recv_drop_wm_trigger(WMDropTriggerResponse& _return, const int32_t seqid); + void get_triggers_for_resourceplan(WMGetTriggersForResourePlanResponse& _return, const WMGetTriggersForResourePlanRequest& request); + int32_t send_get_triggers_for_resourceplan(const WMGetTriggersForResourePlanRequest& request); + void recv_get_triggers_for_resourceplan(WMGetTriggersForResourePlanResponse& _return, const int32_t seqid); }; #ifdef _WIN32 diff --git standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp index 803c7ef61f..199b8deb5e 100644 --- standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp +++ standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp @@ -862,6 +862,26 @@ class ThriftHiveMetastoreHandler : virtual public ThriftHiveMetastoreIf { printf("drop_resource_plan\n"); } + void create_wm_trigger(WMCreateTriggerResponse& _return, const WMCreateTriggerRequest& request) { + // Your implementation goes here + printf("create_wm_trigger\n"); + } + + void alter_wm_trigger(WMAlterTriggerResponse& _return, const WMAlterTriggerRequest& request) { + // Your implementation goes here + printf("alter_wm_trigger\n"); + } + + void drop_wm_trigger(WMDropTriggerResponse& _return, const WMDropTriggerRequest& request) { + // Your implementation goes here + printf("drop_wm_trigger\n"); + } + + void get_triggers_for_resourceplan(WMGetTriggersForResourePlanResponse& _return, const WMGetTriggersForResourePlanRequest& request) { + // Your implementation goes here + printf("get_triggers_for_resourceplan\n"); + } + }; int main(int argc, char **argv) { diff --git standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp index f722085535..6090fc2888 100644 --- standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp +++ standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp @@ -21117,8 +21117,8 @@ void WMTrigger::__set_resourcePlanName(const std::string& val) { this->resourcePlanName = val; } -void WMTrigger::__set_poolName(const std::string& val) { - this->poolName = val; +void WMTrigger::__set_triggerName(const std::string& val) { + this->triggerName = val; } void WMTrigger::__set_triggerExpression(const std::string& val) { @@ -21144,7 +21144,7 @@ uint32_t WMTrigger::read(::apache::thrift::protocol::TProtocol* iprot) { using ::apache::thrift::protocol::TProtocolException; bool isset_resourcePlanName = false; - bool isset_poolName = false; + bool isset_triggerName = false; while (true) { @@ -21164,8 +21164,8 @@ uint32_t WMTrigger::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 2: if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->poolName); - isset_poolName = true; + xfer += iprot->readString(this->triggerName); + isset_triggerName = true; } else { xfer += iprot->skip(ftype); } @@ -21197,7 +21197,7 @@ uint32_t WMTrigger::read(::apache::thrift::protocol::TProtocol* iprot) { if (!isset_resourcePlanName) throw TProtocolException(TProtocolException::INVALID_DATA); - if (!isset_poolName) + if (!isset_triggerName) throw TProtocolException(TProtocolException::INVALID_DATA); return xfer; } @@ -21211,8 +21211,8 @@ uint32_t WMTrigger::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeString(this->resourcePlanName); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("poolName", ::apache::thrift::protocol::T_STRING, 2); - xfer += oprot->writeString(this->poolName); + xfer += oprot->writeFieldBegin("triggerName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->triggerName); xfer += oprot->writeFieldEnd(); if (this->__isset.triggerExpression) { @@ -21233,7 +21233,7 @@ uint32_t WMTrigger::write(::apache::thrift::protocol::TProtocol* oprot) const { void swap(WMTrigger &a, WMTrigger &b) { using ::std::swap; swap(a.resourcePlanName, b.resourcePlanName); - swap(a.poolName, b.poolName); + swap(a.triggerName, b.triggerName); swap(a.triggerExpression, b.triggerExpression); swap(a.actionExpression, b.actionExpression); swap(a.__isset, b.__isset); @@ -21241,14 +21241,14 @@ void swap(WMTrigger &a, WMTrigger &b) { WMTrigger::WMTrigger(const WMTrigger& other868) { resourcePlanName = other868.resourcePlanName; - poolName = other868.poolName; + triggerName = other868.triggerName; triggerExpression = other868.triggerExpression; actionExpression = other868.actionExpression; __isset = other868.__isset; } WMTrigger& WMTrigger::operator=(const WMTrigger& other869) { resourcePlanName = other869.resourcePlanName; - poolName = other869.poolName; + triggerName = other869.triggerName; triggerExpression = other869.triggerExpression; actionExpression = other869.actionExpression; __isset = other869.__isset; @@ -21258,7 +21258,7 @@ void WMTrigger::printTo(std::ostream& out) const { using ::apache::thrift::to_string; out << "WMTrigger("; out << "resourcePlanName=" << to_string(resourcePlanName); - out << ", " << "poolName=" << to_string(poolName); + out << ", " << "triggerName=" << to_string(triggerName); out << ", " << "triggerExpression="; (__isset.triggerExpression ? (out << to_string(triggerExpression)) : (out << "")); out << ", " << "actionExpression="; (__isset.actionExpression ? (out << to_string(actionExpression)) : (out << "")); out << ")"; @@ -21917,44 +21917,687 @@ uint32_t WMGetAllResourcePlanResponse::write(::apache::thrift::protocol::TProtoc return xfer; } -void swap(WMGetAllResourcePlanResponse &a, WMGetAllResourcePlanResponse &b) { +void swap(WMGetAllResourcePlanResponse &a, WMGetAllResourcePlanResponse &b) { + using ::std::swap; + swap(a.resourcePlans, b.resourcePlans); + swap(a.__isset, b.__isset); +} + +WMGetAllResourcePlanResponse::WMGetAllResourcePlanResponse(const WMGetAllResourcePlanResponse& other888) { + resourcePlans = other888.resourcePlans; + __isset = other888.__isset; +} +WMGetAllResourcePlanResponse& WMGetAllResourcePlanResponse::operator=(const WMGetAllResourcePlanResponse& other889) { + resourcePlans = other889.resourcePlans; + __isset = other889.__isset; + return *this; +} +void WMGetAllResourcePlanResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMGetAllResourcePlanResponse("; + out << "resourcePlans="; (__isset.resourcePlans ? (out << to_string(resourcePlans)) : (out << "")); + out << ")"; +} + + +WMAlterResourcePlanRequest::~WMAlterResourcePlanRequest() throw() { +} + + +void WMAlterResourcePlanRequest::__set_resourcePlanName(const std::string& val) { + this->resourcePlanName = val; +__isset.resourcePlanName = true; +} + +void WMAlterResourcePlanRequest::__set_resourcePlan(const WMResourcePlan& val) { + this->resourcePlan = val; +__isset.resourcePlan = true; +} + +uint32_t WMAlterResourcePlanRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->resourcePlanName); + this->__isset.resourcePlanName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->resourcePlan.read(iprot); + this->__isset.resourcePlan = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WMAlterResourcePlanRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMAlterResourcePlanRequest"); + + if (this->__isset.resourcePlanName) { + xfer += oprot->writeFieldBegin("resourcePlanName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->resourcePlanName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.resourcePlan) { + xfer += oprot->writeFieldBegin("resourcePlan", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->resourcePlan.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMAlterResourcePlanRequest &a, WMAlterResourcePlanRequest &b) { + using ::std::swap; + swap(a.resourcePlanName, b.resourcePlanName); + swap(a.resourcePlan, b.resourcePlan); + swap(a.__isset, b.__isset); +} + +WMAlterResourcePlanRequest::WMAlterResourcePlanRequest(const WMAlterResourcePlanRequest& other890) { + resourcePlanName = other890.resourcePlanName; + resourcePlan = other890.resourcePlan; + __isset = other890.__isset; +} +WMAlterResourcePlanRequest& WMAlterResourcePlanRequest::operator=(const WMAlterResourcePlanRequest& other891) { + resourcePlanName = other891.resourcePlanName; + resourcePlan = other891.resourcePlan; + __isset = other891.__isset; + return *this; +} +void WMAlterResourcePlanRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMAlterResourcePlanRequest("; + out << "resourcePlanName="; (__isset.resourcePlanName ? (out << to_string(resourcePlanName)) : (out << "")); + out << ", " << "resourcePlan="; (__isset.resourcePlan ? (out << to_string(resourcePlan)) : (out << "")); + out << ")"; +} + + +WMAlterResourcePlanResponse::~WMAlterResourcePlanResponse() throw() { +} + + +uint32_t WMAlterResourcePlanResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WMAlterResourcePlanResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMAlterResourcePlanResponse"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMAlterResourcePlanResponse &a, WMAlterResourcePlanResponse &b) { + using ::std::swap; + (void) a; + (void) b; +} + +WMAlterResourcePlanResponse::WMAlterResourcePlanResponse(const WMAlterResourcePlanResponse& other892) { + (void) other892; +} +WMAlterResourcePlanResponse& WMAlterResourcePlanResponse::operator=(const WMAlterResourcePlanResponse& other893) { + (void) other893; + return *this; +} +void WMAlterResourcePlanResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMAlterResourcePlanResponse("; + out << ")"; +} + + +WMValidateResourcePlanRequest::~WMValidateResourcePlanRequest() throw() { +} + + +void WMValidateResourcePlanRequest::__set_resourcePlanName(const std::string& val) { + this->resourcePlanName = val; +__isset.resourcePlanName = true; +} + +uint32_t WMValidateResourcePlanRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->resourcePlanName); + this->__isset.resourcePlanName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WMValidateResourcePlanRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMValidateResourcePlanRequest"); + + if (this->__isset.resourcePlanName) { + xfer += oprot->writeFieldBegin("resourcePlanName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->resourcePlanName); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMValidateResourcePlanRequest &a, WMValidateResourcePlanRequest &b) { + using ::std::swap; + swap(a.resourcePlanName, b.resourcePlanName); + swap(a.__isset, b.__isset); +} + +WMValidateResourcePlanRequest::WMValidateResourcePlanRequest(const WMValidateResourcePlanRequest& other894) { + resourcePlanName = other894.resourcePlanName; + __isset = other894.__isset; +} +WMValidateResourcePlanRequest& WMValidateResourcePlanRequest::operator=(const WMValidateResourcePlanRequest& other895) { + resourcePlanName = other895.resourcePlanName; + __isset = other895.__isset; + return *this; +} +void WMValidateResourcePlanRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMValidateResourcePlanRequest("; + out << "resourcePlanName="; (__isset.resourcePlanName ? (out << to_string(resourcePlanName)) : (out << "")); + out << ")"; +} + + +WMValidateResourcePlanResponse::~WMValidateResourcePlanResponse() throw() { +} + + +void WMValidateResourcePlanResponse::__set_isValid(const bool val) { + this->isValid = val; +__isset.isValid = true; +} + +uint32_t WMValidateResourcePlanResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->isValid); + this->__isset.isValid = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WMValidateResourcePlanResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMValidateResourcePlanResponse"); + + if (this->__isset.isValid) { + xfer += oprot->writeFieldBegin("isValid", ::apache::thrift::protocol::T_BOOL, 1); + xfer += oprot->writeBool(this->isValid); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMValidateResourcePlanResponse &a, WMValidateResourcePlanResponse &b) { + using ::std::swap; + swap(a.isValid, b.isValid); + swap(a.__isset, b.__isset); +} + +WMValidateResourcePlanResponse::WMValidateResourcePlanResponse(const WMValidateResourcePlanResponse& other896) { + isValid = other896.isValid; + __isset = other896.__isset; +} +WMValidateResourcePlanResponse& WMValidateResourcePlanResponse::operator=(const WMValidateResourcePlanResponse& other897) { + isValid = other897.isValid; + __isset = other897.__isset; + return *this; +} +void WMValidateResourcePlanResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMValidateResourcePlanResponse("; + out << "isValid="; (__isset.isValid ? (out << to_string(isValid)) : (out << "")); + out << ")"; +} + + +WMDropResourcePlanRequest::~WMDropResourcePlanRequest() throw() { +} + + +void WMDropResourcePlanRequest::__set_resourcePlanName(const std::string& val) { + this->resourcePlanName = val; +__isset.resourcePlanName = true; +} + +uint32_t WMDropResourcePlanRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->resourcePlanName); + this->__isset.resourcePlanName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WMDropResourcePlanRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMDropResourcePlanRequest"); + + if (this->__isset.resourcePlanName) { + xfer += oprot->writeFieldBegin("resourcePlanName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->resourcePlanName); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMDropResourcePlanRequest &a, WMDropResourcePlanRequest &b) { + using ::std::swap; + swap(a.resourcePlanName, b.resourcePlanName); + swap(a.__isset, b.__isset); +} + +WMDropResourcePlanRequest::WMDropResourcePlanRequest(const WMDropResourcePlanRequest& other898) { + resourcePlanName = other898.resourcePlanName; + __isset = other898.__isset; +} +WMDropResourcePlanRequest& WMDropResourcePlanRequest::operator=(const WMDropResourcePlanRequest& other899) { + resourcePlanName = other899.resourcePlanName; + __isset = other899.__isset; + return *this; +} +void WMDropResourcePlanRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMDropResourcePlanRequest("; + out << "resourcePlanName="; (__isset.resourcePlanName ? (out << to_string(resourcePlanName)) : (out << "")); + out << ")"; +} + + +WMDropResourcePlanResponse::~WMDropResourcePlanResponse() throw() { +} + + +uint32_t WMDropResourcePlanResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WMDropResourcePlanResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMDropResourcePlanResponse"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMDropResourcePlanResponse &a, WMDropResourcePlanResponse &b) { + using ::std::swap; + (void) a; + (void) b; +} + +WMDropResourcePlanResponse::WMDropResourcePlanResponse(const WMDropResourcePlanResponse& other900) { + (void) other900; +} +WMDropResourcePlanResponse& WMDropResourcePlanResponse::operator=(const WMDropResourcePlanResponse& other901) { + (void) other901; + return *this; +} +void WMDropResourcePlanResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMDropResourcePlanResponse("; + out << ")"; +} + + +WMCreateTriggerRequest::~WMCreateTriggerRequest() throw() { +} + + +void WMCreateTriggerRequest::__set_trigger(const WMTrigger& val) { + this->trigger = val; +__isset.trigger = true; +} + +uint32_t WMCreateTriggerRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->trigger.read(iprot); + this->__isset.trigger = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WMCreateTriggerRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMCreateTriggerRequest"); + + if (this->__isset.trigger) { + xfer += oprot->writeFieldBegin("trigger", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->trigger.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMCreateTriggerRequest &a, WMCreateTriggerRequest &b) { + using ::std::swap; + swap(a.trigger, b.trigger); + swap(a.__isset, b.__isset); +} + +WMCreateTriggerRequest::WMCreateTriggerRequest(const WMCreateTriggerRequest& other902) { + trigger = other902.trigger; + __isset = other902.__isset; +} +WMCreateTriggerRequest& WMCreateTriggerRequest::operator=(const WMCreateTriggerRequest& other903) { + trigger = other903.trigger; + __isset = other903.__isset; + return *this; +} +void WMCreateTriggerRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMCreateTriggerRequest("; + out << "trigger="; (__isset.trigger ? (out << to_string(trigger)) : (out << "")); + out << ")"; +} + + +WMCreateTriggerResponse::~WMCreateTriggerResponse() throw() { +} + + +uint32_t WMCreateTriggerResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WMCreateTriggerResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMCreateTriggerResponse"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMCreateTriggerResponse &a, WMCreateTriggerResponse &b) { using ::std::swap; - swap(a.resourcePlans, b.resourcePlans); - swap(a.__isset, b.__isset); + (void) a; + (void) b; } -WMGetAllResourcePlanResponse::WMGetAllResourcePlanResponse(const WMGetAllResourcePlanResponse& other888) { - resourcePlans = other888.resourcePlans; - __isset = other888.__isset; +WMCreateTriggerResponse::WMCreateTriggerResponse(const WMCreateTriggerResponse& other904) { + (void) other904; } -WMGetAllResourcePlanResponse& WMGetAllResourcePlanResponse::operator=(const WMGetAllResourcePlanResponse& other889) { - resourcePlans = other889.resourcePlans; - __isset = other889.__isset; +WMCreateTriggerResponse& WMCreateTriggerResponse::operator=(const WMCreateTriggerResponse& other905) { + (void) other905; return *this; } -void WMGetAllResourcePlanResponse::printTo(std::ostream& out) const { +void WMCreateTriggerResponse::printTo(std::ostream& out) const { using ::apache::thrift::to_string; - out << "WMGetAllResourcePlanResponse("; - out << "resourcePlans="; (__isset.resourcePlans ? (out << to_string(resourcePlans)) : (out << "")); + out << "WMCreateTriggerResponse("; out << ")"; } -WMAlterResourcePlanRequest::~WMAlterResourcePlanRequest() throw() { +WMAlterTriggerRequest::~WMAlterTriggerRequest() throw() { } -void WMAlterResourcePlanRequest::__set_resourcePlanName(const std::string& val) { - this->resourcePlanName = val; -__isset.resourcePlanName = true; -} - -void WMAlterResourcePlanRequest::__set_resourcePlan(const WMResourcePlan& val) { - this->resourcePlan = val; -__isset.resourcePlan = true; +void WMAlterTriggerRequest::__set_trigger(const WMTrigger& val) { + this->trigger = val; +__isset.trigger = true; } -uint32_t WMAlterResourcePlanRequest::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t WMAlterTriggerRequest::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -21976,17 +22619,9 @@ uint32_t WMAlterResourcePlanRequest::read(::apache::thrift::protocol::TProtocol* switch (fid) { case 1: - if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->resourcePlanName); - this->__isset.resourcePlanName = true; - } else { - xfer += iprot->skip(ftype); - } - break; - case 2: if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->resourcePlan.read(iprot); - this->__isset.resourcePlan = true; + xfer += this->trigger.read(iprot); + this->__isset.trigger = true; } else { xfer += iprot->skip(ftype); } @@ -22003,19 +22638,14 @@ uint32_t WMAlterResourcePlanRequest::read(::apache::thrift::protocol::TProtocol* return xfer; } -uint32_t WMAlterResourcePlanRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t WMAlterTriggerRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("WMAlterResourcePlanRequest"); + xfer += oprot->writeStructBegin("WMAlterTriggerRequest"); - if (this->__isset.resourcePlanName) { - xfer += oprot->writeFieldBegin("resourcePlanName", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString(this->resourcePlanName); - xfer += oprot->writeFieldEnd(); - } - if (this->__isset.resourcePlan) { - xfer += oprot->writeFieldBegin("resourcePlan", ::apache::thrift::protocol::T_STRUCT, 2); - xfer += this->resourcePlan.write(oprot); + if (this->__isset.trigger) { + xfer += oprot->writeFieldBegin("trigger", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->trigger.write(oprot); xfer += oprot->writeFieldEnd(); } xfer += oprot->writeFieldStop(); @@ -22023,38 +22653,34 @@ uint32_t WMAlterResourcePlanRequest::write(::apache::thrift::protocol::TProtocol return xfer; } -void swap(WMAlterResourcePlanRequest &a, WMAlterResourcePlanRequest &b) { +void swap(WMAlterTriggerRequest &a, WMAlterTriggerRequest &b) { using ::std::swap; - swap(a.resourcePlanName, b.resourcePlanName); - swap(a.resourcePlan, b.resourcePlan); + swap(a.trigger, b.trigger); swap(a.__isset, b.__isset); } -WMAlterResourcePlanRequest::WMAlterResourcePlanRequest(const WMAlterResourcePlanRequest& other890) { - resourcePlanName = other890.resourcePlanName; - resourcePlan = other890.resourcePlan; - __isset = other890.__isset; +WMAlterTriggerRequest::WMAlterTriggerRequest(const WMAlterTriggerRequest& other906) { + trigger = other906.trigger; + __isset = other906.__isset; } -WMAlterResourcePlanRequest& WMAlterResourcePlanRequest::operator=(const WMAlterResourcePlanRequest& other891) { - resourcePlanName = other891.resourcePlanName; - resourcePlan = other891.resourcePlan; - __isset = other891.__isset; +WMAlterTriggerRequest& WMAlterTriggerRequest::operator=(const WMAlterTriggerRequest& other907) { + trigger = other907.trigger; + __isset = other907.__isset; return *this; } -void WMAlterResourcePlanRequest::printTo(std::ostream& out) const { +void WMAlterTriggerRequest::printTo(std::ostream& out) const { using ::apache::thrift::to_string; - out << "WMAlterResourcePlanRequest("; - out << "resourcePlanName="; (__isset.resourcePlanName ? (out << to_string(resourcePlanName)) : (out << "")); - out << ", " << "resourcePlan="; (__isset.resourcePlan ? (out << to_string(resourcePlan)) : (out << "")); + out << "WMAlterTriggerRequest("; + out << "trigger="; (__isset.trigger ? (out << to_string(trigger)) : (out << "")); out << ")"; } -WMAlterResourcePlanResponse::~WMAlterResourcePlanResponse() throw() { +WMAlterTriggerResponse::~WMAlterTriggerResponse() throw() { } -uint32_t WMAlterResourcePlanResponse::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t WMAlterTriggerResponse::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -22082,46 +22708,51 @@ uint32_t WMAlterResourcePlanResponse::read(::apache::thrift::protocol::TProtocol return xfer; } -uint32_t WMAlterResourcePlanResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t WMAlterTriggerResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("WMAlterResourcePlanResponse"); + xfer += oprot->writeStructBegin("WMAlterTriggerResponse"); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; } -void swap(WMAlterResourcePlanResponse &a, WMAlterResourcePlanResponse &b) { +void swap(WMAlterTriggerResponse &a, WMAlterTriggerResponse &b) { using ::std::swap; (void) a; (void) b; } -WMAlterResourcePlanResponse::WMAlterResourcePlanResponse(const WMAlterResourcePlanResponse& other892) { - (void) other892; +WMAlterTriggerResponse::WMAlterTriggerResponse(const WMAlterTriggerResponse& other908) { + (void) other908; } -WMAlterResourcePlanResponse& WMAlterResourcePlanResponse::operator=(const WMAlterResourcePlanResponse& other893) { - (void) other893; +WMAlterTriggerResponse& WMAlterTriggerResponse::operator=(const WMAlterTriggerResponse& other909) { + (void) other909; return *this; } -void WMAlterResourcePlanResponse::printTo(std::ostream& out) const { +void WMAlterTriggerResponse::printTo(std::ostream& out) const { using ::apache::thrift::to_string; - out << "WMAlterResourcePlanResponse("; + out << "WMAlterTriggerResponse("; out << ")"; } -WMValidateResourcePlanRequest::~WMValidateResourcePlanRequest() throw() { +WMDropTriggerRequest::~WMDropTriggerRequest() throw() { } -void WMValidateResourcePlanRequest::__set_resourcePlanName(const std::string& val) { +void WMDropTriggerRequest::__set_resourcePlanName(const std::string& val) { this->resourcePlanName = val; __isset.resourcePlanName = true; } -uint32_t WMValidateResourcePlanRequest::read(::apache::thrift::protocol::TProtocol* iprot) { +void WMDropTriggerRequest::__set_triggerName(const std::string& val) { + this->triggerName = val; +__isset.triggerName = true; +} + +uint32_t WMDropTriggerRequest::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -22150,6 +22781,14 @@ uint32_t WMValidateResourcePlanRequest::read(::apache::thrift::protocol::TProtoc xfer += iprot->skip(ftype); } break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->triggerName); + this->__isset.triggerName = true; + } else { + xfer += iprot->skip(ftype); + } + break; default: xfer += iprot->skip(ftype); break; @@ -22162,54 +22801,58 @@ uint32_t WMValidateResourcePlanRequest::read(::apache::thrift::protocol::TProtoc return xfer; } -uint32_t WMValidateResourcePlanRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t WMDropTriggerRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("WMValidateResourcePlanRequest"); + xfer += oprot->writeStructBegin("WMDropTriggerRequest"); if (this->__isset.resourcePlanName) { xfer += oprot->writeFieldBegin("resourcePlanName", ::apache::thrift::protocol::T_STRING, 1); xfer += oprot->writeString(this->resourcePlanName); xfer += oprot->writeFieldEnd(); } + if (this->__isset.triggerName) { + xfer += oprot->writeFieldBegin("triggerName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->triggerName); + xfer += oprot->writeFieldEnd(); + } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; } -void swap(WMValidateResourcePlanRequest &a, WMValidateResourcePlanRequest &b) { +void swap(WMDropTriggerRequest &a, WMDropTriggerRequest &b) { using ::std::swap; swap(a.resourcePlanName, b.resourcePlanName); + swap(a.triggerName, b.triggerName); swap(a.__isset, b.__isset); } -WMValidateResourcePlanRequest::WMValidateResourcePlanRequest(const WMValidateResourcePlanRequest& other894) { - resourcePlanName = other894.resourcePlanName; - __isset = other894.__isset; +WMDropTriggerRequest::WMDropTriggerRequest(const WMDropTriggerRequest& other910) { + resourcePlanName = other910.resourcePlanName; + triggerName = other910.triggerName; + __isset = other910.__isset; } -WMValidateResourcePlanRequest& WMValidateResourcePlanRequest::operator=(const WMValidateResourcePlanRequest& other895) { - resourcePlanName = other895.resourcePlanName; - __isset = other895.__isset; +WMDropTriggerRequest& WMDropTriggerRequest::operator=(const WMDropTriggerRequest& other911) { + resourcePlanName = other911.resourcePlanName; + triggerName = other911.triggerName; + __isset = other911.__isset; return *this; } -void WMValidateResourcePlanRequest::printTo(std::ostream& out) const { +void WMDropTriggerRequest::printTo(std::ostream& out) const { using ::apache::thrift::to_string; - out << "WMValidateResourcePlanRequest("; + out << "WMDropTriggerRequest("; out << "resourcePlanName="; (__isset.resourcePlanName ? (out << to_string(resourcePlanName)) : (out << "")); + out << ", " << "triggerName="; (__isset.triggerName ? (out << to_string(triggerName)) : (out << "")); out << ")"; } -WMValidateResourcePlanResponse::~WMValidateResourcePlanResponse() throw() { +WMDropTriggerResponse::~WMDropTriggerResponse() throw() { } -void WMValidateResourcePlanResponse::__set_isValid(const bool val) { - this->isValid = val; -__isset.isValid = true; -} - -uint32_t WMValidateResourcePlanResponse::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t WMDropTriggerResponse::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -22228,20 +22871,7 @@ uint32_t WMValidateResourcePlanResponse::read(::apache::thrift::protocol::TProto if (ftype == ::apache::thrift::protocol::T_STOP) { break; } - switch (fid) - { - case 1: - if (ftype == ::apache::thrift::protocol::T_BOOL) { - xfer += iprot->readBool(this->isValid); - this->__isset.isValid = true; - } else { - xfer += iprot->skip(ftype); - } - break; - default: - xfer += iprot->skip(ftype); - break; - } + xfer += iprot->skip(ftype); xfer += iprot->readFieldEnd(); } @@ -22250,54 +22880,46 @@ uint32_t WMValidateResourcePlanResponse::read(::apache::thrift::protocol::TProto return xfer; } -uint32_t WMValidateResourcePlanResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t WMDropTriggerResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("WMValidateResourcePlanResponse"); + xfer += oprot->writeStructBegin("WMDropTriggerResponse"); - if (this->__isset.isValid) { - xfer += oprot->writeFieldBegin("isValid", ::apache::thrift::protocol::T_BOOL, 1); - xfer += oprot->writeBool(this->isValid); - xfer += oprot->writeFieldEnd(); - } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; } -void swap(WMValidateResourcePlanResponse &a, WMValidateResourcePlanResponse &b) { +void swap(WMDropTriggerResponse &a, WMDropTriggerResponse &b) { using ::std::swap; - swap(a.isValid, b.isValid); - swap(a.__isset, b.__isset); + (void) a; + (void) b; } -WMValidateResourcePlanResponse::WMValidateResourcePlanResponse(const WMValidateResourcePlanResponse& other896) { - isValid = other896.isValid; - __isset = other896.__isset; +WMDropTriggerResponse::WMDropTriggerResponse(const WMDropTriggerResponse& other912) { + (void) other912; } -WMValidateResourcePlanResponse& WMValidateResourcePlanResponse::operator=(const WMValidateResourcePlanResponse& other897) { - isValid = other897.isValid; - __isset = other897.__isset; +WMDropTriggerResponse& WMDropTriggerResponse::operator=(const WMDropTriggerResponse& other913) { + (void) other913; return *this; } -void WMValidateResourcePlanResponse::printTo(std::ostream& out) const { +void WMDropTriggerResponse::printTo(std::ostream& out) const { using ::apache::thrift::to_string; - out << "WMValidateResourcePlanResponse("; - out << "isValid="; (__isset.isValid ? (out << to_string(isValid)) : (out << "")); + out << "WMDropTriggerResponse("; out << ")"; } -WMDropResourcePlanRequest::~WMDropResourcePlanRequest() throw() { +WMGetTriggersForResourePlanRequest::~WMGetTriggersForResourePlanRequest() throw() { } -void WMDropResourcePlanRequest::__set_resourcePlanName(const std::string& val) { +void WMGetTriggersForResourePlanRequest::__set_resourcePlanName(const std::string& val) { this->resourcePlanName = val; __isset.resourcePlanName = true; } -uint32_t WMDropResourcePlanRequest::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t WMGetTriggersForResourePlanRequest::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -22338,10 +22960,10 @@ uint32_t WMDropResourcePlanRequest::read(::apache::thrift::protocol::TProtocol* return xfer; } -uint32_t WMDropResourcePlanRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t WMGetTriggersForResourePlanRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("WMDropResourcePlanRequest"); + xfer += oprot->writeStructBegin("WMGetTriggersForResourePlanRequest"); if (this->__isset.resourcePlanName) { xfer += oprot->writeFieldBegin("resourcePlanName", ::apache::thrift::protocol::T_STRING, 1); @@ -22353,34 +22975,39 @@ uint32_t WMDropResourcePlanRequest::write(::apache::thrift::protocol::TProtocol* return xfer; } -void swap(WMDropResourcePlanRequest &a, WMDropResourcePlanRequest &b) { +void swap(WMGetTriggersForResourePlanRequest &a, WMGetTriggersForResourePlanRequest &b) { using ::std::swap; swap(a.resourcePlanName, b.resourcePlanName); swap(a.__isset, b.__isset); } -WMDropResourcePlanRequest::WMDropResourcePlanRequest(const WMDropResourcePlanRequest& other898) { - resourcePlanName = other898.resourcePlanName; - __isset = other898.__isset; +WMGetTriggersForResourePlanRequest::WMGetTriggersForResourePlanRequest(const WMGetTriggersForResourePlanRequest& other914) { + resourcePlanName = other914.resourcePlanName; + __isset = other914.__isset; } -WMDropResourcePlanRequest& WMDropResourcePlanRequest::operator=(const WMDropResourcePlanRequest& other899) { - resourcePlanName = other899.resourcePlanName; - __isset = other899.__isset; +WMGetTriggersForResourePlanRequest& WMGetTriggersForResourePlanRequest::operator=(const WMGetTriggersForResourePlanRequest& other915) { + resourcePlanName = other915.resourcePlanName; + __isset = other915.__isset; return *this; } -void WMDropResourcePlanRequest::printTo(std::ostream& out) const { +void WMGetTriggersForResourePlanRequest::printTo(std::ostream& out) const { using ::apache::thrift::to_string; - out << "WMDropResourcePlanRequest("; + out << "WMGetTriggersForResourePlanRequest("; out << "resourcePlanName="; (__isset.resourcePlanName ? (out << to_string(resourcePlanName)) : (out << "")); out << ")"; } -WMDropResourcePlanResponse::~WMDropResourcePlanResponse() throw() { +WMGetTriggersForResourePlanResponse::~WMGetTriggersForResourePlanResponse() throw() { } -uint32_t WMDropResourcePlanResponse::read(::apache::thrift::protocol::TProtocol* iprot) { +void WMGetTriggersForResourePlanResponse::__set_triggers(const std::vector & val) { + this->triggers = val; +__isset.triggers = true; +} + +uint32_t WMGetTriggersForResourePlanResponse::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -22399,7 +23026,32 @@ uint32_t WMDropResourcePlanResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_STOP) { break; } - xfer += iprot->skip(ftype); + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->triggers.clear(); + uint32_t _size916; + ::apache::thrift::protocol::TType _etype919; + xfer += iprot->readListBegin(_etype919, _size916); + this->triggers.resize(_size916); + uint32_t _i920; + for (_i920 = 0; _i920 < _size916; ++_i920) + { + xfer += this->triggers[_i920].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.triggers = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } xfer += iprot->readFieldEnd(); } @@ -22408,32 +23060,48 @@ uint32_t WMDropResourcePlanResponse::read(::apache::thrift::protocol::TProtocol* return xfer; } -uint32_t WMDropResourcePlanResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t WMGetTriggersForResourePlanResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("WMDropResourcePlanResponse"); + xfer += oprot->writeStructBegin("WMGetTriggersForResourePlanResponse"); + if (this->__isset.triggers) { + xfer += oprot->writeFieldBegin("triggers", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->triggers.size())); + std::vector ::const_iterator _iter921; + for (_iter921 = this->triggers.begin(); _iter921 != this->triggers.end(); ++_iter921) + { + xfer += (*_iter921).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; } -void swap(WMDropResourcePlanResponse &a, WMDropResourcePlanResponse &b) { +void swap(WMGetTriggersForResourePlanResponse &a, WMGetTriggersForResourePlanResponse &b) { using ::std::swap; - (void) a; - (void) b; + swap(a.triggers, b.triggers); + swap(a.__isset, b.__isset); } -WMDropResourcePlanResponse::WMDropResourcePlanResponse(const WMDropResourcePlanResponse& other900) { - (void) other900; +WMGetTriggersForResourePlanResponse::WMGetTriggersForResourePlanResponse(const WMGetTriggersForResourePlanResponse& other922) { + triggers = other922.triggers; + __isset = other922.__isset; } -WMDropResourcePlanResponse& WMDropResourcePlanResponse::operator=(const WMDropResourcePlanResponse& other901) { - (void) other901; +WMGetTriggersForResourePlanResponse& WMGetTriggersForResourePlanResponse::operator=(const WMGetTriggersForResourePlanResponse& other923) { + triggers = other923.triggers; + __isset = other923.__isset; return *this; } -void WMDropResourcePlanResponse::printTo(std::ostream& out) const { +void WMGetTriggersForResourePlanResponse::printTo(std::ostream& out) const { using ::apache::thrift::to_string; - out << "WMDropResourcePlanResponse("; + out << "WMGetTriggersForResourePlanResponse("; + out << "triggers="; (__isset.triggers ? (out << to_string(triggers)) : (out << "")); out << ")"; } @@ -22507,13 +23175,13 @@ void swap(MetaException &a, MetaException &b) { swap(a.__isset, b.__isset); } -MetaException::MetaException(const MetaException& other902) : TException() { - message = other902.message; - __isset = other902.__isset; +MetaException::MetaException(const MetaException& other924) : TException() { + message = other924.message; + __isset = other924.__isset; } -MetaException& MetaException::operator=(const MetaException& other903) { - message = other903.message; - __isset = other903.__isset; +MetaException& MetaException::operator=(const MetaException& other925) { + message = other925.message; + __isset = other925.__isset; return *this; } void MetaException::printTo(std::ostream& out) const { @@ -22604,13 +23272,13 @@ void swap(UnknownTableException &a, UnknownTableException &b) { swap(a.__isset, b.__isset); } -UnknownTableException::UnknownTableException(const UnknownTableException& other904) : TException() { - message = other904.message; - __isset = other904.__isset; +UnknownTableException::UnknownTableException(const UnknownTableException& other926) : TException() { + message = other926.message; + __isset = other926.__isset; } -UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other905) { - message = other905.message; - __isset = other905.__isset; +UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other927) { + message = other927.message; + __isset = other927.__isset; return *this; } void UnknownTableException::printTo(std::ostream& out) const { @@ -22701,13 +23369,13 @@ void swap(UnknownDBException &a, UnknownDBException &b) { swap(a.__isset, b.__isset); } -UnknownDBException::UnknownDBException(const UnknownDBException& other906) : TException() { - message = other906.message; - __isset = other906.__isset; +UnknownDBException::UnknownDBException(const UnknownDBException& other928) : TException() { + message = other928.message; + __isset = other928.__isset; } -UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other907) { - message = other907.message; - __isset = other907.__isset; +UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other929) { + message = other929.message; + __isset = other929.__isset; return *this; } void UnknownDBException::printTo(std::ostream& out) const { @@ -22798,13 +23466,13 @@ void swap(AlreadyExistsException &a, AlreadyExistsException &b) { swap(a.__isset, b.__isset); } -AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other908) : TException() { - message = other908.message; - __isset = other908.__isset; +AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other930) : TException() { + message = other930.message; + __isset = other930.__isset; } -AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other909) { - message = other909.message; - __isset = other909.__isset; +AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other931) { + message = other931.message; + __isset = other931.__isset; return *this; } void AlreadyExistsException::printTo(std::ostream& out) const { @@ -22895,13 +23563,13 @@ void swap(InvalidPartitionException &a, InvalidPartitionException &b) { swap(a.__isset, b.__isset); } -InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other910) : TException() { - message = other910.message; - __isset = other910.__isset; +InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other932) : TException() { + message = other932.message; + __isset = other932.__isset; } -InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other911) { - message = other911.message; - __isset = other911.__isset; +InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other933) { + message = other933.message; + __isset = other933.__isset; return *this; } void InvalidPartitionException::printTo(std::ostream& out) const { @@ -22992,13 +23660,13 @@ void swap(UnknownPartitionException &a, UnknownPartitionException &b) { swap(a.__isset, b.__isset); } -UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other912) : TException() { - message = other912.message; - __isset = other912.__isset; +UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other934) : TException() { + message = other934.message; + __isset = other934.__isset; } -UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other913) { - message = other913.message; - __isset = other913.__isset; +UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other935) { + message = other935.message; + __isset = other935.__isset; return *this; } void UnknownPartitionException::printTo(std::ostream& out) const { @@ -23089,13 +23757,13 @@ void swap(InvalidObjectException &a, InvalidObjectException &b) { swap(a.__isset, b.__isset); } -InvalidObjectException::InvalidObjectException(const InvalidObjectException& other914) : TException() { - message = other914.message; - __isset = other914.__isset; +InvalidObjectException::InvalidObjectException(const InvalidObjectException& other936) : TException() { + message = other936.message; + __isset = other936.__isset; } -InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other915) { - message = other915.message; - __isset = other915.__isset; +InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other937) { + message = other937.message; + __isset = other937.__isset; return *this; } void InvalidObjectException::printTo(std::ostream& out) const { @@ -23186,13 +23854,13 @@ void swap(NoSuchObjectException &a, NoSuchObjectException &b) { swap(a.__isset, b.__isset); } -NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other916) : TException() { - message = other916.message; - __isset = other916.__isset; +NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other938) : TException() { + message = other938.message; + __isset = other938.__isset; } -NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other917) { - message = other917.message; - __isset = other917.__isset; +NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other939) { + message = other939.message; + __isset = other939.__isset; return *this; } void NoSuchObjectException::printTo(std::ostream& out) const { @@ -23283,13 +23951,13 @@ void swap(IndexAlreadyExistsException &a, IndexAlreadyExistsException &b) { swap(a.__isset, b.__isset); } -IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other918) : TException() { - message = other918.message; - __isset = other918.__isset; +IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other940) : TException() { + message = other940.message; + __isset = other940.__isset; } -IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other919) { - message = other919.message; - __isset = other919.__isset; +IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other941) { + message = other941.message; + __isset = other941.__isset; return *this; } void IndexAlreadyExistsException::printTo(std::ostream& out) const { @@ -23380,13 +24048,13 @@ void swap(InvalidOperationException &a, InvalidOperationException &b) { swap(a.__isset, b.__isset); } -InvalidOperationException::InvalidOperationException(const InvalidOperationException& other920) : TException() { - message = other920.message; - __isset = other920.__isset; +InvalidOperationException::InvalidOperationException(const InvalidOperationException& other942) : TException() { + message = other942.message; + __isset = other942.__isset; } -InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other921) { - message = other921.message; - __isset = other921.__isset; +InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other943) { + message = other943.message; + __isset = other943.__isset; return *this; } void InvalidOperationException::printTo(std::ostream& out) const { @@ -23477,13 +24145,13 @@ void swap(ConfigValSecurityException &a, ConfigValSecurityException &b) { swap(a.__isset, b.__isset); } -ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other922) : TException() { - message = other922.message; - __isset = other922.__isset; +ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other944) : TException() { + message = other944.message; + __isset = other944.__isset; } -ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other923) { - message = other923.message; - __isset = other923.__isset; +ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other945) { + message = other945.message; + __isset = other945.__isset; return *this; } void ConfigValSecurityException::printTo(std::ostream& out) const { @@ -23574,13 +24242,13 @@ void swap(InvalidInputException &a, InvalidInputException &b) { swap(a.__isset, b.__isset); } -InvalidInputException::InvalidInputException(const InvalidInputException& other924) : TException() { - message = other924.message; - __isset = other924.__isset; +InvalidInputException::InvalidInputException(const InvalidInputException& other946) : TException() { + message = other946.message; + __isset = other946.__isset; } -InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other925) { - message = other925.message; - __isset = other925.__isset; +InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other947) { + message = other947.message; + __isset = other947.__isset; return *this; } void InvalidInputException::printTo(std::ostream& out) const { @@ -23671,13 +24339,13 @@ void swap(NoSuchTxnException &a, NoSuchTxnException &b) { swap(a.__isset, b.__isset); } -NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other926) : TException() { - message = other926.message; - __isset = other926.__isset; +NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other948) : TException() { + message = other948.message; + __isset = other948.__isset; } -NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other927) { - message = other927.message; - __isset = other927.__isset; +NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other949) { + message = other949.message; + __isset = other949.__isset; return *this; } void NoSuchTxnException::printTo(std::ostream& out) const { @@ -23768,13 +24436,13 @@ void swap(TxnAbortedException &a, TxnAbortedException &b) { swap(a.__isset, b.__isset); } -TxnAbortedException::TxnAbortedException(const TxnAbortedException& other928) : TException() { - message = other928.message; - __isset = other928.__isset; +TxnAbortedException::TxnAbortedException(const TxnAbortedException& other950) : TException() { + message = other950.message; + __isset = other950.__isset; } -TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other929) { - message = other929.message; - __isset = other929.__isset; +TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other951) { + message = other951.message; + __isset = other951.__isset; return *this; } void TxnAbortedException::printTo(std::ostream& out) const { @@ -23865,13 +24533,13 @@ void swap(TxnOpenException &a, TxnOpenException &b) { swap(a.__isset, b.__isset); } -TxnOpenException::TxnOpenException(const TxnOpenException& other930) : TException() { - message = other930.message; - __isset = other930.__isset; +TxnOpenException::TxnOpenException(const TxnOpenException& other952) : TException() { + message = other952.message; + __isset = other952.__isset; } -TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other931) { - message = other931.message; - __isset = other931.__isset; +TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other953) { + message = other953.message; + __isset = other953.__isset; return *this; } void TxnOpenException::printTo(std::ostream& out) const { @@ -23962,13 +24630,13 @@ void swap(NoSuchLockException &a, NoSuchLockException &b) { swap(a.__isset, b.__isset); } -NoSuchLockException::NoSuchLockException(const NoSuchLockException& other932) : TException() { - message = other932.message; - __isset = other932.__isset; +NoSuchLockException::NoSuchLockException(const NoSuchLockException& other954) : TException() { + message = other954.message; + __isset = other954.__isset; } -NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other933) { - message = other933.message; - __isset = other933.__isset; +NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other955) { + message = other955.message; + __isset = other955.__isset; return *this; } void NoSuchLockException::printTo(std::ostream& out) const { diff --git standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h index 159af47348..a46127bb09 100644 --- standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h +++ standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h @@ -481,6 +481,22 @@ class WMDropResourcePlanRequest; class WMDropResourcePlanResponse; +class WMCreateTriggerRequest; + +class WMCreateTriggerResponse; + +class WMAlterTriggerRequest; + +class WMAlterTriggerResponse; + +class WMDropTriggerRequest; + +class WMDropTriggerResponse; + +class WMGetTriggersForResourePlanRequest; + +class WMGetTriggersForResourePlanResponse; + class MetaException; class UnknownTableException; @@ -8638,12 +8654,12 @@ class WMTrigger { WMTrigger(const WMTrigger&); WMTrigger& operator=(const WMTrigger&); - WMTrigger() : resourcePlanName(), poolName(), triggerExpression(), actionExpression() { + WMTrigger() : resourcePlanName(), triggerName(), triggerExpression(), actionExpression() { } virtual ~WMTrigger() throw(); std::string resourcePlanName; - std::string poolName; + std::string triggerName; std::string triggerExpression; std::string actionExpression; @@ -8651,7 +8667,7 @@ class WMTrigger { void __set_resourcePlanName(const std::string& val); - void __set_poolName(const std::string& val); + void __set_triggerName(const std::string& val); void __set_triggerExpression(const std::string& val); @@ -8661,7 +8677,7 @@ class WMTrigger { { if (!(resourcePlanName == rhs.resourcePlanName)) return false; - if (!(poolName == rhs.poolName)) + if (!(triggerName == rhs.triggerName)) return false; if (__isset.triggerExpression != rhs.__isset.triggerExpression) return false; @@ -9296,6 +9312,359 @@ inline std::ostream& operator<<(std::ostream& out, const WMDropResourcePlanRespo return out; } +typedef struct _WMCreateTriggerRequest__isset { + _WMCreateTriggerRequest__isset() : trigger(false) {} + bool trigger :1; +} _WMCreateTriggerRequest__isset; + +class WMCreateTriggerRequest { + public: + + WMCreateTriggerRequest(const WMCreateTriggerRequest&); + WMCreateTriggerRequest& operator=(const WMCreateTriggerRequest&); + WMCreateTriggerRequest() { + } + + virtual ~WMCreateTriggerRequest() throw(); + WMTrigger trigger; + + _WMCreateTriggerRequest__isset __isset; + + void __set_trigger(const WMTrigger& val); + + bool operator == (const WMCreateTriggerRequest & rhs) const + { + if (__isset.trigger != rhs.__isset.trigger) + return false; + else if (__isset.trigger && !(trigger == rhs.trigger)) + return false; + return true; + } + bool operator != (const WMCreateTriggerRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMCreateTriggerRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMCreateTriggerRequest &a, WMCreateTriggerRequest &b); + +inline std::ostream& operator<<(std::ostream& out, const WMCreateTriggerRequest& obj) +{ + obj.printTo(out); + return out; +} + + +class WMCreateTriggerResponse { + public: + + WMCreateTriggerResponse(const WMCreateTriggerResponse&); + WMCreateTriggerResponse& operator=(const WMCreateTriggerResponse&); + WMCreateTriggerResponse() { + } + + virtual ~WMCreateTriggerResponse() throw(); + + bool operator == (const WMCreateTriggerResponse & /* rhs */) const + { + return true; + } + bool operator != (const WMCreateTriggerResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMCreateTriggerResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMCreateTriggerResponse &a, WMCreateTriggerResponse &b); + +inline std::ostream& operator<<(std::ostream& out, const WMCreateTriggerResponse& obj) +{ + obj.printTo(out); + return out; +} + +typedef struct _WMAlterTriggerRequest__isset { + _WMAlterTriggerRequest__isset() : trigger(false) {} + bool trigger :1; +} _WMAlterTriggerRequest__isset; + +class WMAlterTriggerRequest { + public: + + WMAlterTriggerRequest(const WMAlterTriggerRequest&); + WMAlterTriggerRequest& operator=(const WMAlterTriggerRequest&); + WMAlterTriggerRequest() { + } + + virtual ~WMAlterTriggerRequest() throw(); + WMTrigger trigger; + + _WMAlterTriggerRequest__isset __isset; + + void __set_trigger(const WMTrigger& val); + + bool operator == (const WMAlterTriggerRequest & rhs) const + { + if (__isset.trigger != rhs.__isset.trigger) + return false; + else if (__isset.trigger && !(trigger == rhs.trigger)) + return false; + return true; + } + bool operator != (const WMAlterTriggerRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMAlterTriggerRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMAlterTriggerRequest &a, WMAlterTriggerRequest &b); + +inline std::ostream& operator<<(std::ostream& out, const WMAlterTriggerRequest& obj) +{ + obj.printTo(out); + return out; +} + + +class WMAlterTriggerResponse { + public: + + WMAlterTriggerResponse(const WMAlterTriggerResponse&); + WMAlterTriggerResponse& operator=(const WMAlterTriggerResponse&); + WMAlterTriggerResponse() { + } + + virtual ~WMAlterTriggerResponse() throw(); + + bool operator == (const WMAlterTriggerResponse & /* rhs */) const + { + return true; + } + bool operator != (const WMAlterTriggerResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMAlterTriggerResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMAlterTriggerResponse &a, WMAlterTriggerResponse &b); + +inline std::ostream& operator<<(std::ostream& out, const WMAlterTriggerResponse& obj) +{ + obj.printTo(out); + return out; +} + +typedef struct _WMDropTriggerRequest__isset { + _WMDropTriggerRequest__isset() : resourcePlanName(false), triggerName(false) {} + bool resourcePlanName :1; + bool triggerName :1; +} _WMDropTriggerRequest__isset; + +class WMDropTriggerRequest { + public: + + WMDropTriggerRequest(const WMDropTriggerRequest&); + WMDropTriggerRequest& operator=(const WMDropTriggerRequest&); + WMDropTriggerRequest() : resourcePlanName(), triggerName() { + } + + virtual ~WMDropTriggerRequest() throw(); + std::string resourcePlanName; + std::string triggerName; + + _WMDropTriggerRequest__isset __isset; + + void __set_resourcePlanName(const std::string& val); + + void __set_triggerName(const std::string& val); + + bool operator == (const WMDropTriggerRequest & rhs) const + { + if (__isset.resourcePlanName != rhs.__isset.resourcePlanName) + return false; + else if (__isset.resourcePlanName && !(resourcePlanName == rhs.resourcePlanName)) + return false; + if (__isset.triggerName != rhs.__isset.triggerName) + return false; + else if (__isset.triggerName && !(triggerName == rhs.triggerName)) + return false; + return true; + } + bool operator != (const WMDropTriggerRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMDropTriggerRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMDropTriggerRequest &a, WMDropTriggerRequest &b); + +inline std::ostream& operator<<(std::ostream& out, const WMDropTriggerRequest& obj) +{ + obj.printTo(out); + return out; +} + + +class WMDropTriggerResponse { + public: + + WMDropTriggerResponse(const WMDropTriggerResponse&); + WMDropTriggerResponse& operator=(const WMDropTriggerResponse&); + WMDropTriggerResponse() { + } + + virtual ~WMDropTriggerResponse() throw(); + + bool operator == (const WMDropTriggerResponse & /* rhs */) const + { + return true; + } + bool operator != (const WMDropTriggerResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMDropTriggerResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMDropTriggerResponse &a, WMDropTriggerResponse &b); + +inline std::ostream& operator<<(std::ostream& out, const WMDropTriggerResponse& obj) +{ + obj.printTo(out); + return out; +} + +typedef struct _WMGetTriggersForResourePlanRequest__isset { + _WMGetTriggersForResourePlanRequest__isset() : resourcePlanName(false) {} + bool resourcePlanName :1; +} _WMGetTriggersForResourePlanRequest__isset; + +class WMGetTriggersForResourePlanRequest { + public: + + WMGetTriggersForResourePlanRequest(const WMGetTriggersForResourePlanRequest&); + WMGetTriggersForResourePlanRequest& operator=(const WMGetTriggersForResourePlanRequest&); + WMGetTriggersForResourePlanRequest() : resourcePlanName() { + } + + virtual ~WMGetTriggersForResourePlanRequest() throw(); + std::string resourcePlanName; + + _WMGetTriggersForResourePlanRequest__isset __isset; + + void __set_resourcePlanName(const std::string& val); + + bool operator == (const WMGetTriggersForResourePlanRequest & rhs) const + { + if (__isset.resourcePlanName != rhs.__isset.resourcePlanName) + return false; + else if (__isset.resourcePlanName && !(resourcePlanName == rhs.resourcePlanName)) + return false; + return true; + } + bool operator != (const WMGetTriggersForResourePlanRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMGetTriggersForResourePlanRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMGetTriggersForResourePlanRequest &a, WMGetTriggersForResourePlanRequest &b); + +inline std::ostream& operator<<(std::ostream& out, const WMGetTriggersForResourePlanRequest& obj) +{ + obj.printTo(out); + return out; +} + +typedef struct _WMGetTriggersForResourePlanResponse__isset { + _WMGetTriggersForResourePlanResponse__isset() : triggers(false) {} + bool triggers :1; +} _WMGetTriggersForResourePlanResponse__isset; + +class WMGetTriggersForResourePlanResponse { + public: + + WMGetTriggersForResourePlanResponse(const WMGetTriggersForResourePlanResponse&); + WMGetTriggersForResourePlanResponse& operator=(const WMGetTriggersForResourePlanResponse&); + WMGetTriggersForResourePlanResponse() { + } + + virtual ~WMGetTriggersForResourePlanResponse() throw(); + std::vector triggers; + + _WMGetTriggersForResourePlanResponse__isset __isset; + + void __set_triggers(const std::vector & val); + + bool operator == (const WMGetTriggersForResourePlanResponse & rhs) const + { + if (__isset.triggers != rhs.__isset.triggers) + return false; + else if (__isset.triggers && !(triggers == rhs.triggers)) + return false; + return true; + } + bool operator != (const WMGetTriggersForResourePlanResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMGetTriggersForResourePlanResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMGetTriggersForResourePlanResponse &a, WMGetTriggersForResourePlanResponse &b); + +inline std::ostream& operator<<(std::ostream& out, const WMGetTriggersForResourePlanResponse& obj) +{ + obj.printTo(out); + return out; +} + typedef struct _MetaException__isset { _MetaException__isset() : message(false) {} bool message :1; diff --git standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java index 48bfb053de..1e5bc0800f 100644 --- standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java +++ standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java @@ -378,6 +378,14 @@ public WMDropResourcePlanResponse drop_resource_plan(WMDropResourcePlanRequest request) throws NoSuchObjectException, InvalidOperationException, MetaException, org.apache.thrift.TException; + public WMCreateTriggerResponse create_wm_trigger(WMCreateTriggerRequest request) throws AlreadyExistsException, NoSuchObjectException, InvalidObjectException, MetaException, org.apache.thrift.TException; + + public WMAlterTriggerResponse alter_wm_trigger(WMAlterTriggerRequest request) throws NoSuchObjectException, InvalidObjectException, MetaException, org.apache.thrift.TException; + + public WMDropTriggerResponse drop_wm_trigger(WMDropTriggerRequest request) throws NoSuchObjectException, InvalidOperationException, MetaException, org.apache.thrift.TException; + + public WMGetTriggersForResourePlanResponse get_triggers_for_resourceplan(WMGetTriggersForResourePlanRequest request) throws NoSuchObjectException, MetaException, org.apache.thrift.TException; + } @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public interface AsyncIface extends com.facebook.fb303.FacebookService .AsyncIface { @@ -718,6 +726,14 @@ public void drop_resource_plan(WMDropResourcePlanRequest request, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void create_wm_trigger(WMCreateTriggerRequest request, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + + public void alter_wm_trigger(WMAlterTriggerRequest request, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + + public void drop_wm_trigger(WMDropTriggerRequest request, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + + public void get_triggers_for_resourceplan(WMGetTriggersForResourePlanRequest request, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + } @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class Client extends com.facebook.fb303.FacebookService.Client implements Iface { @@ -5565,6 +5581,134 @@ public WMDropResourcePlanResponse recv_drop_resource_plan() throws NoSuchObjectE throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "drop_resource_plan failed: unknown result"); } + public WMCreateTriggerResponse create_wm_trigger(WMCreateTriggerRequest request) throws AlreadyExistsException, NoSuchObjectException, InvalidObjectException, MetaException, org.apache.thrift.TException + { + send_create_wm_trigger(request); + return recv_create_wm_trigger(); + } + + public void send_create_wm_trigger(WMCreateTriggerRequest request) throws org.apache.thrift.TException + { + create_wm_trigger_args args = new create_wm_trigger_args(); + args.setRequest(request); + sendBase("create_wm_trigger", args); + } + + public WMCreateTriggerResponse recv_create_wm_trigger() throws AlreadyExistsException, NoSuchObjectException, InvalidObjectException, MetaException, org.apache.thrift.TException + { + create_wm_trigger_result result = new create_wm_trigger_result(); + receiveBase(result, "create_wm_trigger"); + if (result.isSetSuccess()) { + return result.success; + } + if (result.o1 != null) { + throw result.o1; + } + if (result.o2 != null) { + throw result.o2; + } + if (result.o3 != null) { + throw result.o3; + } + if (result.o4 != null) { + throw result.o4; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "create_wm_trigger failed: unknown result"); + } + + public WMAlterTriggerResponse alter_wm_trigger(WMAlterTriggerRequest request) throws NoSuchObjectException, InvalidObjectException, MetaException, org.apache.thrift.TException + { + send_alter_wm_trigger(request); + return recv_alter_wm_trigger(); + } + + public void send_alter_wm_trigger(WMAlterTriggerRequest request) throws org.apache.thrift.TException + { + alter_wm_trigger_args args = new alter_wm_trigger_args(); + args.setRequest(request); + sendBase("alter_wm_trigger", args); + } + + public WMAlterTriggerResponse recv_alter_wm_trigger() throws NoSuchObjectException, InvalidObjectException, MetaException, org.apache.thrift.TException + { + alter_wm_trigger_result result = new alter_wm_trigger_result(); + receiveBase(result, "alter_wm_trigger"); + if (result.isSetSuccess()) { + return result.success; + } + if (result.o1 != null) { + throw result.o1; + } + if (result.o2 != null) { + throw result.o2; + } + if (result.o3 != null) { + throw result.o3; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "alter_wm_trigger failed: unknown result"); + } + + public WMDropTriggerResponse drop_wm_trigger(WMDropTriggerRequest request) throws NoSuchObjectException, InvalidOperationException, MetaException, org.apache.thrift.TException + { + send_drop_wm_trigger(request); + return recv_drop_wm_trigger(); + } + + public void send_drop_wm_trigger(WMDropTriggerRequest request) throws org.apache.thrift.TException + { + drop_wm_trigger_args args = new drop_wm_trigger_args(); + args.setRequest(request); + sendBase("drop_wm_trigger", args); + } + + public WMDropTriggerResponse recv_drop_wm_trigger() throws NoSuchObjectException, InvalidOperationException, MetaException, org.apache.thrift.TException + { + drop_wm_trigger_result result = new drop_wm_trigger_result(); + receiveBase(result, "drop_wm_trigger"); + if (result.isSetSuccess()) { + return result.success; + } + if (result.o1 != null) { + throw result.o1; + } + if (result.o2 != null) { + throw result.o2; + } + if (result.o3 != null) { + throw result.o3; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "drop_wm_trigger failed: unknown result"); + } + + public WMGetTriggersForResourePlanResponse get_triggers_for_resourceplan(WMGetTriggersForResourePlanRequest request) throws NoSuchObjectException, MetaException, org.apache.thrift.TException + { + send_get_triggers_for_resourceplan(request); + return recv_get_triggers_for_resourceplan(); + } + + public void send_get_triggers_for_resourceplan(WMGetTriggersForResourePlanRequest request) throws org.apache.thrift.TException + { + get_triggers_for_resourceplan_args args = new get_triggers_for_resourceplan_args(); + args.setRequest(request); + sendBase("get_triggers_for_resourceplan", args); + } + + public WMGetTriggersForResourePlanResponse recv_get_triggers_for_resourceplan() throws NoSuchObjectException, MetaException, org.apache.thrift.TException + { + get_triggers_for_resourceplan_result result = new get_triggers_for_resourceplan_result(); + receiveBase(result, "get_triggers_for_resourceplan"); + if (result.isSetSuccess()) { + return result.success; + } + if (result.o1 != null) { + throw result.o1; + } + if (result.o2 != null) { + throw result.o2; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "get_triggers_for_resourceplan failed: unknown result"); + } + } @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class AsyncClient extends com.facebook.fb303.FacebookService.AsyncClient implements AsyncIface { @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class Factory implements org.apache.thrift.async.TAsyncClientFactory { @@ -11457,6 +11601,134 @@ public WMDropResourcePlanResponse getResult() throws NoSuchObjectException, Inva } } + public void create_wm_trigger(WMCreateTriggerRequest request, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + create_wm_trigger_call method_call = new create_wm_trigger_call(request, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class create_wm_trigger_call extends org.apache.thrift.async.TAsyncMethodCall { + private WMCreateTriggerRequest request; + public create_wm_trigger_call(WMCreateTriggerRequest request, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.request = request; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("create_wm_trigger", org.apache.thrift.protocol.TMessageType.CALL, 0)); + create_wm_trigger_args args = new create_wm_trigger_args(); + args.setRequest(request); + args.write(prot); + prot.writeMessageEnd(); + } + + public WMCreateTriggerResponse getResult() throws AlreadyExistsException, NoSuchObjectException, InvalidObjectException, MetaException, org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_create_wm_trigger(); + } + } + + public void alter_wm_trigger(WMAlterTriggerRequest request, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + alter_wm_trigger_call method_call = new alter_wm_trigger_call(request, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class alter_wm_trigger_call extends org.apache.thrift.async.TAsyncMethodCall { + private WMAlterTriggerRequest request; + public alter_wm_trigger_call(WMAlterTriggerRequest request, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.request = request; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("alter_wm_trigger", org.apache.thrift.protocol.TMessageType.CALL, 0)); + alter_wm_trigger_args args = new alter_wm_trigger_args(); + args.setRequest(request); + args.write(prot); + prot.writeMessageEnd(); + } + + public WMAlterTriggerResponse getResult() throws NoSuchObjectException, InvalidObjectException, MetaException, org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_alter_wm_trigger(); + } + } + + public void drop_wm_trigger(WMDropTriggerRequest request, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + drop_wm_trigger_call method_call = new drop_wm_trigger_call(request, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class drop_wm_trigger_call extends org.apache.thrift.async.TAsyncMethodCall { + private WMDropTriggerRequest request; + public drop_wm_trigger_call(WMDropTriggerRequest request, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.request = request; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("drop_wm_trigger", org.apache.thrift.protocol.TMessageType.CALL, 0)); + drop_wm_trigger_args args = new drop_wm_trigger_args(); + args.setRequest(request); + args.write(prot); + prot.writeMessageEnd(); + } + + public WMDropTriggerResponse getResult() throws NoSuchObjectException, InvalidOperationException, MetaException, org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_drop_wm_trigger(); + } + } + + public void get_triggers_for_resourceplan(WMGetTriggersForResourePlanRequest request, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + get_triggers_for_resourceplan_call method_call = new get_triggers_for_resourceplan_call(request, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class get_triggers_for_resourceplan_call extends org.apache.thrift.async.TAsyncMethodCall { + private WMGetTriggersForResourePlanRequest request; + public get_triggers_for_resourceplan_call(WMGetTriggersForResourePlanRequest request, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.request = request; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("get_triggers_for_resourceplan", org.apache.thrift.protocol.TMessageType.CALL, 0)); + get_triggers_for_resourceplan_args args = new get_triggers_for_resourceplan_args(); + args.setRequest(request); + args.write(prot); + prot.writeMessageEnd(); + } + + public WMGetTriggersForResourePlanResponse getResult() throws NoSuchObjectException, MetaException, org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_get_triggers_for_resourceplan(); + } + } + } @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class Processor extends com.facebook.fb303.FacebookService.Processor implements org.apache.thrift.TProcessor { @@ -11638,6 +11910,10 @@ protected Processor(I iface, Map extends org.apache.thrift.ProcessFunction { + public create_wm_trigger() { + super("create_wm_trigger"); + } + + public create_wm_trigger_args getEmptyArgsInstance() { + return new create_wm_trigger_args(); + } + + protected boolean isOneway() { + return false; + } + + public create_wm_trigger_result getResult(I iface, create_wm_trigger_args args) throws org.apache.thrift.TException { + create_wm_trigger_result result = new create_wm_trigger_result(); + try { + result.success = iface.create_wm_trigger(args.request); + } catch (AlreadyExistsException o1) { + result.o1 = o1; + } catch (NoSuchObjectException o2) { + result.o2 = o2; + } catch (InvalidObjectException o3) { + result.o3 = o3; + } catch (MetaException o4) { + result.o4 = o4; + } + return result; + } + } + + public static class alter_wm_trigger extends org.apache.thrift.ProcessFunction { + public alter_wm_trigger() { + super("alter_wm_trigger"); + } + + public alter_wm_trigger_args getEmptyArgsInstance() { + return new alter_wm_trigger_args(); + } + + protected boolean isOneway() { + return false; + } + + public alter_wm_trigger_result getResult(I iface, alter_wm_trigger_args args) throws org.apache.thrift.TException { + alter_wm_trigger_result result = new alter_wm_trigger_result(); + try { + result.success = iface.alter_wm_trigger(args.request); + } catch (NoSuchObjectException o1) { + result.o1 = o1; + } catch (InvalidObjectException o2) { + result.o2 = o2; + } catch (MetaException o3) { + result.o3 = o3; + } + return result; + } + } + + public static class drop_wm_trigger extends org.apache.thrift.ProcessFunction { + public drop_wm_trigger() { + super("drop_wm_trigger"); + } + + public drop_wm_trigger_args getEmptyArgsInstance() { + return new drop_wm_trigger_args(); + } + + protected boolean isOneway() { + return false; + } + + public drop_wm_trigger_result getResult(I iface, drop_wm_trigger_args args) throws org.apache.thrift.TException { + drop_wm_trigger_result result = new drop_wm_trigger_result(); + try { + result.success = iface.drop_wm_trigger(args.request); + } catch (NoSuchObjectException o1) { + result.o1 = o1; + } catch (InvalidOperationException o2) { + result.o2 = o2; + } catch (MetaException o3) { + result.o3 = o3; + } + return result; + } + } + + public static class get_triggers_for_resourceplan extends org.apache.thrift.ProcessFunction { + public get_triggers_for_resourceplan() { + super("get_triggers_for_resourceplan"); + } + + public get_triggers_for_resourceplan_args getEmptyArgsInstance() { + return new get_triggers_for_resourceplan_args(); + } + + protected boolean isOneway() { + return false; + } + + public get_triggers_for_resourceplan_result getResult(I iface, get_triggers_for_resourceplan_args args) throws org.apache.thrift.TException { + get_triggers_for_resourceplan_result result = new get_triggers_for_resourceplan_result(); + try { + result.success = iface.get_triggers_for_resourceplan(args.request); + } catch (NoSuchObjectException o1) { + result.o1 = o1; + } catch (MetaException o2) { + result.o2 = o2; + } + return result; + } + } + } @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class AsyncProcessor extends com.facebook.fb303.FacebookService.AsyncProcessor { @@ -16102,6 +16490,10 @@ protected AsyncProcessor(I iface, Map extends org.apache.thrift.AsyncProcessFunction { + public create_wm_trigger() { + super("create_wm_trigger"); + } + + public create_wm_trigger_args getEmptyArgsInstance() { + return new create_wm_trigger_args(); + } + + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback() { + public void onComplete(WMCreateTriggerResponse o) { + create_wm_trigger_result result = new create_wm_trigger_result(); + result.success = o; + try { + fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + create_wm_trigger_result result = new create_wm_trigger_result(); + if (e instanceof AlreadyExistsException) { + result.o1 = (AlreadyExistsException) e; + result.setO1IsSet(true); + msg = result; + } + else if (e instanceof NoSuchObjectException) { + result.o2 = (NoSuchObjectException) e; + result.setO2IsSet(true); + msg = result; + } + else if (e instanceof InvalidObjectException) { + result.o3 = (InvalidObjectException) e; + result.setO3IsSet(true); + msg = result; + } + else if (e instanceof MetaException) { + result.o4 = (MetaException) e; + result.setO4IsSet(true); + msg = result; + } + else + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb,msg,msgType,seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, create_wm_trigger_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.create_wm_trigger(args.request,resultHandler); + } + } + + public static class alter_wm_trigger extends org.apache.thrift.AsyncProcessFunction { + public alter_wm_trigger() { + super("alter_wm_trigger"); + } + + public alter_wm_trigger_args getEmptyArgsInstance() { + return new alter_wm_trigger_args(); + } + + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback() { + public void onComplete(WMAlterTriggerResponse o) { + alter_wm_trigger_result result = new alter_wm_trigger_result(); + result.success = o; + try { + fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + alter_wm_trigger_result result = new alter_wm_trigger_result(); + if (e instanceof NoSuchObjectException) { + result.o1 = (NoSuchObjectException) e; + result.setO1IsSet(true); + msg = result; + } + else if (e instanceof InvalidObjectException) { + result.o2 = (InvalidObjectException) e; + result.setO2IsSet(true); + msg = result; + } + else if (e instanceof MetaException) { + result.o3 = (MetaException) e; + result.setO3IsSet(true); + msg = result; + } + else + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb,msg,msgType,seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, alter_wm_trigger_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.alter_wm_trigger(args.request,resultHandler); + } + } + + public static class drop_wm_trigger extends org.apache.thrift.AsyncProcessFunction { + public drop_wm_trigger() { + super("drop_wm_trigger"); + } + + public drop_wm_trigger_args getEmptyArgsInstance() { + return new drop_wm_trigger_args(); + } + + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback() { + public void onComplete(WMDropTriggerResponse o) { + drop_wm_trigger_result result = new drop_wm_trigger_result(); + result.success = o; + try { + fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + drop_wm_trigger_result result = new drop_wm_trigger_result(); + if (e instanceof NoSuchObjectException) { + result.o1 = (NoSuchObjectException) e; + result.setO1IsSet(true); + msg = result; + } + else if (e instanceof InvalidOperationException) { + result.o2 = (InvalidOperationException) e; + result.setO2IsSet(true); + msg = result; + } + else if (e instanceof MetaException) { + result.o3 = (MetaException) e; + result.setO3IsSet(true); + msg = result; + } + else + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb,msg,msgType,seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, drop_wm_trigger_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.drop_wm_trigger(args.request,resultHandler); + } + } + + public static class get_triggers_for_resourceplan extends org.apache.thrift.AsyncProcessFunction { + public get_triggers_for_resourceplan() { + super("get_triggers_for_resourceplan"); + } + + public get_triggers_for_resourceplan_args getEmptyArgsInstance() { + return new get_triggers_for_resourceplan_args(); + } + + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback() { + public void onComplete(WMGetTriggersForResourePlanResponse o) { + get_triggers_for_resourceplan_result result = new get_triggers_for_resourceplan_result(); + result.success = o; + try { + fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + get_triggers_for_resourceplan_result result = new get_triggers_for_resourceplan_result(); + if (e instanceof NoSuchObjectException) { + result.o1 = (NoSuchObjectException) e; + result.setO1IsSet(true); + msg = result; + } + else if (e instanceof MetaException) { + result.o2 = (MetaException) e; + result.setO2IsSet(true); + msg = result; + } + else + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb,msg,msgType,seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, get_triggers_for_resourceplan_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.get_triggers_for_resourceplan(args.request,resultHandler); + } + } + } @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class getMetaConf_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { @@ -31716,13 +32376,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_databases_resul case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list746 = iprot.readListBegin(); - struct.success = new ArrayList(_list746.size); - String _elem747; - for (int _i748 = 0; _i748 < _list746.size; ++_i748) + org.apache.thrift.protocol.TList _list754 = iprot.readListBegin(); + struct.success = new ArrayList(_list754.size); + String _elem755; + for (int _i756 = 0; _i756 < _list754.size; ++_i756) { - _elem747 = iprot.readString(); - struct.success.add(_elem747); + _elem755 = iprot.readString(); + struct.success.add(_elem755); } iprot.readListEnd(); } @@ -31757,9 +32417,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_databases_resu oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter749 : struct.success) + for (String _iter757 : struct.success) { - oprot.writeString(_iter749); + oprot.writeString(_iter757); } oprot.writeListEnd(); } @@ -31798,9 +32458,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_databases_resul if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter750 : struct.success) + for (String _iter758 : struct.success) { - oprot.writeString(_iter750); + oprot.writeString(_iter758); } } } @@ -31815,13 +32475,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_databases_result BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list751 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list751.size); - String _elem752; - for (int _i753 = 0; _i753 < _list751.size; ++_i753) + org.apache.thrift.protocol.TList _list759 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list759.size); + String _elem760; + for (int _i761 = 0; _i761 < _list759.size; ++_i761) { - _elem752 = iprot.readString(); - struct.success.add(_elem752); + _elem760 = iprot.readString(); + struct.success.add(_elem760); } } struct.setSuccessIsSet(true); @@ -32475,13 +33135,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_all_databases_r case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list754 = iprot.readListBegin(); - struct.success = new ArrayList(_list754.size); - String _elem755; - for (int _i756 = 0; _i756 < _list754.size; ++_i756) + org.apache.thrift.protocol.TList _list762 = iprot.readListBegin(); + struct.success = new ArrayList(_list762.size); + String _elem763; + for (int _i764 = 0; _i764 < _list762.size; ++_i764) { - _elem755 = iprot.readString(); - struct.success.add(_elem755); + _elem763 = iprot.readString(); + struct.success.add(_elem763); } iprot.readListEnd(); } @@ -32516,9 +33176,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_all_databases_ oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter757 : struct.success) + for (String _iter765 : struct.success) { - oprot.writeString(_iter757); + oprot.writeString(_iter765); } oprot.writeListEnd(); } @@ -32557,9 +33217,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_all_databases_r if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter758 : struct.success) + for (String _iter766 : struct.success) { - oprot.writeString(_iter758); + oprot.writeString(_iter766); } } } @@ -32574,13 +33234,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_all_databases_re BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list759 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list759.size); - String _elem760; - for (int _i761 = 0; _i761 < _list759.size; ++_i761) + org.apache.thrift.protocol.TList _list767 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list767.size); + String _elem768; + for (int _i769 = 0; _i769 < _list767.size; ++_i769) { - _elem760 = iprot.readString(); - struct.success.add(_elem760); + _elem768 = iprot.readString(); + struct.success.add(_elem768); } } struct.setSuccessIsSet(true); @@ -37187,16 +37847,16 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_type_all_result case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map762 = iprot.readMapBegin(); - struct.success = new HashMap(2*_map762.size); - String _key763; - Type _val764; - for (int _i765 = 0; _i765 < _map762.size; ++_i765) + org.apache.thrift.protocol.TMap _map770 = iprot.readMapBegin(); + struct.success = new HashMap(2*_map770.size); + String _key771; + Type _val772; + for (int _i773 = 0; _i773 < _map770.size; ++_i773) { - _key763 = iprot.readString(); - _val764 = new Type(); - _val764.read(iprot); - struct.success.put(_key763, _val764); + _key771 = iprot.readString(); + _val772 = new Type(); + _val772.read(iprot); + struct.success.put(_key771, _val772); } iprot.readMapEnd(); } @@ -37231,10 +37891,10 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_type_all_resul oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (Map.Entry _iter766 : struct.success.entrySet()) + for (Map.Entry _iter774 : struct.success.entrySet()) { - oprot.writeString(_iter766.getKey()); - _iter766.getValue().write(oprot); + oprot.writeString(_iter774.getKey()); + _iter774.getValue().write(oprot); } oprot.writeMapEnd(); } @@ -37273,10 +37933,10 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_type_all_result if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Map.Entry _iter767 : struct.success.entrySet()) + for (Map.Entry _iter775 : struct.success.entrySet()) { - oprot.writeString(_iter767.getKey()); - _iter767.getValue().write(oprot); + oprot.writeString(_iter775.getKey()); + _iter775.getValue().write(oprot); } } } @@ -37291,16 +37951,16 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_type_all_result BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TMap _map768 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new HashMap(2*_map768.size); - String _key769; - Type _val770; - for (int _i771 = 0; _i771 < _map768.size; ++_i771) + org.apache.thrift.protocol.TMap _map776 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new HashMap(2*_map776.size); + String _key777; + Type _val778; + for (int _i779 = 0; _i779 < _map776.size; ++_i779) { - _key769 = iprot.readString(); - _val770 = new Type(); - _val770.read(iprot); - struct.success.put(_key769, _val770); + _key777 = iprot.readString(); + _val778 = new Type(); + _val778.read(iprot); + struct.success.put(_key777, _val778); } } struct.setSuccessIsSet(true); @@ -38335,14 +38995,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_fields_result s case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list772 = iprot.readListBegin(); - struct.success = new ArrayList(_list772.size); - FieldSchema _elem773; - for (int _i774 = 0; _i774 < _list772.size; ++_i774) + org.apache.thrift.protocol.TList _list780 = iprot.readListBegin(); + struct.success = new ArrayList(_list780.size); + FieldSchema _elem781; + for (int _i782 = 0; _i782 < _list780.size; ++_i782) { - _elem773 = new FieldSchema(); - _elem773.read(iprot); - struct.success.add(_elem773); + _elem781 = new FieldSchema(); + _elem781.read(iprot); + struct.success.add(_elem781); } iprot.readListEnd(); } @@ -38395,9 +39055,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_fields_result oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (FieldSchema _iter775 : struct.success) + for (FieldSchema _iter783 : struct.success) { - _iter775.write(oprot); + _iter783.write(oprot); } oprot.writeListEnd(); } @@ -38452,9 +39112,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_fields_result s if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (FieldSchema _iter776 : struct.success) + for (FieldSchema _iter784 : struct.success) { - _iter776.write(oprot); + _iter784.write(oprot); } } } @@ -38475,14 +39135,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_fields_result st BitSet incoming = iprot.readBitSet(4); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list777 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list777.size); - FieldSchema _elem778; - for (int _i779 = 0; _i779 < _list777.size; ++_i779) + org.apache.thrift.protocol.TList _list785 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list785.size); + FieldSchema _elem786; + for (int _i787 = 0; _i787 < _list785.size; ++_i787) { - _elem778 = new FieldSchema(); - _elem778.read(iprot); - struct.success.add(_elem778); + _elem786 = new FieldSchema(); + _elem786.read(iprot); + struct.success.add(_elem786); } } struct.setSuccessIsSet(true); @@ -39636,14 +40296,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_fields_with_env case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list780 = iprot.readListBegin(); - struct.success = new ArrayList(_list780.size); - FieldSchema _elem781; - for (int _i782 = 0; _i782 < _list780.size; ++_i782) + org.apache.thrift.protocol.TList _list788 = iprot.readListBegin(); + struct.success = new ArrayList(_list788.size); + FieldSchema _elem789; + for (int _i790 = 0; _i790 < _list788.size; ++_i790) { - _elem781 = new FieldSchema(); - _elem781.read(iprot); - struct.success.add(_elem781); + _elem789 = new FieldSchema(); + _elem789.read(iprot); + struct.success.add(_elem789); } iprot.readListEnd(); } @@ -39696,9 +40356,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_fields_with_en oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (FieldSchema _iter783 : struct.success) + for (FieldSchema _iter791 : struct.success) { - _iter783.write(oprot); + _iter791.write(oprot); } oprot.writeListEnd(); } @@ -39753,9 +40413,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_fields_with_env if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (FieldSchema _iter784 : struct.success) + for (FieldSchema _iter792 : struct.success) { - _iter784.write(oprot); + _iter792.write(oprot); } } } @@ -39776,14 +40436,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_fields_with_envi BitSet incoming = iprot.readBitSet(4); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list785 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list785.size); - FieldSchema _elem786; - for (int _i787 = 0; _i787 < _list785.size; ++_i787) + org.apache.thrift.protocol.TList _list793 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list793.size); + FieldSchema _elem794; + for (int _i795 = 0; _i795 < _list793.size; ++_i795) { - _elem786 = new FieldSchema(); - _elem786.read(iprot); - struct.success.add(_elem786); + _elem794 = new FieldSchema(); + _elem794.read(iprot); + struct.success.add(_elem794); } } struct.setSuccessIsSet(true); @@ -40828,14 +41488,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_schema_result s case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list788 = iprot.readListBegin(); - struct.success = new ArrayList(_list788.size); - FieldSchema _elem789; - for (int _i790 = 0; _i790 < _list788.size; ++_i790) + org.apache.thrift.protocol.TList _list796 = iprot.readListBegin(); + struct.success = new ArrayList(_list796.size); + FieldSchema _elem797; + for (int _i798 = 0; _i798 < _list796.size; ++_i798) { - _elem789 = new FieldSchema(); - _elem789.read(iprot); - struct.success.add(_elem789); + _elem797 = new FieldSchema(); + _elem797.read(iprot); + struct.success.add(_elem797); } iprot.readListEnd(); } @@ -40888,9 +41548,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_schema_result oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (FieldSchema _iter791 : struct.success) + for (FieldSchema _iter799 : struct.success) { - _iter791.write(oprot); + _iter799.write(oprot); } oprot.writeListEnd(); } @@ -40945,9 +41605,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_schema_result s if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (FieldSchema _iter792 : struct.success) + for (FieldSchema _iter800 : struct.success) { - _iter792.write(oprot); + _iter800.write(oprot); } } } @@ -40968,14 +41628,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_schema_result st BitSet incoming = iprot.readBitSet(4); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list793 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list793.size); - FieldSchema _elem794; - for (int _i795 = 0; _i795 < _list793.size; ++_i795) + org.apache.thrift.protocol.TList _list801 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list801.size); + FieldSchema _elem802; + for (int _i803 = 0; _i803 < _list801.size; ++_i803) { - _elem794 = new FieldSchema(); - _elem794.read(iprot); - struct.success.add(_elem794); + _elem802 = new FieldSchema(); + _elem802.read(iprot); + struct.success.add(_elem802); } } struct.setSuccessIsSet(true); @@ -42129,14 +42789,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_schema_with_env case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list796 = iprot.readListBegin(); - struct.success = new ArrayList(_list796.size); - FieldSchema _elem797; - for (int _i798 = 0; _i798 < _list796.size; ++_i798) + org.apache.thrift.protocol.TList _list804 = iprot.readListBegin(); + struct.success = new ArrayList(_list804.size); + FieldSchema _elem805; + for (int _i806 = 0; _i806 < _list804.size; ++_i806) { - _elem797 = new FieldSchema(); - _elem797.read(iprot); - struct.success.add(_elem797); + _elem805 = new FieldSchema(); + _elem805.read(iprot); + struct.success.add(_elem805); } iprot.readListEnd(); } @@ -42189,9 +42849,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_schema_with_en oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (FieldSchema _iter799 : struct.success) + for (FieldSchema _iter807 : struct.success) { - _iter799.write(oprot); + _iter807.write(oprot); } oprot.writeListEnd(); } @@ -42246,9 +42906,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_schema_with_env if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (FieldSchema _iter800 : struct.success) + for (FieldSchema _iter808 : struct.success) { - _iter800.write(oprot); + _iter808.write(oprot); } } } @@ -42269,14 +42929,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_schema_with_envi BitSet incoming = iprot.readBitSet(4); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list801 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list801.size); - FieldSchema _elem802; - for (int _i803 = 0; _i803 < _list801.size; ++_i803) + org.apache.thrift.protocol.TList _list809 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list809.size); + FieldSchema _elem810; + for (int _i811 = 0; _i811 < _list809.size; ++_i811) { - _elem802 = new FieldSchema(); - _elem802.read(iprot); - struct.success.add(_elem802); + _elem810 = new FieldSchema(); + _elem810.read(iprot); + struct.success.add(_elem810); } } struct.setSuccessIsSet(true); @@ -45203,14 +45863,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, create_table_with_c case 2: // PRIMARY_KEYS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list804 = iprot.readListBegin(); - struct.primaryKeys = new ArrayList(_list804.size); - SQLPrimaryKey _elem805; - for (int _i806 = 0; _i806 < _list804.size; ++_i806) + org.apache.thrift.protocol.TList _list812 = iprot.readListBegin(); + struct.primaryKeys = new ArrayList(_list812.size); + SQLPrimaryKey _elem813; + for (int _i814 = 0; _i814 < _list812.size; ++_i814) { - _elem805 = new SQLPrimaryKey(); - _elem805.read(iprot); - struct.primaryKeys.add(_elem805); + _elem813 = new SQLPrimaryKey(); + _elem813.read(iprot); + struct.primaryKeys.add(_elem813); } iprot.readListEnd(); } @@ -45222,14 +45882,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, create_table_with_c case 3: // FOREIGN_KEYS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list807 = iprot.readListBegin(); - struct.foreignKeys = new ArrayList(_list807.size); - SQLForeignKey _elem808; - for (int _i809 = 0; _i809 < _list807.size; ++_i809) + org.apache.thrift.protocol.TList _list815 = iprot.readListBegin(); + struct.foreignKeys = new ArrayList(_list815.size); + SQLForeignKey _elem816; + for (int _i817 = 0; _i817 < _list815.size; ++_i817) { - _elem808 = new SQLForeignKey(); - _elem808.read(iprot); - struct.foreignKeys.add(_elem808); + _elem816 = new SQLForeignKey(); + _elem816.read(iprot); + struct.foreignKeys.add(_elem816); } iprot.readListEnd(); } @@ -45241,14 +45901,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, create_table_with_c case 4: // UNIQUE_CONSTRAINTS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list810 = iprot.readListBegin(); - struct.uniqueConstraints = new ArrayList(_list810.size); - SQLUniqueConstraint _elem811; - for (int _i812 = 0; _i812 < _list810.size; ++_i812) + org.apache.thrift.protocol.TList _list818 = iprot.readListBegin(); + struct.uniqueConstraints = new ArrayList(_list818.size); + SQLUniqueConstraint _elem819; + for (int _i820 = 0; _i820 < _list818.size; ++_i820) { - _elem811 = new SQLUniqueConstraint(); - _elem811.read(iprot); - struct.uniqueConstraints.add(_elem811); + _elem819 = new SQLUniqueConstraint(); + _elem819.read(iprot); + struct.uniqueConstraints.add(_elem819); } iprot.readListEnd(); } @@ -45260,14 +45920,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, create_table_with_c case 5: // NOT_NULL_CONSTRAINTS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list813 = iprot.readListBegin(); - struct.notNullConstraints = new ArrayList(_list813.size); - SQLNotNullConstraint _elem814; - for (int _i815 = 0; _i815 < _list813.size; ++_i815) + org.apache.thrift.protocol.TList _list821 = iprot.readListBegin(); + struct.notNullConstraints = new ArrayList(_list821.size); + SQLNotNullConstraint _elem822; + for (int _i823 = 0; _i823 < _list821.size; ++_i823) { - _elem814 = new SQLNotNullConstraint(); - _elem814.read(iprot); - struct.notNullConstraints.add(_elem814); + _elem822 = new SQLNotNullConstraint(); + _elem822.read(iprot); + struct.notNullConstraints.add(_elem822); } iprot.readListEnd(); } @@ -45298,9 +45958,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, create_table_with_ oprot.writeFieldBegin(PRIMARY_KEYS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.primaryKeys.size())); - for (SQLPrimaryKey _iter816 : struct.primaryKeys) + for (SQLPrimaryKey _iter824 : struct.primaryKeys) { - _iter816.write(oprot); + _iter824.write(oprot); } oprot.writeListEnd(); } @@ -45310,9 +45970,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, create_table_with_ oprot.writeFieldBegin(FOREIGN_KEYS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.foreignKeys.size())); - for (SQLForeignKey _iter817 : struct.foreignKeys) + for (SQLForeignKey _iter825 : struct.foreignKeys) { - _iter817.write(oprot); + _iter825.write(oprot); } oprot.writeListEnd(); } @@ -45322,9 +45982,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, create_table_with_ oprot.writeFieldBegin(UNIQUE_CONSTRAINTS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.uniqueConstraints.size())); - for (SQLUniqueConstraint _iter818 : struct.uniqueConstraints) + for (SQLUniqueConstraint _iter826 : struct.uniqueConstraints) { - _iter818.write(oprot); + _iter826.write(oprot); } oprot.writeListEnd(); } @@ -45334,9 +45994,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, create_table_with_ oprot.writeFieldBegin(NOT_NULL_CONSTRAINTS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.notNullConstraints.size())); - for (SQLNotNullConstraint _iter819 : struct.notNullConstraints) + for (SQLNotNullConstraint _iter827 : struct.notNullConstraints) { - _iter819.write(oprot); + _iter827.write(oprot); } oprot.writeListEnd(); } @@ -45382,36 +46042,36 @@ public void write(org.apache.thrift.protocol.TProtocol prot, create_table_with_c if (struct.isSetPrimaryKeys()) { { oprot.writeI32(struct.primaryKeys.size()); - for (SQLPrimaryKey _iter820 : struct.primaryKeys) + for (SQLPrimaryKey _iter828 : struct.primaryKeys) { - _iter820.write(oprot); + _iter828.write(oprot); } } } if (struct.isSetForeignKeys()) { { oprot.writeI32(struct.foreignKeys.size()); - for (SQLForeignKey _iter821 : struct.foreignKeys) + for (SQLForeignKey _iter829 : struct.foreignKeys) { - _iter821.write(oprot); + _iter829.write(oprot); } } } if (struct.isSetUniqueConstraints()) { { oprot.writeI32(struct.uniqueConstraints.size()); - for (SQLUniqueConstraint _iter822 : struct.uniqueConstraints) + for (SQLUniqueConstraint _iter830 : struct.uniqueConstraints) { - _iter822.write(oprot); + _iter830.write(oprot); } } } if (struct.isSetNotNullConstraints()) { { oprot.writeI32(struct.notNullConstraints.size()); - for (SQLNotNullConstraint _iter823 : struct.notNullConstraints) + for (SQLNotNullConstraint _iter831 : struct.notNullConstraints) { - _iter823.write(oprot); + _iter831.write(oprot); } } } @@ -45428,56 +46088,56 @@ public void read(org.apache.thrift.protocol.TProtocol prot, create_table_with_co } if (incoming.get(1)) { { - org.apache.thrift.protocol.TList _list824 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.primaryKeys = new ArrayList(_list824.size); - SQLPrimaryKey _elem825; - for (int _i826 = 0; _i826 < _list824.size; ++_i826) + org.apache.thrift.protocol.TList _list832 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.primaryKeys = new ArrayList(_list832.size); + SQLPrimaryKey _elem833; + for (int _i834 = 0; _i834 < _list832.size; ++_i834) { - _elem825 = new SQLPrimaryKey(); - _elem825.read(iprot); - struct.primaryKeys.add(_elem825); + _elem833 = new SQLPrimaryKey(); + _elem833.read(iprot); + struct.primaryKeys.add(_elem833); } } struct.setPrimaryKeysIsSet(true); } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list827 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.foreignKeys = new ArrayList(_list827.size); - SQLForeignKey _elem828; - for (int _i829 = 0; _i829 < _list827.size; ++_i829) + org.apache.thrift.protocol.TList _list835 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.foreignKeys = new ArrayList(_list835.size); + SQLForeignKey _elem836; + for (int _i837 = 0; _i837 < _list835.size; ++_i837) { - _elem828 = new SQLForeignKey(); - _elem828.read(iprot); - struct.foreignKeys.add(_elem828); + _elem836 = new SQLForeignKey(); + _elem836.read(iprot); + struct.foreignKeys.add(_elem836); } } struct.setForeignKeysIsSet(true); } if (incoming.get(3)) { { - org.apache.thrift.protocol.TList _list830 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.uniqueConstraints = new ArrayList(_list830.size); - SQLUniqueConstraint _elem831; - for (int _i832 = 0; _i832 < _list830.size; ++_i832) + org.apache.thrift.protocol.TList _list838 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.uniqueConstraints = new ArrayList(_list838.size); + SQLUniqueConstraint _elem839; + for (int _i840 = 0; _i840 < _list838.size; ++_i840) { - _elem831 = new SQLUniqueConstraint(); - _elem831.read(iprot); - struct.uniqueConstraints.add(_elem831); + _elem839 = new SQLUniqueConstraint(); + _elem839.read(iprot); + struct.uniqueConstraints.add(_elem839); } } struct.setUniqueConstraintsIsSet(true); } if (incoming.get(4)) { { - org.apache.thrift.protocol.TList _list833 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.notNullConstraints = new ArrayList(_list833.size); - SQLNotNullConstraint _elem834; - for (int _i835 = 0; _i835 < _list833.size; ++_i835) + org.apache.thrift.protocol.TList _list841 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.notNullConstraints = new ArrayList(_list841.size); + SQLNotNullConstraint _elem842; + for (int _i843 = 0; _i843 < _list841.size; ++_i843) { - _elem834 = new SQLNotNullConstraint(); - _elem834.read(iprot); - struct.notNullConstraints.add(_elem834); + _elem842 = new SQLNotNullConstraint(); + _elem842.read(iprot); + struct.notNullConstraints.add(_elem842); } } struct.setNotNullConstraintsIsSet(true); @@ -52969,13 +53629,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, truncate_table_args case 3: // PART_NAMES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list836 = iprot.readListBegin(); - struct.partNames = new ArrayList(_list836.size); - String _elem837; - for (int _i838 = 0; _i838 < _list836.size; ++_i838) + org.apache.thrift.protocol.TList _list844 = iprot.readListBegin(); + struct.partNames = new ArrayList(_list844.size); + String _elem845; + for (int _i846 = 0; _i846 < _list844.size; ++_i846) { - _elem837 = iprot.readString(); - struct.partNames.add(_elem837); + _elem845 = iprot.readString(); + struct.partNames.add(_elem845); } iprot.readListEnd(); } @@ -53011,9 +53671,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, truncate_table_arg oprot.writeFieldBegin(PART_NAMES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.partNames.size())); - for (String _iter839 : struct.partNames) + for (String _iter847 : struct.partNames) { - oprot.writeString(_iter839); + oprot.writeString(_iter847); } oprot.writeListEnd(); } @@ -53056,9 +53716,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, truncate_table_args if (struct.isSetPartNames()) { { oprot.writeI32(struct.partNames.size()); - for (String _iter840 : struct.partNames) + for (String _iter848 : struct.partNames) { - oprot.writeString(_iter840); + oprot.writeString(_iter848); } } } @@ -53078,13 +53738,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, truncate_table_args } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list841 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.partNames = new ArrayList(_list841.size); - String _elem842; - for (int _i843 = 0; _i843 < _list841.size; ++_i843) + org.apache.thrift.protocol.TList _list849 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.partNames = new ArrayList(_list849.size); + String _elem850; + for (int _i851 = 0; _i851 < _list849.size; ++_i851) { - _elem842 = iprot.readString(); - struct.partNames.add(_elem842); + _elem850 = iprot.readString(); + struct.partNames.add(_elem850); } } struct.setPartNamesIsSet(true); @@ -54309,13 +54969,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_tables_result s case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list844 = iprot.readListBegin(); - struct.success = new ArrayList(_list844.size); - String _elem845; - for (int _i846 = 0; _i846 < _list844.size; ++_i846) + org.apache.thrift.protocol.TList _list852 = iprot.readListBegin(); + struct.success = new ArrayList(_list852.size); + String _elem853; + for (int _i854 = 0; _i854 < _list852.size; ++_i854) { - _elem845 = iprot.readString(); - struct.success.add(_elem845); + _elem853 = iprot.readString(); + struct.success.add(_elem853); } iprot.readListEnd(); } @@ -54350,9 +55010,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_tables_result oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter847 : struct.success) + for (String _iter855 : struct.success) { - oprot.writeString(_iter847); + oprot.writeString(_iter855); } oprot.writeListEnd(); } @@ -54391,9 +55051,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_tables_result s if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter848 : struct.success) + for (String _iter856 : struct.success) { - oprot.writeString(_iter848); + oprot.writeString(_iter856); } } } @@ -54408,13 +55068,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_tables_result st BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list849 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list849.size); - String _elem850; - for (int _i851 = 0; _i851 < _list849.size; ++_i851) + org.apache.thrift.protocol.TList _list857 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list857.size); + String _elem858; + for (int _i859 = 0; _i859 < _list857.size; ++_i859) { - _elem850 = iprot.readString(); - struct.success.add(_elem850); + _elem858 = iprot.readString(); + struct.success.add(_elem858); } } struct.setSuccessIsSet(true); @@ -55388,13 +56048,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_tables_by_type_ case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list852 = iprot.readListBegin(); - struct.success = new ArrayList(_list852.size); - String _elem853; - for (int _i854 = 0; _i854 < _list852.size; ++_i854) + org.apache.thrift.protocol.TList _list860 = iprot.readListBegin(); + struct.success = new ArrayList(_list860.size); + String _elem861; + for (int _i862 = 0; _i862 < _list860.size; ++_i862) { - _elem853 = iprot.readString(); - struct.success.add(_elem853); + _elem861 = iprot.readString(); + struct.success.add(_elem861); } iprot.readListEnd(); } @@ -55429,9 +56089,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_tables_by_type oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter855 : struct.success) + for (String _iter863 : struct.success) { - oprot.writeString(_iter855); + oprot.writeString(_iter863); } oprot.writeListEnd(); } @@ -55470,9 +56130,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_tables_by_type_ if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter856 : struct.success) + for (String _iter864 : struct.success) { - oprot.writeString(_iter856); + oprot.writeString(_iter864); } } } @@ -55487,13 +56147,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_tables_by_type_r BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list857 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list857.size); - String _elem858; - for (int _i859 = 0; _i859 < _list857.size; ++_i859) + org.apache.thrift.protocol.TList _list865 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list865.size); + String _elem866; + for (int _i867 = 0; _i867 < _list865.size; ++_i867) { - _elem858 = iprot.readString(); - struct.success.add(_elem858); + _elem866 = iprot.readString(); + struct.success.add(_elem866); } } struct.setSuccessIsSet(true); @@ -55998,13 +56658,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_table_meta_args case 3: // TBL_TYPES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list860 = iprot.readListBegin(); - struct.tbl_types = new ArrayList(_list860.size); - String _elem861; - for (int _i862 = 0; _i862 < _list860.size; ++_i862) + org.apache.thrift.protocol.TList _list868 = iprot.readListBegin(); + struct.tbl_types = new ArrayList(_list868.size); + String _elem869; + for (int _i870 = 0; _i870 < _list868.size; ++_i870) { - _elem861 = iprot.readString(); - struct.tbl_types.add(_elem861); + _elem869 = iprot.readString(); + struct.tbl_types.add(_elem869); } iprot.readListEnd(); } @@ -56040,9 +56700,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_table_meta_arg oprot.writeFieldBegin(TBL_TYPES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.tbl_types.size())); - for (String _iter863 : struct.tbl_types) + for (String _iter871 : struct.tbl_types) { - oprot.writeString(_iter863); + oprot.writeString(_iter871); } oprot.writeListEnd(); } @@ -56085,9 +56745,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_table_meta_args if (struct.isSetTbl_types()) { { oprot.writeI32(struct.tbl_types.size()); - for (String _iter864 : struct.tbl_types) + for (String _iter872 : struct.tbl_types) { - oprot.writeString(_iter864); + oprot.writeString(_iter872); } } } @@ -56107,13 +56767,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_table_meta_args } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list865 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.tbl_types = new ArrayList(_list865.size); - String _elem866; - for (int _i867 = 0; _i867 < _list865.size; ++_i867) + org.apache.thrift.protocol.TList _list873 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.tbl_types = new ArrayList(_list873.size); + String _elem874; + for (int _i875 = 0; _i875 < _list873.size; ++_i875) { - _elem866 = iprot.readString(); - struct.tbl_types.add(_elem866); + _elem874 = iprot.readString(); + struct.tbl_types.add(_elem874); } } struct.setTbl_typesIsSet(true); @@ -56519,14 +57179,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_table_meta_resu case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list868 = iprot.readListBegin(); - struct.success = new ArrayList(_list868.size); - TableMeta _elem869; - for (int _i870 = 0; _i870 < _list868.size; ++_i870) + org.apache.thrift.protocol.TList _list876 = iprot.readListBegin(); + struct.success = new ArrayList(_list876.size); + TableMeta _elem877; + for (int _i878 = 0; _i878 < _list876.size; ++_i878) { - _elem869 = new TableMeta(); - _elem869.read(iprot); - struct.success.add(_elem869); + _elem877 = new TableMeta(); + _elem877.read(iprot); + struct.success.add(_elem877); } iprot.readListEnd(); } @@ -56561,9 +57221,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_table_meta_res oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (TableMeta _iter871 : struct.success) + for (TableMeta _iter879 : struct.success) { - _iter871.write(oprot); + _iter879.write(oprot); } oprot.writeListEnd(); } @@ -56602,9 +57262,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_table_meta_resu if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (TableMeta _iter872 : struct.success) + for (TableMeta _iter880 : struct.success) { - _iter872.write(oprot); + _iter880.write(oprot); } } } @@ -56619,14 +57279,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_table_meta_resul BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list873 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list873.size); - TableMeta _elem874; - for (int _i875 = 0; _i875 < _list873.size; ++_i875) + org.apache.thrift.protocol.TList _list881 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list881.size); + TableMeta _elem882; + for (int _i883 = 0; _i883 < _list881.size; ++_i883) { - _elem874 = new TableMeta(); - _elem874.read(iprot); - struct.success.add(_elem874); + _elem882 = new TableMeta(); + _elem882.read(iprot); + struct.success.add(_elem882); } } struct.setSuccessIsSet(true); @@ -57392,13 +58052,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_all_tables_resu case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list876 = iprot.readListBegin(); - struct.success = new ArrayList(_list876.size); - String _elem877; - for (int _i878 = 0; _i878 < _list876.size; ++_i878) + org.apache.thrift.protocol.TList _list884 = iprot.readListBegin(); + struct.success = new ArrayList(_list884.size); + String _elem885; + for (int _i886 = 0; _i886 < _list884.size; ++_i886) { - _elem877 = iprot.readString(); - struct.success.add(_elem877); + _elem885 = iprot.readString(); + struct.success.add(_elem885); } iprot.readListEnd(); } @@ -57433,9 +58093,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_all_tables_res oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter879 : struct.success) + for (String _iter887 : struct.success) { - oprot.writeString(_iter879); + oprot.writeString(_iter887); } oprot.writeListEnd(); } @@ -57474,9 +58134,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_all_tables_resu if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter880 : struct.success) + for (String _iter888 : struct.success) { - oprot.writeString(_iter880); + oprot.writeString(_iter888); } } } @@ -57491,13 +58151,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_all_tables_resul BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list881 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list881.size); - String _elem882; - for (int _i883 = 0; _i883 < _list881.size; ++_i883) + org.apache.thrift.protocol.TList _list889 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list889.size); + String _elem890; + for (int _i891 = 0; _i891 < _list889.size; ++_i891) { - _elem882 = iprot.readString(); - struct.success.add(_elem882); + _elem890 = iprot.readString(); + struct.success.add(_elem890); } } struct.setSuccessIsSet(true); @@ -58950,13 +59610,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_table_objects_b case 2: // TBL_NAMES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list884 = iprot.readListBegin(); - struct.tbl_names = new ArrayList(_list884.size); - String _elem885; - for (int _i886 = 0; _i886 < _list884.size; ++_i886) + org.apache.thrift.protocol.TList _list892 = iprot.readListBegin(); + struct.tbl_names = new ArrayList(_list892.size); + String _elem893; + for (int _i894 = 0; _i894 < _list892.size; ++_i894) { - _elem885 = iprot.readString(); - struct.tbl_names.add(_elem885); + _elem893 = iprot.readString(); + struct.tbl_names.add(_elem893); } iprot.readListEnd(); } @@ -58987,9 +59647,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_table_objects_ oprot.writeFieldBegin(TBL_NAMES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.tbl_names.size())); - for (String _iter887 : struct.tbl_names) + for (String _iter895 : struct.tbl_names) { - oprot.writeString(_iter887); + oprot.writeString(_iter895); } oprot.writeListEnd(); } @@ -59026,9 +59686,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_table_objects_b if (struct.isSetTbl_names()) { { oprot.writeI32(struct.tbl_names.size()); - for (String _iter888 : struct.tbl_names) + for (String _iter896 : struct.tbl_names) { - oprot.writeString(_iter888); + oprot.writeString(_iter896); } } } @@ -59044,13 +59704,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_table_objects_by } if (incoming.get(1)) { { - org.apache.thrift.protocol.TList _list889 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.tbl_names = new ArrayList(_list889.size); - String _elem890; - for (int _i891 = 0; _i891 < _list889.size; ++_i891) + org.apache.thrift.protocol.TList _list897 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.tbl_names = new ArrayList(_list897.size); + String _elem898; + for (int _i899 = 0; _i899 < _list897.size; ++_i899) { - _elem890 = iprot.readString(); - struct.tbl_names.add(_elem890); + _elem898 = iprot.readString(); + struct.tbl_names.add(_elem898); } } struct.setTbl_namesIsSet(true); @@ -59375,14 +60035,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_table_objects_b case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list892 = iprot.readListBegin(); - struct.success = new ArrayList
(_list892.size); - Table _elem893; - for (int _i894 = 0; _i894 < _list892.size; ++_i894) + org.apache.thrift.protocol.TList _list900 = iprot.readListBegin(); + struct.success = new ArrayList
(_list900.size); + Table _elem901; + for (int _i902 = 0; _i902 < _list900.size; ++_i902) { - _elem893 = new Table(); - _elem893.read(iprot); - struct.success.add(_elem893); + _elem901 = new Table(); + _elem901.read(iprot); + struct.success.add(_elem901); } iprot.readListEnd(); } @@ -59408,9 +60068,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_table_objects_ oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (Table _iter895 : struct.success) + for (Table _iter903 : struct.success) { - _iter895.write(oprot); + _iter903.write(oprot); } oprot.writeListEnd(); } @@ -59441,9 +60101,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_table_objects_b if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Table _iter896 : struct.success) + for (Table _iter904 : struct.success) { - _iter896.write(oprot); + _iter904.write(oprot); } } } @@ -59455,14 +60115,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_table_objects_by BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list897 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList
(_list897.size); - Table _elem898; - for (int _i899 = 0; _i899 < _list897.size; ++_i899) + org.apache.thrift.protocol.TList _list905 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList
(_list905.size); + Table _elem906; + for (int _i907 = 0; _i907 < _list905.size; ++_i907) { - _elem898 = new Table(); - _elem898.read(iprot); - struct.success.add(_elem898); + _elem906 = new Table(); + _elem906.read(iprot); + struct.success.add(_elem906); } } struct.setSuccessIsSet(true); @@ -62575,13 +63235,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_table_names_by_ case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list900 = iprot.readListBegin(); - struct.success = new ArrayList(_list900.size); - String _elem901; - for (int _i902 = 0; _i902 < _list900.size; ++_i902) + org.apache.thrift.protocol.TList _list908 = iprot.readListBegin(); + struct.success = new ArrayList(_list908.size); + String _elem909; + for (int _i910 = 0; _i910 < _list908.size; ++_i910) { - _elem901 = iprot.readString(); - struct.success.add(_elem901); + _elem909 = iprot.readString(); + struct.success.add(_elem909); } iprot.readListEnd(); } @@ -62634,9 +63294,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_table_names_by oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter903 : struct.success) + for (String _iter911 : struct.success) { - oprot.writeString(_iter903); + oprot.writeString(_iter911); } oprot.writeListEnd(); } @@ -62691,9 +63351,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_table_names_by_ if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter904 : struct.success) + for (String _iter912 : struct.success) { - oprot.writeString(_iter904); + oprot.writeString(_iter912); } } } @@ -62714,13 +63374,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_table_names_by_f BitSet incoming = iprot.readBitSet(4); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list905 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list905.size); - String _elem906; - for (int _i907 = 0; _i907 < _list905.size; ++_i907) + org.apache.thrift.protocol.TList _list913 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list913.size); + String _elem914; + for (int _i915 = 0; _i915 < _list913.size; ++_i915) { - _elem906 = iprot.readString(); - struct.success.add(_elem906); + _elem914 = iprot.readString(); + struct.success.add(_elem914); } } struct.setSuccessIsSet(true); @@ -68579,14 +69239,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, add_partitions_args case 1: // NEW_PARTS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list908 = iprot.readListBegin(); - struct.new_parts = new ArrayList(_list908.size); - Partition _elem909; - for (int _i910 = 0; _i910 < _list908.size; ++_i910) + org.apache.thrift.protocol.TList _list916 = iprot.readListBegin(); + struct.new_parts = new ArrayList(_list916.size); + Partition _elem917; + for (int _i918 = 0; _i918 < _list916.size; ++_i918) { - _elem909 = new Partition(); - _elem909.read(iprot); - struct.new_parts.add(_elem909); + _elem917 = new Partition(); + _elem917.read(iprot); + struct.new_parts.add(_elem917); } iprot.readListEnd(); } @@ -68612,9 +69272,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, add_partitions_arg oprot.writeFieldBegin(NEW_PARTS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.new_parts.size())); - for (Partition _iter911 : struct.new_parts) + for (Partition _iter919 : struct.new_parts) { - _iter911.write(oprot); + _iter919.write(oprot); } oprot.writeListEnd(); } @@ -68645,9 +69305,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, add_partitions_args if (struct.isSetNew_parts()) { { oprot.writeI32(struct.new_parts.size()); - for (Partition _iter912 : struct.new_parts) + for (Partition _iter920 : struct.new_parts) { - _iter912.write(oprot); + _iter920.write(oprot); } } } @@ -68659,14 +69319,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, add_partitions_args BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list913 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.new_parts = new ArrayList(_list913.size); - Partition _elem914; - for (int _i915 = 0; _i915 < _list913.size; ++_i915) + org.apache.thrift.protocol.TList _list921 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.new_parts = new ArrayList(_list921.size); + Partition _elem922; + for (int _i923 = 0; _i923 < _list921.size; ++_i923) { - _elem914 = new Partition(); - _elem914.read(iprot); - struct.new_parts.add(_elem914); + _elem922 = new Partition(); + _elem922.read(iprot); + struct.new_parts.add(_elem922); } } struct.setNew_partsIsSet(true); @@ -69667,14 +70327,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, add_partitions_pspe case 1: // NEW_PARTS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list916 = iprot.readListBegin(); - struct.new_parts = new ArrayList(_list916.size); - PartitionSpec _elem917; - for (int _i918 = 0; _i918 < _list916.size; ++_i918) + org.apache.thrift.protocol.TList _list924 = iprot.readListBegin(); + struct.new_parts = new ArrayList(_list924.size); + PartitionSpec _elem925; + for (int _i926 = 0; _i926 < _list924.size; ++_i926) { - _elem917 = new PartitionSpec(); - _elem917.read(iprot); - struct.new_parts.add(_elem917); + _elem925 = new PartitionSpec(); + _elem925.read(iprot); + struct.new_parts.add(_elem925); } iprot.readListEnd(); } @@ -69700,9 +70360,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, add_partitions_psp oprot.writeFieldBegin(NEW_PARTS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.new_parts.size())); - for (PartitionSpec _iter919 : struct.new_parts) + for (PartitionSpec _iter927 : struct.new_parts) { - _iter919.write(oprot); + _iter927.write(oprot); } oprot.writeListEnd(); } @@ -69733,9 +70393,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, add_partitions_pspe if (struct.isSetNew_parts()) { { oprot.writeI32(struct.new_parts.size()); - for (PartitionSpec _iter920 : struct.new_parts) + for (PartitionSpec _iter928 : struct.new_parts) { - _iter920.write(oprot); + _iter928.write(oprot); } } } @@ -69747,14 +70407,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, add_partitions_pspec BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list921 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.new_parts = new ArrayList(_list921.size); - PartitionSpec _elem922; - for (int _i923 = 0; _i923 < _list921.size; ++_i923) + org.apache.thrift.protocol.TList _list929 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.new_parts = new ArrayList(_list929.size); + PartitionSpec _elem930; + for (int _i931 = 0; _i931 < _list929.size; ++_i931) { - _elem922 = new PartitionSpec(); - _elem922.read(iprot); - struct.new_parts.add(_elem922); + _elem930 = new PartitionSpec(); + _elem930.read(iprot); + struct.new_parts.add(_elem930); } } struct.setNew_partsIsSet(true); @@ -70930,13 +71590,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, append_partition_ar case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list924 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list924.size); - String _elem925; - for (int _i926 = 0; _i926 < _list924.size; ++_i926) + org.apache.thrift.protocol.TList _list932 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list932.size); + String _elem933; + for (int _i934 = 0; _i934 < _list932.size; ++_i934) { - _elem925 = iprot.readString(); - struct.part_vals.add(_elem925); + _elem933 = iprot.readString(); + struct.part_vals.add(_elem933); } iprot.readListEnd(); } @@ -70972,9 +71632,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, append_partition_a oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (String _iter927 : struct.part_vals) + for (String _iter935 : struct.part_vals) { - oprot.writeString(_iter927); + oprot.writeString(_iter935); } oprot.writeListEnd(); } @@ -71017,9 +71677,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, append_partition_ar if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (String _iter928 : struct.part_vals) + for (String _iter936 : struct.part_vals) { - oprot.writeString(_iter928); + oprot.writeString(_iter936); } } } @@ -71039,13 +71699,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, append_partition_arg } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list929 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list929.size); - String _elem930; - for (int _i931 = 0; _i931 < _list929.size; ++_i931) + org.apache.thrift.protocol.TList _list937 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list937.size); + String _elem938; + for (int _i939 = 0; _i939 < _list937.size; ++_i939) { - _elem930 = iprot.readString(); - struct.part_vals.add(_elem930); + _elem938 = iprot.readString(); + struct.part_vals.add(_elem938); } } struct.setPart_valsIsSet(true); @@ -73354,13 +74014,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, append_partition_wi case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list932 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list932.size); - String _elem933; - for (int _i934 = 0; _i934 < _list932.size; ++_i934) + org.apache.thrift.protocol.TList _list940 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list940.size); + String _elem941; + for (int _i942 = 0; _i942 < _list940.size; ++_i942) { - _elem933 = iprot.readString(); - struct.part_vals.add(_elem933); + _elem941 = iprot.readString(); + struct.part_vals.add(_elem941); } iprot.readListEnd(); } @@ -73405,9 +74065,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, append_partition_w oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (String _iter935 : struct.part_vals) + for (String _iter943 : struct.part_vals) { - oprot.writeString(_iter935); + oprot.writeString(_iter943); } oprot.writeListEnd(); } @@ -73458,9 +74118,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, append_partition_wi if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (String _iter936 : struct.part_vals) + for (String _iter944 : struct.part_vals) { - oprot.writeString(_iter936); + oprot.writeString(_iter944); } } } @@ -73483,13 +74143,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, append_partition_wit } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list937 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list937.size); - String _elem938; - for (int _i939 = 0; _i939 < _list937.size; ++_i939) + org.apache.thrift.protocol.TList _list945 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list945.size); + String _elem946; + for (int _i947 = 0; _i947 < _list945.size; ++_i947) { - _elem938 = iprot.readString(); - struct.part_vals.add(_elem938); + _elem946 = iprot.readString(); + struct.part_vals.add(_elem946); } } struct.setPart_valsIsSet(true); @@ -77359,13 +78019,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, drop_partition_args case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list940 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list940.size); - String _elem941; - for (int _i942 = 0; _i942 < _list940.size; ++_i942) + org.apache.thrift.protocol.TList _list948 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list948.size); + String _elem949; + for (int _i950 = 0; _i950 < _list948.size; ++_i950) { - _elem941 = iprot.readString(); - struct.part_vals.add(_elem941); + _elem949 = iprot.readString(); + struct.part_vals.add(_elem949); } iprot.readListEnd(); } @@ -77409,9 +78069,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, drop_partition_arg oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (String _iter943 : struct.part_vals) + for (String _iter951 : struct.part_vals) { - oprot.writeString(_iter943); + oprot.writeString(_iter951); } oprot.writeListEnd(); } @@ -77460,9 +78120,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, drop_partition_args if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (String _iter944 : struct.part_vals) + for (String _iter952 : struct.part_vals) { - oprot.writeString(_iter944); + oprot.writeString(_iter952); } } } @@ -77485,13 +78145,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, drop_partition_args } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list945 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list945.size); - String _elem946; - for (int _i947 = 0; _i947 < _list945.size; ++_i947) + org.apache.thrift.protocol.TList _list953 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list953.size); + String _elem954; + for (int _i955 = 0; _i955 < _list953.size; ++_i955) { - _elem946 = iprot.readString(); - struct.part_vals.add(_elem946); + _elem954 = iprot.readString(); + struct.part_vals.add(_elem954); } } struct.setPart_valsIsSet(true); @@ -78730,13 +79390,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, drop_partition_with case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list948 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list948.size); - String _elem949; - for (int _i950 = 0; _i950 < _list948.size; ++_i950) + org.apache.thrift.protocol.TList _list956 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list956.size); + String _elem957; + for (int _i958 = 0; _i958 < _list956.size; ++_i958) { - _elem949 = iprot.readString(); - struct.part_vals.add(_elem949); + _elem957 = iprot.readString(); + struct.part_vals.add(_elem957); } iprot.readListEnd(); } @@ -78789,9 +79449,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, drop_partition_wit oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (String _iter951 : struct.part_vals) + for (String _iter959 : struct.part_vals) { - oprot.writeString(_iter951); + oprot.writeString(_iter959); } oprot.writeListEnd(); } @@ -78848,9 +79508,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, drop_partition_with if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (String _iter952 : struct.part_vals) + for (String _iter960 : struct.part_vals) { - oprot.writeString(_iter952); + oprot.writeString(_iter960); } } } @@ -78876,13 +79536,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, drop_partition_with_ } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list953 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list953.size); - String _elem954; - for (int _i955 = 0; _i955 < _list953.size; ++_i955) + org.apache.thrift.protocol.TList _list961 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list961.size); + String _elem962; + for (int _i963 = 0; _i963 < _list961.size; ++_i963) { - _elem954 = iprot.readString(); - struct.part_vals.add(_elem954); + _elem962 = iprot.readString(); + struct.part_vals.add(_elem962); } } struct.setPart_valsIsSet(true); @@ -83484,13 +84144,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partition_args case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list956 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list956.size); - String _elem957; - for (int _i958 = 0; _i958 < _list956.size; ++_i958) + org.apache.thrift.protocol.TList _list964 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list964.size); + String _elem965; + for (int _i966 = 0; _i966 < _list964.size; ++_i966) { - _elem957 = iprot.readString(); - struct.part_vals.add(_elem957); + _elem965 = iprot.readString(); + struct.part_vals.add(_elem965); } iprot.readListEnd(); } @@ -83526,9 +84186,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partition_args oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (String _iter959 : struct.part_vals) + for (String _iter967 : struct.part_vals) { - oprot.writeString(_iter959); + oprot.writeString(_iter967); } oprot.writeListEnd(); } @@ -83571,9 +84231,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partition_args if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (String _iter960 : struct.part_vals) + for (String _iter968 : struct.part_vals) { - oprot.writeString(_iter960); + oprot.writeString(_iter968); } } } @@ -83593,13 +84253,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partition_args s } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list961 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list961.size); - String _elem962; - for (int _i963 = 0; _i963 < _list961.size; ++_i963) + org.apache.thrift.protocol.TList _list969 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list969.size); + String _elem970; + for (int _i971 = 0; _i971 < _list969.size; ++_i971) { - _elem962 = iprot.readString(); - struct.part_vals.add(_elem962); + _elem970 = iprot.readString(); + struct.part_vals.add(_elem970); } } struct.setPart_valsIsSet(true); @@ -84817,15 +85477,15 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, exchange_partition_ case 1: // PARTITION_SPECS if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map964 = iprot.readMapBegin(); - struct.partitionSpecs = new HashMap(2*_map964.size); - String _key965; - String _val966; - for (int _i967 = 0; _i967 < _map964.size; ++_i967) + org.apache.thrift.protocol.TMap _map972 = iprot.readMapBegin(); + struct.partitionSpecs = new HashMap(2*_map972.size); + String _key973; + String _val974; + for (int _i975 = 0; _i975 < _map972.size; ++_i975) { - _key965 = iprot.readString(); - _val966 = iprot.readString(); - struct.partitionSpecs.put(_key965, _val966); + _key973 = iprot.readString(); + _val974 = iprot.readString(); + struct.partitionSpecs.put(_key973, _val974); } iprot.readMapEnd(); } @@ -84883,10 +85543,10 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, exchange_partition oprot.writeFieldBegin(PARTITION_SPECS_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.partitionSpecs.size())); - for (Map.Entry _iter968 : struct.partitionSpecs.entrySet()) + for (Map.Entry _iter976 : struct.partitionSpecs.entrySet()) { - oprot.writeString(_iter968.getKey()); - oprot.writeString(_iter968.getValue()); + oprot.writeString(_iter976.getKey()); + oprot.writeString(_iter976.getValue()); } oprot.writeMapEnd(); } @@ -84949,10 +85609,10 @@ public void write(org.apache.thrift.protocol.TProtocol prot, exchange_partition_ if (struct.isSetPartitionSpecs()) { { oprot.writeI32(struct.partitionSpecs.size()); - for (Map.Entry _iter969 : struct.partitionSpecs.entrySet()) + for (Map.Entry _iter977 : struct.partitionSpecs.entrySet()) { - oprot.writeString(_iter969.getKey()); - oprot.writeString(_iter969.getValue()); + oprot.writeString(_iter977.getKey()); + oprot.writeString(_iter977.getValue()); } } } @@ -84976,15 +85636,15 @@ public void read(org.apache.thrift.protocol.TProtocol prot, exchange_partition_a BitSet incoming = iprot.readBitSet(5); if (incoming.get(0)) { { - org.apache.thrift.protocol.TMap _map970 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.partitionSpecs = new HashMap(2*_map970.size); - String _key971; - String _val972; - for (int _i973 = 0; _i973 < _map970.size; ++_i973) + org.apache.thrift.protocol.TMap _map978 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.partitionSpecs = new HashMap(2*_map978.size); + String _key979; + String _val980; + for (int _i981 = 0; _i981 < _map978.size; ++_i981) { - _key971 = iprot.readString(); - _val972 = iprot.readString(); - struct.partitionSpecs.put(_key971, _val972); + _key979 = iprot.readString(); + _val980 = iprot.readString(); + struct.partitionSpecs.put(_key979, _val980); } } struct.setPartitionSpecsIsSet(true); @@ -86430,15 +87090,15 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, exchange_partitions case 1: // PARTITION_SPECS if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map974 = iprot.readMapBegin(); - struct.partitionSpecs = new HashMap(2*_map974.size); - String _key975; - String _val976; - for (int _i977 = 0; _i977 < _map974.size; ++_i977) + org.apache.thrift.protocol.TMap _map982 = iprot.readMapBegin(); + struct.partitionSpecs = new HashMap(2*_map982.size); + String _key983; + String _val984; + for (int _i985 = 0; _i985 < _map982.size; ++_i985) { - _key975 = iprot.readString(); - _val976 = iprot.readString(); - struct.partitionSpecs.put(_key975, _val976); + _key983 = iprot.readString(); + _val984 = iprot.readString(); + struct.partitionSpecs.put(_key983, _val984); } iprot.readMapEnd(); } @@ -86496,10 +87156,10 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, exchange_partition oprot.writeFieldBegin(PARTITION_SPECS_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.partitionSpecs.size())); - for (Map.Entry _iter978 : struct.partitionSpecs.entrySet()) + for (Map.Entry _iter986 : struct.partitionSpecs.entrySet()) { - oprot.writeString(_iter978.getKey()); - oprot.writeString(_iter978.getValue()); + oprot.writeString(_iter986.getKey()); + oprot.writeString(_iter986.getValue()); } oprot.writeMapEnd(); } @@ -86562,10 +87222,10 @@ public void write(org.apache.thrift.protocol.TProtocol prot, exchange_partitions if (struct.isSetPartitionSpecs()) { { oprot.writeI32(struct.partitionSpecs.size()); - for (Map.Entry _iter979 : struct.partitionSpecs.entrySet()) + for (Map.Entry _iter987 : struct.partitionSpecs.entrySet()) { - oprot.writeString(_iter979.getKey()); - oprot.writeString(_iter979.getValue()); + oprot.writeString(_iter987.getKey()); + oprot.writeString(_iter987.getValue()); } } } @@ -86589,15 +87249,15 @@ public void read(org.apache.thrift.protocol.TProtocol prot, exchange_partitions_ BitSet incoming = iprot.readBitSet(5); if (incoming.get(0)) { { - org.apache.thrift.protocol.TMap _map980 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.partitionSpecs = new HashMap(2*_map980.size); - String _key981; - String _val982; - for (int _i983 = 0; _i983 < _map980.size; ++_i983) + org.apache.thrift.protocol.TMap _map988 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.partitionSpecs = new HashMap(2*_map988.size); + String _key989; + String _val990; + for (int _i991 = 0; _i991 < _map988.size; ++_i991) { - _key981 = iprot.readString(); - _val982 = iprot.readString(); - struct.partitionSpecs.put(_key981, _val982); + _key989 = iprot.readString(); + _val990 = iprot.readString(); + struct.partitionSpecs.put(_key989, _val990); } } struct.setPartitionSpecsIsSet(true); @@ -87262,14 +87922,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, exchange_partitions case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list984 = iprot.readListBegin(); - struct.success = new ArrayList(_list984.size); - Partition _elem985; - for (int _i986 = 0; _i986 < _list984.size; ++_i986) + org.apache.thrift.protocol.TList _list992 = iprot.readListBegin(); + struct.success = new ArrayList(_list992.size); + Partition _elem993; + for (int _i994 = 0; _i994 < _list992.size; ++_i994) { - _elem985 = new Partition(); - _elem985.read(iprot); - struct.success.add(_elem985); + _elem993 = new Partition(); + _elem993.read(iprot); + struct.success.add(_elem993); } iprot.readListEnd(); } @@ -87331,9 +87991,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, exchange_partition oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (Partition _iter987 : struct.success) + for (Partition _iter995 : struct.success) { - _iter987.write(oprot); + _iter995.write(oprot); } oprot.writeListEnd(); } @@ -87396,9 +88056,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, exchange_partitions if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Partition _iter988 : struct.success) + for (Partition _iter996 : struct.success) { - _iter988.write(oprot); + _iter996.write(oprot); } } } @@ -87422,14 +88082,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, exchange_partitions_ BitSet incoming = iprot.readBitSet(5); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list989 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list989.size); - Partition _elem990; - for (int _i991 = 0; _i991 < _list989.size; ++_i991) + org.apache.thrift.protocol.TList _list997 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list997.size); + Partition _elem998; + for (int _i999 = 0; _i999 < _list997.size; ++_i999) { - _elem990 = new Partition(); - _elem990.read(iprot); - struct.success.add(_elem990); + _elem998 = new Partition(); + _elem998.read(iprot); + struct.success.add(_elem998); } } struct.setSuccessIsSet(true); @@ -88128,13 +88788,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partition_with_ case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list992 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list992.size); - String _elem993; - for (int _i994 = 0; _i994 < _list992.size; ++_i994) + org.apache.thrift.protocol.TList _list1000 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list1000.size); + String _elem1001; + for (int _i1002 = 0; _i1002 < _list1000.size; ++_i1002) { - _elem993 = iprot.readString(); - struct.part_vals.add(_elem993); + _elem1001 = iprot.readString(); + struct.part_vals.add(_elem1001); } iprot.readListEnd(); } @@ -88154,13 +88814,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partition_with_ case 5: // GROUP_NAMES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list995 = iprot.readListBegin(); - struct.group_names = new ArrayList(_list995.size); - String _elem996; - for (int _i997 = 0; _i997 < _list995.size; ++_i997) + org.apache.thrift.protocol.TList _list1003 = iprot.readListBegin(); + struct.group_names = new ArrayList(_list1003.size); + String _elem1004; + for (int _i1005 = 0; _i1005 < _list1003.size; ++_i1005) { - _elem996 = iprot.readString(); - struct.group_names.add(_elem996); + _elem1004 = iprot.readString(); + struct.group_names.add(_elem1004); } iprot.readListEnd(); } @@ -88196,9 +88856,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partition_with oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (String _iter998 : struct.part_vals) + for (String _iter1006 : struct.part_vals) { - oprot.writeString(_iter998); + oprot.writeString(_iter1006); } oprot.writeListEnd(); } @@ -88213,9 +88873,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partition_with oprot.writeFieldBegin(GROUP_NAMES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.group_names.size())); - for (String _iter999 : struct.group_names) + for (String _iter1007 : struct.group_names) { - oprot.writeString(_iter999); + oprot.writeString(_iter1007); } oprot.writeListEnd(); } @@ -88264,9 +88924,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partition_with_ if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (String _iter1000 : struct.part_vals) + for (String _iter1008 : struct.part_vals) { - oprot.writeString(_iter1000); + oprot.writeString(_iter1008); } } } @@ -88276,9 +88936,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partition_with_ if (struct.isSetGroup_names()) { { oprot.writeI32(struct.group_names.size()); - for (String _iter1001 : struct.group_names) + for (String _iter1009 : struct.group_names) { - oprot.writeString(_iter1001); + oprot.writeString(_iter1009); } } } @@ -88298,13 +88958,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partition_with_a } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list1002 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list1002.size); - String _elem1003; - for (int _i1004 = 0; _i1004 < _list1002.size; ++_i1004) + org.apache.thrift.protocol.TList _list1010 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list1010.size); + String _elem1011; + for (int _i1012 = 0; _i1012 < _list1010.size; ++_i1012) { - _elem1003 = iprot.readString(); - struct.part_vals.add(_elem1003); + _elem1011 = iprot.readString(); + struct.part_vals.add(_elem1011); } } struct.setPart_valsIsSet(true); @@ -88315,13 +88975,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partition_with_a } if (incoming.get(4)) { { - org.apache.thrift.protocol.TList _list1005 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.group_names = new ArrayList(_list1005.size); - String _elem1006; - for (int _i1007 = 0; _i1007 < _list1005.size; ++_i1007) + org.apache.thrift.protocol.TList _list1013 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.group_names = new ArrayList(_list1013.size); + String _elem1014; + for (int _i1015 = 0; _i1015 < _list1013.size; ++_i1015) { - _elem1006 = iprot.readString(); - struct.group_names.add(_elem1006); + _elem1014 = iprot.readString(); + struct.group_names.add(_elem1014); } } struct.setGroup_namesIsSet(true); @@ -91090,14 +91750,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_resu case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1008 = iprot.readListBegin(); - struct.success = new ArrayList(_list1008.size); - Partition _elem1009; - for (int _i1010 = 0; _i1010 < _list1008.size; ++_i1010) + org.apache.thrift.protocol.TList _list1016 = iprot.readListBegin(); + struct.success = new ArrayList(_list1016.size); + Partition _elem1017; + for (int _i1018 = 0; _i1018 < _list1016.size; ++_i1018) { - _elem1009 = new Partition(); - _elem1009.read(iprot); - struct.success.add(_elem1009); + _elem1017 = new Partition(); + _elem1017.read(iprot); + struct.success.add(_elem1017); } iprot.readListEnd(); } @@ -91141,9 +91801,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_res oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (Partition _iter1011 : struct.success) + for (Partition _iter1019 : struct.success) { - _iter1011.write(oprot); + _iter1019.write(oprot); } oprot.writeListEnd(); } @@ -91190,9 +91850,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_resu if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Partition _iter1012 : struct.success) + for (Partition _iter1020 : struct.success) { - _iter1012.write(oprot); + _iter1020.write(oprot); } } } @@ -91210,14 +91870,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_resul BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1013 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list1013.size); - Partition _elem1014; - for (int _i1015 = 0; _i1015 < _list1013.size; ++_i1015) + org.apache.thrift.protocol.TList _list1021 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list1021.size); + Partition _elem1022; + for (int _i1023 = 0; _i1023 < _list1021.size; ++_i1023) { - _elem1014 = new Partition(); - _elem1014.read(iprot); - struct.success.add(_elem1014); + _elem1022 = new Partition(); + _elem1022.read(iprot); + struct.success.add(_elem1022); } } struct.setSuccessIsSet(true); @@ -91907,13 +92567,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_with case 5: // GROUP_NAMES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1016 = iprot.readListBegin(); - struct.group_names = new ArrayList(_list1016.size); - String _elem1017; - for (int _i1018 = 0; _i1018 < _list1016.size; ++_i1018) + org.apache.thrift.protocol.TList _list1024 = iprot.readListBegin(); + struct.group_names = new ArrayList(_list1024.size); + String _elem1025; + for (int _i1026 = 0; _i1026 < _list1024.size; ++_i1026) { - _elem1017 = iprot.readString(); - struct.group_names.add(_elem1017); + _elem1025 = iprot.readString(); + struct.group_names.add(_elem1025); } iprot.readListEnd(); } @@ -91957,9 +92617,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_wit oprot.writeFieldBegin(GROUP_NAMES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.group_names.size())); - for (String _iter1019 : struct.group_names) + for (String _iter1027 : struct.group_names) { - oprot.writeString(_iter1019); + oprot.writeString(_iter1027); } oprot.writeListEnd(); } @@ -92014,9 +92674,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_with if (struct.isSetGroup_names()) { { oprot.writeI32(struct.group_names.size()); - for (String _iter1020 : struct.group_names) + for (String _iter1028 : struct.group_names) { - oprot.writeString(_iter1020); + oprot.writeString(_iter1028); } } } @@ -92044,13 +92704,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_with_ } if (incoming.get(4)) { { - org.apache.thrift.protocol.TList _list1021 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.group_names = new ArrayList(_list1021.size); - String _elem1022; - for (int _i1023 = 0; _i1023 < _list1021.size; ++_i1023) + org.apache.thrift.protocol.TList _list1029 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.group_names = new ArrayList(_list1029.size); + String _elem1030; + for (int _i1031 = 0; _i1031 < _list1029.size; ++_i1031) { - _elem1022 = iprot.readString(); - struct.group_names.add(_elem1022); + _elem1030 = iprot.readString(); + struct.group_names.add(_elem1030); } } struct.setGroup_namesIsSet(true); @@ -92537,14 +93197,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_with case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1024 = iprot.readListBegin(); - struct.success = new ArrayList(_list1024.size); - Partition _elem1025; - for (int _i1026 = 0; _i1026 < _list1024.size; ++_i1026) + org.apache.thrift.protocol.TList _list1032 = iprot.readListBegin(); + struct.success = new ArrayList(_list1032.size); + Partition _elem1033; + for (int _i1034 = 0; _i1034 < _list1032.size; ++_i1034) { - _elem1025 = new Partition(); - _elem1025.read(iprot); - struct.success.add(_elem1025); + _elem1033 = new Partition(); + _elem1033.read(iprot); + struct.success.add(_elem1033); } iprot.readListEnd(); } @@ -92588,9 +93248,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_wit oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (Partition _iter1027 : struct.success) + for (Partition _iter1035 : struct.success) { - _iter1027.write(oprot); + _iter1035.write(oprot); } oprot.writeListEnd(); } @@ -92637,9 +93297,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_with if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Partition _iter1028 : struct.success) + for (Partition _iter1036 : struct.success) { - _iter1028.write(oprot); + _iter1036.write(oprot); } } } @@ -92657,14 +93317,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_with_ BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1029 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list1029.size); - Partition _elem1030; - for (int _i1031 = 0; _i1031 < _list1029.size; ++_i1031) + org.apache.thrift.protocol.TList _list1037 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list1037.size); + Partition _elem1038; + for (int _i1039 = 0; _i1039 < _list1037.size; ++_i1039) { - _elem1030 = new Partition(); - _elem1030.read(iprot); - struct.success.add(_elem1030); + _elem1038 = new Partition(); + _elem1038.read(iprot); + struct.success.add(_elem1038); } } struct.setSuccessIsSet(true); @@ -93727,14 +94387,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_pspe case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1032 = iprot.readListBegin(); - struct.success = new ArrayList(_list1032.size); - PartitionSpec _elem1033; - for (int _i1034 = 0; _i1034 < _list1032.size; ++_i1034) + org.apache.thrift.protocol.TList _list1040 = iprot.readListBegin(); + struct.success = new ArrayList(_list1040.size); + PartitionSpec _elem1041; + for (int _i1042 = 0; _i1042 < _list1040.size; ++_i1042) { - _elem1033 = new PartitionSpec(); - _elem1033.read(iprot); - struct.success.add(_elem1033); + _elem1041 = new PartitionSpec(); + _elem1041.read(iprot); + struct.success.add(_elem1041); } iprot.readListEnd(); } @@ -93778,9 +94438,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_psp oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (PartitionSpec _iter1035 : struct.success) + for (PartitionSpec _iter1043 : struct.success) { - _iter1035.write(oprot); + _iter1043.write(oprot); } oprot.writeListEnd(); } @@ -93827,9 +94487,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_pspe if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (PartitionSpec _iter1036 : struct.success) + for (PartitionSpec _iter1044 : struct.success) { - _iter1036.write(oprot); + _iter1044.write(oprot); } } } @@ -93847,14 +94507,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_pspec BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1037 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list1037.size); - PartitionSpec _elem1038; - for (int _i1039 = 0; _i1039 < _list1037.size; ++_i1039) + org.apache.thrift.protocol.TList _list1045 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list1045.size); + PartitionSpec _elem1046; + for (int _i1047 = 0; _i1047 < _list1045.size; ++_i1047) { - _elem1038 = new PartitionSpec(); - _elem1038.read(iprot); - struct.success.add(_elem1038); + _elem1046 = new PartitionSpec(); + _elem1046.read(iprot); + struct.success.add(_elem1046); } } struct.setSuccessIsSet(true); @@ -94914,13 +95574,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partition_names case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1040 = iprot.readListBegin(); - struct.success = new ArrayList(_list1040.size); - String _elem1041; - for (int _i1042 = 0; _i1042 < _list1040.size; ++_i1042) + org.apache.thrift.protocol.TList _list1048 = iprot.readListBegin(); + struct.success = new ArrayList(_list1048.size); + String _elem1049; + for (int _i1050 = 0; _i1050 < _list1048.size; ++_i1050) { - _elem1041 = iprot.readString(); - struct.success.add(_elem1041); + _elem1049 = iprot.readString(); + struct.success.add(_elem1049); } iprot.readListEnd(); } @@ -94964,9 +95624,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partition_name oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter1043 : struct.success) + for (String _iter1051 : struct.success) { - oprot.writeString(_iter1043); + oprot.writeString(_iter1051); } oprot.writeListEnd(); } @@ -95013,9 +95673,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partition_names if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter1044 : struct.success) + for (String _iter1052 : struct.success) { - oprot.writeString(_iter1044); + oprot.writeString(_iter1052); } } } @@ -95033,13 +95693,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partition_names_ BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1045 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list1045.size); - String _elem1046; - for (int _i1047 = 0; _i1047 < _list1045.size; ++_i1047) + org.apache.thrift.protocol.TList _list1053 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list1053.size); + String _elem1054; + for (int _i1055 = 0; _i1055 < _list1053.size; ++_i1055) { - _elem1046 = iprot.readString(); - struct.success.add(_elem1046); + _elem1054 = iprot.readString(); + struct.success.add(_elem1054); } } struct.setSuccessIsSet(true); @@ -96570,13 +97230,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_ps_a case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1048 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list1048.size); - String _elem1049; - for (int _i1050 = 0; _i1050 < _list1048.size; ++_i1050) + org.apache.thrift.protocol.TList _list1056 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list1056.size); + String _elem1057; + for (int _i1058 = 0; _i1058 < _list1056.size; ++_i1058) { - _elem1049 = iprot.readString(); - struct.part_vals.add(_elem1049); + _elem1057 = iprot.readString(); + struct.part_vals.add(_elem1057); } iprot.readListEnd(); } @@ -96620,9 +97280,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_ps_ oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (String _iter1051 : struct.part_vals) + for (String _iter1059 : struct.part_vals) { - oprot.writeString(_iter1051); + oprot.writeString(_iter1059); } oprot.writeListEnd(); } @@ -96671,9 +97331,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_a if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (String _iter1052 : struct.part_vals) + for (String _iter1060 : struct.part_vals) { - oprot.writeString(_iter1052); + oprot.writeString(_iter1060); } } } @@ -96696,13 +97356,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_ar } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list1053 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list1053.size); - String _elem1054; - for (int _i1055 = 0; _i1055 < _list1053.size; ++_i1055) + org.apache.thrift.protocol.TList _list1061 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list1061.size); + String _elem1062; + for (int _i1063 = 0; _i1063 < _list1061.size; ++_i1063) { - _elem1054 = iprot.readString(); - struct.part_vals.add(_elem1054); + _elem1062 = iprot.readString(); + struct.part_vals.add(_elem1062); } } struct.setPart_valsIsSet(true); @@ -97193,14 +97853,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_ps_r case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1056 = iprot.readListBegin(); - struct.success = new ArrayList(_list1056.size); - Partition _elem1057; - for (int _i1058 = 0; _i1058 < _list1056.size; ++_i1058) + org.apache.thrift.protocol.TList _list1064 = iprot.readListBegin(); + struct.success = new ArrayList(_list1064.size); + Partition _elem1065; + for (int _i1066 = 0; _i1066 < _list1064.size; ++_i1066) { - _elem1057 = new Partition(); - _elem1057.read(iprot); - struct.success.add(_elem1057); + _elem1065 = new Partition(); + _elem1065.read(iprot); + struct.success.add(_elem1065); } iprot.readListEnd(); } @@ -97244,9 +97904,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_ps_ oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (Partition _iter1059 : struct.success) + for (Partition _iter1067 : struct.success) { - _iter1059.write(oprot); + _iter1067.write(oprot); } oprot.writeListEnd(); } @@ -97293,9 +97953,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_r if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Partition _iter1060 : struct.success) + for (Partition _iter1068 : struct.success) { - _iter1060.write(oprot); + _iter1068.write(oprot); } } } @@ -97313,14 +97973,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_re BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1061 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list1061.size); - Partition _elem1062; - for (int _i1063 = 0; _i1063 < _list1061.size; ++_i1063) + org.apache.thrift.protocol.TList _list1069 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list1069.size); + Partition _elem1070; + for (int _i1071 = 0; _i1071 < _list1069.size; ++_i1071) { - _elem1062 = new Partition(); - _elem1062.read(iprot); - struct.success.add(_elem1062); + _elem1070 = new Partition(); + _elem1070.read(iprot); + struct.success.add(_elem1070); } } struct.setSuccessIsSet(true); @@ -98092,13 +98752,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_ps_w case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1064 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list1064.size); - String _elem1065; - for (int _i1066 = 0; _i1066 < _list1064.size; ++_i1066) + org.apache.thrift.protocol.TList _list1072 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list1072.size); + String _elem1073; + for (int _i1074 = 0; _i1074 < _list1072.size; ++_i1074) { - _elem1065 = iprot.readString(); - struct.part_vals.add(_elem1065); + _elem1073 = iprot.readString(); + struct.part_vals.add(_elem1073); } iprot.readListEnd(); } @@ -98126,13 +98786,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_ps_w case 6: // GROUP_NAMES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1067 = iprot.readListBegin(); - struct.group_names = new ArrayList(_list1067.size); - String _elem1068; - for (int _i1069 = 0; _i1069 < _list1067.size; ++_i1069) + org.apache.thrift.protocol.TList _list1075 = iprot.readListBegin(); + struct.group_names = new ArrayList(_list1075.size); + String _elem1076; + for (int _i1077 = 0; _i1077 < _list1075.size; ++_i1077) { - _elem1068 = iprot.readString(); - struct.group_names.add(_elem1068); + _elem1076 = iprot.readString(); + struct.group_names.add(_elem1076); } iprot.readListEnd(); } @@ -98168,9 +98828,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_ps_ oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (String _iter1070 : struct.part_vals) + for (String _iter1078 : struct.part_vals) { - oprot.writeString(_iter1070); + oprot.writeString(_iter1078); } oprot.writeListEnd(); } @@ -98188,9 +98848,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_ps_ oprot.writeFieldBegin(GROUP_NAMES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.group_names.size())); - for (String _iter1071 : struct.group_names) + for (String _iter1079 : struct.group_names) { - oprot.writeString(_iter1071); + oprot.writeString(_iter1079); } oprot.writeListEnd(); } @@ -98242,9 +98902,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_w if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (String _iter1072 : struct.part_vals) + for (String _iter1080 : struct.part_vals) { - oprot.writeString(_iter1072); + oprot.writeString(_iter1080); } } } @@ -98257,9 +98917,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_w if (struct.isSetGroup_names()) { { oprot.writeI32(struct.group_names.size()); - for (String _iter1073 : struct.group_names) + for (String _iter1081 : struct.group_names) { - oprot.writeString(_iter1073); + oprot.writeString(_iter1081); } } } @@ -98279,13 +98939,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_wi } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list1074 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list1074.size); - String _elem1075; - for (int _i1076 = 0; _i1076 < _list1074.size; ++_i1076) + org.apache.thrift.protocol.TList _list1082 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list1082.size); + String _elem1083; + for (int _i1084 = 0; _i1084 < _list1082.size; ++_i1084) { - _elem1075 = iprot.readString(); - struct.part_vals.add(_elem1075); + _elem1083 = iprot.readString(); + struct.part_vals.add(_elem1083); } } struct.setPart_valsIsSet(true); @@ -98300,13 +98960,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_wi } if (incoming.get(5)) { { - org.apache.thrift.protocol.TList _list1077 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.group_names = new ArrayList(_list1077.size); - String _elem1078; - for (int _i1079 = 0; _i1079 < _list1077.size; ++_i1079) + org.apache.thrift.protocol.TList _list1085 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.group_names = new ArrayList(_list1085.size); + String _elem1086; + for (int _i1087 = 0; _i1087 < _list1085.size; ++_i1087) { - _elem1078 = iprot.readString(); - struct.group_names.add(_elem1078); + _elem1086 = iprot.readString(); + struct.group_names.add(_elem1086); } } struct.setGroup_namesIsSet(true); @@ -98793,14 +99453,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_ps_w case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1080 = iprot.readListBegin(); - struct.success = new ArrayList(_list1080.size); - Partition _elem1081; - for (int _i1082 = 0; _i1082 < _list1080.size; ++_i1082) + org.apache.thrift.protocol.TList _list1088 = iprot.readListBegin(); + struct.success = new ArrayList(_list1088.size); + Partition _elem1089; + for (int _i1090 = 0; _i1090 < _list1088.size; ++_i1090) { - _elem1081 = new Partition(); - _elem1081.read(iprot); - struct.success.add(_elem1081); + _elem1089 = new Partition(); + _elem1089.read(iprot); + struct.success.add(_elem1089); } iprot.readListEnd(); } @@ -98844,9 +99504,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_ps_ oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (Partition _iter1083 : struct.success) + for (Partition _iter1091 : struct.success) { - _iter1083.write(oprot); + _iter1091.write(oprot); } oprot.writeListEnd(); } @@ -98893,9 +99553,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_w if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Partition _iter1084 : struct.success) + for (Partition _iter1092 : struct.success) { - _iter1084.write(oprot); + _iter1092.write(oprot); } } } @@ -98913,14 +99573,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_wi BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1085 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list1085.size); - Partition _elem1086; - for (int _i1087 = 0; _i1087 < _list1085.size; ++_i1087) + org.apache.thrift.protocol.TList _list1093 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list1093.size); + Partition _elem1094; + for (int _i1095 = 0; _i1095 < _list1093.size; ++_i1095) { - _elem1086 = new Partition(); - _elem1086.read(iprot); - struct.success.add(_elem1086); + _elem1094 = new Partition(); + _elem1094.read(iprot); + struct.success.add(_elem1094); } } struct.setSuccessIsSet(true); @@ -99513,13 +100173,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partition_names case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1088 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list1088.size); - String _elem1089; - for (int _i1090 = 0; _i1090 < _list1088.size; ++_i1090) + org.apache.thrift.protocol.TList _list1096 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list1096.size); + String _elem1097; + for (int _i1098 = 0; _i1098 < _list1096.size; ++_i1098) { - _elem1089 = iprot.readString(); - struct.part_vals.add(_elem1089); + _elem1097 = iprot.readString(); + struct.part_vals.add(_elem1097); } iprot.readListEnd(); } @@ -99563,9 +100223,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partition_name oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (String _iter1091 : struct.part_vals) + for (String _iter1099 : struct.part_vals) { - oprot.writeString(_iter1091); + oprot.writeString(_iter1099); } oprot.writeListEnd(); } @@ -99614,9 +100274,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partition_names if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (String _iter1092 : struct.part_vals) + for (String _iter1100 : struct.part_vals) { - oprot.writeString(_iter1092); + oprot.writeString(_iter1100); } } } @@ -99639,13 +100299,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partition_names_ } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list1093 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list1093.size); - String _elem1094; - for (int _i1095 = 0; _i1095 < _list1093.size; ++_i1095) + org.apache.thrift.protocol.TList _list1101 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list1101.size); + String _elem1102; + for (int _i1103 = 0; _i1103 < _list1101.size; ++_i1103) { - _elem1094 = iprot.readString(); - struct.part_vals.add(_elem1094); + _elem1102 = iprot.readString(); + struct.part_vals.add(_elem1102); } } struct.setPart_valsIsSet(true); @@ -100133,13 +100793,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partition_names case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1096 = iprot.readListBegin(); - struct.success = new ArrayList(_list1096.size); - String _elem1097; - for (int _i1098 = 0; _i1098 < _list1096.size; ++_i1098) + org.apache.thrift.protocol.TList _list1104 = iprot.readListBegin(); + struct.success = new ArrayList(_list1104.size); + String _elem1105; + for (int _i1106 = 0; _i1106 < _list1104.size; ++_i1106) { - _elem1097 = iprot.readString(); - struct.success.add(_elem1097); + _elem1105 = iprot.readString(); + struct.success.add(_elem1105); } iprot.readListEnd(); } @@ -100183,9 +100843,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partition_name oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter1099 : struct.success) + for (String _iter1107 : struct.success) { - oprot.writeString(_iter1099); + oprot.writeString(_iter1107); } oprot.writeListEnd(); } @@ -100232,9 +100892,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partition_names if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter1100 : struct.success) + for (String _iter1108 : struct.success) { - oprot.writeString(_iter1100); + oprot.writeString(_iter1108); } } } @@ -100252,13 +100912,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partition_names_ BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1101 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list1101.size); - String _elem1102; - for (int _i1103 = 0; _i1103 < _list1101.size; ++_i1103) + org.apache.thrift.protocol.TList _list1109 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list1109.size); + String _elem1110; + for (int _i1111 = 0; _i1111 < _list1109.size; ++_i1111) { - _elem1102 = iprot.readString(); - struct.success.add(_elem1102); + _elem1110 = iprot.readString(); + struct.success.add(_elem1110); } } struct.setSuccessIsSet(true); @@ -101425,14 +102085,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_by_f case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1104 = iprot.readListBegin(); - struct.success = new ArrayList(_list1104.size); - Partition _elem1105; - for (int _i1106 = 0; _i1106 < _list1104.size; ++_i1106) + org.apache.thrift.protocol.TList _list1112 = iprot.readListBegin(); + struct.success = new ArrayList(_list1112.size); + Partition _elem1113; + for (int _i1114 = 0; _i1114 < _list1112.size; ++_i1114) { - _elem1105 = new Partition(); - _elem1105.read(iprot); - struct.success.add(_elem1105); + _elem1113 = new Partition(); + _elem1113.read(iprot); + struct.success.add(_elem1113); } iprot.readListEnd(); } @@ -101476,9 +102136,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_by_ oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (Partition _iter1107 : struct.success) + for (Partition _iter1115 : struct.success) { - _iter1107.write(oprot); + _iter1115.write(oprot); } oprot.writeListEnd(); } @@ -101525,9 +102185,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_by_f if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Partition _iter1108 : struct.success) + for (Partition _iter1116 : struct.success) { - _iter1108.write(oprot); + _iter1116.write(oprot); } } } @@ -101545,14 +102205,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_by_fi BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1109 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list1109.size); - Partition _elem1110; - for (int _i1111 = 0; _i1111 < _list1109.size; ++_i1111) + org.apache.thrift.protocol.TList _list1117 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list1117.size); + Partition _elem1118; + for (int _i1119 = 0; _i1119 < _list1117.size; ++_i1119) { - _elem1110 = new Partition(); - _elem1110.read(iprot); - struct.success.add(_elem1110); + _elem1118 = new Partition(); + _elem1118.read(iprot); + struct.success.add(_elem1118); } } struct.setSuccessIsSet(true); @@ -102719,14 +103379,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_part_specs_by_f case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1112 = iprot.readListBegin(); - struct.success = new ArrayList(_list1112.size); - PartitionSpec _elem1113; - for (int _i1114 = 0; _i1114 < _list1112.size; ++_i1114) + org.apache.thrift.protocol.TList _list1120 = iprot.readListBegin(); + struct.success = new ArrayList(_list1120.size); + PartitionSpec _elem1121; + for (int _i1122 = 0; _i1122 < _list1120.size; ++_i1122) { - _elem1113 = new PartitionSpec(); - _elem1113.read(iprot); - struct.success.add(_elem1113); + _elem1121 = new PartitionSpec(); + _elem1121.read(iprot); + struct.success.add(_elem1121); } iprot.readListEnd(); } @@ -102770,9 +103430,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_part_specs_by_ oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (PartitionSpec _iter1115 : struct.success) + for (PartitionSpec _iter1123 : struct.success) { - _iter1115.write(oprot); + _iter1123.write(oprot); } oprot.writeListEnd(); } @@ -102819,9 +103479,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_part_specs_by_f if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (PartitionSpec _iter1116 : struct.success) + for (PartitionSpec _iter1124 : struct.success) { - _iter1116.write(oprot); + _iter1124.write(oprot); } } } @@ -102839,14 +103499,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_part_specs_by_fi BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1117 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list1117.size); - PartitionSpec _elem1118; - for (int _i1119 = 0; _i1119 < _list1117.size; ++_i1119) + org.apache.thrift.protocol.TList _list1125 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list1125.size); + PartitionSpec _elem1126; + for (int _i1127 = 0; _i1127 < _list1125.size; ++_i1127) { - _elem1118 = new PartitionSpec(); - _elem1118.read(iprot); - struct.success.add(_elem1118); + _elem1126 = new PartitionSpec(); + _elem1126.read(iprot); + struct.success.add(_elem1126); } } struct.setSuccessIsSet(true); @@ -105430,13 +106090,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_by_n case 3: // NAMES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1120 = iprot.readListBegin(); - struct.names = new ArrayList(_list1120.size); - String _elem1121; - for (int _i1122 = 0; _i1122 < _list1120.size; ++_i1122) + org.apache.thrift.protocol.TList _list1128 = iprot.readListBegin(); + struct.names = new ArrayList(_list1128.size); + String _elem1129; + for (int _i1130 = 0; _i1130 < _list1128.size; ++_i1130) { - _elem1121 = iprot.readString(); - struct.names.add(_elem1121); + _elem1129 = iprot.readString(); + struct.names.add(_elem1129); } iprot.readListEnd(); } @@ -105472,9 +106132,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_by_ oprot.writeFieldBegin(NAMES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.names.size())); - for (String _iter1123 : struct.names) + for (String _iter1131 : struct.names) { - oprot.writeString(_iter1123); + oprot.writeString(_iter1131); } oprot.writeListEnd(); } @@ -105517,9 +106177,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_by_n if (struct.isSetNames()) { { oprot.writeI32(struct.names.size()); - for (String _iter1124 : struct.names) + for (String _iter1132 : struct.names) { - oprot.writeString(_iter1124); + oprot.writeString(_iter1132); } } } @@ -105539,13 +106199,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_by_na } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list1125 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.names = new ArrayList(_list1125.size); - String _elem1126; - for (int _i1127 = 0; _i1127 < _list1125.size; ++_i1127) + org.apache.thrift.protocol.TList _list1133 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.names = new ArrayList(_list1133.size); + String _elem1134; + for (int _i1135 = 0; _i1135 < _list1133.size; ++_i1135) { - _elem1126 = iprot.readString(); - struct.names.add(_elem1126); + _elem1134 = iprot.readString(); + struct.names.add(_elem1134); } } struct.setNamesIsSet(true); @@ -106032,14 +106692,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_by_n case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1128 = iprot.readListBegin(); - struct.success = new ArrayList(_list1128.size); - Partition _elem1129; - for (int _i1130 = 0; _i1130 < _list1128.size; ++_i1130) + org.apache.thrift.protocol.TList _list1136 = iprot.readListBegin(); + struct.success = new ArrayList(_list1136.size); + Partition _elem1137; + for (int _i1138 = 0; _i1138 < _list1136.size; ++_i1138) { - _elem1129 = new Partition(); - _elem1129.read(iprot); - struct.success.add(_elem1129); + _elem1137 = new Partition(); + _elem1137.read(iprot); + struct.success.add(_elem1137); } iprot.readListEnd(); } @@ -106083,9 +106743,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_by_ oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (Partition _iter1131 : struct.success) + for (Partition _iter1139 : struct.success) { - _iter1131.write(oprot); + _iter1139.write(oprot); } oprot.writeListEnd(); } @@ -106132,9 +106792,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_by_n if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Partition _iter1132 : struct.success) + for (Partition _iter1140 : struct.success) { - _iter1132.write(oprot); + _iter1140.write(oprot); } } } @@ -106152,14 +106812,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_by_na BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1133 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list1133.size); - Partition _elem1134; - for (int _i1135 = 0; _i1135 < _list1133.size; ++_i1135) + org.apache.thrift.protocol.TList _list1141 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list1141.size); + Partition _elem1142; + for (int _i1143 = 0; _i1143 < _list1141.size; ++_i1143) { - _elem1134 = new Partition(); - _elem1134.read(iprot); - struct.success.add(_elem1134); + _elem1142 = new Partition(); + _elem1142.read(iprot); + struct.success.add(_elem1142); } } struct.setSuccessIsSet(true); @@ -107709,14 +108369,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, alter_partitions_ar case 3: // NEW_PARTS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1136 = iprot.readListBegin(); - struct.new_parts = new ArrayList(_list1136.size); - Partition _elem1137; - for (int _i1138 = 0; _i1138 < _list1136.size; ++_i1138) + org.apache.thrift.protocol.TList _list1144 = iprot.readListBegin(); + struct.new_parts = new ArrayList(_list1144.size); + Partition _elem1145; + for (int _i1146 = 0; _i1146 < _list1144.size; ++_i1146) { - _elem1137 = new Partition(); - _elem1137.read(iprot); - struct.new_parts.add(_elem1137); + _elem1145 = new Partition(); + _elem1145.read(iprot); + struct.new_parts.add(_elem1145); } iprot.readListEnd(); } @@ -107752,9 +108412,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, alter_partitions_a oprot.writeFieldBegin(NEW_PARTS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.new_parts.size())); - for (Partition _iter1139 : struct.new_parts) + for (Partition _iter1147 : struct.new_parts) { - _iter1139.write(oprot); + _iter1147.write(oprot); } oprot.writeListEnd(); } @@ -107797,9 +108457,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, alter_partitions_ar if (struct.isSetNew_parts()) { { oprot.writeI32(struct.new_parts.size()); - for (Partition _iter1140 : struct.new_parts) + for (Partition _iter1148 : struct.new_parts) { - _iter1140.write(oprot); + _iter1148.write(oprot); } } } @@ -107819,14 +108479,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, alter_partitions_arg } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list1141 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.new_parts = new ArrayList(_list1141.size); - Partition _elem1142; - for (int _i1143 = 0; _i1143 < _list1141.size; ++_i1143) + org.apache.thrift.protocol.TList _list1149 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.new_parts = new ArrayList(_list1149.size); + Partition _elem1150; + for (int _i1151 = 0; _i1151 < _list1149.size; ++_i1151) { - _elem1142 = new Partition(); - _elem1142.read(iprot); - struct.new_parts.add(_elem1142); + _elem1150 = new Partition(); + _elem1150.read(iprot); + struct.new_parts.add(_elem1150); } } struct.setNew_partsIsSet(true); @@ -108879,14 +109539,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, alter_partitions_wi case 3: // NEW_PARTS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1144 = iprot.readListBegin(); - struct.new_parts = new ArrayList(_list1144.size); - Partition _elem1145; - for (int _i1146 = 0; _i1146 < _list1144.size; ++_i1146) + org.apache.thrift.protocol.TList _list1152 = iprot.readListBegin(); + struct.new_parts = new ArrayList(_list1152.size); + Partition _elem1153; + for (int _i1154 = 0; _i1154 < _list1152.size; ++_i1154) { - _elem1145 = new Partition(); - _elem1145.read(iprot); - struct.new_parts.add(_elem1145); + _elem1153 = new Partition(); + _elem1153.read(iprot); + struct.new_parts.add(_elem1153); } iprot.readListEnd(); } @@ -108931,9 +109591,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, alter_partitions_w oprot.writeFieldBegin(NEW_PARTS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.new_parts.size())); - for (Partition _iter1147 : struct.new_parts) + for (Partition _iter1155 : struct.new_parts) { - _iter1147.write(oprot); + _iter1155.write(oprot); } oprot.writeListEnd(); } @@ -108984,9 +109644,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, alter_partitions_wi if (struct.isSetNew_parts()) { { oprot.writeI32(struct.new_parts.size()); - for (Partition _iter1148 : struct.new_parts) + for (Partition _iter1156 : struct.new_parts) { - _iter1148.write(oprot); + _iter1156.write(oprot); } } } @@ -109009,14 +109669,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, alter_partitions_wit } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list1149 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.new_parts = new ArrayList(_list1149.size); - Partition _elem1150; - for (int _i1151 = 0; _i1151 < _list1149.size; ++_i1151) + org.apache.thrift.protocol.TList _list1157 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.new_parts = new ArrayList(_list1157.size); + Partition _elem1158; + for (int _i1159 = 0; _i1159 < _list1157.size; ++_i1159) { - _elem1150 = new Partition(); - _elem1150.read(iprot); - struct.new_parts.add(_elem1150); + _elem1158 = new Partition(); + _elem1158.read(iprot); + struct.new_parts.add(_elem1158); } } struct.setNew_partsIsSet(true); @@ -111217,13 +111877,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, rename_partition_ar case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1152 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list1152.size); - String _elem1153; - for (int _i1154 = 0; _i1154 < _list1152.size; ++_i1154) + org.apache.thrift.protocol.TList _list1160 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list1160.size); + String _elem1161; + for (int _i1162 = 0; _i1162 < _list1160.size; ++_i1162) { - _elem1153 = iprot.readString(); - struct.part_vals.add(_elem1153); + _elem1161 = iprot.readString(); + struct.part_vals.add(_elem1161); } iprot.readListEnd(); } @@ -111268,9 +111928,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, rename_partition_a oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (String _iter1155 : struct.part_vals) + for (String _iter1163 : struct.part_vals) { - oprot.writeString(_iter1155); + oprot.writeString(_iter1163); } oprot.writeListEnd(); } @@ -111321,9 +111981,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, rename_partition_ar if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (String _iter1156 : struct.part_vals) + for (String _iter1164 : struct.part_vals) { - oprot.writeString(_iter1156); + oprot.writeString(_iter1164); } } } @@ -111346,13 +112006,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, rename_partition_arg } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list1157 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list1157.size); - String _elem1158; - for (int _i1159 = 0; _i1159 < _list1157.size; ++_i1159) + org.apache.thrift.protocol.TList _list1165 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list1165.size); + String _elem1166; + for (int _i1167 = 0; _i1167 < _list1165.size; ++_i1167) { - _elem1158 = iprot.readString(); - struct.part_vals.add(_elem1158); + _elem1166 = iprot.readString(); + struct.part_vals.add(_elem1166); } } struct.setPart_valsIsSet(true); @@ -112226,13 +112886,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, partition_name_has_ case 1: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1160 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list1160.size); - String _elem1161; - for (int _i1162 = 0; _i1162 < _list1160.size; ++_i1162) + org.apache.thrift.protocol.TList _list1168 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list1168.size); + String _elem1169; + for (int _i1170 = 0; _i1170 < _list1168.size; ++_i1170) { - _elem1161 = iprot.readString(); - struct.part_vals.add(_elem1161); + _elem1169 = iprot.readString(); + struct.part_vals.add(_elem1169); } iprot.readListEnd(); } @@ -112266,9 +112926,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, partition_name_has oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (String _iter1163 : struct.part_vals) + for (String _iter1171 : struct.part_vals) { - oprot.writeString(_iter1163); + oprot.writeString(_iter1171); } oprot.writeListEnd(); } @@ -112305,9 +112965,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, partition_name_has_ if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (String _iter1164 : struct.part_vals) + for (String _iter1172 : struct.part_vals) { - oprot.writeString(_iter1164); + oprot.writeString(_iter1172); } } } @@ -112322,13 +112982,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, partition_name_has_v BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1165 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list1165.size); - String _elem1166; - for (int _i1167 = 0; _i1167 < _list1165.size; ++_i1167) + org.apache.thrift.protocol.TList _list1173 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list1173.size); + String _elem1174; + for (int _i1175 = 0; _i1175 < _list1173.size; ++_i1175) { - _elem1166 = iprot.readString(); - struct.part_vals.add(_elem1166); + _elem1174 = iprot.readString(); + struct.part_vals.add(_elem1174); } } struct.setPart_valsIsSet(true); @@ -114483,13 +115143,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, partition_name_to_v case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1168 = iprot.readListBegin(); - struct.success = new ArrayList(_list1168.size); - String _elem1169; - for (int _i1170 = 0; _i1170 < _list1168.size; ++_i1170) + org.apache.thrift.protocol.TList _list1176 = iprot.readListBegin(); + struct.success = new ArrayList(_list1176.size); + String _elem1177; + for (int _i1178 = 0; _i1178 < _list1176.size; ++_i1178) { - _elem1169 = iprot.readString(); - struct.success.add(_elem1169); + _elem1177 = iprot.readString(); + struct.success.add(_elem1177); } iprot.readListEnd(); } @@ -114524,9 +115184,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, partition_name_to_ oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter1171 : struct.success) + for (String _iter1179 : struct.success) { - oprot.writeString(_iter1171); + oprot.writeString(_iter1179); } oprot.writeListEnd(); } @@ -114565,9 +115225,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, partition_name_to_v if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter1172 : struct.success) + for (String _iter1180 : struct.success) { - oprot.writeString(_iter1172); + oprot.writeString(_iter1180); } } } @@ -114582,13 +115242,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, partition_name_to_va BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1173 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list1173.size); - String _elem1174; - for (int _i1175 = 0; _i1175 < _list1173.size; ++_i1175) + org.apache.thrift.protocol.TList _list1181 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list1181.size); + String _elem1182; + for (int _i1183 = 0; _i1183 < _list1181.size; ++_i1183) { - _elem1174 = iprot.readString(); - struct.success.add(_elem1174); + _elem1182 = iprot.readString(); + struct.success.add(_elem1182); } } struct.setSuccessIsSet(true); @@ -115351,15 +116011,15 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, partition_name_to_s case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map1176 = iprot.readMapBegin(); - struct.success = new HashMap(2*_map1176.size); - String _key1177; - String _val1178; - for (int _i1179 = 0; _i1179 < _map1176.size; ++_i1179) + org.apache.thrift.protocol.TMap _map1184 = iprot.readMapBegin(); + struct.success = new HashMap(2*_map1184.size); + String _key1185; + String _val1186; + for (int _i1187 = 0; _i1187 < _map1184.size; ++_i1187) { - _key1177 = iprot.readString(); - _val1178 = iprot.readString(); - struct.success.put(_key1177, _val1178); + _key1185 = iprot.readString(); + _val1186 = iprot.readString(); + struct.success.put(_key1185, _val1186); } iprot.readMapEnd(); } @@ -115394,10 +116054,10 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, partition_name_to_ oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (Map.Entry _iter1180 : struct.success.entrySet()) + for (Map.Entry _iter1188 : struct.success.entrySet()) { - oprot.writeString(_iter1180.getKey()); - oprot.writeString(_iter1180.getValue()); + oprot.writeString(_iter1188.getKey()); + oprot.writeString(_iter1188.getValue()); } oprot.writeMapEnd(); } @@ -115436,10 +116096,10 @@ public void write(org.apache.thrift.protocol.TProtocol prot, partition_name_to_s if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Map.Entry _iter1181 : struct.success.entrySet()) + for (Map.Entry _iter1189 : struct.success.entrySet()) { - oprot.writeString(_iter1181.getKey()); - oprot.writeString(_iter1181.getValue()); + oprot.writeString(_iter1189.getKey()); + oprot.writeString(_iter1189.getValue()); } } } @@ -115454,15 +116114,15 @@ public void read(org.apache.thrift.protocol.TProtocol prot, partition_name_to_sp BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TMap _map1182 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new HashMap(2*_map1182.size); - String _key1183; - String _val1184; - for (int _i1185 = 0; _i1185 < _map1182.size; ++_i1185) + org.apache.thrift.protocol.TMap _map1190 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new HashMap(2*_map1190.size); + String _key1191; + String _val1192; + for (int _i1193 = 0; _i1193 < _map1190.size; ++_i1193) { - _key1183 = iprot.readString(); - _val1184 = iprot.readString(); - struct.success.put(_key1183, _val1184); + _key1191 = iprot.readString(); + _val1192 = iprot.readString(); + struct.success.put(_key1191, _val1192); } } struct.setSuccessIsSet(true); @@ -116057,15 +116717,15 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, markPartitionForEve case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map1186 = iprot.readMapBegin(); - struct.part_vals = new HashMap(2*_map1186.size); - String _key1187; - String _val1188; - for (int _i1189 = 0; _i1189 < _map1186.size; ++_i1189) + org.apache.thrift.protocol.TMap _map1194 = iprot.readMapBegin(); + struct.part_vals = new HashMap(2*_map1194.size); + String _key1195; + String _val1196; + for (int _i1197 = 0; _i1197 < _map1194.size; ++_i1197) { - _key1187 = iprot.readString(); - _val1188 = iprot.readString(); - struct.part_vals.put(_key1187, _val1188); + _key1195 = iprot.readString(); + _val1196 = iprot.readString(); + struct.part_vals.put(_key1195, _val1196); } iprot.readMapEnd(); } @@ -116109,10 +116769,10 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, markPartitionForEv oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (Map.Entry _iter1190 : struct.part_vals.entrySet()) + for (Map.Entry _iter1198 : struct.part_vals.entrySet()) { - oprot.writeString(_iter1190.getKey()); - oprot.writeString(_iter1190.getValue()); + oprot.writeString(_iter1198.getKey()); + oprot.writeString(_iter1198.getValue()); } oprot.writeMapEnd(); } @@ -116163,10 +116823,10 @@ public void write(org.apache.thrift.protocol.TProtocol prot, markPartitionForEve if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (Map.Entry _iter1191 : struct.part_vals.entrySet()) + for (Map.Entry _iter1199 : struct.part_vals.entrySet()) { - oprot.writeString(_iter1191.getKey()); - oprot.writeString(_iter1191.getValue()); + oprot.writeString(_iter1199.getKey()); + oprot.writeString(_iter1199.getValue()); } } } @@ -116189,15 +116849,15 @@ public void read(org.apache.thrift.protocol.TProtocol prot, markPartitionForEven } if (incoming.get(2)) { { - org.apache.thrift.protocol.TMap _map1192 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new HashMap(2*_map1192.size); - String _key1193; - String _val1194; - for (int _i1195 = 0; _i1195 < _map1192.size; ++_i1195) + org.apache.thrift.protocol.TMap _map1200 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new HashMap(2*_map1200.size); + String _key1201; + String _val1202; + for (int _i1203 = 0; _i1203 < _map1200.size; ++_i1203) { - _key1193 = iprot.readString(); - _val1194 = iprot.readString(); - struct.part_vals.put(_key1193, _val1194); + _key1201 = iprot.readString(); + _val1202 = iprot.readString(); + struct.part_vals.put(_key1201, _val1202); } } struct.setPart_valsIsSet(true); @@ -117681,15 +118341,15 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, isPartitionMarkedFo case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map1196 = iprot.readMapBegin(); - struct.part_vals = new HashMap(2*_map1196.size); - String _key1197; - String _val1198; - for (int _i1199 = 0; _i1199 < _map1196.size; ++_i1199) + org.apache.thrift.protocol.TMap _map1204 = iprot.readMapBegin(); + struct.part_vals = new HashMap(2*_map1204.size); + String _key1205; + String _val1206; + for (int _i1207 = 0; _i1207 < _map1204.size; ++_i1207) { - _key1197 = iprot.readString(); - _val1198 = iprot.readString(); - struct.part_vals.put(_key1197, _val1198); + _key1205 = iprot.readString(); + _val1206 = iprot.readString(); + struct.part_vals.put(_key1205, _val1206); } iprot.readMapEnd(); } @@ -117733,10 +118393,10 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, isPartitionMarkedF oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (Map.Entry _iter1200 : struct.part_vals.entrySet()) + for (Map.Entry _iter1208 : struct.part_vals.entrySet()) { - oprot.writeString(_iter1200.getKey()); - oprot.writeString(_iter1200.getValue()); + oprot.writeString(_iter1208.getKey()); + oprot.writeString(_iter1208.getValue()); } oprot.writeMapEnd(); } @@ -117787,10 +118447,10 @@ public void write(org.apache.thrift.protocol.TProtocol prot, isPartitionMarkedFo if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (Map.Entry _iter1201 : struct.part_vals.entrySet()) + for (Map.Entry _iter1209 : struct.part_vals.entrySet()) { - oprot.writeString(_iter1201.getKey()); - oprot.writeString(_iter1201.getValue()); + oprot.writeString(_iter1209.getKey()); + oprot.writeString(_iter1209.getValue()); } } } @@ -117813,15 +118473,15 @@ public void read(org.apache.thrift.protocol.TProtocol prot, isPartitionMarkedFor } if (incoming.get(2)) { { - org.apache.thrift.protocol.TMap _map1202 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new HashMap(2*_map1202.size); - String _key1203; - String _val1204; - for (int _i1205 = 0; _i1205 < _map1202.size; ++_i1205) + org.apache.thrift.protocol.TMap _map1210 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new HashMap(2*_map1210.size); + String _key1211; + String _val1212; + for (int _i1213 = 0; _i1213 < _map1210.size; ++_i1213) { - _key1203 = iprot.readString(); - _val1204 = iprot.readString(); - struct.part_vals.put(_key1203, _val1204); + _key1211 = iprot.readString(); + _val1212 = iprot.readString(); + struct.part_vals.put(_key1211, _val1212); } } struct.setPart_valsIsSet(true); @@ -124545,14 +125205,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_indexes_result case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1206 = iprot.readListBegin(); - struct.success = new ArrayList(_list1206.size); - Index _elem1207; - for (int _i1208 = 0; _i1208 < _list1206.size; ++_i1208) + org.apache.thrift.protocol.TList _list1214 = iprot.readListBegin(); + struct.success = new ArrayList(_list1214.size); + Index _elem1215; + for (int _i1216 = 0; _i1216 < _list1214.size; ++_i1216) { - _elem1207 = new Index(); - _elem1207.read(iprot); - struct.success.add(_elem1207); + _elem1215 = new Index(); + _elem1215.read(iprot); + struct.success.add(_elem1215); } iprot.readListEnd(); } @@ -124596,9 +125256,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_indexes_result oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (Index _iter1209 : struct.success) + for (Index _iter1217 : struct.success) { - _iter1209.write(oprot); + _iter1217.write(oprot); } oprot.writeListEnd(); } @@ -124645,9 +125305,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_indexes_result if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Index _iter1210 : struct.success) + for (Index _iter1218 : struct.success) { - _iter1210.write(oprot); + _iter1218.write(oprot); } } } @@ -124665,14 +125325,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_indexes_result s BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1211 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list1211.size); - Index _elem1212; - for (int _i1213 = 0; _i1213 < _list1211.size; ++_i1213) + org.apache.thrift.protocol.TList _list1219 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list1219.size); + Index _elem1220; + for (int _i1221 = 0; _i1221 < _list1219.size; ++_i1221) { - _elem1212 = new Index(); - _elem1212.read(iprot); - struct.success.add(_elem1212); + _elem1220 = new Index(); + _elem1220.read(iprot); + struct.success.add(_elem1220); } } struct.setSuccessIsSet(true); @@ -125651,13 +126311,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_index_names_res case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1214 = iprot.readListBegin(); - struct.success = new ArrayList(_list1214.size); - String _elem1215; - for (int _i1216 = 0; _i1216 < _list1214.size; ++_i1216) + org.apache.thrift.protocol.TList _list1222 = iprot.readListBegin(); + struct.success = new ArrayList(_list1222.size); + String _elem1223; + for (int _i1224 = 0; _i1224 < _list1222.size; ++_i1224) { - _elem1215 = iprot.readString(); - struct.success.add(_elem1215); + _elem1223 = iprot.readString(); + struct.success.add(_elem1223); } iprot.readListEnd(); } @@ -125692,9 +126352,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_index_names_re oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter1217 : struct.success) + for (String _iter1225 : struct.success) { - oprot.writeString(_iter1217); + oprot.writeString(_iter1225); } oprot.writeListEnd(); } @@ -125733,9 +126393,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_index_names_res if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter1218 : struct.success) + for (String _iter1226 : struct.success) { - oprot.writeString(_iter1218); + oprot.writeString(_iter1226); } } } @@ -125750,13 +126410,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_index_names_resu BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1219 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list1219.size); - String _elem1220; - for (int _i1221 = 0; _i1221 < _list1219.size; ++_i1221) + org.apache.thrift.protocol.TList _list1227 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list1227.size); + String _elem1228; + for (int _i1229 = 0; _i1229 < _list1227.size; ++_i1229) { - _elem1220 = iprot.readString(); - struct.success.add(_elem1220); + _elem1228 = iprot.readString(); + struct.success.add(_elem1228); } } struct.setSuccessIsSet(true); @@ -145243,13 +145903,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_functions_resul case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1222 = iprot.readListBegin(); - struct.success = new ArrayList(_list1222.size); - String _elem1223; - for (int _i1224 = 0; _i1224 < _list1222.size; ++_i1224) + org.apache.thrift.protocol.TList _list1230 = iprot.readListBegin(); + struct.success = new ArrayList(_list1230.size); + String _elem1231; + for (int _i1232 = 0; _i1232 < _list1230.size; ++_i1232) { - _elem1223 = iprot.readString(); - struct.success.add(_elem1223); + _elem1231 = iprot.readString(); + struct.success.add(_elem1231); } iprot.readListEnd(); } @@ -145284,9 +145944,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_functions_resu oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter1225 : struct.success) + for (String _iter1233 : struct.success) { - oprot.writeString(_iter1225); + oprot.writeString(_iter1233); } oprot.writeListEnd(); } @@ -145325,9 +145985,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_functions_resul if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter1226 : struct.success) + for (String _iter1234 : struct.success) { - oprot.writeString(_iter1226); + oprot.writeString(_iter1234); } } } @@ -145342,13 +146002,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_functions_result BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1227 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list1227.size); - String _elem1228; - for (int _i1229 = 0; _i1229 < _list1227.size; ++_i1229) + org.apache.thrift.protocol.TList _list1235 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list1235.size); + String _elem1236; + for (int _i1237 = 0; _i1237 < _list1235.size; ++_i1237) { - _elem1228 = iprot.readString(); - struct.success.add(_elem1228); + _elem1236 = iprot.readString(); + struct.success.add(_elem1236); } } struct.setSuccessIsSet(true); @@ -149403,13 +150063,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_role_names_resu case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1230 = iprot.readListBegin(); - struct.success = new ArrayList(_list1230.size); - String _elem1231; - for (int _i1232 = 0; _i1232 < _list1230.size; ++_i1232) + org.apache.thrift.protocol.TList _list1238 = iprot.readListBegin(); + struct.success = new ArrayList(_list1238.size); + String _elem1239; + for (int _i1240 = 0; _i1240 < _list1238.size; ++_i1240) { - _elem1231 = iprot.readString(); - struct.success.add(_elem1231); + _elem1239 = iprot.readString(); + struct.success.add(_elem1239); } iprot.readListEnd(); } @@ -149444,9 +150104,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_role_names_res oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter1233 : struct.success) + for (String _iter1241 : struct.success) { - oprot.writeString(_iter1233); + oprot.writeString(_iter1241); } oprot.writeListEnd(); } @@ -149485,9 +150145,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_role_names_resu if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter1234 : struct.success) + for (String _iter1242 : struct.success) { - oprot.writeString(_iter1234); + oprot.writeString(_iter1242); } } } @@ -149502,13 +150162,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_role_names_resul BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1235 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list1235.size); - String _elem1236; - for (int _i1237 = 0; _i1237 < _list1235.size; ++_i1237) + org.apache.thrift.protocol.TList _list1243 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list1243.size); + String _elem1244; + for (int _i1245 = 0; _i1245 < _list1243.size; ++_i1245) { - _elem1236 = iprot.readString(); - struct.success.add(_elem1236); + _elem1244 = iprot.readString(); + struct.success.add(_elem1244); } } struct.setSuccessIsSet(true); @@ -152799,14 +153459,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, list_roles_result s case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1238 = iprot.readListBegin(); - struct.success = new ArrayList(_list1238.size); - Role _elem1239; - for (int _i1240 = 0; _i1240 < _list1238.size; ++_i1240) + org.apache.thrift.protocol.TList _list1246 = iprot.readListBegin(); + struct.success = new ArrayList(_list1246.size); + Role _elem1247; + for (int _i1248 = 0; _i1248 < _list1246.size; ++_i1248) { - _elem1239 = new Role(); - _elem1239.read(iprot); - struct.success.add(_elem1239); + _elem1247 = new Role(); + _elem1247.read(iprot); + struct.success.add(_elem1247); } iprot.readListEnd(); } @@ -152841,9 +153501,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, list_roles_result oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (Role _iter1241 : struct.success) + for (Role _iter1249 : struct.success) { - _iter1241.write(oprot); + _iter1249.write(oprot); } oprot.writeListEnd(); } @@ -152882,9 +153542,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, list_roles_result s if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Role _iter1242 : struct.success) + for (Role _iter1250 : struct.success) { - _iter1242.write(oprot); + _iter1250.write(oprot); } } } @@ -152899,14 +153559,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, list_roles_result st BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1243 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list1243.size); - Role _elem1244; - for (int _i1245 = 0; _i1245 < _list1243.size; ++_i1245) + org.apache.thrift.protocol.TList _list1251 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list1251.size); + Role _elem1252; + for (int _i1253 = 0; _i1253 < _list1251.size; ++_i1253) { - _elem1244 = new Role(); - _elem1244.read(iprot); - struct.success.add(_elem1244); + _elem1252 = new Role(); + _elem1252.read(iprot); + struct.success.add(_elem1252); } } struct.setSuccessIsSet(true); @@ -155911,13 +156571,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_privilege_set_a case 3: // GROUP_NAMES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1246 = iprot.readListBegin(); - struct.group_names = new ArrayList(_list1246.size); - String _elem1247; - for (int _i1248 = 0; _i1248 < _list1246.size; ++_i1248) + org.apache.thrift.protocol.TList _list1254 = iprot.readListBegin(); + struct.group_names = new ArrayList(_list1254.size); + String _elem1255; + for (int _i1256 = 0; _i1256 < _list1254.size; ++_i1256) { - _elem1247 = iprot.readString(); - struct.group_names.add(_elem1247); + _elem1255 = iprot.readString(); + struct.group_names.add(_elem1255); } iprot.readListEnd(); } @@ -155953,9 +156613,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_privilege_set_ oprot.writeFieldBegin(GROUP_NAMES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.group_names.size())); - for (String _iter1249 : struct.group_names) + for (String _iter1257 : struct.group_names) { - oprot.writeString(_iter1249); + oprot.writeString(_iter1257); } oprot.writeListEnd(); } @@ -155998,9 +156658,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_privilege_set_a if (struct.isSetGroup_names()) { { oprot.writeI32(struct.group_names.size()); - for (String _iter1250 : struct.group_names) + for (String _iter1258 : struct.group_names) { - oprot.writeString(_iter1250); + oprot.writeString(_iter1258); } } } @@ -156021,13 +156681,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_privilege_set_ar } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list1251 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.group_names = new ArrayList(_list1251.size); - String _elem1252; - for (int _i1253 = 0; _i1253 < _list1251.size; ++_i1253) + org.apache.thrift.protocol.TList _list1259 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.group_names = new ArrayList(_list1259.size); + String _elem1260; + for (int _i1261 = 0; _i1261 < _list1259.size; ++_i1261) { - _elem1252 = iprot.readString(); - struct.group_names.add(_elem1252); + _elem1260 = iprot.readString(); + struct.group_names.add(_elem1260); } } struct.setGroup_namesIsSet(true); @@ -157485,14 +158145,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, list_privileges_res case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1254 = iprot.readListBegin(); - struct.success = new ArrayList(_list1254.size); - HiveObjectPrivilege _elem1255; - for (int _i1256 = 0; _i1256 < _list1254.size; ++_i1256) + org.apache.thrift.protocol.TList _list1262 = iprot.readListBegin(); + struct.success = new ArrayList(_list1262.size); + HiveObjectPrivilege _elem1263; + for (int _i1264 = 0; _i1264 < _list1262.size; ++_i1264) { - _elem1255 = new HiveObjectPrivilege(); - _elem1255.read(iprot); - struct.success.add(_elem1255); + _elem1263 = new HiveObjectPrivilege(); + _elem1263.read(iprot); + struct.success.add(_elem1263); } iprot.readListEnd(); } @@ -157527,9 +158187,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, list_privileges_re oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (HiveObjectPrivilege _iter1257 : struct.success) + for (HiveObjectPrivilege _iter1265 : struct.success) { - _iter1257.write(oprot); + _iter1265.write(oprot); } oprot.writeListEnd(); } @@ -157568,9 +158228,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, list_privileges_res if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (HiveObjectPrivilege _iter1258 : struct.success) + for (HiveObjectPrivilege _iter1266 : struct.success) { - _iter1258.write(oprot); + _iter1266.write(oprot); } } } @@ -157585,14 +158245,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, list_privileges_resu BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1259 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list1259.size); - HiveObjectPrivilege _elem1260; - for (int _i1261 = 0; _i1261 < _list1259.size; ++_i1261) + org.apache.thrift.protocol.TList _list1267 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list1267.size); + HiveObjectPrivilege _elem1268; + for (int _i1269 = 0; _i1269 < _list1267.size; ++_i1269) { - _elem1260 = new HiveObjectPrivilege(); - _elem1260.read(iprot); - struct.success.add(_elem1260); + _elem1268 = new HiveObjectPrivilege(); + _elem1268.read(iprot); + struct.success.add(_elem1268); } } struct.setSuccessIsSet(true); @@ -160494,13 +161154,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, set_ugi_args struct case 2: // GROUP_NAMES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1262 = iprot.readListBegin(); - struct.group_names = new ArrayList(_list1262.size); - String _elem1263; - for (int _i1264 = 0; _i1264 < _list1262.size; ++_i1264) + org.apache.thrift.protocol.TList _list1270 = iprot.readListBegin(); + struct.group_names = new ArrayList(_list1270.size); + String _elem1271; + for (int _i1272 = 0; _i1272 < _list1270.size; ++_i1272) { - _elem1263 = iprot.readString(); - struct.group_names.add(_elem1263); + _elem1271 = iprot.readString(); + struct.group_names.add(_elem1271); } iprot.readListEnd(); } @@ -160531,9 +161191,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, set_ugi_args struc oprot.writeFieldBegin(GROUP_NAMES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.group_names.size())); - for (String _iter1265 : struct.group_names) + for (String _iter1273 : struct.group_names) { - oprot.writeString(_iter1265); + oprot.writeString(_iter1273); } oprot.writeListEnd(); } @@ -160570,9 +161230,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, set_ugi_args struct if (struct.isSetGroup_names()) { { oprot.writeI32(struct.group_names.size()); - for (String _iter1266 : struct.group_names) + for (String _iter1274 : struct.group_names) { - oprot.writeString(_iter1266); + oprot.writeString(_iter1274); } } } @@ -160588,13 +161248,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, set_ugi_args struct) } if (incoming.get(1)) { { - org.apache.thrift.protocol.TList _list1267 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.group_names = new ArrayList(_list1267.size); - String _elem1268; - for (int _i1269 = 0; _i1269 < _list1267.size; ++_i1269) + org.apache.thrift.protocol.TList _list1275 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.group_names = new ArrayList(_list1275.size); + String _elem1276; + for (int _i1277 = 0; _i1277 < _list1275.size; ++_i1277) { - _elem1268 = iprot.readString(); - struct.group_names.add(_elem1268); + _elem1276 = iprot.readString(); + struct.group_names.add(_elem1276); } } struct.setGroup_namesIsSet(true); @@ -160997,13 +161657,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, set_ugi_result stru case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1270 = iprot.readListBegin(); - struct.success = new ArrayList(_list1270.size); - String _elem1271; - for (int _i1272 = 0; _i1272 < _list1270.size; ++_i1272) + org.apache.thrift.protocol.TList _list1278 = iprot.readListBegin(); + struct.success = new ArrayList(_list1278.size); + String _elem1279; + for (int _i1280 = 0; _i1280 < _list1278.size; ++_i1280) { - _elem1271 = iprot.readString(); - struct.success.add(_elem1271); + _elem1279 = iprot.readString(); + struct.success.add(_elem1279); } iprot.readListEnd(); } @@ -161038,9 +161698,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, set_ugi_result str oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter1273 : struct.success) + for (String _iter1281 : struct.success) { - oprot.writeString(_iter1273); + oprot.writeString(_iter1281); } oprot.writeListEnd(); } @@ -161079,9 +161739,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, set_ugi_result stru if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter1274 : struct.success) + for (String _iter1282 : struct.success) { - oprot.writeString(_iter1274); + oprot.writeString(_iter1282); } } } @@ -161096,13 +161756,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, set_ugi_result struc BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1275 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list1275.size); - String _elem1276; - for (int _i1277 = 0; _i1277 < _list1275.size; ++_i1277) + org.apache.thrift.protocol.TList _list1283 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list1283.size); + String _elem1284; + for (int _i1285 = 0; _i1285 < _list1283.size; ++_i1285) { - _elem1276 = iprot.readString(); - struct.success.add(_elem1276); + _elem1284 = iprot.readString(); + struct.success.add(_elem1284); } } struct.setSuccessIsSet(true); @@ -166393,13 +167053,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_all_token_ident case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1278 = iprot.readListBegin(); - struct.success = new ArrayList(_list1278.size); - String _elem1279; - for (int _i1280 = 0; _i1280 < _list1278.size; ++_i1280) + org.apache.thrift.protocol.TList _list1286 = iprot.readListBegin(); + struct.success = new ArrayList(_list1286.size); + String _elem1287; + for (int _i1288 = 0; _i1288 < _list1286.size; ++_i1288) { - _elem1279 = iprot.readString(); - struct.success.add(_elem1279); + _elem1287 = iprot.readString(); + struct.success.add(_elem1287); } iprot.readListEnd(); } @@ -166425,9 +167085,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_all_token_iden oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter1281 : struct.success) + for (String _iter1289 : struct.success) { - oprot.writeString(_iter1281); + oprot.writeString(_iter1289); } oprot.writeListEnd(); } @@ -166458,9 +167118,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_all_token_ident if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter1282 : struct.success) + for (String _iter1290 : struct.success) { - oprot.writeString(_iter1282); + oprot.writeString(_iter1290); } } } @@ -166472,13 +167132,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_all_token_identi BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1283 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list1283.size); - String _elem1284; - for (int _i1285 = 0; _i1285 < _list1283.size; ++_i1285) + org.apache.thrift.protocol.TList _list1291 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list1291.size); + String _elem1292; + for (int _i1293 = 0; _i1293 < _list1291.size; ++_i1293) { - _elem1284 = iprot.readString(); - struct.success.add(_elem1284); + _elem1292 = iprot.readString(); + struct.success.add(_elem1292); } } struct.setSuccessIsSet(true); @@ -169508,13 +170168,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_master_keys_res case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1286 = iprot.readListBegin(); - struct.success = new ArrayList(_list1286.size); - String _elem1287; - for (int _i1288 = 0; _i1288 < _list1286.size; ++_i1288) + org.apache.thrift.protocol.TList _list1294 = iprot.readListBegin(); + struct.success = new ArrayList(_list1294.size); + String _elem1295; + for (int _i1296 = 0; _i1296 < _list1294.size; ++_i1296) { - _elem1287 = iprot.readString(); - struct.success.add(_elem1287); + _elem1295 = iprot.readString(); + struct.success.add(_elem1295); } iprot.readListEnd(); } @@ -169540,9 +170200,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_master_keys_re oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter1289 : struct.success) + for (String _iter1297 : struct.success) { - oprot.writeString(_iter1289); + oprot.writeString(_iter1297); } oprot.writeListEnd(); } @@ -169573,9 +170233,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_master_keys_res if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter1290 : struct.success) + for (String _iter1298 : struct.success) { - oprot.writeString(_iter1290); + oprot.writeString(_iter1298); } } } @@ -169587,13 +170247,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_master_keys_resu BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1291 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list1291.size); - String _elem1292; - for (int _i1293 = 0; _i1293 < _list1291.size; ++_i1293) + org.apache.thrift.protocol.TList _list1299 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list1299.size); + String _elem1300; + for (int _i1301 = 0; _i1301 < _list1299.size; ++_i1301) { - _elem1292 = iprot.readString(); - struct.success.add(_elem1292); + _elem1300 = iprot.readString(); + struct.success.add(_elem1300); } } struct.setSuccessIsSet(true); @@ -190566,7 +191226,3865 @@ public int hashCode() { } @Override - public int compareTo(create_resource_plan_args other) { + public int compareTo(create_resource_plan_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetRequest()).compareTo(other.isSetRequest()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetRequest()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.request, other.request); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("create_resource_plan_args("); + boolean first = true; + + sb.append("request:"); + if (this.request == null) { + sb.append("null"); + } else { + sb.append(this.request); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + if (request != null) { + request.validate(); + } + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class create_resource_plan_argsStandardSchemeFactory implements SchemeFactory { + public create_resource_plan_argsStandardScheme getScheme() { + return new create_resource_plan_argsStandardScheme(); + } + } + + private static class create_resource_plan_argsStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, create_resource_plan_args struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField schemeField; + iprot.readStructBegin(); + while (true) + { + schemeField = iprot.readFieldBegin(); + if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (schemeField.id) { + case 1: // REQUEST + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.request = new WMCreateResourcePlanRequest(); + struct.request.read(iprot); + struct.setRequestIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + struct.validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot, create_resource_plan_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.request != null) { + oprot.writeFieldBegin(REQUEST_FIELD_DESC); + struct.request.write(oprot); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class create_resource_plan_argsTupleSchemeFactory implements SchemeFactory { + public create_resource_plan_argsTupleScheme getScheme() { + return new create_resource_plan_argsTupleScheme(); + } + } + + private static class create_resource_plan_argsTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, create_resource_plan_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetRequest()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetRequest()) { + struct.request.write(oprot); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, create_resource_plan_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.request = new WMCreateResourcePlanRequest(); + struct.request.read(iprot); + struct.setRequestIsSet(true); + } + } + } + + } + + public static class create_resource_plan_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("create_resource_plan_result"); + + private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0); + private static final org.apache.thrift.protocol.TField O1_FIELD_DESC = new org.apache.thrift.protocol.TField("o1", org.apache.thrift.protocol.TType.STRUCT, (short)1); + private static final org.apache.thrift.protocol.TField O2_FIELD_DESC = new org.apache.thrift.protocol.TField("o2", org.apache.thrift.protocol.TType.STRUCT, (short)2); + private static final org.apache.thrift.protocol.TField O3_FIELD_DESC = new org.apache.thrift.protocol.TField("o3", org.apache.thrift.protocol.TType.STRUCT, (short)3); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new create_resource_plan_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new create_resource_plan_resultTupleSchemeFactory()); + } + + private WMCreateResourcePlanResponse success; // required + private AlreadyExistsException o1; // required + private InvalidObjectException o2; // required + private MetaException o3; // required + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + SUCCESS((short)0, "success"), + O1((short)1, "o1"), + O2((short)2, "o2"), + O3((short)3, "o3"); + + private static final Map byName = new HashMap(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 0: // SUCCESS + return SUCCESS; + case 1: // O1 + return O1; + case 2: // O2 + return O2; + case 3: // O3 + return O3; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, WMCreateResourcePlanResponse.class))); + tmpMap.put(_Fields.O1, new org.apache.thrift.meta_data.FieldMetaData("o1", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + tmpMap.put(_Fields.O2, new org.apache.thrift.meta_data.FieldMetaData("o2", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + tmpMap.put(_Fields.O3, new org.apache.thrift.meta_data.FieldMetaData("o3", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(create_resource_plan_result.class, metaDataMap); + } + + public create_resource_plan_result() { + } + + public create_resource_plan_result( + WMCreateResourcePlanResponse success, + AlreadyExistsException o1, + InvalidObjectException o2, + MetaException o3) + { + this(); + this.success = success; + this.o1 = o1; + this.o2 = o2; + this.o3 = o3; + } + + /** + * Performs a deep copy on other. + */ + public create_resource_plan_result(create_resource_plan_result other) { + if (other.isSetSuccess()) { + this.success = new WMCreateResourcePlanResponse(other.success); + } + if (other.isSetO1()) { + this.o1 = new AlreadyExistsException(other.o1); + } + if (other.isSetO2()) { + this.o2 = new InvalidObjectException(other.o2); + } + if (other.isSetO3()) { + this.o3 = new MetaException(other.o3); + } + } + + public create_resource_plan_result deepCopy() { + return new create_resource_plan_result(this); + } + + @Override + public void clear() { + this.success = null; + this.o1 = null; + this.o2 = null; + this.o3 = null; + } + + public WMCreateResourcePlanResponse getSuccess() { + return this.success; + } + + public void setSuccess(WMCreateResourcePlanResponse success) { + this.success = success; + } + + public void unsetSuccess() { + this.success = null; + } + + /** Returns true if field success is set (has been assigned a value) and false otherwise */ + public boolean isSetSuccess() { + return this.success != null; + } + + public void setSuccessIsSet(boolean value) { + if (!value) { + this.success = null; + } + } + + public AlreadyExistsException getO1() { + return this.o1; + } + + public void setO1(AlreadyExistsException o1) { + this.o1 = o1; + } + + public void unsetO1() { + this.o1 = null; + } + + /** Returns true if field o1 is set (has been assigned a value) and false otherwise */ + public boolean isSetO1() { + return this.o1 != null; + } + + public void setO1IsSet(boolean value) { + if (!value) { + this.o1 = null; + } + } + + public InvalidObjectException getO2() { + return this.o2; + } + + public void setO2(InvalidObjectException o2) { + this.o2 = o2; + } + + public void unsetO2() { + this.o2 = null; + } + + /** Returns true if field o2 is set (has been assigned a value) and false otherwise */ + public boolean isSetO2() { + return this.o2 != null; + } + + public void setO2IsSet(boolean value) { + if (!value) { + this.o2 = null; + } + } + + public MetaException getO3() { + return this.o3; + } + + public void setO3(MetaException o3) { + this.o3 = o3; + } + + public void unsetO3() { + this.o3 = null; + } + + /** Returns true if field o3 is set (has been assigned a value) and false otherwise */ + public boolean isSetO3() { + return this.o3 != null; + } + + public void setO3IsSet(boolean value) { + if (!value) { + this.o3 = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((WMCreateResourcePlanResponse)value); + } + break; + + case O1: + if (value == null) { + unsetO1(); + } else { + setO1((AlreadyExistsException)value); + } + break; + + case O2: + if (value == null) { + unsetO2(); + } else { + setO2((InvalidObjectException)value); + } + break; + + case O3: + if (value == null) { + unsetO3(); + } else { + setO3((MetaException)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); + + case O1: + return getO1(); + + case O2: + return getO2(); + + case O3: + return getO3(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case SUCCESS: + return isSetSuccess(); + case O1: + return isSetO1(); + case O2: + return isSetO2(); + case O3: + return isSetO3(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof create_resource_plan_result) + return this.equals((create_resource_plan_result)that); + return false; + } + + public boolean equals(create_resource_plan_result that) { + if (that == null) + return false; + + boolean this_present_success = true && this.isSetSuccess(); + boolean that_present_success = true && that.isSetSuccess(); + if (this_present_success || that_present_success) { + if (!(this_present_success && that_present_success)) + return false; + if (!this.success.equals(that.success)) + return false; + } + + boolean this_present_o1 = true && this.isSetO1(); + boolean that_present_o1 = true && that.isSetO1(); + if (this_present_o1 || that_present_o1) { + if (!(this_present_o1 && that_present_o1)) + return false; + if (!this.o1.equals(that.o1)) + return false; + } + + boolean this_present_o2 = true && this.isSetO2(); + boolean that_present_o2 = true && that.isSetO2(); + if (this_present_o2 || that_present_o2) { + if (!(this_present_o2 && that_present_o2)) + return false; + if (!this.o2.equals(that.o2)) + return false; + } + + boolean this_present_o3 = true && this.isSetO3(); + boolean that_present_o3 = true && that.isSetO3(); + if (this_present_o3 || that_present_o3) { + if (!(this_present_o3 && that_present_o3)) + return false; + if (!this.o3.equals(that.o3)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + boolean present_success = true && (isSetSuccess()); + list.add(present_success); + if (present_success) + list.add(success); + + boolean present_o1 = true && (isSetO1()); + list.add(present_o1); + if (present_o1) + list.add(o1); + + boolean present_o2 = true && (isSetO2()); + list.add(present_o2); + if (present_o2) + list.add(o2); + + boolean present_o3 = true && (isSetO3()); + list.add(present_o3); + if (present_o3) + list.add(o3); + + return list.hashCode(); + } + + @Override + public int compareTo(create_resource_plan_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(other.isSetSuccess()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetSuccess()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetO1()).compareTo(other.isSetO1()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetO1()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.o1, other.o1); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetO2()).compareTo(other.isSetO2()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetO2()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.o2, other.o2); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetO3()).compareTo(other.isSetO3()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetO3()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.o3, other.o3); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("create_resource_plan_result("); + boolean first = true; + + sb.append("success:"); + if (this.success == null) { + sb.append("null"); + } else { + sb.append(this.success); + } + first = false; + if (!first) sb.append(", "); + sb.append("o1:"); + if (this.o1 == null) { + sb.append("null"); + } else { + sb.append(this.o1); + } + first = false; + if (!first) sb.append(", "); + sb.append("o2:"); + if (this.o2 == null) { + sb.append("null"); + } else { + sb.append(this.o2); + } + first = false; + if (!first) sb.append(", "); + sb.append("o3:"); + if (this.o3 == null) { + sb.append("null"); + } else { + sb.append(this.o3); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + if (success != null) { + success.validate(); + } + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class create_resource_plan_resultStandardSchemeFactory implements SchemeFactory { + public create_resource_plan_resultStandardScheme getScheme() { + return new create_resource_plan_resultStandardScheme(); + } + } + + private static class create_resource_plan_resultStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, create_resource_plan_result struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField schemeField; + iprot.readStructBegin(); + while (true) + { + schemeField = iprot.readFieldBegin(); + if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (schemeField.id) { + case 0: // SUCCESS + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.success = new WMCreateResourcePlanResponse(); + struct.success.read(iprot); + struct.setSuccessIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 1: // O1 + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.o1 = new AlreadyExistsException(); + struct.o1.read(iprot); + struct.setO1IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // O2 + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.o2 = new InvalidObjectException(); + struct.o2.read(iprot); + struct.setO2IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 3: // O3 + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.o3 = new MetaException(); + struct.o3.read(iprot); + struct.setO3IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + struct.validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot, create_resource_plan_result struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.success != null) { + oprot.writeFieldBegin(SUCCESS_FIELD_DESC); + struct.success.write(oprot); + oprot.writeFieldEnd(); + } + if (struct.o1 != null) { + oprot.writeFieldBegin(O1_FIELD_DESC); + struct.o1.write(oprot); + oprot.writeFieldEnd(); + } + if (struct.o2 != null) { + oprot.writeFieldBegin(O2_FIELD_DESC); + struct.o2.write(oprot); + oprot.writeFieldEnd(); + } + if (struct.o3 != null) { + oprot.writeFieldBegin(O3_FIELD_DESC); + struct.o3.write(oprot); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class create_resource_plan_resultTupleSchemeFactory implements SchemeFactory { + public create_resource_plan_resultTupleScheme getScheme() { + return new create_resource_plan_resultTupleScheme(); + } + } + + private static class create_resource_plan_resultTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, create_resource_plan_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + if (struct.isSetO1()) { + optionals.set(1); + } + if (struct.isSetO2()) { + optionals.set(2); + } + if (struct.isSetO3()) { + optionals.set(3); + } + oprot.writeBitSet(optionals, 4); + if (struct.isSetSuccess()) { + struct.success.write(oprot); + } + if (struct.isSetO1()) { + struct.o1.write(oprot); + } + if (struct.isSetO2()) { + struct.o2.write(oprot); + } + if (struct.isSetO3()) { + struct.o3.write(oprot); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, create_resource_plan_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(4); + if (incoming.get(0)) { + struct.success = new WMCreateResourcePlanResponse(); + struct.success.read(iprot); + struct.setSuccessIsSet(true); + } + if (incoming.get(1)) { + struct.o1 = new AlreadyExistsException(); + struct.o1.read(iprot); + struct.setO1IsSet(true); + } + if (incoming.get(2)) { + struct.o2 = new InvalidObjectException(); + struct.o2.read(iprot); + struct.setO2IsSet(true); + } + if (incoming.get(3)) { + struct.o3 = new MetaException(); + struct.o3.read(iprot); + struct.setO3IsSet(true); + } + } + } + + } + + public static class get_resource_plan_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("get_resource_plan_args"); + + private static final org.apache.thrift.protocol.TField REQUEST_FIELD_DESC = new org.apache.thrift.protocol.TField("request", org.apache.thrift.protocol.TType.STRUCT, (short)1); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new get_resource_plan_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new get_resource_plan_argsTupleSchemeFactory()); + } + + private WMGetResourcePlanRequest request; // required + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + REQUEST((short)1, "request"); + + private static final Map byName = new HashMap(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 1: // REQUEST + return REQUEST; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.REQUEST, new org.apache.thrift.meta_data.FieldMetaData("request", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, WMGetResourcePlanRequest.class))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(get_resource_plan_args.class, metaDataMap); + } + + public get_resource_plan_args() { + } + + public get_resource_plan_args( + WMGetResourcePlanRequest request) + { + this(); + this.request = request; + } + + /** + * Performs a deep copy on other. + */ + public get_resource_plan_args(get_resource_plan_args other) { + if (other.isSetRequest()) { + this.request = new WMGetResourcePlanRequest(other.request); + } + } + + public get_resource_plan_args deepCopy() { + return new get_resource_plan_args(this); + } + + @Override + public void clear() { + this.request = null; + } + + public WMGetResourcePlanRequest getRequest() { + return this.request; + } + + public void setRequest(WMGetResourcePlanRequest request) { + this.request = request; + } + + public void unsetRequest() { + this.request = null; + } + + /** Returns true if field request is set (has been assigned a value) and false otherwise */ + public boolean isSetRequest() { + return this.request != null; + } + + public void setRequestIsSet(boolean value) { + if (!value) { + this.request = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case REQUEST: + if (value == null) { + unsetRequest(); + } else { + setRequest((WMGetResourcePlanRequest)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case REQUEST: + return getRequest(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case REQUEST: + return isSetRequest(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof get_resource_plan_args) + return this.equals((get_resource_plan_args)that); + return false; + } + + public boolean equals(get_resource_plan_args that) { + if (that == null) + return false; + + boolean this_present_request = true && this.isSetRequest(); + boolean that_present_request = true && that.isSetRequest(); + if (this_present_request || that_present_request) { + if (!(this_present_request && that_present_request)) + return false; + if (!this.request.equals(that.request)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + boolean present_request = true && (isSetRequest()); + list.add(present_request); + if (present_request) + list.add(request); + + return list.hashCode(); + } + + @Override + public int compareTo(get_resource_plan_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetRequest()).compareTo(other.isSetRequest()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetRequest()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.request, other.request); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("get_resource_plan_args("); + boolean first = true; + + sb.append("request:"); + if (this.request == null) { + sb.append("null"); + } else { + sb.append(this.request); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + if (request != null) { + request.validate(); + } + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class get_resource_plan_argsStandardSchemeFactory implements SchemeFactory { + public get_resource_plan_argsStandardScheme getScheme() { + return new get_resource_plan_argsStandardScheme(); + } + } + + private static class get_resource_plan_argsStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, get_resource_plan_args struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField schemeField; + iprot.readStructBegin(); + while (true) + { + schemeField = iprot.readFieldBegin(); + if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (schemeField.id) { + case 1: // REQUEST + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.request = new WMGetResourcePlanRequest(); + struct.request.read(iprot); + struct.setRequestIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + struct.validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot, get_resource_plan_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.request != null) { + oprot.writeFieldBegin(REQUEST_FIELD_DESC); + struct.request.write(oprot); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class get_resource_plan_argsTupleSchemeFactory implements SchemeFactory { + public get_resource_plan_argsTupleScheme getScheme() { + return new get_resource_plan_argsTupleScheme(); + } + } + + private static class get_resource_plan_argsTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, get_resource_plan_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetRequest()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetRequest()) { + struct.request.write(oprot); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, get_resource_plan_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.request = new WMGetResourcePlanRequest(); + struct.request.read(iprot); + struct.setRequestIsSet(true); + } + } + } + + } + + public static class get_resource_plan_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("get_resource_plan_result"); + + private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0); + private static final org.apache.thrift.protocol.TField O1_FIELD_DESC = new org.apache.thrift.protocol.TField("o1", org.apache.thrift.protocol.TType.STRUCT, (short)1); + private static final org.apache.thrift.protocol.TField O2_FIELD_DESC = new org.apache.thrift.protocol.TField("o2", org.apache.thrift.protocol.TType.STRUCT, (short)2); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new get_resource_plan_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new get_resource_plan_resultTupleSchemeFactory()); + } + + private WMGetResourcePlanResponse success; // required + private NoSuchObjectException o1; // required + private MetaException o2; // required + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + SUCCESS((short)0, "success"), + O1((short)1, "o1"), + O2((short)2, "o2"); + + private static final Map byName = new HashMap(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 0: // SUCCESS + return SUCCESS; + case 1: // O1 + return O1; + case 2: // O2 + return O2; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, WMGetResourcePlanResponse.class))); + tmpMap.put(_Fields.O1, new org.apache.thrift.meta_data.FieldMetaData("o1", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + tmpMap.put(_Fields.O2, new org.apache.thrift.meta_data.FieldMetaData("o2", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(get_resource_plan_result.class, metaDataMap); + } + + public get_resource_plan_result() { + } + + public get_resource_plan_result( + WMGetResourcePlanResponse success, + NoSuchObjectException o1, + MetaException o2) + { + this(); + this.success = success; + this.o1 = o1; + this.o2 = o2; + } + + /** + * Performs a deep copy on other. + */ + public get_resource_plan_result(get_resource_plan_result other) { + if (other.isSetSuccess()) { + this.success = new WMGetResourcePlanResponse(other.success); + } + if (other.isSetO1()) { + this.o1 = new NoSuchObjectException(other.o1); + } + if (other.isSetO2()) { + this.o2 = new MetaException(other.o2); + } + } + + public get_resource_plan_result deepCopy() { + return new get_resource_plan_result(this); + } + + @Override + public void clear() { + this.success = null; + this.o1 = null; + this.o2 = null; + } + + public WMGetResourcePlanResponse getSuccess() { + return this.success; + } + + public void setSuccess(WMGetResourcePlanResponse success) { + this.success = success; + } + + public void unsetSuccess() { + this.success = null; + } + + /** Returns true if field success is set (has been assigned a value) and false otherwise */ + public boolean isSetSuccess() { + return this.success != null; + } + + public void setSuccessIsSet(boolean value) { + if (!value) { + this.success = null; + } + } + + public NoSuchObjectException getO1() { + return this.o1; + } + + public void setO1(NoSuchObjectException o1) { + this.o1 = o1; + } + + public void unsetO1() { + this.o1 = null; + } + + /** Returns true if field o1 is set (has been assigned a value) and false otherwise */ + public boolean isSetO1() { + return this.o1 != null; + } + + public void setO1IsSet(boolean value) { + if (!value) { + this.o1 = null; + } + } + + public MetaException getO2() { + return this.o2; + } + + public void setO2(MetaException o2) { + this.o2 = o2; + } + + public void unsetO2() { + this.o2 = null; + } + + /** Returns true if field o2 is set (has been assigned a value) and false otherwise */ + public boolean isSetO2() { + return this.o2 != null; + } + + public void setO2IsSet(boolean value) { + if (!value) { + this.o2 = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((WMGetResourcePlanResponse)value); + } + break; + + case O1: + if (value == null) { + unsetO1(); + } else { + setO1((NoSuchObjectException)value); + } + break; + + case O2: + if (value == null) { + unsetO2(); + } else { + setO2((MetaException)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); + + case O1: + return getO1(); + + case O2: + return getO2(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case SUCCESS: + return isSetSuccess(); + case O1: + return isSetO1(); + case O2: + return isSetO2(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof get_resource_plan_result) + return this.equals((get_resource_plan_result)that); + return false; + } + + public boolean equals(get_resource_plan_result that) { + if (that == null) + return false; + + boolean this_present_success = true && this.isSetSuccess(); + boolean that_present_success = true && that.isSetSuccess(); + if (this_present_success || that_present_success) { + if (!(this_present_success && that_present_success)) + return false; + if (!this.success.equals(that.success)) + return false; + } + + boolean this_present_o1 = true && this.isSetO1(); + boolean that_present_o1 = true && that.isSetO1(); + if (this_present_o1 || that_present_o1) { + if (!(this_present_o1 && that_present_o1)) + return false; + if (!this.o1.equals(that.o1)) + return false; + } + + boolean this_present_o2 = true && this.isSetO2(); + boolean that_present_o2 = true && that.isSetO2(); + if (this_present_o2 || that_present_o2) { + if (!(this_present_o2 && that_present_o2)) + return false; + if (!this.o2.equals(that.o2)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + boolean present_success = true && (isSetSuccess()); + list.add(present_success); + if (present_success) + list.add(success); + + boolean present_o1 = true && (isSetO1()); + list.add(present_o1); + if (present_o1) + list.add(o1); + + boolean present_o2 = true && (isSetO2()); + list.add(present_o2); + if (present_o2) + list.add(o2); + + return list.hashCode(); + } + + @Override + public int compareTo(get_resource_plan_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(other.isSetSuccess()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetSuccess()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetO1()).compareTo(other.isSetO1()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetO1()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.o1, other.o1); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetO2()).compareTo(other.isSetO2()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetO2()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.o2, other.o2); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("get_resource_plan_result("); + boolean first = true; + + sb.append("success:"); + if (this.success == null) { + sb.append("null"); + } else { + sb.append(this.success); + } + first = false; + if (!first) sb.append(", "); + sb.append("o1:"); + if (this.o1 == null) { + sb.append("null"); + } else { + sb.append(this.o1); + } + first = false; + if (!first) sb.append(", "); + sb.append("o2:"); + if (this.o2 == null) { + sb.append("null"); + } else { + sb.append(this.o2); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + if (success != null) { + success.validate(); + } + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class get_resource_plan_resultStandardSchemeFactory implements SchemeFactory { + public get_resource_plan_resultStandardScheme getScheme() { + return new get_resource_plan_resultStandardScheme(); + } + } + + private static class get_resource_plan_resultStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, get_resource_plan_result struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField schemeField; + iprot.readStructBegin(); + while (true) + { + schemeField = iprot.readFieldBegin(); + if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (schemeField.id) { + case 0: // SUCCESS + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.success = new WMGetResourcePlanResponse(); + struct.success.read(iprot); + struct.setSuccessIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 1: // O1 + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.o1 = new NoSuchObjectException(); + struct.o1.read(iprot); + struct.setO1IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // O2 + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.o2 = new MetaException(); + struct.o2.read(iprot); + struct.setO2IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + struct.validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot, get_resource_plan_result struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.success != null) { + oprot.writeFieldBegin(SUCCESS_FIELD_DESC); + struct.success.write(oprot); + oprot.writeFieldEnd(); + } + if (struct.o1 != null) { + oprot.writeFieldBegin(O1_FIELD_DESC); + struct.o1.write(oprot); + oprot.writeFieldEnd(); + } + if (struct.o2 != null) { + oprot.writeFieldBegin(O2_FIELD_DESC); + struct.o2.write(oprot); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class get_resource_plan_resultTupleSchemeFactory implements SchemeFactory { + public get_resource_plan_resultTupleScheme getScheme() { + return new get_resource_plan_resultTupleScheme(); + } + } + + private static class get_resource_plan_resultTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, get_resource_plan_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + if (struct.isSetO1()) { + optionals.set(1); + } + if (struct.isSetO2()) { + optionals.set(2); + } + oprot.writeBitSet(optionals, 3); + if (struct.isSetSuccess()) { + struct.success.write(oprot); + } + if (struct.isSetO1()) { + struct.o1.write(oprot); + } + if (struct.isSetO2()) { + struct.o2.write(oprot); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, get_resource_plan_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(3); + if (incoming.get(0)) { + struct.success = new WMGetResourcePlanResponse(); + struct.success.read(iprot); + struct.setSuccessIsSet(true); + } + if (incoming.get(1)) { + struct.o1 = new NoSuchObjectException(); + struct.o1.read(iprot); + struct.setO1IsSet(true); + } + if (incoming.get(2)) { + struct.o2 = new MetaException(); + struct.o2.read(iprot); + struct.setO2IsSet(true); + } + } + } + + } + + public static class get_all_resource_plans_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("get_all_resource_plans_args"); + + private static final org.apache.thrift.protocol.TField REQUEST_FIELD_DESC = new org.apache.thrift.protocol.TField("request", org.apache.thrift.protocol.TType.STRUCT, (short)1); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new get_all_resource_plans_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new get_all_resource_plans_argsTupleSchemeFactory()); + } + + private WMGetAllResourcePlanRequest request; // required + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + REQUEST((short)1, "request"); + + private static final Map byName = new HashMap(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 1: // REQUEST + return REQUEST; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.REQUEST, new org.apache.thrift.meta_data.FieldMetaData("request", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, WMGetAllResourcePlanRequest.class))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(get_all_resource_plans_args.class, metaDataMap); + } + + public get_all_resource_plans_args() { + } + + public get_all_resource_plans_args( + WMGetAllResourcePlanRequest request) + { + this(); + this.request = request; + } + + /** + * Performs a deep copy on other. + */ + public get_all_resource_plans_args(get_all_resource_plans_args other) { + if (other.isSetRequest()) { + this.request = new WMGetAllResourcePlanRequest(other.request); + } + } + + public get_all_resource_plans_args deepCopy() { + return new get_all_resource_plans_args(this); + } + + @Override + public void clear() { + this.request = null; + } + + public WMGetAllResourcePlanRequest getRequest() { + return this.request; + } + + public void setRequest(WMGetAllResourcePlanRequest request) { + this.request = request; + } + + public void unsetRequest() { + this.request = null; + } + + /** Returns true if field request is set (has been assigned a value) and false otherwise */ + public boolean isSetRequest() { + return this.request != null; + } + + public void setRequestIsSet(boolean value) { + if (!value) { + this.request = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case REQUEST: + if (value == null) { + unsetRequest(); + } else { + setRequest((WMGetAllResourcePlanRequest)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case REQUEST: + return getRequest(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case REQUEST: + return isSetRequest(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof get_all_resource_plans_args) + return this.equals((get_all_resource_plans_args)that); + return false; + } + + public boolean equals(get_all_resource_plans_args that) { + if (that == null) + return false; + + boolean this_present_request = true && this.isSetRequest(); + boolean that_present_request = true && that.isSetRequest(); + if (this_present_request || that_present_request) { + if (!(this_present_request && that_present_request)) + return false; + if (!this.request.equals(that.request)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + boolean present_request = true && (isSetRequest()); + list.add(present_request); + if (present_request) + list.add(request); + + return list.hashCode(); + } + + @Override + public int compareTo(get_all_resource_plans_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetRequest()).compareTo(other.isSetRequest()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetRequest()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.request, other.request); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("get_all_resource_plans_args("); + boolean first = true; + + sb.append("request:"); + if (this.request == null) { + sb.append("null"); + } else { + sb.append(this.request); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + if (request != null) { + request.validate(); + } + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class get_all_resource_plans_argsStandardSchemeFactory implements SchemeFactory { + public get_all_resource_plans_argsStandardScheme getScheme() { + return new get_all_resource_plans_argsStandardScheme(); + } + } + + private static class get_all_resource_plans_argsStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, get_all_resource_plans_args struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField schemeField; + iprot.readStructBegin(); + while (true) + { + schemeField = iprot.readFieldBegin(); + if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (schemeField.id) { + case 1: // REQUEST + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.request = new WMGetAllResourcePlanRequest(); + struct.request.read(iprot); + struct.setRequestIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + struct.validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot, get_all_resource_plans_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.request != null) { + oprot.writeFieldBegin(REQUEST_FIELD_DESC); + struct.request.write(oprot); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class get_all_resource_plans_argsTupleSchemeFactory implements SchemeFactory { + public get_all_resource_plans_argsTupleScheme getScheme() { + return new get_all_resource_plans_argsTupleScheme(); + } + } + + private static class get_all_resource_plans_argsTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, get_all_resource_plans_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetRequest()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetRequest()) { + struct.request.write(oprot); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, get_all_resource_plans_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.request = new WMGetAllResourcePlanRequest(); + struct.request.read(iprot); + struct.setRequestIsSet(true); + } + } + } + + } + + public static class get_all_resource_plans_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("get_all_resource_plans_result"); + + private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0); + private static final org.apache.thrift.protocol.TField O1_FIELD_DESC = new org.apache.thrift.protocol.TField("o1", org.apache.thrift.protocol.TType.STRUCT, (short)1); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new get_all_resource_plans_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new get_all_resource_plans_resultTupleSchemeFactory()); + } + + private WMGetAllResourcePlanResponse success; // required + private MetaException o1; // required + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + SUCCESS((short)0, "success"), + O1((short)1, "o1"); + + private static final Map byName = new HashMap(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 0: // SUCCESS + return SUCCESS; + case 1: // O1 + return O1; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, WMGetAllResourcePlanResponse.class))); + tmpMap.put(_Fields.O1, new org.apache.thrift.meta_data.FieldMetaData("o1", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(get_all_resource_plans_result.class, metaDataMap); + } + + public get_all_resource_plans_result() { + } + + public get_all_resource_plans_result( + WMGetAllResourcePlanResponse success, + MetaException o1) + { + this(); + this.success = success; + this.o1 = o1; + } + + /** + * Performs a deep copy on other. + */ + public get_all_resource_plans_result(get_all_resource_plans_result other) { + if (other.isSetSuccess()) { + this.success = new WMGetAllResourcePlanResponse(other.success); + } + if (other.isSetO1()) { + this.o1 = new MetaException(other.o1); + } + } + + public get_all_resource_plans_result deepCopy() { + return new get_all_resource_plans_result(this); + } + + @Override + public void clear() { + this.success = null; + this.o1 = null; + } + + public WMGetAllResourcePlanResponse getSuccess() { + return this.success; + } + + public void setSuccess(WMGetAllResourcePlanResponse success) { + this.success = success; + } + + public void unsetSuccess() { + this.success = null; + } + + /** Returns true if field success is set (has been assigned a value) and false otherwise */ + public boolean isSetSuccess() { + return this.success != null; + } + + public void setSuccessIsSet(boolean value) { + if (!value) { + this.success = null; + } + } + + public MetaException getO1() { + return this.o1; + } + + public void setO1(MetaException o1) { + this.o1 = o1; + } + + public void unsetO1() { + this.o1 = null; + } + + /** Returns true if field o1 is set (has been assigned a value) and false otherwise */ + public boolean isSetO1() { + return this.o1 != null; + } + + public void setO1IsSet(boolean value) { + if (!value) { + this.o1 = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((WMGetAllResourcePlanResponse)value); + } + break; + + case O1: + if (value == null) { + unsetO1(); + } else { + setO1((MetaException)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); + + case O1: + return getO1(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case SUCCESS: + return isSetSuccess(); + case O1: + return isSetO1(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof get_all_resource_plans_result) + return this.equals((get_all_resource_plans_result)that); + return false; + } + + public boolean equals(get_all_resource_plans_result that) { + if (that == null) + return false; + + boolean this_present_success = true && this.isSetSuccess(); + boolean that_present_success = true && that.isSetSuccess(); + if (this_present_success || that_present_success) { + if (!(this_present_success && that_present_success)) + return false; + if (!this.success.equals(that.success)) + return false; + } + + boolean this_present_o1 = true && this.isSetO1(); + boolean that_present_o1 = true && that.isSetO1(); + if (this_present_o1 || that_present_o1) { + if (!(this_present_o1 && that_present_o1)) + return false; + if (!this.o1.equals(that.o1)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + boolean present_success = true && (isSetSuccess()); + list.add(present_success); + if (present_success) + list.add(success); + + boolean present_o1 = true && (isSetO1()); + list.add(present_o1); + if (present_o1) + list.add(o1); + + return list.hashCode(); + } + + @Override + public int compareTo(get_all_resource_plans_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(other.isSetSuccess()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetSuccess()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetO1()).compareTo(other.isSetO1()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetO1()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.o1, other.o1); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("get_all_resource_plans_result("); + boolean first = true; + + sb.append("success:"); + if (this.success == null) { + sb.append("null"); + } else { + sb.append(this.success); + } + first = false; + if (!first) sb.append(", "); + sb.append("o1:"); + if (this.o1 == null) { + sb.append("null"); + } else { + sb.append(this.o1); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + if (success != null) { + success.validate(); + } + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class get_all_resource_plans_resultStandardSchemeFactory implements SchemeFactory { + public get_all_resource_plans_resultStandardScheme getScheme() { + return new get_all_resource_plans_resultStandardScheme(); + } + } + + private static class get_all_resource_plans_resultStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, get_all_resource_plans_result struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField schemeField; + iprot.readStructBegin(); + while (true) + { + schemeField = iprot.readFieldBegin(); + if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (schemeField.id) { + case 0: // SUCCESS + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.success = new WMGetAllResourcePlanResponse(); + struct.success.read(iprot); + struct.setSuccessIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 1: // O1 + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.o1 = new MetaException(); + struct.o1.read(iprot); + struct.setO1IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + struct.validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot, get_all_resource_plans_result struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.success != null) { + oprot.writeFieldBegin(SUCCESS_FIELD_DESC); + struct.success.write(oprot); + oprot.writeFieldEnd(); + } + if (struct.o1 != null) { + oprot.writeFieldBegin(O1_FIELD_DESC); + struct.o1.write(oprot); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class get_all_resource_plans_resultTupleSchemeFactory implements SchemeFactory { + public get_all_resource_plans_resultTupleScheme getScheme() { + return new get_all_resource_plans_resultTupleScheme(); + } + } + + private static class get_all_resource_plans_resultTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, get_all_resource_plans_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + if (struct.isSetO1()) { + optionals.set(1); + } + oprot.writeBitSet(optionals, 2); + if (struct.isSetSuccess()) { + struct.success.write(oprot); + } + if (struct.isSetO1()) { + struct.o1.write(oprot); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, get_all_resource_plans_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(2); + if (incoming.get(0)) { + struct.success = new WMGetAllResourcePlanResponse(); + struct.success.read(iprot); + struct.setSuccessIsSet(true); + } + if (incoming.get(1)) { + struct.o1 = new MetaException(); + struct.o1.read(iprot); + struct.setO1IsSet(true); + } + } + } + + } + + public static class alter_resource_plan_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("alter_resource_plan_args"); + + private static final org.apache.thrift.protocol.TField REQUEST_FIELD_DESC = new org.apache.thrift.protocol.TField("request", org.apache.thrift.protocol.TType.STRUCT, (short)1); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new alter_resource_plan_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new alter_resource_plan_argsTupleSchemeFactory()); + } + + private WMAlterResourcePlanRequest request; // required + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + REQUEST((short)1, "request"); + + private static final Map byName = new HashMap(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 1: // REQUEST + return REQUEST; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.REQUEST, new org.apache.thrift.meta_data.FieldMetaData("request", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, WMAlterResourcePlanRequest.class))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(alter_resource_plan_args.class, metaDataMap); + } + + public alter_resource_plan_args() { + } + + public alter_resource_plan_args( + WMAlterResourcePlanRequest request) + { + this(); + this.request = request; + } + + /** + * Performs a deep copy on other. + */ + public alter_resource_plan_args(alter_resource_plan_args other) { + if (other.isSetRequest()) { + this.request = new WMAlterResourcePlanRequest(other.request); + } + } + + public alter_resource_plan_args deepCopy() { + return new alter_resource_plan_args(this); + } + + @Override + public void clear() { + this.request = null; + } + + public WMAlterResourcePlanRequest getRequest() { + return this.request; + } + + public void setRequest(WMAlterResourcePlanRequest request) { + this.request = request; + } + + public void unsetRequest() { + this.request = null; + } + + /** Returns true if field request is set (has been assigned a value) and false otherwise */ + public boolean isSetRequest() { + return this.request != null; + } + + public void setRequestIsSet(boolean value) { + if (!value) { + this.request = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case REQUEST: + if (value == null) { + unsetRequest(); + } else { + setRequest((WMAlterResourcePlanRequest)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case REQUEST: + return getRequest(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case REQUEST: + return isSetRequest(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof alter_resource_plan_args) + return this.equals((alter_resource_plan_args)that); + return false; + } + + public boolean equals(alter_resource_plan_args that) { + if (that == null) + return false; + + boolean this_present_request = true && this.isSetRequest(); + boolean that_present_request = true && that.isSetRequest(); + if (this_present_request || that_present_request) { + if (!(this_present_request && that_present_request)) + return false; + if (!this.request.equals(that.request)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + boolean present_request = true && (isSetRequest()); + list.add(present_request); + if (present_request) + list.add(request); + + return list.hashCode(); + } + + @Override + public int compareTo(alter_resource_plan_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetRequest()).compareTo(other.isSetRequest()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetRequest()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.request, other.request); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("alter_resource_plan_args("); + boolean first = true; + + sb.append("request:"); + if (this.request == null) { + sb.append("null"); + } else { + sb.append(this.request); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + if (request != null) { + request.validate(); + } + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class alter_resource_plan_argsStandardSchemeFactory implements SchemeFactory { + public alter_resource_plan_argsStandardScheme getScheme() { + return new alter_resource_plan_argsStandardScheme(); + } + } + + private static class alter_resource_plan_argsStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, alter_resource_plan_args struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField schemeField; + iprot.readStructBegin(); + while (true) + { + schemeField = iprot.readFieldBegin(); + if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (schemeField.id) { + case 1: // REQUEST + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.request = new WMAlterResourcePlanRequest(); + struct.request.read(iprot); + struct.setRequestIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + struct.validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot, alter_resource_plan_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.request != null) { + oprot.writeFieldBegin(REQUEST_FIELD_DESC); + struct.request.write(oprot); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class alter_resource_plan_argsTupleSchemeFactory implements SchemeFactory { + public alter_resource_plan_argsTupleScheme getScheme() { + return new alter_resource_plan_argsTupleScheme(); + } + } + + private static class alter_resource_plan_argsTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, alter_resource_plan_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetRequest()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetRequest()) { + struct.request.write(oprot); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, alter_resource_plan_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.request = new WMAlterResourcePlanRequest(); + struct.request.read(iprot); + struct.setRequestIsSet(true); + } + } + } + + } + + public static class alter_resource_plan_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("alter_resource_plan_result"); + + private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0); + private static final org.apache.thrift.protocol.TField O1_FIELD_DESC = new org.apache.thrift.protocol.TField("o1", org.apache.thrift.protocol.TType.STRUCT, (short)1); + private static final org.apache.thrift.protocol.TField O2_FIELD_DESC = new org.apache.thrift.protocol.TField("o2", org.apache.thrift.protocol.TType.STRUCT, (short)2); + private static final org.apache.thrift.protocol.TField O3_FIELD_DESC = new org.apache.thrift.protocol.TField("o3", org.apache.thrift.protocol.TType.STRUCT, (short)3); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new alter_resource_plan_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new alter_resource_plan_resultTupleSchemeFactory()); + } + + private WMAlterResourcePlanResponse success; // required + private NoSuchObjectException o1; // required + private InvalidOperationException o2; // required + private MetaException o3; // required + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + SUCCESS((short)0, "success"), + O1((short)1, "o1"), + O2((short)2, "o2"), + O3((short)3, "o3"); + + private static final Map byName = new HashMap(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 0: // SUCCESS + return SUCCESS; + case 1: // O1 + return O1; + case 2: // O2 + return O2; + case 3: // O3 + return O3; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, WMAlterResourcePlanResponse.class))); + tmpMap.put(_Fields.O1, new org.apache.thrift.meta_data.FieldMetaData("o1", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + tmpMap.put(_Fields.O2, new org.apache.thrift.meta_data.FieldMetaData("o2", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + tmpMap.put(_Fields.O3, new org.apache.thrift.meta_data.FieldMetaData("o3", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(alter_resource_plan_result.class, metaDataMap); + } + + public alter_resource_plan_result() { + } + + public alter_resource_plan_result( + WMAlterResourcePlanResponse success, + NoSuchObjectException o1, + InvalidOperationException o2, + MetaException o3) + { + this(); + this.success = success; + this.o1 = o1; + this.o2 = o2; + this.o3 = o3; + } + + /** + * Performs a deep copy on other. + */ + public alter_resource_plan_result(alter_resource_plan_result other) { + if (other.isSetSuccess()) { + this.success = new WMAlterResourcePlanResponse(other.success); + } + if (other.isSetO1()) { + this.o1 = new NoSuchObjectException(other.o1); + } + if (other.isSetO2()) { + this.o2 = new InvalidOperationException(other.o2); + } + if (other.isSetO3()) { + this.o3 = new MetaException(other.o3); + } + } + + public alter_resource_plan_result deepCopy() { + return new alter_resource_plan_result(this); + } + + @Override + public void clear() { + this.success = null; + this.o1 = null; + this.o2 = null; + this.o3 = null; + } + + public WMAlterResourcePlanResponse getSuccess() { + return this.success; + } + + public void setSuccess(WMAlterResourcePlanResponse success) { + this.success = success; + } + + public void unsetSuccess() { + this.success = null; + } + + /** Returns true if field success is set (has been assigned a value) and false otherwise */ + public boolean isSetSuccess() { + return this.success != null; + } + + public void setSuccessIsSet(boolean value) { + if (!value) { + this.success = null; + } + } + + public NoSuchObjectException getO1() { + return this.o1; + } + + public void setO1(NoSuchObjectException o1) { + this.o1 = o1; + } + + public void unsetO1() { + this.o1 = null; + } + + /** Returns true if field o1 is set (has been assigned a value) and false otherwise */ + public boolean isSetO1() { + return this.o1 != null; + } + + public void setO1IsSet(boolean value) { + if (!value) { + this.o1 = null; + } + } + + public InvalidOperationException getO2() { + return this.o2; + } + + public void setO2(InvalidOperationException o2) { + this.o2 = o2; + } + + public void unsetO2() { + this.o2 = null; + } + + /** Returns true if field o2 is set (has been assigned a value) and false otherwise */ + public boolean isSetO2() { + return this.o2 != null; + } + + public void setO2IsSet(boolean value) { + if (!value) { + this.o2 = null; + } + } + + public MetaException getO3() { + return this.o3; + } + + public void setO3(MetaException o3) { + this.o3 = o3; + } + + public void unsetO3() { + this.o3 = null; + } + + /** Returns true if field o3 is set (has been assigned a value) and false otherwise */ + public boolean isSetO3() { + return this.o3 != null; + } + + public void setO3IsSet(boolean value) { + if (!value) { + this.o3 = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((WMAlterResourcePlanResponse)value); + } + break; + + case O1: + if (value == null) { + unsetO1(); + } else { + setO1((NoSuchObjectException)value); + } + break; + + case O2: + if (value == null) { + unsetO2(); + } else { + setO2((InvalidOperationException)value); + } + break; + + case O3: + if (value == null) { + unsetO3(); + } else { + setO3((MetaException)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); + + case O1: + return getO1(); + + case O2: + return getO2(); + + case O3: + return getO3(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case SUCCESS: + return isSetSuccess(); + case O1: + return isSetO1(); + case O2: + return isSetO2(); + case O3: + return isSetO3(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof alter_resource_plan_result) + return this.equals((alter_resource_plan_result)that); + return false; + } + + public boolean equals(alter_resource_plan_result that) { + if (that == null) + return false; + + boolean this_present_success = true && this.isSetSuccess(); + boolean that_present_success = true && that.isSetSuccess(); + if (this_present_success || that_present_success) { + if (!(this_present_success && that_present_success)) + return false; + if (!this.success.equals(that.success)) + return false; + } + + boolean this_present_o1 = true && this.isSetO1(); + boolean that_present_o1 = true && that.isSetO1(); + if (this_present_o1 || that_present_o1) { + if (!(this_present_o1 && that_present_o1)) + return false; + if (!this.o1.equals(that.o1)) + return false; + } + + boolean this_present_o2 = true && this.isSetO2(); + boolean that_present_o2 = true && that.isSetO2(); + if (this_present_o2 || that_present_o2) { + if (!(this_present_o2 && that_present_o2)) + return false; + if (!this.o2.equals(that.o2)) + return false; + } + + boolean this_present_o3 = true && this.isSetO3(); + boolean that_present_o3 = true && that.isSetO3(); + if (this_present_o3 || that_present_o3) { + if (!(this_present_o3 && that_present_o3)) + return false; + if (!this.o3.equals(that.o3)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + boolean present_success = true && (isSetSuccess()); + list.add(present_success); + if (present_success) + list.add(success); + + boolean present_o1 = true && (isSetO1()); + list.add(present_o1); + if (present_o1) + list.add(o1); + + boolean present_o2 = true && (isSetO2()); + list.add(present_o2); + if (present_o2) + list.add(o2); + + boolean present_o3 = true && (isSetO3()); + list.add(present_o3); + if (present_o3) + list.add(o3); + + return list.hashCode(); + } + + @Override + public int compareTo(alter_resource_plan_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(other.isSetSuccess()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetSuccess()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetO1()).compareTo(other.isSetO1()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetO1()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.o1, other.o1); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetO2()).compareTo(other.isSetO2()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetO2()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.o2, other.o2); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetO3()).compareTo(other.isSetO3()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetO3()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.o3, other.o3); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("alter_resource_plan_result("); + boolean first = true; + + sb.append("success:"); + if (this.success == null) { + sb.append("null"); + } else { + sb.append(this.success); + } + first = false; + if (!first) sb.append(", "); + sb.append("o1:"); + if (this.o1 == null) { + sb.append("null"); + } else { + sb.append(this.o1); + } + first = false; + if (!first) sb.append(", "); + sb.append("o2:"); + if (this.o2 == null) { + sb.append("null"); + } else { + sb.append(this.o2); + } + first = false; + if (!first) sb.append(", "); + sb.append("o3:"); + if (this.o3 == null) { + sb.append("null"); + } else { + sb.append(this.o3); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + if (success != null) { + success.validate(); + } + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class alter_resource_plan_resultStandardSchemeFactory implements SchemeFactory { + public alter_resource_plan_resultStandardScheme getScheme() { + return new alter_resource_plan_resultStandardScheme(); + } + } + + private static class alter_resource_plan_resultStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, alter_resource_plan_result struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField schemeField; + iprot.readStructBegin(); + while (true) + { + schemeField = iprot.readFieldBegin(); + if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (schemeField.id) { + case 0: // SUCCESS + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.success = new WMAlterResourcePlanResponse(); + struct.success.read(iprot); + struct.setSuccessIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 1: // O1 + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.o1 = new NoSuchObjectException(); + struct.o1.read(iprot); + struct.setO1IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // O2 + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.o2 = new InvalidOperationException(); + struct.o2.read(iprot); + struct.setO2IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 3: // O3 + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.o3 = new MetaException(); + struct.o3.read(iprot); + struct.setO3IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + struct.validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot, alter_resource_plan_result struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.success != null) { + oprot.writeFieldBegin(SUCCESS_FIELD_DESC); + struct.success.write(oprot); + oprot.writeFieldEnd(); + } + if (struct.o1 != null) { + oprot.writeFieldBegin(O1_FIELD_DESC); + struct.o1.write(oprot); + oprot.writeFieldEnd(); + } + if (struct.o2 != null) { + oprot.writeFieldBegin(O2_FIELD_DESC); + struct.o2.write(oprot); + oprot.writeFieldEnd(); + } + if (struct.o3 != null) { + oprot.writeFieldBegin(O3_FIELD_DESC); + struct.o3.write(oprot); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class alter_resource_plan_resultTupleSchemeFactory implements SchemeFactory { + public alter_resource_plan_resultTupleScheme getScheme() { + return new alter_resource_plan_resultTupleScheme(); + } + } + + private static class alter_resource_plan_resultTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, alter_resource_plan_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + if (struct.isSetO1()) { + optionals.set(1); + } + if (struct.isSetO2()) { + optionals.set(2); + } + if (struct.isSetO3()) { + optionals.set(3); + } + oprot.writeBitSet(optionals, 4); + if (struct.isSetSuccess()) { + struct.success.write(oprot); + } + if (struct.isSetO1()) { + struct.o1.write(oprot); + } + if (struct.isSetO2()) { + struct.o2.write(oprot); + } + if (struct.isSetO3()) { + struct.o3.write(oprot); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, alter_resource_plan_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(4); + if (incoming.get(0)) { + struct.success = new WMAlterResourcePlanResponse(); + struct.success.read(iprot); + struct.setSuccessIsSet(true); + } + if (incoming.get(1)) { + struct.o1 = new NoSuchObjectException(); + struct.o1.read(iprot); + struct.setO1IsSet(true); + } + if (incoming.get(2)) { + struct.o2 = new InvalidOperationException(); + struct.o2.read(iprot); + struct.setO2IsSet(true); + } + if (incoming.get(3)) { + struct.o3 = new MetaException(); + struct.o3.read(iprot); + struct.setO3IsSet(true); + } + } + } + + } + + public static class validate_resource_plan_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("validate_resource_plan_args"); + + private static final org.apache.thrift.protocol.TField REQUEST_FIELD_DESC = new org.apache.thrift.protocol.TField("request", org.apache.thrift.protocol.TType.STRUCT, (short)1); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new validate_resource_plan_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new validate_resource_plan_argsTupleSchemeFactory()); + } + + private WMValidateResourcePlanRequest request; // required + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + REQUEST((short)1, "request"); + + private static final Map byName = new HashMap(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 1: // REQUEST + return REQUEST; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.REQUEST, new org.apache.thrift.meta_data.FieldMetaData("request", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, WMValidateResourcePlanRequest.class))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(validate_resource_plan_args.class, metaDataMap); + } + + public validate_resource_plan_args() { + } + + public validate_resource_plan_args( + WMValidateResourcePlanRequest request) + { + this(); + this.request = request; + } + + /** + * Performs a deep copy on other. + */ + public validate_resource_plan_args(validate_resource_plan_args other) { + if (other.isSetRequest()) { + this.request = new WMValidateResourcePlanRequest(other.request); + } + } + + public validate_resource_plan_args deepCopy() { + return new validate_resource_plan_args(this); + } + + @Override + public void clear() { + this.request = null; + } + + public WMValidateResourcePlanRequest getRequest() { + return this.request; + } + + public void setRequest(WMValidateResourcePlanRequest request) { + this.request = request; + } + + public void unsetRequest() { + this.request = null; + } + + /** Returns true if field request is set (has been assigned a value) and false otherwise */ + public boolean isSetRequest() { + return this.request != null; + } + + public void setRequestIsSet(boolean value) { + if (!value) { + this.request = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case REQUEST: + if (value == null) { + unsetRequest(); + } else { + setRequest((WMValidateResourcePlanRequest)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case REQUEST: + return getRequest(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case REQUEST: + return isSetRequest(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof validate_resource_plan_args) + return this.equals((validate_resource_plan_args)that); + return false; + } + + public boolean equals(validate_resource_plan_args that) { + if (that == null) + return false; + + boolean this_present_request = true && this.isSetRequest(); + boolean that_present_request = true && that.isSetRequest(); + if (this_present_request || that_present_request) { + if (!(this_present_request && that_present_request)) + return false; + if (!this.request.equals(that.request)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + boolean present_request = true && (isSetRequest()); + list.add(present_request); + if (present_request) + list.add(request); + + return list.hashCode(); + } + + @Override + public int compareTo(validate_resource_plan_args other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -190600,7 +195118,7 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("create_resource_plan_args("); + StringBuilder sb = new StringBuilder("validate_resource_plan_args("); boolean first = true; sb.append("request:"); @@ -190638,15 +195156,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class create_resource_plan_argsStandardSchemeFactory implements SchemeFactory { - public create_resource_plan_argsStandardScheme getScheme() { - return new create_resource_plan_argsStandardScheme(); + private static class validate_resource_plan_argsStandardSchemeFactory implements SchemeFactory { + public validate_resource_plan_argsStandardScheme getScheme() { + return new validate_resource_plan_argsStandardScheme(); } } - private static class create_resource_plan_argsStandardScheme extends StandardScheme { + private static class validate_resource_plan_argsStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, create_resource_plan_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, validate_resource_plan_args struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -190658,7 +195176,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, create_resource_pla switch (schemeField.id) { case 1: // REQUEST if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.request = new WMCreateResourcePlanRequest(); + struct.request = new WMValidateResourcePlanRequest(); struct.request.read(iprot); struct.setRequestIsSet(true); } else { @@ -190674,7 +195192,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, create_resource_pla struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, create_resource_plan_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, validate_resource_plan_args struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -190689,16 +195207,16 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, create_resource_pl } - private static class create_resource_plan_argsTupleSchemeFactory implements SchemeFactory { - public create_resource_plan_argsTupleScheme getScheme() { - return new create_resource_plan_argsTupleScheme(); + private static class validate_resource_plan_argsTupleSchemeFactory implements SchemeFactory { + public validate_resource_plan_argsTupleScheme getScheme() { + return new validate_resource_plan_argsTupleScheme(); } } - private static class create_resource_plan_argsTupleScheme extends TupleScheme { + private static class validate_resource_plan_argsTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, create_resource_plan_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, validate_resource_plan_args struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetRequest()) { @@ -190711,11 +195229,11 @@ public void write(org.apache.thrift.protocol.TProtocol prot, create_resource_pla } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, create_resource_plan_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, validate_resource_plan_args struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { - struct.request = new WMCreateResourcePlanRequest(); + struct.request = new WMValidateResourcePlanRequest(); struct.request.read(iprot); struct.setRequestIsSet(true); } @@ -190724,31 +195242,28 @@ public void read(org.apache.thrift.protocol.TProtocol prot, create_resource_plan } - public static class create_resource_plan_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("create_resource_plan_result"); + public static class validate_resource_plan_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("validate_resource_plan_result"); private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0); private static final org.apache.thrift.protocol.TField O1_FIELD_DESC = new org.apache.thrift.protocol.TField("o1", org.apache.thrift.protocol.TType.STRUCT, (short)1); private static final org.apache.thrift.protocol.TField O2_FIELD_DESC = new org.apache.thrift.protocol.TField("o2", org.apache.thrift.protocol.TType.STRUCT, (short)2); - private static final org.apache.thrift.protocol.TField O3_FIELD_DESC = new org.apache.thrift.protocol.TField("o3", org.apache.thrift.protocol.TType.STRUCT, (short)3); private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { - schemes.put(StandardScheme.class, new create_resource_plan_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new create_resource_plan_resultTupleSchemeFactory()); + schemes.put(StandardScheme.class, new validate_resource_plan_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new validate_resource_plan_resultTupleSchemeFactory()); } - private WMCreateResourcePlanResponse success; // required - private AlreadyExistsException o1; // required - private InvalidObjectException o2; // required - private MetaException o3; // required + private WMValidateResourcePlanResponse success; // required + private NoSuchObjectException o1; // required + private MetaException o2; // required /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ public enum _Fields implements org.apache.thrift.TFieldIdEnum { SUCCESS((short)0, "success"), O1((short)1, "o1"), - O2((short)2, "o2"), - O3((short)3, "o3"); + O2((short)2, "o2"); private static final Map byName = new HashMap(); @@ -190769,8 +195284,6 @@ public static _Fields findByThriftId(int fieldId) { return O1; case 2: // O2 return O2; - case 3: // O3 - return O3; default: return null; } @@ -190815,53 +195328,46 @@ public String getFieldName() { static { Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, WMCreateResourcePlanResponse.class))); + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, WMValidateResourcePlanResponse.class))); tmpMap.put(_Fields.O1, new org.apache.thrift.meta_data.FieldMetaData("o1", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); tmpMap.put(_Fields.O2, new org.apache.thrift.meta_data.FieldMetaData("o2", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); - tmpMap.put(_Fields.O3, new org.apache.thrift.meta_data.FieldMetaData("o3", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(create_resource_plan_result.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(validate_resource_plan_result.class, metaDataMap); } - public create_resource_plan_result() { + public validate_resource_plan_result() { } - public create_resource_plan_result( - WMCreateResourcePlanResponse success, - AlreadyExistsException o1, - InvalidObjectException o2, - MetaException o3) + public validate_resource_plan_result( + WMValidateResourcePlanResponse success, + NoSuchObjectException o1, + MetaException o2) { this(); this.success = success; this.o1 = o1; this.o2 = o2; - this.o3 = o3; } /** * Performs a deep copy on other. */ - public create_resource_plan_result(create_resource_plan_result other) { + public validate_resource_plan_result(validate_resource_plan_result other) { if (other.isSetSuccess()) { - this.success = new WMCreateResourcePlanResponse(other.success); + this.success = new WMValidateResourcePlanResponse(other.success); } if (other.isSetO1()) { - this.o1 = new AlreadyExistsException(other.o1); + this.o1 = new NoSuchObjectException(other.o1); } if (other.isSetO2()) { - this.o2 = new InvalidObjectException(other.o2); - } - if (other.isSetO3()) { - this.o3 = new MetaException(other.o3); + this.o2 = new MetaException(other.o2); } } - public create_resource_plan_result deepCopy() { - return new create_resource_plan_result(this); + public validate_resource_plan_result deepCopy() { + return new validate_resource_plan_result(this); } @Override @@ -190869,14 +195375,13 @@ public void clear() { this.success = null; this.o1 = null; this.o2 = null; - this.o3 = null; } - public WMCreateResourcePlanResponse getSuccess() { + public WMValidateResourcePlanResponse getSuccess() { return this.success; } - public void setSuccess(WMCreateResourcePlanResponse success) { + public void setSuccess(WMValidateResourcePlanResponse success) { this.success = success; } @@ -190895,11 +195400,11 @@ public void setSuccessIsSet(boolean value) { } } - public AlreadyExistsException getO1() { + public NoSuchObjectException getO1() { return this.o1; } - public void setO1(AlreadyExistsException o1) { + public void setO1(NoSuchObjectException o1) { this.o1 = o1; } @@ -190918,11 +195423,11 @@ public void setO1IsSet(boolean value) { } } - public InvalidObjectException getO2() { + public MetaException getO2() { return this.o2; } - public void setO2(InvalidObjectException o2) { + public void setO2(MetaException o2) { this.o2 = o2; } @@ -190941,36 +195446,13 @@ public void setO2IsSet(boolean value) { } } - public MetaException getO3() { - return this.o3; - } - - public void setO3(MetaException o3) { - this.o3 = o3; - } - - public void unsetO3() { - this.o3 = null; - } - - /** Returns true if field o3 is set (has been assigned a value) and false otherwise */ - public boolean isSetO3() { - return this.o3 != null; - } - - public void setO3IsSet(boolean value) { - if (!value) { - this.o3 = null; - } - } - public void setFieldValue(_Fields field, Object value) { switch (field) { case SUCCESS: if (value == null) { unsetSuccess(); } else { - setSuccess((WMCreateResourcePlanResponse)value); + setSuccess((WMValidateResourcePlanResponse)value); } break; @@ -190978,7 +195460,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetO1(); } else { - setO1((AlreadyExistsException)value); + setO1((NoSuchObjectException)value); } break; @@ -190986,15 +195468,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetO2(); } else { - setO2((InvalidObjectException)value); - } - break; - - case O3: - if (value == null) { - unsetO3(); - } else { - setO3((MetaException)value); + setO2((MetaException)value); } break; @@ -191012,9 +195486,6 @@ public Object getFieldValue(_Fields field) { case O2: return getO2(); - case O3: - return getO3(); - } throw new IllegalStateException(); } @@ -191032,8 +195503,6 @@ public boolean isSet(_Fields field) { return isSetO1(); case O2: return isSetO2(); - case O3: - return isSetO3(); } throw new IllegalStateException(); } @@ -191042,12 +195511,12 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof create_resource_plan_result) - return this.equals((create_resource_plan_result)that); + if (that instanceof validate_resource_plan_result) + return this.equals((validate_resource_plan_result)that); return false; } - public boolean equals(create_resource_plan_result that) { + public boolean equals(validate_resource_plan_result that) { if (that == null) return false; @@ -191078,15 +195547,6 @@ public boolean equals(create_resource_plan_result that) { return false; } - boolean this_present_o3 = true && this.isSetO3(); - boolean that_present_o3 = true && that.isSetO3(); - if (this_present_o3 || that_present_o3) { - if (!(this_present_o3 && that_present_o3)) - return false; - if (!this.o3.equals(that.o3)) - return false; - } - return true; } @@ -191109,16 +195569,11 @@ public int hashCode() { if (present_o2) list.add(o2); - boolean present_o3 = true && (isSetO3()); - list.add(present_o3); - if (present_o3) - list.add(o3); - return list.hashCode(); } @Override - public int compareTo(create_resource_plan_result other) { + public int compareTo(validate_resource_plan_result other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -191155,16 +195610,6 @@ public int compareTo(create_resource_plan_result other) { return lastComparison; } } - lastComparison = Boolean.valueOf(isSetO3()).compareTo(other.isSetO3()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetO3()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.o3, other.o3); - if (lastComparison != 0) { - return lastComparison; - } - } return 0; } @@ -191182,7 +195627,7 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("create_resource_plan_result("); + StringBuilder sb = new StringBuilder("validate_resource_plan_result("); boolean first = true; sb.append("success:"); @@ -191208,14 +195653,6 @@ public String toString() { sb.append(this.o2); } first = false; - if (!first) sb.append(", "); - sb.append("o3:"); - if (this.o3 == null) { - sb.append("null"); - } else { - sb.append(this.o3); - } - first = false; sb.append(")"); return sb.toString(); } @@ -191244,15 +195681,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class create_resource_plan_resultStandardSchemeFactory implements SchemeFactory { - public create_resource_plan_resultStandardScheme getScheme() { - return new create_resource_plan_resultStandardScheme(); + private static class validate_resource_plan_resultStandardSchemeFactory implements SchemeFactory { + public validate_resource_plan_resultStandardScheme getScheme() { + return new validate_resource_plan_resultStandardScheme(); } } - private static class create_resource_plan_resultStandardScheme extends StandardScheme { + private static class validate_resource_plan_resultStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, create_resource_plan_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, validate_resource_plan_result struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -191264,7 +195701,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, create_resource_pla switch (schemeField.id) { case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.success = new WMCreateResourcePlanResponse(); + struct.success = new WMValidateResourcePlanResponse(); struct.success.read(iprot); struct.setSuccessIsSet(true); } else { @@ -191273,7 +195710,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, create_resource_pla break; case 1: // O1 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.o1 = new AlreadyExistsException(); + struct.o1 = new NoSuchObjectException(); struct.o1.read(iprot); struct.setO1IsSet(true); } else { @@ -191282,22 +195719,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, create_resource_pla break; case 2: // O2 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.o2 = new InvalidObjectException(); + struct.o2 = new MetaException(); struct.o2.read(iprot); struct.setO2IsSet(true); } else { org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } break; - case 3: // O3 - if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.o3 = new MetaException(); - struct.o3.read(iprot); - struct.setO3IsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; default: org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } @@ -191307,7 +195735,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, create_resource_pla struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, create_resource_plan_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, validate_resource_plan_result struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -191326,27 +195754,22 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, create_resource_pl struct.o2.write(oprot); oprot.writeFieldEnd(); } - if (struct.o3 != null) { - oprot.writeFieldBegin(O3_FIELD_DESC); - struct.o3.write(oprot); - oprot.writeFieldEnd(); - } oprot.writeFieldStop(); oprot.writeStructEnd(); } } - private static class create_resource_plan_resultTupleSchemeFactory implements SchemeFactory { - public create_resource_plan_resultTupleScheme getScheme() { - return new create_resource_plan_resultTupleScheme(); + private static class validate_resource_plan_resultTupleSchemeFactory implements SchemeFactory { + public validate_resource_plan_resultTupleScheme getScheme() { + return new validate_resource_plan_resultTupleScheme(); } } - private static class create_resource_plan_resultTupleScheme extends TupleScheme { + private static class validate_resource_plan_resultTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, create_resource_plan_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, validate_resource_plan_result struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetSuccess()) { @@ -191358,10 +195781,7 @@ public void write(org.apache.thrift.protocol.TProtocol prot, create_resource_pla if (struct.isSetO2()) { optionals.set(2); } - if (struct.isSetO3()) { - optionals.set(3); - } - oprot.writeBitSet(optionals, 4); + oprot.writeBitSet(optionals, 3); if (struct.isSetSuccess()) { struct.success.write(oprot); } @@ -191371,52 +195791,44 @@ public void write(org.apache.thrift.protocol.TProtocol prot, create_resource_pla if (struct.isSetO2()) { struct.o2.write(oprot); } - if (struct.isSetO3()) { - struct.o3.write(oprot); - } } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, create_resource_plan_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, validate_resource_plan_result struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(4); + BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { - struct.success = new WMCreateResourcePlanResponse(); + struct.success = new WMValidateResourcePlanResponse(); struct.success.read(iprot); struct.setSuccessIsSet(true); } if (incoming.get(1)) { - struct.o1 = new AlreadyExistsException(); + struct.o1 = new NoSuchObjectException(); struct.o1.read(iprot); struct.setO1IsSet(true); } if (incoming.get(2)) { - struct.o2 = new InvalidObjectException(); + struct.o2 = new MetaException(); struct.o2.read(iprot); struct.setO2IsSet(true); } - if (incoming.get(3)) { - struct.o3 = new MetaException(); - struct.o3.read(iprot); - struct.setO3IsSet(true); - } } } } - public static class get_resource_plan_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("get_resource_plan_args"); + public static class drop_resource_plan_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("drop_resource_plan_args"); private static final org.apache.thrift.protocol.TField REQUEST_FIELD_DESC = new org.apache.thrift.protocol.TField("request", org.apache.thrift.protocol.TType.STRUCT, (short)1); private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { - schemes.put(StandardScheme.class, new get_resource_plan_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new get_resource_plan_argsTupleSchemeFactory()); + schemes.put(StandardScheme.class, new drop_resource_plan_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new drop_resource_plan_argsTupleSchemeFactory()); } - private WMGetResourcePlanRequest request; // required + private WMDropResourcePlanRequest request; // required /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ public enum _Fields implements org.apache.thrift.TFieldIdEnum { @@ -191481,16 +195893,16 @@ public String getFieldName() { static { Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); tmpMap.put(_Fields.REQUEST, new org.apache.thrift.meta_data.FieldMetaData("request", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, WMGetResourcePlanRequest.class))); + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, WMDropResourcePlanRequest.class))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(get_resource_plan_args.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(drop_resource_plan_args.class, metaDataMap); } - public get_resource_plan_args() { + public drop_resource_plan_args() { } - public get_resource_plan_args( - WMGetResourcePlanRequest request) + public drop_resource_plan_args( + WMDropResourcePlanRequest request) { this(); this.request = request; @@ -191499,14 +195911,14 @@ public get_resource_plan_args( /** * Performs a deep copy on other. */ - public get_resource_plan_args(get_resource_plan_args other) { + public drop_resource_plan_args(drop_resource_plan_args other) { if (other.isSetRequest()) { - this.request = new WMGetResourcePlanRequest(other.request); + this.request = new WMDropResourcePlanRequest(other.request); } } - public get_resource_plan_args deepCopy() { - return new get_resource_plan_args(this); + public drop_resource_plan_args deepCopy() { + return new drop_resource_plan_args(this); } @Override @@ -191514,11 +195926,11 @@ public void clear() { this.request = null; } - public WMGetResourcePlanRequest getRequest() { + public WMDropResourcePlanRequest getRequest() { return this.request; } - public void setRequest(WMGetResourcePlanRequest request) { + public void setRequest(WMDropResourcePlanRequest request) { this.request = request; } @@ -191543,7 +195955,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetRequest(); } else { - setRequest((WMGetResourcePlanRequest)value); + setRequest((WMDropResourcePlanRequest)value); } break; @@ -191576,12 +195988,12 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof get_resource_plan_args) - return this.equals((get_resource_plan_args)that); + if (that instanceof drop_resource_plan_args) + return this.equals((drop_resource_plan_args)that); return false; } - public boolean equals(get_resource_plan_args that) { + public boolean equals(drop_resource_plan_args that) { if (that == null) return false; @@ -191610,7 +196022,7 @@ public int hashCode() { } @Override - public int compareTo(get_resource_plan_args other) { + public int compareTo(drop_resource_plan_args other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -191644,7 +196056,7 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("get_resource_plan_args("); + StringBuilder sb = new StringBuilder("drop_resource_plan_args("); boolean first = true; sb.append("request:"); @@ -191682,15 +196094,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class get_resource_plan_argsStandardSchemeFactory implements SchemeFactory { - public get_resource_plan_argsStandardScheme getScheme() { - return new get_resource_plan_argsStandardScheme(); + private static class drop_resource_plan_argsStandardSchemeFactory implements SchemeFactory { + public drop_resource_plan_argsStandardScheme getScheme() { + return new drop_resource_plan_argsStandardScheme(); } } - private static class get_resource_plan_argsStandardScheme extends StandardScheme { + private static class drop_resource_plan_argsStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, get_resource_plan_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, drop_resource_plan_args struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -191702,7 +196114,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_resource_plan_a switch (schemeField.id) { case 1: // REQUEST if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.request = new WMGetResourcePlanRequest(); + struct.request = new WMDropResourcePlanRequest(); struct.request.read(iprot); struct.setRequestIsSet(true); } else { @@ -191718,7 +196130,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_resource_plan_a struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, get_resource_plan_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, drop_resource_plan_args struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -191733,16 +196145,16 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_resource_plan_ } - private static class get_resource_plan_argsTupleSchemeFactory implements SchemeFactory { - public get_resource_plan_argsTupleScheme getScheme() { - return new get_resource_plan_argsTupleScheme(); + private static class drop_resource_plan_argsTupleSchemeFactory implements SchemeFactory { + public drop_resource_plan_argsTupleScheme getScheme() { + return new drop_resource_plan_argsTupleScheme(); } } - private static class get_resource_plan_argsTupleScheme extends TupleScheme { + private static class drop_resource_plan_argsTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, get_resource_plan_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, drop_resource_plan_args struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetRequest()) { @@ -191755,11 +196167,11 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_resource_plan_a } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, get_resource_plan_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, drop_resource_plan_args struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { - struct.request = new WMGetResourcePlanRequest(); + struct.request = new WMDropResourcePlanRequest(); struct.request.read(iprot); struct.setRequestIsSet(true); } @@ -191768,28 +196180,31 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_resource_plan_ar } - public static class get_resource_plan_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("get_resource_plan_result"); + public static class drop_resource_plan_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("drop_resource_plan_result"); private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0); private static final org.apache.thrift.protocol.TField O1_FIELD_DESC = new org.apache.thrift.protocol.TField("o1", org.apache.thrift.protocol.TType.STRUCT, (short)1); private static final org.apache.thrift.protocol.TField O2_FIELD_DESC = new org.apache.thrift.protocol.TField("o2", org.apache.thrift.protocol.TType.STRUCT, (short)2); + private static final org.apache.thrift.protocol.TField O3_FIELD_DESC = new org.apache.thrift.protocol.TField("o3", org.apache.thrift.protocol.TType.STRUCT, (short)3); private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { - schemes.put(StandardScheme.class, new get_resource_plan_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new get_resource_plan_resultTupleSchemeFactory()); + schemes.put(StandardScheme.class, new drop_resource_plan_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new drop_resource_plan_resultTupleSchemeFactory()); } - private WMGetResourcePlanResponse success; // required + private WMDropResourcePlanResponse success; // required private NoSuchObjectException o1; // required - private MetaException o2; // required + private InvalidOperationException o2; // required + private MetaException o3; // required /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ public enum _Fields implements org.apache.thrift.TFieldIdEnum { SUCCESS((short)0, "success"), O1((short)1, "o1"), - O2((short)2, "o2"); + O2((short)2, "o2"), + O3((short)3, "o3"); private static final Map byName = new HashMap(); @@ -191810,6 +196225,8 @@ public static _Fields findByThriftId(int fieldId) { return O1; case 2: // O2 return O2; + case 3: // O3 + return O3; default: return null; } @@ -191854,46 +196271,53 @@ public String getFieldName() { static { Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, WMGetResourcePlanResponse.class))); + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, WMDropResourcePlanResponse.class))); tmpMap.put(_Fields.O1, new org.apache.thrift.meta_data.FieldMetaData("o1", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); tmpMap.put(_Fields.O2, new org.apache.thrift.meta_data.FieldMetaData("o2", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + tmpMap.put(_Fields.O3, new org.apache.thrift.meta_data.FieldMetaData("o3", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(get_resource_plan_result.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(drop_resource_plan_result.class, metaDataMap); } - public get_resource_plan_result() { + public drop_resource_plan_result() { } - public get_resource_plan_result( - WMGetResourcePlanResponse success, + public drop_resource_plan_result( + WMDropResourcePlanResponse success, NoSuchObjectException o1, - MetaException o2) + InvalidOperationException o2, + MetaException o3) { this(); this.success = success; this.o1 = o1; this.o2 = o2; + this.o3 = o3; } /** * Performs a deep copy on other. */ - public get_resource_plan_result(get_resource_plan_result other) { + public drop_resource_plan_result(drop_resource_plan_result other) { if (other.isSetSuccess()) { - this.success = new WMGetResourcePlanResponse(other.success); + this.success = new WMDropResourcePlanResponse(other.success); } if (other.isSetO1()) { this.o1 = new NoSuchObjectException(other.o1); } if (other.isSetO2()) { - this.o2 = new MetaException(other.o2); + this.o2 = new InvalidOperationException(other.o2); + } + if (other.isSetO3()) { + this.o3 = new MetaException(other.o3); } } - public get_resource_plan_result deepCopy() { - return new get_resource_plan_result(this); + public drop_resource_plan_result deepCopy() { + return new drop_resource_plan_result(this); } @Override @@ -191901,13 +196325,14 @@ public void clear() { this.success = null; this.o1 = null; this.o2 = null; + this.o3 = null; } - public WMGetResourcePlanResponse getSuccess() { + public WMDropResourcePlanResponse getSuccess() { return this.success; } - public void setSuccess(WMGetResourcePlanResponse success) { + public void setSuccess(WMDropResourcePlanResponse success) { this.success = success; } @@ -191949,11 +196374,11 @@ public void setO1IsSet(boolean value) { } } - public MetaException getO2() { + public InvalidOperationException getO2() { return this.o2; } - public void setO2(MetaException o2) { + public void setO2(InvalidOperationException o2) { this.o2 = o2; } @@ -191972,13 +196397,36 @@ public void setO2IsSet(boolean value) { } } + public MetaException getO3() { + return this.o3; + } + + public void setO3(MetaException o3) { + this.o3 = o3; + } + + public void unsetO3() { + this.o3 = null; + } + + /** Returns true if field o3 is set (has been assigned a value) and false otherwise */ + public boolean isSetO3() { + return this.o3 != null; + } + + public void setO3IsSet(boolean value) { + if (!value) { + this.o3 = null; + } + } + public void setFieldValue(_Fields field, Object value) { switch (field) { case SUCCESS: if (value == null) { unsetSuccess(); } else { - setSuccess((WMGetResourcePlanResponse)value); + setSuccess((WMDropResourcePlanResponse)value); } break; @@ -191994,7 +196442,15 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetO2(); } else { - setO2((MetaException)value); + setO2((InvalidOperationException)value); + } + break; + + case O3: + if (value == null) { + unsetO3(); + } else { + setO3((MetaException)value); } break; @@ -192012,6 +196468,9 @@ public Object getFieldValue(_Fields field) { case O2: return getO2(); + case O3: + return getO3(); + } throw new IllegalStateException(); } @@ -192029,6 +196488,8 @@ public boolean isSet(_Fields field) { return isSetO1(); case O2: return isSetO2(); + case O3: + return isSetO3(); } throw new IllegalStateException(); } @@ -192037,12 +196498,12 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof get_resource_plan_result) - return this.equals((get_resource_plan_result)that); + if (that instanceof drop_resource_plan_result) + return this.equals((drop_resource_plan_result)that); return false; } - public boolean equals(get_resource_plan_result that) { + public boolean equals(drop_resource_plan_result that) { if (that == null) return false; @@ -192073,6 +196534,15 @@ public boolean equals(get_resource_plan_result that) { return false; } + boolean this_present_o3 = true && this.isSetO3(); + boolean that_present_o3 = true && that.isSetO3(); + if (this_present_o3 || that_present_o3) { + if (!(this_present_o3 && that_present_o3)) + return false; + if (!this.o3.equals(that.o3)) + return false; + } + return true; } @@ -192095,11 +196565,16 @@ public int hashCode() { if (present_o2) list.add(o2); + boolean present_o3 = true && (isSetO3()); + list.add(present_o3); + if (present_o3) + list.add(o3); + return list.hashCode(); } @Override - public int compareTo(get_resource_plan_result other) { + public int compareTo(drop_resource_plan_result other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -192136,6 +196611,16 @@ public int compareTo(get_resource_plan_result other) { return lastComparison; } } + lastComparison = Boolean.valueOf(isSetO3()).compareTo(other.isSetO3()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetO3()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.o3, other.o3); + if (lastComparison != 0) { + return lastComparison; + } + } return 0; } @@ -192153,7 +196638,7 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("get_resource_plan_result("); + StringBuilder sb = new StringBuilder("drop_resource_plan_result("); boolean first = true; sb.append("success:"); @@ -192179,6 +196664,14 @@ public String toString() { sb.append(this.o2); } first = false; + if (!first) sb.append(", "); + sb.append("o3:"); + if (this.o3 == null) { + sb.append("null"); + } else { + sb.append(this.o3); + } + first = false; sb.append(")"); return sb.toString(); } @@ -192207,15 +196700,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class get_resource_plan_resultStandardSchemeFactory implements SchemeFactory { - public get_resource_plan_resultStandardScheme getScheme() { - return new get_resource_plan_resultStandardScheme(); + private static class drop_resource_plan_resultStandardSchemeFactory implements SchemeFactory { + public drop_resource_plan_resultStandardScheme getScheme() { + return new drop_resource_plan_resultStandardScheme(); } } - private static class get_resource_plan_resultStandardScheme extends StandardScheme { + private static class drop_resource_plan_resultStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, get_resource_plan_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, drop_resource_plan_result struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -192227,7 +196720,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_resource_plan_r switch (schemeField.id) { case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.success = new WMGetResourcePlanResponse(); + struct.success = new WMDropResourcePlanResponse(); struct.success.read(iprot); struct.setSuccessIsSet(true); } else { @@ -192245,13 +196738,22 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_resource_plan_r break; case 2: // O2 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.o2 = new MetaException(); + struct.o2 = new InvalidOperationException(); struct.o2.read(iprot); struct.setO2IsSet(true); } else { org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } break; + case 3: // O3 + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.o3 = new MetaException(); + struct.o3.read(iprot); + struct.setO3IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; default: org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } @@ -192261,7 +196763,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_resource_plan_r struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, get_resource_plan_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, drop_resource_plan_result struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -192280,22 +196782,27 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_resource_plan_ struct.o2.write(oprot); oprot.writeFieldEnd(); } + if (struct.o3 != null) { + oprot.writeFieldBegin(O3_FIELD_DESC); + struct.o3.write(oprot); + oprot.writeFieldEnd(); + } oprot.writeFieldStop(); oprot.writeStructEnd(); } } - private static class get_resource_plan_resultTupleSchemeFactory implements SchemeFactory { - public get_resource_plan_resultTupleScheme getScheme() { - return new get_resource_plan_resultTupleScheme(); + private static class drop_resource_plan_resultTupleSchemeFactory implements SchemeFactory { + public drop_resource_plan_resultTupleScheme getScheme() { + return new drop_resource_plan_resultTupleScheme(); } } - private static class get_resource_plan_resultTupleScheme extends TupleScheme { + private static class drop_resource_plan_resultTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, get_resource_plan_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, drop_resource_plan_result struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetSuccess()) { @@ -192307,7 +196814,10 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_resource_plan_r if (struct.isSetO2()) { optionals.set(2); } - oprot.writeBitSet(optionals, 3); + if (struct.isSetO3()) { + optionals.set(3); + } + oprot.writeBitSet(optionals, 4); if (struct.isSetSuccess()) { struct.success.write(oprot); } @@ -192317,14 +196827,17 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_resource_plan_r if (struct.isSetO2()) { struct.o2.write(oprot); } + if (struct.isSetO3()) { + struct.o3.write(oprot); + } } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, get_resource_plan_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, drop_resource_plan_result struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(3); + BitSet incoming = iprot.readBitSet(4); if (incoming.get(0)) { - struct.success = new WMGetResourcePlanResponse(); + struct.success = new WMDropResourcePlanResponse(); struct.success.read(iprot); struct.setSuccessIsSet(true); } @@ -192334,27 +196847,32 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_resource_plan_re struct.setO1IsSet(true); } if (incoming.get(2)) { - struct.o2 = new MetaException(); + struct.o2 = new InvalidOperationException(); struct.o2.read(iprot); struct.setO2IsSet(true); } + if (incoming.get(3)) { + struct.o3 = new MetaException(); + struct.o3.read(iprot); + struct.setO3IsSet(true); + } } } } - public static class get_all_resource_plans_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("get_all_resource_plans_args"); + public static class create_wm_trigger_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("create_wm_trigger_args"); private static final org.apache.thrift.protocol.TField REQUEST_FIELD_DESC = new org.apache.thrift.protocol.TField("request", org.apache.thrift.protocol.TType.STRUCT, (short)1); private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { - schemes.put(StandardScheme.class, new get_all_resource_plans_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new get_all_resource_plans_argsTupleSchemeFactory()); + schemes.put(StandardScheme.class, new create_wm_trigger_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new create_wm_trigger_argsTupleSchemeFactory()); } - private WMGetAllResourcePlanRequest request; // required + private WMCreateTriggerRequest request; // required /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ public enum _Fields implements org.apache.thrift.TFieldIdEnum { @@ -192419,16 +196937,16 @@ public String getFieldName() { static { Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); tmpMap.put(_Fields.REQUEST, new org.apache.thrift.meta_data.FieldMetaData("request", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, WMGetAllResourcePlanRequest.class))); + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, WMCreateTriggerRequest.class))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(get_all_resource_plans_args.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(create_wm_trigger_args.class, metaDataMap); } - public get_all_resource_plans_args() { + public create_wm_trigger_args() { } - public get_all_resource_plans_args( - WMGetAllResourcePlanRequest request) + public create_wm_trigger_args( + WMCreateTriggerRequest request) { this(); this.request = request; @@ -192437,14 +196955,14 @@ public get_all_resource_plans_args( /** * Performs a deep copy on other. */ - public get_all_resource_plans_args(get_all_resource_plans_args other) { + public create_wm_trigger_args(create_wm_trigger_args other) { if (other.isSetRequest()) { - this.request = new WMGetAllResourcePlanRequest(other.request); + this.request = new WMCreateTriggerRequest(other.request); } } - public get_all_resource_plans_args deepCopy() { - return new get_all_resource_plans_args(this); + public create_wm_trigger_args deepCopy() { + return new create_wm_trigger_args(this); } @Override @@ -192452,11 +196970,11 @@ public void clear() { this.request = null; } - public WMGetAllResourcePlanRequest getRequest() { + public WMCreateTriggerRequest getRequest() { return this.request; } - public void setRequest(WMGetAllResourcePlanRequest request) { + public void setRequest(WMCreateTriggerRequest request) { this.request = request; } @@ -192481,7 +196999,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetRequest(); } else { - setRequest((WMGetAllResourcePlanRequest)value); + setRequest((WMCreateTriggerRequest)value); } break; @@ -192514,12 +197032,12 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof get_all_resource_plans_args) - return this.equals((get_all_resource_plans_args)that); + if (that instanceof create_wm_trigger_args) + return this.equals((create_wm_trigger_args)that); return false; } - public boolean equals(get_all_resource_plans_args that) { + public boolean equals(create_wm_trigger_args that) { if (that == null) return false; @@ -192548,7 +197066,7 @@ public int hashCode() { } @Override - public int compareTo(get_all_resource_plans_args other) { + public int compareTo(create_wm_trigger_args other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -192582,7 +197100,7 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("get_all_resource_plans_args("); + StringBuilder sb = new StringBuilder("create_wm_trigger_args("); boolean first = true; sb.append("request:"); @@ -192620,15 +197138,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class get_all_resource_plans_argsStandardSchemeFactory implements SchemeFactory { - public get_all_resource_plans_argsStandardScheme getScheme() { - return new get_all_resource_plans_argsStandardScheme(); + private static class create_wm_trigger_argsStandardSchemeFactory implements SchemeFactory { + public create_wm_trigger_argsStandardScheme getScheme() { + return new create_wm_trigger_argsStandardScheme(); } } - private static class get_all_resource_plans_argsStandardScheme extends StandardScheme { + private static class create_wm_trigger_argsStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, get_all_resource_plans_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, create_wm_trigger_args struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -192640,7 +197158,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_all_resource_pl switch (schemeField.id) { case 1: // REQUEST if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.request = new WMGetAllResourcePlanRequest(); + struct.request = new WMCreateTriggerRequest(); struct.request.read(iprot); struct.setRequestIsSet(true); } else { @@ -192656,7 +197174,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_all_resource_pl struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, get_all_resource_plans_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, create_wm_trigger_args struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -192671,16 +197189,16 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_all_resource_p } - private static class get_all_resource_plans_argsTupleSchemeFactory implements SchemeFactory { - public get_all_resource_plans_argsTupleScheme getScheme() { - return new get_all_resource_plans_argsTupleScheme(); + private static class create_wm_trigger_argsTupleSchemeFactory implements SchemeFactory { + public create_wm_trigger_argsTupleScheme getScheme() { + return new create_wm_trigger_argsTupleScheme(); } } - private static class get_all_resource_plans_argsTupleScheme extends TupleScheme { + private static class create_wm_trigger_argsTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, get_all_resource_plans_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, create_wm_trigger_args struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetRequest()) { @@ -192693,11 +197211,11 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_all_resource_pl } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, get_all_resource_plans_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, create_wm_trigger_args struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { - struct.request = new WMGetAllResourcePlanRequest(); + struct.request = new WMCreateTriggerRequest(); struct.request.read(iprot); struct.setRequestIsSet(true); } @@ -192706,25 +197224,34 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_all_resource_pla } - public static class get_all_resource_plans_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("get_all_resource_plans_result"); + public static class create_wm_trigger_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("create_wm_trigger_result"); private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0); private static final org.apache.thrift.protocol.TField O1_FIELD_DESC = new org.apache.thrift.protocol.TField("o1", org.apache.thrift.protocol.TType.STRUCT, (short)1); + private static final org.apache.thrift.protocol.TField O2_FIELD_DESC = new org.apache.thrift.protocol.TField("o2", org.apache.thrift.protocol.TType.STRUCT, (short)2); + private static final org.apache.thrift.protocol.TField O3_FIELD_DESC = new org.apache.thrift.protocol.TField("o3", org.apache.thrift.protocol.TType.STRUCT, (short)3); + private static final org.apache.thrift.protocol.TField O4_FIELD_DESC = new org.apache.thrift.protocol.TField("o4", org.apache.thrift.protocol.TType.STRUCT, (short)4); private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { - schemes.put(StandardScheme.class, new get_all_resource_plans_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new get_all_resource_plans_resultTupleSchemeFactory()); + schemes.put(StandardScheme.class, new create_wm_trigger_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new create_wm_trigger_resultTupleSchemeFactory()); } - private WMGetAllResourcePlanResponse success; // required - private MetaException o1; // required + private WMCreateTriggerResponse success; // required + private AlreadyExistsException o1; // required + private NoSuchObjectException o2; // required + private InvalidObjectException o3; // required + private MetaException o4; // required /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ public enum _Fields implements org.apache.thrift.TFieldIdEnum { SUCCESS((short)0, "success"), - O1((short)1, "o1"); + O1((short)1, "o1"), + O2((short)2, "o2"), + O3((short)3, "o3"), + O4((short)4, "o4"); private static final Map byName = new HashMap(); @@ -192743,6 +197270,12 @@ public static _Fields findByThriftId(int fieldId) { return SUCCESS; case 1: // O1 return O1; + case 2: // O2 + return O2; + case 3: // O3 + return O3; + case 4: // O4 + return O4; default: return null; } @@ -192787,52 +197320,76 @@ public String getFieldName() { static { Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, WMGetAllResourcePlanResponse.class))); + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, WMCreateTriggerResponse.class))); tmpMap.put(_Fields.O1, new org.apache.thrift.meta_data.FieldMetaData("o1", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + tmpMap.put(_Fields.O2, new org.apache.thrift.meta_data.FieldMetaData("o2", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + tmpMap.put(_Fields.O3, new org.apache.thrift.meta_data.FieldMetaData("o3", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + tmpMap.put(_Fields.O4, new org.apache.thrift.meta_data.FieldMetaData("o4", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(get_all_resource_plans_result.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(create_wm_trigger_result.class, metaDataMap); } - public get_all_resource_plans_result() { + public create_wm_trigger_result() { } - public get_all_resource_plans_result( - WMGetAllResourcePlanResponse success, - MetaException o1) + public create_wm_trigger_result( + WMCreateTriggerResponse success, + AlreadyExistsException o1, + NoSuchObjectException o2, + InvalidObjectException o3, + MetaException o4) { this(); this.success = success; this.o1 = o1; + this.o2 = o2; + this.o3 = o3; + this.o4 = o4; } /** * Performs a deep copy on other. */ - public get_all_resource_plans_result(get_all_resource_plans_result other) { + public create_wm_trigger_result(create_wm_trigger_result other) { if (other.isSetSuccess()) { - this.success = new WMGetAllResourcePlanResponse(other.success); + this.success = new WMCreateTriggerResponse(other.success); } if (other.isSetO1()) { - this.o1 = new MetaException(other.o1); + this.o1 = new AlreadyExistsException(other.o1); + } + if (other.isSetO2()) { + this.o2 = new NoSuchObjectException(other.o2); + } + if (other.isSetO3()) { + this.o3 = new InvalidObjectException(other.o3); + } + if (other.isSetO4()) { + this.o4 = new MetaException(other.o4); } } - public get_all_resource_plans_result deepCopy() { - return new get_all_resource_plans_result(this); + public create_wm_trigger_result deepCopy() { + return new create_wm_trigger_result(this); } @Override public void clear() { this.success = null; this.o1 = null; + this.o2 = null; + this.o3 = null; + this.o4 = null; } - public WMGetAllResourcePlanResponse getSuccess() { + public WMCreateTriggerResponse getSuccess() { return this.success; } - public void setSuccess(WMGetAllResourcePlanResponse success) { + public void setSuccess(WMCreateTriggerResponse success) { this.success = success; } @@ -192851,11 +197408,11 @@ public void setSuccessIsSet(boolean value) { } } - public MetaException getO1() { + public AlreadyExistsException getO1() { return this.o1; } - public void setO1(MetaException o1) { + public void setO1(AlreadyExistsException o1) { this.o1 = o1; } @@ -192874,13 +197431,82 @@ public void setO1IsSet(boolean value) { } } + public NoSuchObjectException getO2() { + return this.o2; + } + + public void setO2(NoSuchObjectException o2) { + this.o2 = o2; + } + + public void unsetO2() { + this.o2 = null; + } + + /** Returns true if field o2 is set (has been assigned a value) and false otherwise */ + public boolean isSetO2() { + return this.o2 != null; + } + + public void setO2IsSet(boolean value) { + if (!value) { + this.o2 = null; + } + } + + public InvalidObjectException getO3() { + return this.o3; + } + + public void setO3(InvalidObjectException o3) { + this.o3 = o3; + } + + public void unsetO3() { + this.o3 = null; + } + + /** Returns true if field o3 is set (has been assigned a value) and false otherwise */ + public boolean isSetO3() { + return this.o3 != null; + } + + public void setO3IsSet(boolean value) { + if (!value) { + this.o3 = null; + } + } + + public MetaException getO4() { + return this.o4; + } + + public void setO4(MetaException o4) { + this.o4 = o4; + } + + public void unsetO4() { + this.o4 = null; + } + + /** Returns true if field o4 is set (has been assigned a value) and false otherwise */ + public boolean isSetO4() { + return this.o4 != null; + } + + public void setO4IsSet(boolean value) { + if (!value) { + this.o4 = null; + } + } + public void setFieldValue(_Fields field, Object value) { switch (field) { case SUCCESS: if (value == null) { unsetSuccess(); } else { - setSuccess((WMGetAllResourcePlanResponse)value); + setSuccess((WMCreateTriggerResponse)value); } break; @@ -192888,7 +197514,31 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetO1(); } else { - setO1((MetaException)value); + setO1((AlreadyExistsException)value); + } + break; + + case O2: + if (value == null) { + unsetO2(); + } else { + setO2((NoSuchObjectException)value); + } + break; + + case O3: + if (value == null) { + unsetO3(); + } else { + setO3((InvalidObjectException)value); + } + break; + + case O4: + if (value == null) { + unsetO4(); + } else { + setO4((MetaException)value); } break; @@ -192903,6 +197553,15 @@ public Object getFieldValue(_Fields field) { case O1: return getO1(); + case O2: + return getO2(); + + case O3: + return getO3(); + + case O4: + return getO4(); + } throw new IllegalStateException(); } @@ -192918,6 +197577,12 @@ public boolean isSet(_Fields field) { return isSetSuccess(); case O1: return isSetO1(); + case O2: + return isSetO2(); + case O3: + return isSetO3(); + case O4: + return isSetO4(); } throw new IllegalStateException(); } @@ -192926,12 +197591,12 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof get_all_resource_plans_result) - return this.equals((get_all_resource_plans_result)that); + if (that instanceof create_wm_trigger_result) + return this.equals((create_wm_trigger_result)that); return false; } - public boolean equals(get_all_resource_plans_result that) { + public boolean equals(create_wm_trigger_result that) { if (that == null) return false; @@ -192953,6 +197618,33 @@ public boolean equals(get_all_resource_plans_result that) { return false; } + boolean this_present_o2 = true && this.isSetO2(); + boolean that_present_o2 = true && that.isSetO2(); + if (this_present_o2 || that_present_o2) { + if (!(this_present_o2 && that_present_o2)) + return false; + if (!this.o2.equals(that.o2)) + return false; + } + + boolean this_present_o3 = true && this.isSetO3(); + boolean that_present_o3 = true && that.isSetO3(); + if (this_present_o3 || that_present_o3) { + if (!(this_present_o3 && that_present_o3)) + return false; + if (!this.o3.equals(that.o3)) + return false; + } + + boolean this_present_o4 = true && this.isSetO4(); + boolean that_present_o4 = true && that.isSetO4(); + if (this_present_o4 || that_present_o4) { + if (!(this_present_o4 && that_present_o4)) + return false; + if (!this.o4.equals(that.o4)) + return false; + } + return true; } @@ -192970,11 +197662,26 @@ public int hashCode() { if (present_o1) list.add(o1); + boolean present_o2 = true && (isSetO2()); + list.add(present_o2); + if (present_o2) + list.add(o2); + + boolean present_o3 = true && (isSetO3()); + list.add(present_o3); + if (present_o3) + list.add(o3); + + boolean present_o4 = true && (isSetO4()); + list.add(present_o4); + if (present_o4) + list.add(o4); + return list.hashCode(); } @Override - public int compareTo(get_all_resource_plans_result other) { + public int compareTo(create_wm_trigger_result other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -193001,6 +197708,36 @@ public int compareTo(get_all_resource_plans_result other) { return lastComparison; } } + lastComparison = Boolean.valueOf(isSetO2()).compareTo(other.isSetO2()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetO2()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.o2, other.o2); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetO3()).compareTo(other.isSetO3()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetO3()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.o3, other.o3); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetO4()).compareTo(other.isSetO4()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetO4()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.o4, other.o4); + if (lastComparison != 0) { + return lastComparison; + } + } return 0; } @@ -193018,7 +197755,7 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("get_all_resource_plans_result("); + StringBuilder sb = new StringBuilder("create_wm_trigger_result("); boolean first = true; sb.append("success:"); @@ -193036,6 +197773,30 @@ public String toString() { sb.append(this.o1); } first = false; + if (!first) sb.append(", "); + sb.append("o2:"); + if (this.o2 == null) { + sb.append("null"); + } else { + sb.append(this.o2); + } + first = false; + if (!first) sb.append(", "); + sb.append("o3:"); + if (this.o3 == null) { + sb.append("null"); + } else { + sb.append(this.o3); + } + first = false; + if (!first) sb.append(", "); + sb.append("o4:"); + if (this.o4 == null) { + sb.append("null"); + } else { + sb.append(this.o4); + } + first = false; sb.append(")"); return sb.toString(); } @@ -193064,15 +197825,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class get_all_resource_plans_resultStandardSchemeFactory implements SchemeFactory { - public get_all_resource_plans_resultStandardScheme getScheme() { - return new get_all_resource_plans_resultStandardScheme(); + private static class create_wm_trigger_resultStandardSchemeFactory implements SchemeFactory { + public create_wm_trigger_resultStandardScheme getScheme() { + return new create_wm_trigger_resultStandardScheme(); } } - private static class get_all_resource_plans_resultStandardScheme extends StandardScheme { + private static class create_wm_trigger_resultStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, get_all_resource_plans_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, create_wm_trigger_result struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -193084,7 +197845,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_all_resource_pl switch (schemeField.id) { case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.success = new WMGetAllResourcePlanResponse(); + struct.success = new WMCreateTriggerResponse(); struct.success.read(iprot); struct.setSuccessIsSet(true); } else { @@ -193093,13 +197854,40 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_all_resource_pl break; case 1: // O1 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.o1 = new MetaException(); + struct.o1 = new AlreadyExistsException(); struct.o1.read(iprot); struct.setO1IsSet(true); } else { org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } break; + case 2: // O2 + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.o2 = new NoSuchObjectException(); + struct.o2.read(iprot); + struct.setO2IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 3: // O3 + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.o3 = new InvalidObjectException(); + struct.o3.read(iprot); + struct.setO3IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 4: // O4 + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.o4 = new MetaException(); + struct.o4.read(iprot); + struct.setO4IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; default: org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } @@ -193109,7 +197897,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_all_resource_pl struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, get_all_resource_plans_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, create_wm_trigger_result struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -193123,22 +197911,37 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_all_resource_p struct.o1.write(oprot); oprot.writeFieldEnd(); } + if (struct.o2 != null) { + oprot.writeFieldBegin(O2_FIELD_DESC); + struct.o2.write(oprot); + oprot.writeFieldEnd(); + } + if (struct.o3 != null) { + oprot.writeFieldBegin(O3_FIELD_DESC); + struct.o3.write(oprot); + oprot.writeFieldEnd(); + } + if (struct.o4 != null) { + oprot.writeFieldBegin(O4_FIELD_DESC); + struct.o4.write(oprot); + oprot.writeFieldEnd(); + } oprot.writeFieldStop(); oprot.writeStructEnd(); } } - private static class get_all_resource_plans_resultTupleSchemeFactory implements SchemeFactory { - public get_all_resource_plans_resultTupleScheme getScheme() { - return new get_all_resource_plans_resultTupleScheme(); + private static class create_wm_trigger_resultTupleSchemeFactory implements SchemeFactory { + public create_wm_trigger_resultTupleScheme getScheme() { + return new create_wm_trigger_resultTupleScheme(); } } - private static class get_all_resource_plans_resultTupleScheme extends TupleScheme { + private static class create_wm_trigger_resultTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, get_all_resource_plans_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, create_wm_trigger_result struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetSuccess()) { @@ -193147,46 +197950,79 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_all_resource_pl if (struct.isSetO1()) { optionals.set(1); } - oprot.writeBitSet(optionals, 2); + if (struct.isSetO2()) { + optionals.set(2); + } + if (struct.isSetO3()) { + optionals.set(3); + } + if (struct.isSetO4()) { + optionals.set(4); + } + oprot.writeBitSet(optionals, 5); if (struct.isSetSuccess()) { struct.success.write(oprot); } if (struct.isSetO1()) { struct.o1.write(oprot); } + if (struct.isSetO2()) { + struct.o2.write(oprot); + } + if (struct.isSetO3()) { + struct.o3.write(oprot); + } + if (struct.isSetO4()) { + struct.o4.write(oprot); + } } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, get_all_resource_plans_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, create_wm_trigger_result struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(2); + BitSet incoming = iprot.readBitSet(5); if (incoming.get(0)) { - struct.success = new WMGetAllResourcePlanResponse(); + struct.success = new WMCreateTriggerResponse(); struct.success.read(iprot); struct.setSuccessIsSet(true); } if (incoming.get(1)) { - struct.o1 = new MetaException(); + struct.o1 = new AlreadyExistsException(); struct.o1.read(iprot); struct.setO1IsSet(true); } + if (incoming.get(2)) { + struct.o2 = new NoSuchObjectException(); + struct.o2.read(iprot); + struct.setO2IsSet(true); + } + if (incoming.get(3)) { + struct.o3 = new InvalidObjectException(); + struct.o3.read(iprot); + struct.setO3IsSet(true); + } + if (incoming.get(4)) { + struct.o4 = new MetaException(); + struct.o4.read(iprot); + struct.setO4IsSet(true); + } } } } - public static class alter_resource_plan_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("alter_resource_plan_args"); + public static class alter_wm_trigger_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("alter_wm_trigger_args"); private static final org.apache.thrift.protocol.TField REQUEST_FIELD_DESC = new org.apache.thrift.protocol.TField("request", org.apache.thrift.protocol.TType.STRUCT, (short)1); private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { - schemes.put(StandardScheme.class, new alter_resource_plan_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new alter_resource_plan_argsTupleSchemeFactory()); + schemes.put(StandardScheme.class, new alter_wm_trigger_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new alter_wm_trigger_argsTupleSchemeFactory()); } - private WMAlterResourcePlanRequest request; // required + private WMAlterTriggerRequest request; // required /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ public enum _Fields implements org.apache.thrift.TFieldIdEnum { @@ -193251,16 +198087,16 @@ public String getFieldName() { static { Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); tmpMap.put(_Fields.REQUEST, new org.apache.thrift.meta_data.FieldMetaData("request", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, WMAlterResourcePlanRequest.class))); + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, WMAlterTriggerRequest.class))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(alter_resource_plan_args.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(alter_wm_trigger_args.class, metaDataMap); } - public alter_resource_plan_args() { + public alter_wm_trigger_args() { } - public alter_resource_plan_args( - WMAlterResourcePlanRequest request) + public alter_wm_trigger_args( + WMAlterTriggerRequest request) { this(); this.request = request; @@ -193269,14 +198105,14 @@ public alter_resource_plan_args( /** * Performs a deep copy on other. */ - public alter_resource_plan_args(alter_resource_plan_args other) { + public alter_wm_trigger_args(alter_wm_trigger_args other) { if (other.isSetRequest()) { - this.request = new WMAlterResourcePlanRequest(other.request); + this.request = new WMAlterTriggerRequest(other.request); } } - public alter_resource_plan_args deepCopy() { - return new alter_resource_plan_args(this); + public alter_wm_trigger_args deepCopy() { + return new alter_wm_trigger_args(this); } @Override @@ -193284,11 +198120,11 @@ public void clear() { this.request = null; } - public WMAlterResourcePlanRequest getRequest() { + public WMAlterTriggerRequest getRequest() { return this.request; } - public void setRequest(WMAlterResourcePlanRequest request) { + public void setRequest(WMAlterTriggerRequest request) { this.request = request; } @@ -193313,7 +198149,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetRequest(); } else { - setRequest((WMAlterResourcePlanRequest)value); + setRequest((WMAlterTriggerRequest)value); } break; @@ -193346,12 +198182,12 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof alter_resource_plan_args) - return this.equals((alter_resource_plan_args)that); + if (that instanceof alter_wm_trigger_args) + return this.equals((alter_wm_trigger_args)that); return false; } - public boolean equals(alter_resource_plan_args that) { + public boolean equals(alter_wm_trigger_args that) { if (that == null) return false; @@ -193380,7 +198216,7 @@ public int hashCode() { } @Override - public int compareTo(alter_resource_plan_args other) { + public int compareTo(alter_wm_trigger_args other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -193414,7 +198250,7 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("alter_resource_plan_args("); + StringBuilder sb = new StringBuilder("alter_wm_trigger_args("); boolean first = true; sb.append("request:"); @@ -193452,15 +198288,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class alter_resource_plan_argsStandardSchemeFactory implements SchemeFactory { - public alter_resource_plan_argsStandardScheme getScheme() { - return new alter_resource_plan_argsStandardScheme(); + private static class alter_wm_trigger_argsStandardSchemeFactory implements SchemeFactory { + public alter_wm_trigger_argsStandardScheme getScheme() { + return new alter_wm_trigger_argsStandardScheme(); } } - private static class alter_resource_plan_argsStandardScheme extends StandardScheme { + private static class alter_wm_trigger_argsStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, alter_resource_plan_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, alter_wm_trigger_args struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -193472,7 +198308,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, alter_resource_plan switch (schemeField.id) { case 1: // REQUEST if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.request = new WMAlterResourcePlanRequest(); + struct.request = new WMAlterTriggerRequest(); struct.request.read(iprot); struct.setRequestIsSet(true); } else { @@ -193488,7 +198324,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, alter_resource_plan struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, alter_resource_plan_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, alter_wm_trigger_args struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -193503,16 +198339,16 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, alter_resource_pla } - private static class alter_resource_plan_argsTupleSchemeFactory implements SchemeFactory { - public alter_resource_plan_argsTupleScheme getScheme() { - return new alter_resource_plan_argsTupleScheme(); + private static class alter_wm_trigger_argsTupleSchemeFactory implements SchemeFactory { + public alter_wm_trigger_argsTupleScheme getScheme() { + return new alter_wm_trigger_argsTupleScheme(); } } - private static class alter_resource_plan_argsTupleScheme extends TupleScheme { + private static class alter_wm_trigger_argsTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, alter_resource_plan_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, alter_wm_trigger_args struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetRequest()) { @@ -193525,11 +198361,11 @@ public void write(org.apache.thrift.protocol.TProtocol prot, alter_resource_plan } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, alter_resource_plan_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, alter_wm_trigger_args struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { - struct.request = new WMAlterResourcePlanRequest(); + struct.request = new WMAlterTriggerRequest(); struct.request.read(iprot); struct.setRequestIsSet(true); } @@ -193538,8 +198374,8 @@ public void read(org.apache.thrift.protocol.TProtocol prot, alter_resource_plan_ } - public static class alter_resource_plan_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("alter_resource_plan_result"); + public static class alter_wm_trigger_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("alter_wm_trigger_result"); private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0); private static final org.apache.thrift.protocol.TField O1_FIELD_DESC = new org.apache.thrift.protocol.TField("o1", org.apache.thrift.protocol.TType.STRUCT, (short)1); @@ -193548,13 +198384,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, alter_resource_plan_ private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { - schemes.put(StandardScheme.class, new alter_resource_plan_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new alter_resource_plan_resultTupleSchemeFactory()); + schemes.put(StandardScheme.class, new alter_wm_trigger_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new alter_wm_trigger_resultTupleSchemeFactory()); } - private WMAlterResourcePlanResponse success; // required + private WMAlterTriggerResponse success; // required private NoSuchObjectException o1; // required - private InvalidOperationException o2; // required + private InvalidObjectException o2; // required private MetaException o3; // required /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ @@ -193629,7 +198465,7 @@ public String getFieldName() { static { Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, WMAlterResourcePlanResponse.class))); + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, WMAlterTriggerResponse.class))); tmpMap.put(_Fields.O1, new org.apache.thrift.meta_data.FieldMetaData("o1", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); tmpMap.put(_Fields.O2, new org.apache.thrift.meta_data.FieldMetaData("o2", org.apache.thrift.TFieldRequirementType.DEFAULT, @@ -193637,16 +198473,16 @@ public String getFieldName() { tmpMap.put(_Fields.O3, new org.apache.thrift.meta_data.FieldMetaData("o3", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(alter_resource_plan_result.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(alter_wm_trigger_result.class, metaDataMap); } - public alter_resource_plan_result() { + public alter_wm_trigger_result() { } - public alter_resource_plan_result( - WMAlterResourcePlanResponse success, + public alter_wm_trigger_result( + WMAlterTriggerResponse success, NoSuchObjectException o1, - InvalidOperationException o2, + InvalidObjectException o2, MetaException o3) { this(); @@ -193659,23 +198495,23 @@ public alter_resource_plan_result( /** * Performs a deep copy on other. */ - public alter_resource_plan_result(alter_resource_plan_result other) { + public alter_wm_trigger_result(alter_wm_trigger_result other) { if (other.isSetSuccess()) { - this.success = new WMAlterResourcePlanResponse(other.success); + this.success = new WMAlterTriggerResponse(other.success); } if (other.isSetO1()) { this.o1 = new NoSuchObjectException(other.o1); } if (other.isSetO2()) { - this.o2 = new InvalidOperationException(other.o2); + this.o2 = new InvalidObjectException(other.o2); } if (other.isSetO3()) { this.o3 = new MetaException(other.o3); } } - public alter_resource_plan_result deepCopy() { - return new alter_resource_plan_result(this); + public alter_wm_trigger_result deepCopy() { + return new alter_wm_trigger_result(this); } @Override @@ -193686,11 +198522,11 @@ public void clear() { this.o3 = null; } - public WMAlterResourcePlanResponse getSuccess() { + public WMAlterTriggerResponse getSuccess() { return this.success; } - public void setSuccess(WMAlterResourcePlanResponse success) { + public void setSuccess(WMAlterTriggerResponse success) { this.success = success; } @@ -193732,11 +198568,11 @@ public void setO1IsSet(boolean value) { } } - public InvalidOperationException getO2() { + public InvalidObjectException getO2() { return this.o2; } - public void setO2(InvalidOperationException o2) { + public void setO2(InvalidObjectException o2) { this.o2 = o2; } @@ -193784,7 +198620,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetSuccess(); } else { - setSuccess((WMAlterResourcePlanResponse)value); + setSuccess((WMAlterTriggerResponse)value); } break; @@ -193800,7 +198636,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetO2(); } else { - setO2((InvalidOperationException)value); + setO2((InvalidObjectException)value); } break; @@ -193856,12 +198692,12 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof alter_resource_plan_result) - return this.equals((alter_resource_plan_result)that); + if (that instanceof alter_wm_trigger_result) + return this.equals((alter_wm_trigger_result)that); return false; } - public boolean equals(alter_resource_plan_result that) { + public boolean equals(alter_wm_trigger_result that) { if (that == null) return false; @@ -193932,7 +198768,7 @@ public int hashCode() { } @Override - public int compareTo(alter_resource_plan_result other) { + public int compareTo(alter_wm_trigger_result other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -193996,7 +198832,7 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("alter_resource_plan_result("); + StringBuilder sb = new StringBuilder("alter_wm_trigger_result("); boolean first = true; sb.append("success:"); @@ -194058,15 +198894,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class alter_resource_plan_resultStandardSchemeFactory implements SchemeFactory { - public alter_resource_plan_resultStandardScheme getScheme() { - return new alter_resource_plan_resultStandardScheme(); + private static class alter_wm_trigger_resultStandardSchemeFactory implements SchemeFactory { + public alter_wm_trigger_resultStandardScheme getScheme() { + return new alter_wm_trigger_resultStandardScheme(); } } - private static class alter_resource_plan_resultStandardScheme extends StandardScheme { + private static class alter_wm_trigger_resultStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, alter_resource_plan_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, alter_wm_trigger_result struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -194078,7 +198914,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, alter_resource_plan switch (schemeField.id) { case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.success = new WMAlterResourcePlanResponse(); + struct.success = new WMAlterTriggerResponse(); struct.success.read(iprot); struct.setSuccessIsSet(true); } else { @@ -194096,7 +198932,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, alter_resource_plan break; case 2: // O2 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.o2 = new InvalidOperationException(); + struct.o2 = new InvalidObjectException(); struct.o2.read(iprot); struct.setO2IsSet(true); } else { @@ -194121,7 +198957,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, alter_resource_plan struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, alter_resource_plan_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, alter_wm_trigger_result struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -194151,16 +198987,16 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, alter_resource_pla } - private static class alter_resource_plan_resultTupleSchemeFactory implements SchemeFactory { - public alter_resource_plan_resultTupleScheme getScheme() { - return new alter_resource_plan_resultTupleScheme(); + private static class alter_wm_trigger_resultTupleSchemeFactory implements SchemeFactory { + public alter_wm_trigger_resultTupleScheme getScheme() { + return new alter_wm_trigger_resultTupleScheme(); } } - private static class alter_resource_plan_resultTupleScheme extends TupleScheme { + private static class alter_wm_trigger_resultTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, alter_resource_plan_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, alter_wm_trigger_result struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetSuccess()) { @@ -194191,11 +199027,11 @@ public void write(org.apache.thrift.protocol.TProtocol prot, alter_resource_plan } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, alter_resource_plan_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, alter_wm_trigger_result struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; BitSet incoming = iprot.readBitSet(4); if (incoming.get(0)) { - struct.success = new WMAlterResourcePlanResponse(); + struct.success = new WMAlterTriggerResponse(); struct.success.read(iprot); struct.setSuccessIsSet(true); } @@ -194205,7 +199041,7 @@ public void read(org.apache.thrift.protocol.TProtocol prot, alter_resource_plan_ struct.setO1IsSet(true); } if (incoming.get(2)) { - struct.o2 = new InvalidOperationException(); + struct.o2 = new InvalidObjectException(); struct.o2.read(iprot); struct.setO2IsSet(true); } @@ -194219,18 +199055,18 @@ public void read(org.apache.thrift.protocol.TProtocol prot, alter_resource_plan_ } - public static class validate_resource_plan_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("validate_resource_plan_args"); + public static class drop_wm_trigger_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("drop_wm_trigger_args"); private static final org.apache.thrift.protocol.TField REQUEST_FIELD_DESC = new org.apache.thrift.protocol.TField("request", org.apache.thrift.protocol.TType.STRUCT, (short)1); private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { - schemes.put(StandardScheme.class, new validate_resource_plan_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new validate_resource_plan_argsTupleSchemeFactory()); + schemes.put(StandardScheme.class, new drop_wm_trigger_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new drop_wm_trigger_argsTupleSchemeFactory()); } - private WMValidateResourcePlanRequest request; // required + private WMDropTriggerRequest request; // required /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ public enum _Fields implements org.apache.thrift.TFieldIdEnum { @@ -194295,16 +199131,16 @@ public String getFieldName() { static { Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); tmpMap.put(_Fields.REQUEST, new org.apache.thrift.meta_data.FieldMetaData("request", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, WMValidateResourcePlanRequest.class))); + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, WMDropTriggerRequest.class))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(validate_resource_plan_args.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(drop_wm_trigger_args.class, metaDataMap); } - public validate_resource_plan_args() { + public drop_wm_trigger_args() { } - public validate_resource_plan_args( - WMValidateResourcePlanRequest request) + public drop_wm_trigger_args( + WMDropTriggerRequest request) { this(); this.request = request; @@ -194313,14 +199149,14 @@ public validate_resource_plan_args( /** * Performs a deep copy on other. */ - public validate_resource_plan_args(validate_resource_plan_args other) { + public drop_wm_trigger_args(drop_wm_trigger_args other) { if (other.isSetRequest()) { - this.request = new WMValidateResourcePlanRequest(other.request); + this.request = new WMDropTriggerRequest(other.request); } } - public validate_resource_plan_args deepCopy() { - return new validate_resource_plan_args(this); + public drop_wm_trigger_args deepCopy() { + return new drop_wm_trigger_args(this); } @Override @@ -194328,11 +199164,11 @@ public void clear() { this.request = null; } - public WMValidateResourcePlanRequest getRequest() { + public WMDropTriggerRequest getRequest() { return this.request; } - public void setRequest(WMValidateResourcePlanRequest request) { + public void setRequest(WMDropTriggerRequest request) { this.request = request; } @@ -194357,7 +199193,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetRequest(); } else { - setRequest((WMValidateResourcePlanRequest)value); + setRequest((WMDropTriggerRequest)value); } break; @@ -194390,12 +199226,12 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof validate_resource_plan_args) - return this.equals((validate_resource_plan_args)that); + if (that instanceof drop_wm_trigger_args) + return this.equals((drop_wm_trigger_args)that); return false; } - public boolean equals(validate_resource_plan_args that) { + public boolean equals(drop_wm_trigger_args that) { if (that == null) return false; @@ -194424,7 +199260,7 @@ public int hashCode() { } @Override - public int compareTo(validate_resource_plan_args other) { + public int compareTo(drop_wm_trigger_args other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -194458,7 +199294,7 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("validate_resource_plan_args("); + StringBuilder sb = new StringBuilder("drop_wm_trigger_args("); boolean first = true; sb.append("request:"); @@ -194496,15 +199332,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class validate_resource_plan_argsStandardSchemeFactory implements SchemeFactory { - public validate_resource_plan_argsStandardScheme getScheme() { - return new validate_resource_plan_argsStandardScheme(); + private static class drop_wm_trigger_argsStandardSchemeFactory implements SchemeFactory { + public drop_wm_trigger_argsStandardScheme getScheme() { + return new drop_wm_trigger_argsStandardScheme(); } } - private static class validate_resource_plan_argsStandardScheme extends StandardScheme { + private static class drop_wm_trigger_argsStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, validate_resource_plan_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, drop_wm_trigger_args struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -194516,7 +199352,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, validate_resource_p switch (schemeField.id) { case 1: // REQUEST if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.request = new WMValidateResourcePlanRequest(); + struct.request = new WMDropTriggerRequest(); struct.request.read(iprot); struct.setRequestIsSet(true); } else { @@ -194532,7 +199368,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, validate_resource_p struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, validate_resource_plan_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, drop_wm_trigger_args struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -194547,16 +199383,16 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, validate_resource_ } - private static class validate_resource_plan_argsTupleSchemeFactory implements SchemeFactory { - public validate_resource_plan_argsTupleScheme getScheme() { - return new validate_resource_plan_argsTupleScheme(); + private static class drop_wm_trigger_argsTupleSchemeFactory implements SchemeFactory { + public drop_wm_trigger_argsTupleScheme getScheme() { + return new drop_wm_trigger_argsTupleScheme(); } } - private static class validate_resource_plan_argsTupleScheme extends TupleScheme { + private static class drop_wm_trigger_argsTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, validate_resource_plan_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, drop_wm_trigger_args struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetRequest()) { @@ -194569,11 +199405,11 @@ public void write(org.apache.thrift.protocol.TProtocol prot, validate_resource_p } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, validate_resource_plan_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, drop_wm_trigger_args struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { - struct.request = new WMValidateResourcePlanRequest(); + struct.request = new WMDropTriggerRequest(); struct.request.read(iprot); struct.setRequestIsSet(true); } @@ -194582,28 +199418,31 @@ public void read(org.apache.thrift.protocol.TProtocol prot, validate_resource_pl } - public static class validate_resource_plan_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("validate_resource_plan_result"); + public static class drop_wm_trigger_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("drop_wm_trigger_result"); private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0); private static final org.apache.thrift.protocol.TField O1_FIELD_DESC = new org.apache.thrift.protocol.TField("o1", org.apache.thrift.protocol.TType.STRUCT, (short)1); private static final org.apache.thrift.protocol.TField O2_FIELD_DESC = new org.apache.thrift.protocol.TField("o2", org.apache.thrift.protocol.TType.STRUCT, (short)2); + private static final org.apache.thrift.protocol.TField O3_FIELD_DESC = new org.apache.thrift.protocol.TField("o3", org.apache.thrift.protocol.TType.STRUCT, (short)3); private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { - schemes.put(StandardScheme.class, new validate_resource_plan_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new validate_resource_plan_resultTupleSchemeFactory()); + schemes.put(StandardScheme.class, new drop_wm_trigger_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new drop_wm_trigger_resultTupleSchemeFactory()); } - private WMValidateResourcePlanResponse success; // required + private WMDropTriggerResponse success; // required private NoSuchObjectException o1; // required - private MetaException o2; // required + private InvalidOperationException o2; // required + private MetaException o3; // required /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ public enum _Fields implements org.apache.thrift.TFieldIdEnum { SUCCESS((short)0, "success"), O1((short)1, "o1"), - O2((short)2, "o2"); + O2((short)2, "o2"), + O3((short)3, "o3"); private static final Map byName = new HashMap(); @@ -194624,6 +199463,8 @@ public static _Fields findByThriftId(int fieldId) { return O1; case 2: // O2 return O2; + case 3: // O3 + return O3; default: return null; } @@ -194668,46 +199509,53 @@ public String getFieldName() { static { Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, WMValidateResourcePlanResponse.class))); + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, WMDropTriggerResponse.class))); tmpMap.put(_Fields.O1, new org.apache.thrift.meta_data.FieldMetaData("o1", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); tmpMap.put(_Fields.O2, new org.apache.thrift.meta_data.FieldMetaData("o2", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + tmpMap.put(_Fields.O3, new org.apache.thrift.meta_data.FieldMetaData("o3", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(validate_resource_plan_result.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(drop_wm_trigger_result.class, metaDataMap); } - public validate_resource_plan_result() { + public drop_wm_trigger_result() { } - public validate_resource_plan_result( - WMValidateResourcePlanResponse success, + public drop_wm_trigger_result( + WMDropTriggerResponse success, NoSuchObjectException o1, - MetaException o2) + InvalidOperationException o2, + MetaException o3) { this(); this.success = success; this.o1 = o1; this.o2 = o2; + this.o3 = o3; } /** * Performs a deep copy on other. */ - public validate_resource_plan_result(validate_resource_plan_result other) { + public drop_wm_trigger_result(drop_wm_trigger_result other) { if (other.isSetSuccess()) { - this.success = new WMValidateResourcePlanResponse(other.success); + this.success = new WMDropTriggerResponse(other.success); } if (other.isSetO1()) { this.o1 = new NoSuchObjectException(other.o1); } if (other.isSetO2()) { - this.o2 = new MetaException(other.o2); + this.o2 = new InvalidOperationException(other.o2); + } + if (other.isSetO3()) { + this.o3 = new MetaException(other.o3); } } - public validate_resource_plan_result deepCopy() { - return new validate_resource_plan_result(this); + public drop_wm_trigger_result deepCopy() { + return new drop_wm_trigger_result(this); } @Override @@ -194715,13 +199563,14 @@ public void clear() { this.success = null; this.o1 = null; this.o2 = null; + this.o3 = null; } - public WMValidateResourcePlanResponse getSuccess() { + public WMDropTriggerResponse getSuccess() { return this.success; } - public void setSuccess(WMValidateResourcePlanResponse success) { + public void setSuccess(WMDropTriggerResponse success) { this.success = success; } @@ -194763,11 +199612,11 @@ public void setO1IsSet(boolean value) { } } - public MetaException getO2() { + public InvalidOperationException getO2() { return this.o2; } - public void setO2(MetaException o2) { + public void setO2(InvalidOperationException o2) { this.o2 = o2; } @@ -194786,13 +199635,36 @@ public void setO2IsSet(boolean value) { } } + public MetaException getO3() { + return this.o3; + } + + public void setO3(MetaException o3) { + this.o3 = o3; + } + + public void unsetO3() { + this.o3 = null; + } + + /** Returns true if field o3 is set (has been assigned a value) and false otherwise */ + public boolean isSetO3() { + return this.o3 != null; + } + + public void setO3IsSet(boolean value) { + if (!value) { + this.o3 = null; + } + } + public void setFieldValue(_Fields field, Object value) { switch (field) { case SUCCESS: if (value == null) { unsetSuccess(); } else { - setSuccess((WMValidateResourcePlanResponse)value); + setSuccess((WMDropTriggerResponse)value); } break; @@ -194808,7 +199680,15 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetO2(); } else { - setO2((MetaException)value); + setO2((InvalidOperationException)value); + } + break; + + case O3: + if (value == null) { + unsetO3(); + } else { + setO3((MetaException)value); } break; @@ -194826,6 +199706,9 @@ public Object getFieldValue(_Fields field) { case O2: return getO2(); + case O3: + return getO3(); + } throw new IllegalStateException(); } @@ -194843,6 +199726,8 @@ public boolean isSet(_Fields field) { return isSetO1(); case O2: return isSetO2(); + case O3: + return isSetO3(); } throw new IllegalStateException(); } @@ -194851,12 +199736,12 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof validate_resource_plan_result) - return this.equals((validate_resource_plan_result)that); + if (that instanceof drop_wm_trigger_result) + return this.equals((drop_wm_trigger_result)that); return false; } - public boolean equals(validate_resource_plan_result that) { + public boolean equals(drop_wm_trigger_result that) { if (that == null) return false; @@ -194887,6 +199772,15 @@ public boolean equals(validate_resource_plan_result that) { return false; } + boolean this_present_o3 = true && this.isSetO3(); + boolean that_present_o3 = true && that.isSetO3(); + if (this_present_o3 || that_present_o3) { + if (!(this_present_o3 && that_present_o3)) + return false; + if (!this.o3.equals(that.o3)) + return false; + } + return true; } @@ -194909,11 +199803,16 @@ public int hashCode() { if (present_o2) list.add(o2); + boolean present_o3 = true && (isSetO3()); + list.add(present_o3); + if (present_o3) + list.add(o3); + return list.hashCode(); } @Override - public int compareTo(validate_resource_plan_result other) { + public int compareTo(drop_wm_trigger_result other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -194950,6 +199849,16 @@ public int compareTo(validate_resource_plan_result other) { return lastComparison; } } + lastComparison = Boolean.valueOf(isSetO3()).compareTo(other.isSetO3()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetO3()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.o3, other.o3); + if (lastComparison != 0) { + return lastComparison; + } + } return 0; } @@ -194967,7 +199876,7 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("validate_resource_plan_result("); + StringBuilder sb = new StringBuilder("drop_wm_trigger_result("); boolean first = true; sb.append("success:"); @@ -194993,6 +199902,14 @@ public String toString() { sb.append(this.o2); } first = false; + if (!first) sb.append(", "); + sb.append("o3:"); + if (this.o3 == null) { + sb.append("null"); + } else { + sb.append(this.o3); + } + first = false; sb.append(")"); return sb.toString(); } @@ -195021,15 +199938,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class validate_resource_plan_resultStandardSchemeFactory implements SchemeFactory { - public validate_resource_plan_resultStandardScheme getScheme() { - return new validate_resource_plan_resultStandardScheme(); + private static class drop_wm_trigger_resultStandardSchemeFactory implements SchemeFactory { + public drop_wm_trigger_resultStandardScheme getScheme() { + return new drop_wm_trigger_resultStandardScheme(); } } - private static class validate_resource_plan_resultStandardScheme extends StandardScheme { + private static class drop_wm_trigger_resultStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, validate_resource_plan_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, drop_wm_trigger_result struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -195041,7 +199958,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, validate_resource_p switch (schemeField.id) { case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.success = new WMValidateResourcePlanResponse(); + struct.success = new WMDropTriggerResponse(); struct.success.read(iprot); struct.setSuccessIsSet(true); } else { @@ -195059,13 +199976,22 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, validate_resource_p break; case 2: // O2 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.o2 = new MetaException(); + struct.o2 = new InvalidOperationException(); struct.o2.read(iprot); struct.setO2IsSet(true); } else { org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } break; + case 3: // O3 + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.o3 = new MetaException(); + struct.o3.read(iprot); + struct.setO3IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; default: org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } @@ -195075,7 +200001,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, validate_resource_p struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, validate_resource_plan_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, drop_wm_trigger_result struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -195094,22 +200020,27 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, validate_resource_ struct.o2.write(oprot); oprot.writeFieldEnd(); } + if (struct.o3 != null) { + oprot.writeFieldBegin(O3_FIELD_DESC); + struct.o3.write(oprot); + oprot.writeFieldEnd(); + } oprot.writeFieldStop(); oprot.writeStructEnd(); } } - private static class validate_resource_plan_resultTupleSchemeFactory implements SchemeFactory { - public validate_resource_plan_resultTupleScheme getScheme() { - return new validate_resource_plan_resultTupleScheme(); + private static class drop_wm_trigger_resultTupleSchemeFactory implements SchemeFactory { + public drop_wm_trigger_resultTupleScheme getScheme() { + return new drop_wm_trigger_resultTupleScheme(); } } - private static class validate_resource_plan_resultTupleScheme extends TupleScheme { + private static class drop_wm_trigger_resultTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, validate_resource_plan_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, drop_wm_trigger_result struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetSuccess()) { @@ -195121,7 +200052,10 @@ public void write(org.apache.thrift.protocol.TProtocol prot, validate_resource_p if (struct.isSetO2()) { optionals.set(2); } - oprot.writeBitSet(optionals, 3); + if (struct.isSetO3()) { + optionals.set(3); + } + oprot.writeBitSet(optionals, 4); if (struct.isSetSuccess()) { struct.success.write(oprot); } @@ -195131,14 +200065,17 @@ public void write(org.apache.thrift.protocol.TProtocol prot, validate_resource_p if (struct.isSetO2()) { struct.o2.write(oprot); } + if (struct.isSetO3()) { + struct.o3.write(oprot); + } } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, validate_resource_plan_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, drop_wm_trigger_result struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(3); + BitSet incoming = iprot.readBitSet(4); if (incoming.get(0)) { - struct.success = new WMValidateResourcePlanResponse(); + struct.success = new WMDropTriggerResponse(); struct.success.read(iprot); struct.setSuccessIsSet(true); } @@ -195148,27 +200085,32 @@ public void read(org.apache.thrift.protocol.TProtocol prot, validate_resource_pl struct.setO1IsSet(true); } if (incoming.get(2)) { - struct.o2 = new MetaException(); + struct.o2 = new InvalidOperationException(); struct.o2.read(iprot); struct.setO2IsSet(true); } + if (incoming.get(3)) { + struct.o3 = new MetaException(); + struct.o3.read(iprot); + struct.setO3IsSet(true); + } } } } - public static class drop_resource_plan_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("drop_resource_plan_args"); + public static class get_triggers_for_resourceplan_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("get_triggers_for_resourceplan_args"); private static final org.apache.thrift.protocol.TField REQUEST_FIELD_DESC = new org.apache.thrift.protocol.TField("request", org.apache.thrift.protocol.TType.STRUCT, (short)1); private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { - schemes.put(StandardScheme.class, new drop_resource_plan_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new drop_resource_plan_argsTupleSchemeFactory()); + schemes.put(StandardScheme.class, new get_triggers_for_resourceplan_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new get_triggers_for_resourceplan_argsTupleSchemeFactory()); } - private WMDropResourcePlanRequest request; // required + private WMGetTriggersForResourePlanRequest request; // required /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ public enum _Fields implements org.apache.thrift.TFieldIdEnum { @@ -195233,16 +200175,16 @@ public String getFieldName() { static { Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); tmpMap.put(_Fields.REQUEST, new org.apache.thrift.meta_data.FieldMetaData("request", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, WMDropResourcePlanRequest.class))); + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, WMGetTriggersForResourePlanRequest.class))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(drop_resource_plan_args.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(get_triggers_for_resourceplan_args.class, metaDataMap); } - public drop_resource_plan_args() { + public get_triggers_for_resourceplan_args() { } - public drop_resource_plan_args( - WMDropResourcePlanRequest request) + public get_triggers_for_resourceplan_args( + WMGetTriggersForResourePlanRequest request) { this(); this.request = request; @@ -195251,14 +200193,14 @@ public drop_resource_plan_args( /** * Performs a deep copy on other. */ - public drop_resource_plan_args(drop_resource_plan_args other) { + public get_triggers_for_resourceplan_args(get_triggers_for_resourceplan_args other) { if (other.isSetRequest()) { - this.request = new WMDropResourcePlanRequest(other.request); + this.request = new WMGetTriggersForResourePlanRequest(other.request); } } - public drop_resource_plan_args deepCopy() { - return new drop_resource_plan_args(this); + public get_triggers_for_resourceplan_args deepCopy() { + return new get_triggers_for_resourceplan_args(this); } @Override @@ -195266,11 +200208,11 @@ public void clear() { this.request = null; } - public WMDropResourcePlanRequest getRequest() { + public WMGetTriggersForResourePlanRequest getRequest() { return this.request; } - public void setRequest(WMDropResourcePlanRequest request) { + public void setRequest(WMGetTriggersForResourePlanRequest request) { this.request = request; } @@ -195295,7 +200237,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetRequest(); } else { - setRequest((WMDropResourcePlanRequest)value); + setRequest((WMGetTriggersForResourePlanRequest)value); } break; @@ -195328,12 +200270,12 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof drop_resource_plan_args) - return this.equals((drop_resource_plan_args)that); + if (that instanceof get_triggers_for_resourceplan_args) + return this.equals((get_triggers_for_resourceplan_args)that); return false; } - public boolean equals(drop_resource_plan_args that) { + public boolean equals(get_triggers_for_resourceplan_args that) { if (that == null) return false; @@ -195362,7 +200304,7 @@ public int hashCode() { } @Override - public int compareTo(drop_resource_plan_args other) { + public int compareTo(get_triggers_for_resourceplan_args other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -195396,7 +200338,7 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("drop_resource_plan_args("); + StringBuilder sb = new StringBuilder("get_triggers_for_resourceplan_args("); boolean first = true; sb.append("request:"); @@ -195434,15 +200376,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class drop_resource_plan_argsStandardSchemeFactory implements SchemeFactory { - public drop_resource_plan_argsStandardScheme getScheme() { - return new drop_resource_plan_argsStandardScheme(); + private static class get_triggers_for_resourceplan_argsStandardSchemeFactory implements SchemeFactory { + public get_triggers_for_resourceplan_argsStandardScheme getScheme() { + return new get_triggers_for_resourceplan_argsStandardScheme(); } } - private static class drop_resource_plan_argsStandardScheme extends StandardScheme { + private static class get_triggers_for_resourceplan_argsStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, drop_resource_plan_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, get_triggers_for_resourceplan_args struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -195454,7 +200396,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, drop_resource_plan_ switch (schemeField.id) { case 1: // REQUEST if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.request = new WMDropResourcePlanRequest(); + struct.request = new WMGetTriggersForResourePlanRequest(); struct.request.read(iprot); struct.setRequestIsSet(true); } else { @@ -195470,7 +200412,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, drop_resource_plan_ struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, drop_resource_plan_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, get_triggers_for_resourceplan_args struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -195485,16 +200427,16 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, drop_resource_plan } - private static class drop_resource_plan_argsTupleSchemeFactory implements SchemeFactory { - public drop_resource_plan_argsTupleScheme getScheme() { - return new drop_resource_plan_argsTupleScheme(); + private static class get_triggers_for_resourceplan_argsTupleSchemeFactory implements SchemeFactory { + public get_triggers_for_resourceplan_argsTupleScheme getScheme() { + return new get_triggers_for_resourceplan_argsTupleScheme(); } } - private static class drop_resource_plan_argsTupleScheme extends TupleScheme { + private static class get_triggers_for_resourceplan_argsTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, drop_resource_plan_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, get_triggers_for_resourceplan_args struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetRequest()) { @@ -195507,11 +200449,11 @@ public void write(org.apache.thrift.protocol.TProtocol prot, drop_resource_plan_ } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, drop_resource_plan_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, get_triggers_for_resourceplan_args struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { - struct.request = new WMDropResourcePlanRequest(); + struct.request = new WMGetTriggersForResourePlanRequest(); struct.request.read(iprot); struct.setRequestIsSet(true); } @@ -195520,31 +200462,28 @@ public void read(org.apache.thrift.protocol.TProtocol prot, drop_resource_plan_a } - public static class drop_resource_plan_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("drop_resource_plan_result"); + public static class get_triggers_for_resourceplan_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("get_triggers_for_resourceplan_result"); private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0); private static final org.apache.thrift.protocol.TField O1_FIELD_DESC = new org.apache.thrift.protocol.TField("o1", org.apache.thrift.protocol.TType.STRUCT, (short)1); private static final org.apache.thrift.protocol.TField O2_FIELD_DESC = new org.apache.thrift.protocol.TField("o2", org.apache.thrift.protocol.TType.STRUCT, (short)2); - private static final org.apache.thrift.protocol.TField O3_FIELD_DESC = new org.apache.thrift.protocol.TField("o3", org.apache.thrift.protocol.TType.STRUCT, (short)3); private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { - schemes.put(StandardScheme.class, new drop_resource_plan_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new drop_resource_plan_resultTupleSchemeFactory()); + schemes.put(StandardScheme.class, new get_triggers_for_resourceplan_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new get_triggers_for_resourceplan_resultTupleSchemeFactory()); } - private WMDropResourcePlanResponse success; // required + private WMGetTriggersForResourePlanResponse success; // required private NoSuchObjectException o1; // required - private InvalidOperationException o2; // required - private MetaException o3; // required + private MetaException o2; // required /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ public enum _Fields implements org.apache.thrift.TFieldIdEnum { SUCCESS((short)0, "success"), O1((short)1, "o1"), - O2((short)2, "o2"), - O3((short)3, "o3"); + O2((short)2, "o2"); private static final Map byName = new HashMap(); @@ -195565,8 +200504,6 @@ public static _Fields findByThriftId(int fieldId) { return O1; case 2: // O2 return O2; - case 3: // O3 - return O3; default: return null; } @@ -195611,53 +200548,46 @@ public String getFieldName() { static { Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, WMDropResourcePlanResponse.class))); + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, WMGetTriggersForResourePlanResponse.class))); tmpMap.put(_Fields.O1, new org.apache.thrift.meta_data.FieldMetaData("o1", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); tmpMap.put(_Fields.O2, new org.apache.thrift.meta_data.FieldMetaData("o2", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); - tmpMap.put(_Fields.O3, new org.apache.thrift.meta_data.FieldMetaData("o3", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(drop_resource_plan_result.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(get_triggers_for_resourceplan_result.class, metaDataMap); } - public drop_resource_plan_result() { + public get_triggers_for_resourceplan_result() { } - public drop_resource_plan_result( - WMDropResourcePlanResponse success, + public get_triggers_for_resourceplan_result( + WMGetTriggersForResourePlanResponse success, NoSuchObjectException o1, - InvalidOperationException o2, - MetaException o3) + MetaException o2) { this(); this.success = success; this.o1 = o1; this.o2 = o2; - this.o3 = o3; } /** * Performs a deep copy on other. */ - public drop_resource_plan_result(drop_resource_plan_result other) { + public get_triggers_for_resourceplan_result(get_triggers_for_resourceplan_result other) { if (other.isSetSuccess()) { - this.success = new WMDropResourcePlanResponse(other.success); + this.success = new WMGetTriggersForResourePlanResponse(other.success); } if (other.isSetO1()) { this.o1 = new NoSuchObjectException(other.o1); } if (other.isSetO2()) { - this.o2 = new InvalidOperationException(other.o2); - } - if (other.isSetO3()) { - this.o3 = new MetaException(other.o3); + this.o2 = new MetaException(other.o2); } } - public drop_resource_plan_result deepCopy() { - return new drop_resource_plan_result(this); + public get_triggers_for_resourceplan_result deepCopy() { + return new get_triggers_for_resourceplan_result(this); } @Override @@ -195665,14 +200595,13 @@ public void clear() { this.success = null; this.o1 = null; this.o2 = null; - this.o3 = null; } - public WMDropResourcePlanResponse getSuccess() { + public WMGetTriggersForResourePlanResponse getSuccess() { return this.success; } - public void setSuccess(WMDropResourcePlanResponse success) { + public void setSuccess(WMGetTriggersForResourePlanResponse success) { this.success = success; } @@ -195714,11 +200643,11 @@ public void setO1IsSet(boolean value) { } } - public InvalidOperationException getO2() { + public MetaException getO2() { return this.o2; } - public void setO2(InvalidOperationException o2) { + public void setO2(MetaException o2) { this.o2 = o2; } @@ -195737,36 +200666,13 @@ public void setO2IsSet(boolean value) { } } - public MetaException getO3() { - return this.o3; - } - - public void setO3(MetaException o3) { - this.o3 = o3; - } - - public void unsetO3() { - this.o3 = null; - } - - /** Returns true if field o3 is set (has been assigned a value) and false otherwise */ - public boolean isSetO3() { - return this.o3 != null; - } - - public void setO3IsSet(boolean value) { - if (!value) { - this.o3 = null; - } - } - public void setFieldValue(_Fields field, Object value) { switch (field) { case SUCCESS: if (value == null) { unsetSuccess(); } else { - setSuccess((WMDropResourcePlanResponse)value); + setSuccess((WMGetTriggersForResourePlanResponse)value); } break; @@ -195782,15 +200688,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetO2(); } else { - setO2((InvalidOperationException)value); - } - break; - - case O3: - if (value == null) { - unsetO3(); - } else { - setO3((MetaException)value); + setO2((MetaException)value); } break; @@ -195808,9 +200706,6 @@ public Object getFieldValue(_Fields field) { case O2: return getO2(); - case O3: - return getO3(); - } throw new IllegalStateException(); } @@ -195828,8 +200723,6 @@ public boolean isSet(_Fields field) { return isSetO1(); case O2: return isSetO2(); - case O3: - return isSetO3(); } throw new IllegalStateException(); } @@ -195838,12 +200731,12 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof drop_resource_plan_result) - return this.equals((drop_resource_plan_result)that); + if (that instanceof get_triggers_for_resourceplan_result) + return this.equals((get_triggers_for_resourceplan_result)that); return false; } - public boolean equals(drop_resource_plan_result that) { + public boolean equals(get_triggers_for_resourceplan_result that) { if (that == null) return false; @@ -195874,15 +200767,6 @@ public boolean equals(drop_resource_plan_result that) { return false; } - boolean this_present_o3 = true && this.isSetO3(); - boolean that_present_o3 = true && that.isSetO3(); - if (this_present_o3 || that_present_o3) { - if (!(this_present_o3 && that_present_o3)) - return false; - if (!this.o3.equals(that.o3)) - return false; - } - return true; } @@ -195905,16 +200789,11 @@ public int hashCode() { if (present_o2) list.add(o2); - boolean present_o3 = true && (isSetO3()); - list.add(present_o3); - if (present_o3) - list.add(o3); - return list.hashCode(); } @Override - public int compareTo(drop_resource_plan_result other) { + public int compareTo(get_triggers_for_resourceplan_result other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -195951,16 +200830,6 @@ public int compareTo(drop_resource_plan_result other) { return lastComparison; } } - lastComparison = Boolean.valueOf(isSetO3()).compareTo(other.isSetO3()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetO3()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.o3, other.o3); - if (lastComparison != 0) { - return lastComparison; - } - } return 0; } @@ -195978,7 +200847,7 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("drop_resource_plan_result("); + StringBuilder sb = new StringBuilder("get_triggers_for_resourceplan_result("); boolean first = true; sb.append("success:"); @@ -196004,14 +200873,6 @@ public String toString() { sb.append(this.o2); } first = false; - if (!first) sb.append(", "); - sb.append("o3:"); - if (this.o3 == null) { - sb.append("null"); - } else { - sb.append(this.o3); - } - first = false; sb.append(")"); return sb.toString(); } @@ -196040,15 +200901,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class drop_resource_plan_resultStandardSchemeFactory implements SchemeFactory { - public drop_resource_plan_resultStandardScheme getScheme() { - return new drop_resource_plan_resultStandardScheme(); + private static class get_triggers_for_resourceplan_resultStandardSchemeFactory implements SchemeFactory { + public get_triggers_for_resourceplan_resultStandardScheme getScheme() { + return new get_triggers_for_resourceplan_resultStandardScheme(); } } - private static class drop_resource_plan_resultStandardScheme extends StandardScheme { + private static class get_triggers_for_resourceplan_resultStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, drop_resource_plan_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, get_triggers_for_resourceplan_result struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -196060,7 +200921,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, drop_resource_plan_ switch (schemeField.id) { case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.success = new WMDropResourcePlanResponse(); + struct.success = new WMGetTriggersForResourePlanResponse(); struct.success.read(iprot); struct.setSuccessIsSet(true); } else { @@ -196078,22 +200939,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, drop_resource_plan_ break; case 2: // O2 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.o2 = new InvalidOperationException(); + struct.o2 = new MetaException(); struct.o2.read(iprot); struct.setO2IsSet(true); } else { org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } break; - case 3: // O3 - if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.o3 = new MetaException(); - struct.o3.read(iprot); - struct.setO3IsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; default: org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } @@ -196103,7 +200955,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, drop_resource_plan_ struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, drop_resource_plan_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, get_triggers_for_resourceplan_result struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -196122,27 +200974,22 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, drop_resource_plan struct.o2.write(oprot); oprot.writeFieldEnd(); } - if (struct.o3 != null) { - oprot.writeFieldBegin(O3_FIELD_DESC); - struct.o3.write(oprot); - oprot.writeFieldEnd(); - } oprot.writeFieldStop(); oprot.writeStructEnd(); } } - private static class drop_resource_plan_resultTupleSchemeFactory implements SchemeFactory { - public drop_resource_plan_resultTupleScheme getScheme() { - return new drop_resource_plan_resultTupleScheme(); + private static class get_triggers_for_resourceplan_resultTupleSchemeFactory implements SchemeFactory { + public get_triggers_for_resourceplan_resultTupleScheme getScheme() { + return new get_triggers_for_resourceplan_resultTupleScheme(); } } - private static class drop_resource_plan_resultTupleScheme extends TupleScheme { + private static class get_triggers_for_resourceplan_resultTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, drop_resource_plan_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, get_triggers_for_resourceplan_result struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetSuccess()) { @@ -196154,10 +201001,7 @@ public void write(org.apache.thrift.protocol.TProtocol prot, drop_resource_plan_ if (struct.isSetO2()) { optionals.set(2); } - if (struct.isSetO3()) { - optionals.set(3); - } - oprot.writeBitSet(optionals, 4); + oprot.writeBitSet(optionals, 3); if (struct.isSetSuccess()) { struct.success.write(oprot); } @@ -196167,17 +201011,14 @@ public void write(org.apache.thrift.protocol.TProtocol prot, drop_resource_plan_ if (struct.isSetO2()) { struct.o2.write(oprot); } - if (struct.isSetO3()) { - struct.o3.write(oprot); - } } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, drop_resource_plan_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, get_triggers_for_resourceplan_result struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(4); + BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { - struct.success = new WMDropResourcePlanResponse(); + struct.success = new WMGetTriggersForResourePlanResponse(); struct.success.read(iprot); struct.setSuccessIsSet(true); } @@ -196187,15 +201028,10 @@ public void read(org.apache.thrift.protocol.TProtocol prot, drop_resource_plan_r struct.setO1IsSet(true); } if (incoming.get(2)) { - struct.o2 = new InvalidOperationException(); + struct.o2 = new MetaException(); struct.o2.read(iprot); struct.setO2IsSet(true); } - if (incoming.get(3)) { - struct.o3 = new MetaException(); - struct.o3.read(iprot); - struct.setO3IsSet(true); - } } } diff --git standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMAlterTriggerRequest.java standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMAlterTriggerRequest.java new file mode 100644 index 0000000000..d9938dc20e --- /dev/null +++ standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMAlterTriggerRequest.java @@ -0,0 +1,398 @@ +/** + * Autogenerated by Thrift Compiler (0.9.3) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +package org.apache.hadoop.hive.metastore.api; + +import org.apache.thrift.scheme.IScheme; +import org.apache.thrift.scheme.SchemeFactory; +import org.apache.thrift.scheme.StandardScheme; + +import org.apache.thrift.scheme.TupleScheme; +import org.apache.thrift.protocol.TTupleProtocol; +import org.apache.thrift.protocol.TProtocolException; +import org.apache.thrift.EncodingUtils; +import org.apache.thrift.TException; +import org.apache.thrift.async.AsyncMethodCallback; +import org.apache.thrift.server.AbstractNonblockingServer.*; +import java.util.List; +import java.util.ArrayList; +import java.util.Map; +import java.util.HashMap; +import java.util.EnumMap; +import java.util.Set; +import java.util.HashSet; +import java.util.EnumSet; +import java.util.Collections; +import java.util.BitSet; +import java.nio.ByteBuffer; +import java.util.Arrays; +import javax.annotation.Generated; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) +@Generated(value = "Autogenerated by Thrift Compiler (0.9.3)") +public class WMAlterTriggerRequest implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("WMAlterTriggerRequest"); + + private static final org.apache.thrift.protocol.TField TRIGGER_FIELD_DESC = new org.apache.thrift.protocol.TField("trigger", org.apache.thrift.protocol.TType.STRUCT, (short)1); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new WMAlterTriggerRequestStandardSchemeFactory()); + schemes.put(TupleScheme.class, new WMAlterTriggerRequestTupleSchemeFactory()); + } + + private WMTrigger trigger; // optional + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + TRIGGER((short)1, "trigger"); + + private static final Map byName = new HashMap(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 1: // TRIGGER + return TRIGGER; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + private static final _Fields optionals[] = {_Fields.TRIGGER}; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TRIGGER, new org.apache.thrift.meta_data.FieldMetaData("trigger", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, WMTrigger.class))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(WMAlterTriggerRequest.class, metaDataMap); + } + + public WMAlterTriggerRequest() { + } + + /** + * Performs a deep copy on other. + */ + public WMAlterTriggerRequest(WMAlterTriggerRequest other) { + if (other.isSetTrigger()) { + this.trigger = new WMTrigger(other.trigger); + } + } + + public WMAlterTriggerRequest deepCopy() { + return new WMAlterTriggerRequest(this); + } + + @Override + public void clear() { + this.trigger = null; + } + + public WMTrigger getTrigger() { + return this.trigger; + } + + public void setTrigger(WMTrigger trigger) { + this.trigger = trigger; + } + + public void unsetTrigger() { + this.trigger = null; + } + + /** Returns true if field trigger is set (has been assigned a value) and false otherwise */ + public boolean isSetTrigger() { + return this.trigger != null; + } + + public void setTriggerIsSet(boolean value) { + if (!value) { + this.trigger = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case TRIGGER: + if (value == null) { + unsetTrigger(); + } else { + setTrigger((WMTrigger)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case TRIGGER: + return getTrigger(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case TRIGGER: + return isSetTrigger(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof WMAlterTriggerRequest) + return this.equals((WMAlterTriggerRequest)that); + return false; + } + + public boolean equals(WMAlterTriggerRequest that) { + if (that == null) + return false; + + boolean this_present_trigger = true && this.isSetTrigger(); + boolean that_present_trigger = true && that.isSetTrigger(); + if (this_present_trigger || that_present_trigger) { + if (!(this_present_trigger && that_present_trigger)) + return false; + if (!this.trigger.equals(that.trigger)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + boolean present_trigger = true && (isSetTrigger()); + list.add(present_trigger); + if (present_trigger) + list.add(trigger); + + return list.hashCode(); + } + + @Override + public int compareTo(WMAlterTriggerRequest other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetTrigger()).compareTo(other.isSetTrigger()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetTrigger()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.trigger, other.trigger); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("WMAlterTriggerRequest("); + boolean first = true; + + if (isSetTrigger()) { + sb.append("trigger:"); + if (this.trigger == null) { + sb.append("null"); + } else { + sb.append(this.trigger); + } + first = false; + } + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + if (trigger != null) { + trigger.validate(); + } + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class WMAlterTriggerRequestStandardSchemeFactory implements SchemeFactory { + public WMAlterTriggerRequestStandardScheme getScheme() { + return new WMAlterTriggerRequestStandardScheme(); + } + } + + private static class WMAlterTriggerRequestStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, WMAlterTriggerRequest struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField schemeField; + iprot.readStructBegin(); + while (true) + { + schemeField = iprot.readFieldBegin(); + if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (schemeField.id) { + case 1: // TRIGGER + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.trigger = new WMTrigger(); + struct.trigger.read(iprot); + struct.setTriggerIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + struct.validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot, WMAlterTriggerRequest struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.trigger != null) { + if (struct.isSetTrigger()) { + oprot.writeFieldBegin(TRIGGER_FIELD_DESC); + struct.trigger.write(oprot); + oprot.writeFieldEnd(); + } + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class WMAlterTriggerRequestTupleSchemeFactory implements SchemeFactory { + public WMAlterTriggerRequestTupleScheme getScheme() { + return new WMAlterTriggerRequestTupleScheme(); + } + } + + private static class WMAlterTriggerRequestTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, WMAlterTriggerRequest struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetTrigger()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetTrigger()) { + struct.trigger.write(oprot); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, WMAlterTriggerRequest struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.trigger = new WMTrigger(); + struct.trigger.read(iprot); + struct.setTriggerIsSet(true); + } + } + } + +} + diff --git standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMAlterTriggerResponse.java standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMAlterTriggerResponse.java new file mode 100644 index 0000000000..d66aeaaa69 --- /dev/null +++ standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMAlterTriggerResponse.java @@ -0,0 +1,283 @@ +/** + * Autogenerated by Thrift Compiler (0.9.3) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +package org.apache.hadoop.hive.metastore.api; + +import org.apache.thrift.scheme.IScheme; +import org.apache.thrift.scheme.SchemeFactory; +import org.apache.thrift.scheme.StandardScheme; + +import org.apache.thrift.scheme.TupleScheme; +import org.apache.thrift.protocol.TTupleProtocol; +import org.apache.thrift.protocol.TProtocolException; +import org.apache.thrift.EncodingUtils; +import org.apache.thrift.TException; +import org.apache.thrift.async.AsyncMethodCallback; +import org.apache.thrift.server.AbstractNonblockingServer.*; +import java.util.List; +import java.util.ArrayList; +import java.util.Map; +import java.util.HashMap; +import java.util.EnumMap; +import java.util.Set; +import java.util.HashSet; +import java.util.EnumSet; +import java.util.Collections; +import java.util.BitSet; +import java.nio.ByteBuffer; +import java.util.Arrays; +import javax.annotation.Generated; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) +@Generated(value = "Autogenerated by Thrift Compiler (0.9.3)") +public class WMAlterTriggerResponse implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("WMAlterTriggerResponse"); + + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new WMAlterTriggerResponseStandardSchemeFactory()); + schemes.put(TupleScheme.class, new WMAlterTriggerResponseTupleSchemeFactory()); + } + + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { +; + + private static final Map byName = new HashMap(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(WMAlterTriggerResponse.class, metaDataMap); + } + + public WMAlterTriggerResponse() { + } + + /** + * Performs a deep copy on other. + */ + public WMAlterTriggerResponse(WMAlterTriggerResponse other) { + } + + public WMAlterTriggerResponse deepCopy() { + return new WMAlterTriggerResponse(this); + } + + @Override + public void clear() { + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof WMAlterTriggerResponse) + return this.equals((WMAlterTriggerResponse)that); + return false; + } + + public boolean equals(WMAlterTriggerResponse that) { + if (that == null) + return false; + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + return list.hashCode(); + } + + @Override + public int compareTo(WMAlterTriggerResponse other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("WMAlterTriggerResponse("); + boolean first = true; + + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class WMAlterTriggerResponseStandardSchemeFactory implements SchemeFactory { + public WMAlterTriggerResponseStandardScheme getScheme() { + return new WMAlterTriggerResponseStandardScheme(); + } + } + + private static class WMAlterTriggerResponseStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, WMAlterTriggerResponse struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField schemeField; + iprot.readStructBegin(); + while (true) + { + schemeField = iprot.readFieldBegin(); + if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (schemeField.id) { + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + struct.validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot, WMAlterTriggerResponse struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class WMAlterTriggerResponseTupleSchemeFactory implements SchemeFactory { + public WMAlterTriggerResponseTupleScheme getScheme() { + return new WMAlterTriggerResponseTupleScheme(); + } + } + + private static class WMAlterTriggerResponseTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, WMAlterTriggerResponse struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, WMAlterTriggerResponse struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } + +} + diff --git standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMCreateTriggerRequest.java standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMCreateTriggerRequest.java new file mode 100644 index 0000000000..be72429401 --- /dev/null +++ standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMCreateTriggerRequest.java @@ -0,0 +1,398 @@ +/** + * Autogenerated by Thrift Compiler (0.9.3) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +package org.apache.hadoop.hive.metastore.api; + +import org.apache.thrift.scheme.IScheme; +import org.apache.thrift.scheme.SchemeFactory; +import org.apache.thrift.scheme.StandardScheme; + +import org.apache.thrift.scheme.TupleScheme; +import org.apache.thrift.protocol.TTupleProtocol; +import org.apache.thrift.protocol.TProtocolException; +import org.apache.thrift.EncodingUtils; +import org.apache.thrift.TException; +import org.apache.thrift.async.AsyncMethodCallback; +import org.apache.thrift.server.AbstractNonblockingServer.*; +import java.util.List; +import java.util.ArrayList; +import java.util.Map; +import java.util.HashMap; +import java.util.EnumMap; +import java.util.Set; +import java.util.HashSet; +import java.util.EnumSet; +import java.util.Collections; +import java.util.BitSet; +import java.nio.ByteBuffer; +import java.util.Arrays; +import javax.annotation.Generated; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) +@Generated(value = "Autogenerated by Thrift Compiler (0.9.3)") +public class WMCreateTriggerRequest implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("WMCreateTriggerRequest"); + + private static final org.apache.thrift.protocol.TField TRIGGER_FIELD_DESC = new org.apache.thrift.protocol.TField("trigger", org.apache.thrift.protocol.TType.STRUCT, (short)1); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new WMCreateTriggerRequestStandardSchemeFactory()); + schemes.put(TupleScheme.class, new WMCreateTriggerRequestTupleSchemeFactory()); + } + + private WMTrigger trigger; // optional + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + TRIGGER((short)1, "trigger"); + + private static final Map byName = new HashMap(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 1: // TRIGGER + return TRIGGER; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + private static final _Fields optionals[] = {_Fields.TRIGGER}; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TRIGGER, new org.apache.thrift.meta_data.FieldMetaData("trigger", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, WMTrigger.class))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(WMCreateTriggerRequest.class, metaDataMap); + } + + public WMCreateTriggerRequest() { + } + + /** + * Performs a deep copy on other. + */ + public WMCreateTriggerRequest(WMCreateTriggerRequest other) { + if (other.isSetTrigger()) { + this.trigger = new WMTrigger(other.trigger); + } + } + + public WMCreateTriggerRequest deepCopy() { + return new WMCreateTriggerRequest(this); + } + + @Override + public void clear() { + this.trigger = null; + } + + public WMTrigger getTrigger() { + return this.trigger; + } + + public void setTrigger(WMTrigger trigger) { + this.trigger = trigger; + } + + public void unsetTrigger() { + this.trigger = null; + } + + /** Returns true if field trigger is set (has been assigned a value) and false otherwise */ + public boolean isSetTrigger() { + return this.trigger != null; + } + + public void setTriggerIsSet(boolean value) { + if (!value) { + this.trigger = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case TRIGGER: + if (value == null) { + unsetTrigger(); + } else { + setTrigger((WMTrigger)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case TRIGGER: + return getTrigger(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case TRIGGER: + return isSetTrigger(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof WMCreateTriggerRequest) + return this.equals((WMCreateTriggerRequest)that); + return false; + } + + public boolean equals(WMCreateTriggerRequest that) { + if (that == null) + return false; + + boolean this_present_trigger = true && this.isSetTrigger(); + boolean that_present_trigger = true && that.isSetTrigger(); + if (this_present_trigger || that_present_trigger) { + if (!(this_present_trigger && that_present_trigger)) + return false; + if (!this.trigger.equals(that.trigger)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + boolean present_trigger = true && (isSetTrigger()); + list.add(present_trigger); + if (present_trigger) + list.add(trigger); + + return list.hashCode(); + } + + @Override + public int compareTo(WMCreateTriggerRequest other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetTrigger()).compareTo(other.isSetTrigger()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetTrigger()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.trigger, other.trigger); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("WMCreateTriggerRequest("); + boolean first = true; + + if (isSetTrigger()) { + sb.append("trigger:"); + if (this.trigger == null) { + sb.append("null"); + } else { + sb.append(this.trigger); + } + first = false; + } + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + if (trigger != null) { + trigger.validate(); + } + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class WMCreateTriggerRequestStandardSchemeFactory implements SchemeFactory { + public WMCreateTriggerRequestStandardScheme getScheme() { + return new WMCreateTriggerRequestStandardScheme(); + } + } + + private static class WMCreateTriggerRequestStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, WMCreateTriggerRequest struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField schemeField; + iprot.readStructBegin(); + while (true) + { + schemeField = iprot.readFieldBegin(); + if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (schemeField.id) { + case 1: // TRIGGER + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.trigger = new WMTrigger(); + struct.trigger.read(iprot); + struct.setTriggerIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + struct.validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot, WMCreateTriggerRequest struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.trigger != null) { + if (struct.isSetTrigger()) { + oprot.writeFieldBegin(TRIGGER_FIELD_DESC); + struct.trigger.write(oprot); + oprot.writeFieldEnd(); + } + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class WMCreateTriggerRequestTupleSchemeFactory implements SchemeFactory { + public WMCreateTriggerRequestTupleScheme getScheme() { + return new WMCreateTriggerRequestTupleScheme(); + } + } + + private static class WMCreateTriggerRequestTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, WMCreateTriggerRequest struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetTrigger()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetTrigger()) { + struct.trigger.write(oprot); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, WMCreateTriggerRequest struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.trigger = new WMTrigger(); + struct.trigger.read(iprot); + struct.setTriggerIsSet(true); + } + } + } + +} + diff --git standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMCreateTriggerResponse.java standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMCreateTriggerResponse.java new file mode 100644 index 0000000000..53e0082a67 --- /dev/null +++ standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMCreateTriggerResponse.java @@ -0,0 +1,283 @@ +/** + * Autogenerated by Thrift Compiler (0.9.3) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +package org.apache.hadoop.hive.metastore.api; + +import org.apache.thrift.scheme.IScheme; +import org.apache.thrift.scheme.SchemeFactory; +import org.apache.thrift.scheme.StandardScheme; + +import org.apache.thrift.scheme.TupleScheme; +import org.apache.thrift.protocol.TTupleProtocol; +import org.apache.thrift.protocol.TProtocolException; +import org.apache.thrift.EncodingUtils; +import org.apache.thrift.TException; +import org.apache.thrift.async.AsyncMethodCallback; +import org.apache.thrift.server.AbstractNonblockingServer.*; +import java.util.List; +import java.util.ArrayList; +import java.util.Map; +import java.util.HashMap; +import java.util.EnumMap; +import java.util.Set; +import java.util.HashSet; +import java.util.EnumSet; +import java.util.Collections; +import java.util.BitSet; +import java.nio.ByteBuffer; +import java.util.Arrays; +import javax.annotation.Generated; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) +@Generated(value = "Autogenerated by Thrift Compiler (0.9.3)") +public class WMCreateTriggerResponse implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("WMCreateTriggerResponse"); + + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new WMCreateTriggerResponseStandardSchemeFactory()); + schemes.put(TupleScheme.class, new WMCreateTriggerResponseTupleSchemeFactory()); + } + + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { +; + + private static final Map byName = new HashMap(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(WMCreateTriggerResponse.class, metaDataMap); + } + + public WMCreateTriggerResponse() { + } + + /** + * Performs a deep copy on other. + */ + public WMCreateTriggerResponse(WMCreateTriggerResponse other) { + } + + public WMCreateTriggerResponse deepCopy() { + return new WMCreateTriggerResponse(this); + } + + @Override + public void clear() { + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof WMCreateTriggerResponse) + return this.equals((WMCreateTriggerResponse)that); + return false; + } + + public boolean equals(WMCreateTriggerResponse that) { + if (that == null) + return false; + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + return list.hashCode(); + } + + @Override + public int compareTo(WMCreateTriggerResponse other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("WMCreateTriggerResponse("); + boolean first = true; + + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class WMCreateTriggerResponseStandardSchemeFactory implements SchemeFactory { + public WMCreateTriggerResponseStandardScheme getScheme() { + return new WMCreateTriggerResponseStandardScheme(); + } + } + + private static class WMCreateTriggerResponseStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, WMCreateTriggerResponse struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField schemeField; + iprot.readStructBegin(); + while (true) + { + schemeField = iprot.readFieldBegin(); + if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (schemeField.id) { + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + struct.validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot, WMCreateTriggerResponse struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class WMCreateTriggerResponseTupleSchemeFactory implements SchemeFactory { + public WMCreateTriggerResponseTupleScheme getScheme() { + return new WMCreateTriggerResponseTupleScheme(); + } + } + + private static class WMCreateTriggerResponseTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, WMCreateTriggerResponse struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, WMCreateTriggerResponse struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } + +} + diff --git standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMDropTriggerRequest.java standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMDropTriggerRequest.java new file mode 100644 index 0000000000..05f9c43f6b --- /dev/null +++ standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMDropTriggerRequest.java @@ -0,0 +1,499 @@ +/** + * Autogenerated by Thrift Compiler (0.9.3) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +package org.apache.hadoop.hive.metastore.api; + +import org.apache.thrift.scheme.IScheme; +import org.apache.thrift.scheme.SchemeFactory; +import org.apache.thrift.scheme.StandardScheme; + +import org.apache.thrift.scheme.TupleScheme; +import org.apache.thrift.protocol.TTupleProtocol; +import org.apache.thrift.protocol.TProtocolException; +import org.apache.thrift.EncodingUtils; +import org.apache.thrift.TException; +import org.apache.thrift.async.AsyncMethodCallback; +import org.apache.thrift.server.AbstractNonblockingServer.*; +import java.util.List; +import java.util.ArrayList; +import java.util.Map; +import java.util.HashMap; +import java.util.EnumMap; +import java.util.Set; +import java.util.HashSet; +import java.util.EnumSet; +import java.util.Collections; +import java.util.BitSet; +import java.nio.ByteBuffer; +import java.util.Arrays; +import javax.annotation.Generated; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) +@Generated(value = "Autogenerated by Thrift Compiler (0.9.3)") +public class WMDropTriggerRequest implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("WMDropTriggerRequest"); + + private static final org.apache.thrift.protocol.TField RESOURCE_PLAN_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("resourcePlanName", org.apache.thrift.protocol.TType.STRING, (short)1); + private static final org.apache.thrift.protocol.TField TRIGGER_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("triggerName", org.apache.thrift.protocol.TType.STRING, (short)2); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new WMDropTriggerRequestStandardSchemeFactory()); + schemes.put(TupleScheme.class, new WMDropTriggerRequestTupleSchemeFactory()); + } + + private String resourcePlanName; // optional + private String triggerName; // optional + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + RESOURCE_PLAN_NAME((short)1, "resourcePlanName"), + TRIGGER_NAME((short)2, "triggerName"); + + private static final Map byName = new HashMap(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 1: // RESOURCE_PLAN_NAME + return RESOURCE_PLAN_NAME; + case 2: // TRIGGER_NAME + return TRIGGER_NAME; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + private static final _Fields optionals[] = {_Fields.RESOURCE_PLAN_NAME,_Fields.TRIGGER_NAME}; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.RESOURCE_PLAN_NAME, new org.apache.thrift.meta_data.FieldMetaData("resourcePlanName", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.TRIGGER_NAME, new org.apache.thrift.meta_data.FieldMetaData("triggerName", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(WMDropTriggerRequest.class, metaDataMap); + } + + public WMDropTriggerRequest() { + } + + /** + * Performs a deep copy on other. + */ + public WMDropTriggerRequest(WMDropTriggerRequest other) { + if (other.isSetResourcePlanName()) { + this.resourcePlanName = other.resourcePlanName; + } + if (other.isSetTriggerName()) { + this.triggerName = other.triggerName; + } + } + + public WMDropTriggerRequest deepCopy() { + return new WMDropTriggerRequest(this); + } + + @Override + public void clear() { + this.resourcePlanName = null; + this.triggerName = null; + } + + public String getResourcePlanName() { + return this.resourcePlanName; + } + + public void setResourcePlanName(String resourcePlanName) { + this.resourcePlanName = resourcePlanName; + } + + public void unsetResourcePlanName() { + this.resourcePlanName = null; + } + + /** Returns true if field resourcePlanName is set (has been assigned a value) and false otherwise */ + public boolean isSetResourcePlanName() { + return this.resourcePlanName != null; + } + + public void setResourcePlanNameIsSet(boolean value) { + if (!value) { + this.resourcePlanName = null; + } + } + + public String getTriggerName() { + return this.triggerName; + } + + public void setTriggerName(String triggerName) { + this.triggerName = triggerName; + } + + public void unsetTriggerName() { + this.triggerName = null; + } + + /** Returns true if field triggerName is set (has been assigned a value) and false otherwise */ + public boolean isSetTriggerName() { + return this.triggerName != null; + } + + public void setTriggerNameIsSet(boolean value) { + if (!value) { + this.triggerName = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case RESOURCE_PLAN_NAME: + if (value == null) { + unsetResourcePlanName(); + } else { + setResourcePlanName((String)value); + } + break; + + case TRIGGER_NAME: + if (value == null) { + unsetTriggerName(); + } else { + setTriggerName((String)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case RESOURCE_PLAN_NAME: + return getResourcePlanName(); + + case TRIGGER_NAME: + return getTriggerName(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case RESOURCE_PLAN_NAME: + return isSetResourcePlanName(); + case TRIGGER_NAME: + return isSetTriggerName(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof WMDropTriggerRequest) + return this.equals((WMDropTriggerRequest)that); + return false; + } + + public boolean equals(WMDropTriggerRequest that) { + if (that == null) + return false; + + boolean this_present_resourcePlanName = true && this.isSetResourcePlanName(); + boolean that_present_resourcePlanName = true && that.isSetResourcePlanName(); + if (this_present_resourcePlanName || that_present_resourcePlanName) { + if (!(this_present_resourcePlanName && that_present_resourcePlanName)) + return false; + if (!this.resourcePlanName.equals(that.resourcePlanName)) + return false; + } + + boolean this_present_triggerName = true && this.isSetTriggerName(); + boolean that_present_triggerName = true && that.isSetTriggerName(); + if (this_present_triggerName || that_present_triggerName) { + if (!(this_present_triggerName && that_present_triggerName)) + return false; + if (!this.triggerName.equals(that.triggerName)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + boolean present_resourcePlanName = true && (isSetResourcePlanName()); + list.add(present_resourcePlanName); + if (present_resourcePlanName) + list.add(resourcePlanName); + + boolean present_triggerName = true && (isSetTriggerName()); + list.add(present_triggerName); + if (present_triggerName) + list.add(triggerName); + + return list.hashCode(); + } + + @Override + public int compareTo(WMDropTriggerRequest other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetResourcePlanName()).compareTo(other.isSetResourcePlanName()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetResourcePlanName()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.resourcePlanName, other.resourcePlanName); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetTriggerName()).compareTo(other.isSetTriggerName()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetTriggerName()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.triggerName, other.triggerName); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("WMDropTriggerRequest("); + boolean first = true; + + if (isSetResourcePlanName()) { + sb.append("resourcePlanName:"); + if (this.resourcePlanName == null) { + sb.append("null"); + } else { + sb.append(this.resourcePlanName); + } + first = false; + } + if (isSetTriggerName()) { + if (!first) sb.append(", "); + sb.append("triggerName:"); + if (this.triggerName == null) { + sb.append("null"); + } else { + sb.append(this.triggerName); + } + first = false; + } + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class WMDropTriggerRequestStandardSchemeFactory implements SchemeFactory { + public WMDropTriggerRequestStandardScheme getScheme() { + return new WMDropTriggerRequestStandardScheme(); + } + } + + private static class WMDropTriggerRequestStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, WMDropTriggerRequest struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField schemeField; + iprot.readStructBegin(); + while (true) + { + schemeField = iprot.readFieldBegin(); + if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (schemeField.id) { + case 1: // RESOURCE_PLAN_NAME + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.resourcePlanName = iprot.readString(); + struct.setResourcePlanNameIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // TRIGGER_NAME + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.triggerName = iprot.readString(); + struct.setTriggerNameIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + struct.validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot, WMDropTriggerRequest struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.resourcePlanName != null) { + if (struct.isSetResourcePlanName()) { + oprot.writeFieldBegin(RESOURCE_PLAN_NAME_FIELD_DESC); + oprot.writeString(struct.resourcePlanName); + oprot.writeFieldEnd(); + } + } + if (struct.triggerName != null) { + if (struct.isSetTriggerName()) { + oprot.writeFieldBegin(TRIGGER_NAME_FIELD_DESC); + oprot.writeString(struct.triggerName); + oprot.writeFieldEnd(); + } + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class WMDropTriggerRequestTupleSchemeFactory implements SchemeFactory { + public WMDropTriggerRequestTupleScheme getScheme() { + return new WMDropTriggerRequestTupleScheme(); + } + } + + private static class WMDropTriggerRequestTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, WMDropTriggerRequest struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetResourcePlanName()) { + optionals.set(0); + } + if (struct.isSetTriggerName()) { + optionals.set(1); + } + oprot.writeBitSet(optionals, 2); + if (struct.isSetResourcePlanName()) { + oprot.writeString(struct.resourcePlanName); + } + if (struct.isSetTriggerName()) { + oprot.writeString(struct.triggerName); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, WMDropTriggerRequest struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(2); + if (incoming.get(0)) { + struct.resourcePlanName = iprot.readString(); + struct.setResourcePlanNameIsSet(true); + } + if (incoming.get(1)) { + struct.triggerName = iprot.readString(); + struct.setTriggerNameIsSet(true); + } + } + } + +} + diff --git standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMDropTriggerResponse.java standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMDropTriggerResponse.java new file mode 100644 index 0000000000..363018e5d2 --- /dev/null +++ standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMDropTriggerResponse.java @@ -0,0 +1,283 @@ +/** + * Autogenerated by Thrift Compiler (0.9.3) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +package org.apache.hadoop.hive.metastore.api; + +import org.apache.thrift.scheme.IScheme; +import org.apache.thrift.scheme.SchemeFactory; +import org.apache.thrift.scheme.StandardScheme; + +import org.apache.thrift.scheme.TupleScheme; +import org.apache.thrift.protocol.TTupleProtocol; +import org.apache.thrift.protocol.TProtocolException; +import org.apache.thrift.EncodingUtils; +import org.apache.thrift.TException; +import org.apache.thrift.async.AsyncMethodCallback; +import org.apache.thrift.server.AbstractNonblockingServer.*; +import java.util.List; +import java.util.ArrayList; +import java.util.Map; +import java.util.HashMap; +import java.util.EnumMap; +import java.util.Set; +import java.util.HashSet; +import java.util.EnumSet; +import java.util.Collections; +import java.util.BitSet; +import java.nio.ByteBuffer; +import java.util.Arrays; +import javax.annotation.Generated; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) +@Generated(value = "Autogenerated by Thrift Compiler (0.9.3)") +public class WMDropTriggerResponse implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("WMDropTriggerResponse"); + + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new WMDropTriggerResponseStandardSchemeFactory()); + schemes.put(TupleScheme.class, new WMDropTriggerResponseTupleSchemeFactory()); + } + + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { +; + + private static final Map byName = new HashMap(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(WMDropTriggerResponse.class, metaDataMap); + } + + public WMDropTriggerResponse() { + } + + /** + * Performs a deep copy on other. + */ + public WMDropTriggerResponse(WMDropTriggerResponse other) { + } + + public WMDropTriggerResponse deepCopy() { + return new WMDropTriggerResponse(this); + } + + @Override + public void clear() { + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof WMDropTriggerResponse) + return this.equals((WMDropTriggerResponse)that); + return false; + } + + public boolean equals(WMDropTriggerResponse that) { + if (that == null) + return false; + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + return list.hashCode(); + } + + @Override + public int compareTo(WMDropTriggerResponse other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("WMDropTriggerResponse("); + boolean first = true; + + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class WMDropTriggerResponseStandardSchemeFactory implements SchemeFactory { + public WMDropTriggerResponseStandardScheme getScheme() { + return new WMDropTriggerResponseStandardScheme(); + } + } + + private static class WMDropTriggerResponseStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, WMDropTriggerResponse struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField schemeField; + iprot.readStructBegin(); + while (true) + { + schemeField = iprot.readFieldBegin(); + if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (schemeField.id) { + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + struct.validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot, WMDropTriggerResponse struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class WMDropTriggerResponseTupleSchemeFactory implements SchemeFactory { + public WMDropTriggerResponseTupleScheme getScheme() { + return new WMDropTriggerResponseTupleScheme(); + } + } + + private static class WMDropTriggerResponseTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, WMDropTriggerResponse struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, WMDropTriggerResponse struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } + +} + diff --git standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMGetTriggersForResourePlanRequest.java standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMGetTriggersForResourePlanRequest.java new file mode 100644 index 0000000000..a9daf439ca --- /dev/null +++ standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMGetTriggersForResourePlanRequest.java @@ -0,0 +1,393 @@ +/** + * Autogenerated by Thrift Compiler (0.9.3) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +package org.apache.hadoop.hive.metastore.api; + +import org.apache.thrift.scheme.IScheme; +import org.apache.thrift.scheme.SchemeFactory; +import org.apache.thrift.scheme.StandardScheme; + +import org.apache.thrift.scheme.TupleScheme; +import org.apache.thrift.protocol.TTupleProtocol; +import org.apache.thrift.protocol.TProtocolException; +import org.apache.thrift.EncodingUtils; +import org.apache.thrift.TException; +import org.apache.thrift.async.AsyncMethodCallback; +import org.apache.thrift.server.AbstractNonblockingServer.*; +import java.util.List; +import java.util.ArrayList; +import java.util.Map; +import java.util.HashMap; +import java.util.EnumMap; +import java.util.Set; +import java.util.HashSet; +import java.util.EnumSet; +import java.util.Collections; +import java.util.BitSet; +import java.nio.ByteBuffer; +import java.util.Arrays; +import javax.annotation.Generated; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) +@Generated(value = "Autogenerated by Thrift Compiler (0.9.3)") +public class WMGetTriggersForResourePlanRequest implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("WMGetTriggersForResourePlanRequest"); + + private static final org.apache.thrift.protocol.TField RESOURCE_PLAN_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("resourcePlanName", org.apache.thrift.protocol.TType.STRING, (short)1); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new WMGetTriggersForResourePlanRequestStandardSchemeFactory()); + schemes.put(TupleScheme.class, new WMGetTriggersForResourePlanRequestTupleSchemeFactory()); + } + + private String resourcePlanName; // optional + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + RESOURCE_PLAN_NAME((short)1, "resourcePlanName"); + + private static final Map byName = new HashMap(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 1: // RESOURCE_PLAN_NAME + return RESOURCE_PLAN_NAME; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + private static final _Fields optionals[] = {_Fields.RESOURCE_PLAN_NAME}; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.RESOURCE_PLAN_NAME, new org.apache.thrift.meta_data.FieldMetaData("resourcePlanName", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(WMGetTriggersForResourePlanRequest.class, metaDataMap); + } + + public WMGetTriggersForResourePlanRequest() { + } + + /** + * Performs a deep copy on other. + */ + public WMGetTriggersForResourePlanRequest(WMGetTriggersForResourePlanRequest other) { + if (other.isSetResourcePlanName()) { + this.resourcePlanName = other.resourcePlanName; + } + } + + public WMGetTriggersForResourePlanRequest deepCopy() { + return new WMGetTriggersForResourePlanRequest(this); + } + + @Override + public void clear() { + this.resourcePlanName = null; + } + + public String getResourcePlanName() { + return this.resourcePlanName; + } + + public void setResourcePlanName(String resourcePlanName) { + this.resourcePlanName = resourcePlanName; + } + + public void unsetResourcePlanName() { + this.resourcePlanName = null; + } + + /** Returns true if field resourcePlanName is set (has been assigned a value) and false otherwise */ + public boolean isSetResourcePlanName() { + return this.resourcePlanName != null; + } + + public void setResourcePlanNameIsSet(boolean value) { + if (!value) { + this.resourcePlanName = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case RESOURCE_PLAN_NAME: + if (value == null) { + unsetResourcePlanName(); + } else { + setResourcePlanName((String)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case RESOURCE_PLAN_NAME: + return getResourcePlanName(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case RESOURCE_PLAN_NAME: + return isSetResourcePlanName(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof WMGetTriggersForResourePlanRequest) + return this.equals((WMGetTriggersForResourePlanRequest)that); + return false; + } + + public boolean equals(WMGetTriggersForResourePlanRequest that) { + if (that == null) + return false; + + boolean this_present_resourcePlanName = true && this.isSetResourcePlanName(); + boolean that_present_resourcePlanName = true && that.isSetResourcePlanName(); + if (this_present_resourcePlanName || that_present_resourcePlanName) { + if (!(this_present_resourcePlanName && that_present_resourcePlanName)) + return false; + if (!this.resourcePlanName.equals(that.resourcePlanName)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + boolean present_resourcePlanName = true && (isSetResourcePlanName()); + list.add(present_resourcePlanName); + if (present_resourcePlanName) + list.add(resourcePlanName); + + return list.hashCode(); + } + + @Override + public int compareTo(WMGetTriggersForResourePlanRequest other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetResourcePlanName()).compareTo(other.isSetResourcePlanName()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetResourcePlanName()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.resourcePlanName, other.resourcePlanName); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("WMGetTriggersForResourePlanRequest("); + boolean first = true; + + if (isSetResourcePlanName()) { + sb.append("resourcePlanName:"); + if (this.resourcePlanName == null) { + sb.append("null"); + } else { + sb.append(this.resourcePlanName); + } + first = false; + } + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class WMGetTriggersForResourePlanRequestStandardSchemeFactory implements SchemeFactory { + public WMGetTriggersForResourePlanRequestStandardScheme getScheme() { + return new WMGetTriggersForResourePlanRequestStandardScheme(); + } + } + + private static class WMGetTriggersForResourePlanRequestStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, WMGetTriggersForResourePlanRequest struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField schemeField; + iprot.readStructBegin(); + while (true) + { + schemeField = iprot.readFieldBegin(); + if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (schemeField.id) { + case 1: // RESOURCE_PLAN_NAME + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.resourcePlanName = iprot.readString(); + struct.setResourcePlanNameIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + struct.validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot, WMGetTriggersForResourePlanRequest struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.resourcePlanName != null) { + if (struct.isSetResourcePlanName()) { + oprot.writeFieldBegin(RESOURCE_PLAN_NAME_FIELD_DESC); + oprot.writeString(struct.resourcePlanName); + oprot.writeFieldEnd(); + } + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class WMGetTriggersForResourePlanRequestTupleSchemeFactory implements SchemeFactory { + public WMGetTriggersForResourePlanRequestTupleScheme getScheme() { + return new WMGetTriggersForResourePlanRequestTupleScheme(); + } + } + + private static class WMGetTriggersForResourePlanRequestTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, WMGetTriggersForResourePlanRequest struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetResourcePlanName()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetResourcePlanName()) { + oprot.writeString(struct.resourcePlanName); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, WMGetTriggersForResourePlanRequest struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.resourcePlanName = iprot.readString(); + struct.setResourcePlanNameIsSet(true); + } + } + } + +} + diff --git standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMGetTriggersForResourePlanResponse.java standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMGetTriggersForResourePlanResponse.java new file mode 100644 index 0000000000..c7f62ad0c4 --- /dev/null +++ standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMGetTriggersForResourePlanResponse.java @@ -0,0 +1,447 @@ +/** + * Autogenerated by Thrift Compiler (0.9.3) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +package org.apache.hadoop.hive.metastore.api; + +import org.apache.thrift.scheme.IScheme; +import org.apache.thrift.scheme.SchemeFactory; +import org.apache.thrift.scheme.StandardScheme; + +import org.apache.thrift.scheme.TupleScheme; +import org.apache.thrift.protocol.TTupleProtocol; +import org.apache.thrift.protocol.TProtocolException; +import org.apache.thrift.EncodingUtils; +import org.apache.thrift.TException; +import org.apache.thrift.async.AsyncMethodCallback; +import org.apache.thrift.server.AbstractNonblockingServer.*; +import java.util.List; +import java.util.ArrayList; +import java.util.Map; +import java.util.HashMap; +import java.util.EnumMap; +import java.util.Set; +import java.util.HashSet; +import java.util.EnumSet; +import java.util.Collections; +import java.util.BitSet; +import java.nio.ByteBuffer; +import java.util.Arrays; +import javax.annotation.Generated; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) +@Generated(value = "Autogenerated by Thrift Compiler (0.9.3)") +public class WMGetTriggersForResourePlanResponse implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("WMGetTriggersForResourePlanResponse"); + + private static final org.apache.thrift.protocol.TField TRIGGERS_FIELD_DESC = new org.apache.thrift.protocol.TField("triggers", org.apache.thrift.protocol.TType.LIST, (short)1); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new WMGetTriggersForResourePlanResponseStandardSchemeFactory()); + schemes.put(TupleScheme.class, new WMGetTriggersForResourePlanResponseTupleSchemeFactory()); + } + + private List triggers; // optional + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + TRIGGERS((short)1, "triggers"); + + private static final Map byName = new HashMap(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 1: // TRIGGERS + return TRIGGERS; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + private static final _Fields optionals[] = {_Fields.TRIGGERS}; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TRIGGERS, new org.apache.thrift.meta_data.FieldMetaData("triggers", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, WMTrigger.class)))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(WMGetTriggersForResourePlanResponse.class, metaDataMap); + } + + public WMGetTriggersForResourePlanResponse() { + } + + /** + * Performs a deep copy on other. + */ + public WMGetTriggersForResourePlanResponse(WMGetTriggersForResourePlanResponse other) { + if (other.isSetTriggers()) { + List __this__triggers = new ArrayList(other.triggers.size()); + for (WMTrigger other_element : other.triggers) { + __this__triggers.add(new WMTrigger(other_element)); + } + this.triggers = __this__triggers; + } + } + + public WMGetTriggersForResourePlanResponse deepCopy() { + return new WMGetTriggersForResourePlanResponse(this); + } + + @Override + public void clear() { + this.triggers = null; + } + + public int getTriggersSize() { + return (this.triggers == null) ? 0 : this.triggers.size(); + } + + public java.util.Iterator getTriggersIterator() { + return (this.triggers == null) ? null : this.triggers.iterator(); + } + + public void addToTriggers(WMTrigger elem) { + if (this.triggers == null) { + this.triggers = new ArrayList(); + } + this.triggers.add(elem); + } + + public List getTriggers() { + return this.triggers; + } + + public void setTriggers(List triggers) { + this.triggers = triggers; + } + + public void unsetTriggers() { + this.triggers = null; + } + + /** Returns true if field triggers is set (has been assigned a value) and false otherwise */ + public boolean isSetTriggers() { + return this.triggers != null; + } + + public void setTriggersIsSet(boolean value) { + if (!value) { + this.triggers = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case TRIGGERS: + if (value == null) { + unsetTriggers(); + } else { + setTriggers((List)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case TRIGGERS: + return getTriggers(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case TRIGGERS: + return isSetTriggers(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof WMGetTriggersForResourePlanResponse) + return this.equals((WMGetTriggersForResourePlanResponse)that); + return false; + } + + public boolean equals(WMGetTriggersForResourePlanResponse that) { + if (that == null) + return false; + + boolean this_present_triggers = true && this.isSetTriggers(); + boolean that_present_triggers = true && that.isSetTriggers(); + if (this_present_triggers || that_present_triggers) { + if (!(this_present_triggers && that_present_triggers)) + return false; + if (!this.triggers.equals(that.triggers)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + boolean present_triggers = true && (isSetTriggers()); + list.add(present_triggers); + if (present_triggers) + list.add(triggers); + + return list.hashCode(); + } + + @Override + public int compareTo(WMGetTriggersForResourePlanResponse other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetTriggers()).compareTo(other.isSetTriggers()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetTriggers()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.triggers, other.triggers); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("WMGetTriggersForResourePlanResponse("); + boolean first = true; + + if (isSetTriggers()) { + sb.append("triggers:"); + if (this.triggers == null) { + sb.append("null"); + } else { + sb.append(this.triggers); + } + first = false; + } + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class WMGetTriggersForResourePlanResponseStandardSchemeFactory implements SchemeFactory { + public WMGetTriggersForResourePlanResponseStandardScheme getScheme() { + return new WMGetTriggersForResourePlanResponseStandardScheme(); + } + } + + private static class WMGetTriggersForResourePlanResponseStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, WMGetTriggersForResourePlanResponse struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField schemeField; + iprot.readStructBegin(); + while (true) + { + schemeField = iprot.readFieldBegin(); + if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (schemeField.id) { + case 1: // TRIGGERS + if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { + { + org.apache.thrift.protocol.TList _list746 = iprot.readListBegin(); + struct.triggers = new ArrayList(_list746.size); + WMTrigger _elem747; + for (int _i748 = 0; _i748 < _list746.size; ++_i748) + { + _elem747 = new WMTrigger(); + _elem747.read(iprot); + struct.triggers.add(_elem747); + } + iprot.readListEnd(); + } + struct.setTriggersIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + struct.validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot, WMGetTriggersForResourePlanResponse struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.triggers != null) { + if (struct.isSetTriggers()) { + oprot.writeFieldBegin(TRIGGERS_FIELD_DESC); + { + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.triggers.size())); + for (WMTrigger _iter749 : struct.triggers) + { + _iter749.write(oprot); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class WMGetTriggersForResourePlanResponseTupleSchemeFactory implements SchemeFactory { + public WMGetTriggersForResourePlanResponseTupleScheme getScheme() { + return new WMGetTriggersForResourePlanResponseTupleScheme(); + } + } + + private static class WMGetTriggersForResourePlanResponseTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, WMGetTriggersForResourePlanResponse struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetTriggers()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetTriggers()) { + { + oprot.writeI32(struct.triggers.size()); + for (WMTrigger _iter750 : struct.triggers) + { + _iter750.write(oprot); + } + } + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, WMGetTriggersForResourePlanResponse struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + { + org.apache.thrift.protocol.TList _list751 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.triggers = new ArrayList(_list751.size); + WMTrigger _elem752; + for (int _i753 = 0; _i753 < _list751.size; ++_i753) + { + _elem752 = new WMTrigger(); + _elem752.read(iprot); + struct.triggers.add(_elem752); + } + } + struct.setTriggersIsSet(true); + } + } + } + +} + diff --git standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMTrigger.java standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMTrigger.java index 848b8c2c9f..eb745d6de2 100644 --- standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMTrigger.java +++ standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMTrigger.java @@ -39,7 +39,7 @@ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("WMTrigger"); private static final org.apache.thrift.protocol.TField RESOURCE_PLAN_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("resourcePlanName", org.apache.thrift.protocol.TType.STRING, (short)1); - private static final org.apache.thrift.protocol.TField POOL_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("poolName", org.apache.thrift.protocol.TType.STRING, (short)2); + private static final org.apache.thrift.protocol.TField TRIGGER_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("triggerName", org.apache.thrift.protocol.TType.STRING, (short)2); private static final org.apache.thrift.protocol.TField TRIGGER_EXPRESSION_FIELD_DESC = new org.apache.thrift.protocol.TField("triggerExpression", org.apache.thrift.protocol.TType.STRING, (short)3); private static final org.apache.thrift.protocol.TField ACTION_EXPRESSION_FIELD_DESC = new org.apache.thrift.protocol.TField("actionExpression", org.apache.thrift.protocol.TType.STRING, (short)4); @@ -50,14 +50,14 @@ } private String resourcePlanName; // required - private String poolName; // required + private String triggerName; // required private String triggerExpression; // optional private String actionExpression; // optional /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ public enum _Fields implements org.apache.thrift.TFieldIdEnum { RESOURCE_PLAN_NAME((short)1, "resourcePlanName"), - POOL_NAME((short)2, "poolName"), + TRIGGER_NAME((short)2, "triggerName"), TRIGGER_EXPRESSION((short)3, "triggerExpression"), ACTION_EXPRESSION((short)4, "actionExpression"); @@ -76,8 +76,8 @@ public static _Fields findByThriftId(int fieldId) { switch(fieldId) { case 1: // RESOURCE_PLAN_NAME return RESOURCE_PLAN_NAME; - case 2: // POOL_NAME - return POOL_NAME; + case 2: // TRIGGER_NAME + return TRIGGER_NAME; case 3: // TRIGGER_EXPRESSION return TRIGGER_EXPRESSION; case 4: // ACTION_EXPRESSION @@ -128,7 +128,7 @@ public String getFieldName() { Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); tmpMap.put(_Fields.RESOURCE_PLAN_NAME, new org.apache.thrift.meta_data.FieldMetaData("resourcePlanName", org.apache.thrift.TFieldRequirementType.REQUIRED, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - tmpMap.put(_Fields.POOL_NAME, new org.apache.thrift.meta_data.FieldMetaData("poolName", org.apache.thrift.TFieldRequirementType.REQUIRED, + tmpMap.put(_Fields.TRIGGER_NAME, new org.apache.thrift.meta_data.FieldMetaData("triggerName", org.apache.thrift.TFieldRequirementType.REQUIRED, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); tmpMap.put(_Fields.TRIGGER_EXPRESSION, new org.apache.thrift.meta_data.FieldMetaData("triggerExpression", org.apache.thrift.TFieldRequirementType.OPTIONAL, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); @@ -143,11 +143,11 @@ public WMTrigger() { public WMTrigger( String resourcePlanName, - String poolName) + String triggerName) { this(); this.resourcePlanName = resourcePlanName; - this.poolName = poolName; + this.triggerName = triggerName; } /** @@ -157,8 +157,8 @@ public WMTrigger(WMTrigger other) { if (other.isSetResourcePlanName()) { this.resourcePlanName = other.resourcePlanName; } - if (other.isSetPoolName()) { - this.poolName = other.poolName; + if (other.isSetTriggerName()) { + this.triggerName = other.triggerName; } if (other.isSetTriggerExpression()) { this.triggerExpression = other.triggerExpression; @@ -175,7 +175,7 @@ public WMTrigger deepCopy() { @Override public void clear() { this.resourcePlanName = null; - this.poolName = null; + this.triggerName = null; this.triggerExpression = null; this.actionExpression = null; } @@ -203,26 +203,26 @@ public void setResourcePlanNameIsSet(boolean value) { } } - public String getPoolName() { - return this.poolName; + public String getTriggerName() { + return this.triggerName; } - public void setPoolName(String poolName) { - this.poolName = poolName; + public void setTriggerName(String triggerName) { + this.triggerName = triggerName; } - public void unsetPoolName() { - this.poolName = null; + public void unsetTriggerName() { + this.triggerName = null; } - /** Returns true if field poolName is set (has been assigned a value) and false otherwise */ - public boolean isSetPoolName() { - return this.poolName != null; + /** Returns true if field triggerName is set (has been assigned a value) and false otherwise */ + public boolean isSetTriggerName() { + return this.triggerName != null; } - public void setPoolNameIsSet(boolean value) { + public void setTriggerNameIsSet(boolean value) { if (!value) { - this.poolName = null; + this.triggerName = null; } } @@ -282,11 +282,11 @@ public void setFieldValue(_Fields field, Object value) { } break; - case POOL_NAME: + case TRIGGER_NAME: if (value == null) { - unsetPoolName(); + unsetTriggerName(); } else { - setPoolName((String)value); + setTriggerName((String)value); } break; @@ -314,8 +314,8 @@ public Object getFieldValue(_Fields field) { case RESOURCE_PLAN_NAME: return getResourcePlanName(); - case POOL_NAME: - return getPoolName(); + case TRIGGER_NAME: + return getTriggerName(); case TRIGGER_EXPRESSION: return getTriggerExpression(); @@ -336,8 +336,8 @@ public boolean isSet(_Fields field) { switch (field) { case RESOURCE_PLAN_NAME: return isSetResourcePlanName(); - case POOL_NAME: - return isSetPoolName(); + case TRIGGER_NAME: + return isSetTriggerName(); case TRIGGER_EXPRESSION: return isSetTriggerExpression(); case ACTION_EXPRESSION: @@ -368,12 +368,12 @@ public boolean equals(WMTrigger that) { return false; } - boolean this_present_poolName = true && this.isSetPoolName(); - boolean that_present_poolName = true && that.isSetPoolName(); - if (this_present_poolName || that_present_poolName) { - if (!(this_present_poolName && that_present_poolName)) + boolean this_present_triggerName = true && this.isSetTriggerName(); + boolean that_present_triggerName = true && that.isSetTriggerName(); + if (this_present_triggerName || that_present_triggerName) { + if (!(this_present_triggerName && that_present_triggerName)) return false; - if (!this.poolName.equals(that.poolName)) + if (!this.triggerName.equals(that.triggerName)) return false; } @@ -407,10 +407,10 @@ public int hashCode() { if (present_resourcePlanName) list.add(resourcePlanName); - boolean present_poolName = true && (isSetPoolName()); - list.add(present_poolName); - if (present_poolName) - list.add(poolName); + boolean present_triggerName = true && (isSetTriggerName()); + list.add(present_triggerName); + if (present_triggerName) + list.add(triggerName); boolean present_triggerExpression = true && (isSetTriggerExpression()); list.add(present_triggerExpression); @@ -443,12 +443,12 @@ public int compareTo(WMTrigger other) { return lastComparison; } } - lastComparison = Boolean.valueOf(isSetPoolName()).compareTo(other.isSetPoolName()); + lastComparison = Boolean.valueOf(isSetTriggerName()).compareTo(other.isSetTriggerName()); if (lastComparison != 0) { return lastComparison; } - if (isSetPoolName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.poolName, other.poolName); + if (isSetTriggerName()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.triggerName, other.triggerName); if (lastComparison != 0) { return lastComparison; } @@ -501,11 +501,11 @@ public String toString() { } first = false; if (!first) sb.append(", "); - sb.append("poolName:"); - if (this.poolName == null) { + sb.append("triggerName:"); + if (this.triggerName == null) { sb.append("null"); } else { - sb.append(this.poolName); + sb.append(this.triggerName); } first = false; if (isSetTriggerExpression()) { @@ -538,8 +538,8 @@ public void validate() throws org.apache.thrift.TException { throw new org.apache.thrift.protocol.TProtocolException("Required field 'resourcePlanName' is unset! Struct:" + toString()); } - if (!isSetPoolName()) { - throw new org.apache.thrift.protocol.TProtocolException("Required field 'poolName' is unset! Struct:" + toString()); + if (!isSetTriggerName()) { + throw new org.apache.thrift.protocol.TProtocolException("Required field 'triggerName' is unset! Struct:" + toString()); } // check for sub-struct validity @@ -587,10 +587,10 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, WMTrigger struct) t org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } break; - case 2: // POOL_NAME + case 2: // TRIGGER_NAME if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.poolName = iprot.readString(); - struct.setPoolNameIsSet(true); + struct.triggerName = iprot.readString(); + struct.setTriggerNameIsSet(true); } else { org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } @@ -629,9 +629,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, WMTrigger struct) oprot.writeString(struct.resourcePlanName); oprot.writeFieldEnd(); } - if (struct.poolName != null) { - oprot.writeFieldBegin(POOL_NAME_FIELD_DESC); - oprot.writeString(struct.poolName); + if (struct.triggerName != null) { + oprot.writeFieldBegin(TRIGGER_NAME_FIELD_DESC); + oprot.writeString(struct.triggerName); oprot.writeFieldEnd(); } if (struct.triggerExpression != null) { @@ -666,7 +666,7 @@ public WMTriggerTupleScheme getScheme() { public void write(org.apache.thrift.protocol.TProtocol prot, WMTrigger struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; oprot.writeString(struct.resourcePlanName); - oprot.writeString(struct.poolName); + oprot.writeString(struct.triggerName); BitSet optionals = new BitSet(); if (struct.isSetTriggerExpression()) { optionals.set(0); @@ -688,8 +688,8 @@ public void read(org.apache.thrift.protocol.TProtocol prot, WMTrigger struct) th TTupleProtocol iprot = (TTupleProtocol) prot; struct.resourcePlanName = iprot.readString(); struct.setResourcePlanNameIsSet(true); - struct.poolName = iprot.readString(); - struct.setPoolNameIsSet(true); + struct.triggerName = iprot.readString(); + struct.setTriggerNameIsSet(true); BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { struct.triggerExpression = iprot.readString(); diff --git standalone-metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php standalone-metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php index 4998dc058b..cc813cd099 100644 --- standalone-metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php +++ standalone-metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php @@ -1291,6 +1291,38 @@ interface ThriftHiveMetastoreIf extends \FacebookServiceIf { * @throws \metastore\MetaException */ public function drop_resource_plan(\metastore\WMDropResourcePlanRequest $request); + /** + * @param \metastore\WMCreateTriggerRequest $request + * @return \metastore\WMCreateTriggerResponse + * @throws \metastore\AlreadyExistsException + * @throws \metastore\NoSuchObjectException + * @throws \metastore\InvalidObjectException + * @throws \metastore\MetaException + */ + public function create_wm_trigger(\metastore\WMCreateTriggerRequest $request); + /** + * @param \metastore\WMAlterTriggerRequest $request + * @return \metastore\WMAlterTriggerResponse + * @throws \metastore\NoSuchObjectException + * @throws \metastore\InvalidObjectException + * @throws \metastore\MetaException + */ + public function alter_wm_trigger(\metastore\WMAlterTriggerRequest $request); + /** + * @param \metastore\WMDropTriggerRequest $request + * @return \metastore\WMDropTriggerResponse + * @throws \metastore\NoSuchObjectException + * @throws \metastore\InvalidOperationException + * @throws \metastore\MetaException + */ + public function drop_wm_trigger(\metastore\WMDropTriggerRequest $request); + /** + * @param \metastore\WMGetTriggersForResourePlanRequest $request + * @return \metastore\WMGetTriggersForResourePlanResponse + * @throws \metastore\NoSuchObjectException + * @throws \metastore\MetaException + */ + public function get_triggers_for_resourceplan(\metastore\WMGetTriggersForResourePlanRequest $request); } class ThriftHiveMetastoreClient extends \FacebookServiceClient implements \metastore\ThriftHiveMetastoreIf { @@ -10827,6 +10859,246 @@ class ThriftHiveMetastoreClient extends \FacebookServiceClient implements \metas throw new \Exception("drop_resource_plan failed: unknown result"); } + public function create_wm_trigger(\metastore\WMCreateTriggerRequest $request) + { + $this->send_create_wm_trigger($request); + return $this->recv_create_wm_trigger(); + } + + public function send_create_wm_trigger(\metastore\WMCreateTriggerRequest $request) + { + $args = new \metastore\ThriftHiveMetastore_create_wm_trigger_args(); + $args->request = $request; + $bin_accel = ($this->output_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_write_binary'); + if ($bin_accel) + { + thrift_protocol_write_binary($this->output_, 'create_wm_trigger', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite()); + } + else + { + $this->output_->writeMessageBegin('create_wm_trigger', TMessageType::CALL, $this->seqid_); + $args->write($this->output_); + $this->output_->writeMessageEnd(); + $this->output_->getTransport()->flush(); + } + } + + public function recv_create_wm_trigger() + { + $bin_accel = ($this->input_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_read_binary'); + if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\metastore\ThriftHiveMetastore_create_wm_trigger_result', $this->input_->isStrictRead()); + else + { + $rseqid = 0; + $fname = null; + $mtype = 0; + + $this->input_->readMessageBegin($fname, $mtype, $rseqid); + if ($mtype == TMessageType::EXCEPTION) { + $x = new TApplicationException(); + $x->read($this->input_); + $this->input_->readMessageEnd(); + throw $x; + } + $result = new \metastore\ThriftHiveMetastore_create_wm_trigger_result(); + $result->read($this->input_); + $this->input_->readMessageEnd(); + } + if ($result->success !== null) { + return $result->success; + } + if ($result->o1 !== null) { + throw $result->o1; + } + if ($result->o2 !== null) { + throw $result->o2; + } + if ($result->o3 !== null) { + throw $result->o3; + } + if ($result->o4 !== null) { + throw $result->o4; + } + throw new \Exception("create_wm_trigger failed: unknown result"); + } + + public function alter_wm_trigger(\metastore\WMAlterTriggerRequest $request) + { + $this->send_alter_wm_trigger($request); + return $this->recv_alter_wm_trigger(); + } + + public function send_alter_wm_trigger(\metastore\WMAlterTriggerRequest $request) + { + $args = new \metastore\ThriftHiveMetastore_alter_wm_trigger_args(); + $args->request = $request; + $bin_accel = ($this->output_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_write_binary'); + if ($bin_accel) + { + thrift_protocol_write_binary($this->output_, 'alter_wm_trigger', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite()); + } + else + { + $this->output_->writeMessageBegin('alter_wm_trigger', TMessageType::CALL, $this->seqid_); + $args->write($this->output_); + $this->output_->writeMessageEnd(); + $this->output_->getTransport()->flush(); + } + } + + public function recv_alter_wm_trigger() + { + $bin_accel = ($this->input_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_read_binary'); + if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\metastore\ThriftHiveMetastore_alter_wm_trigger_result', $this->input_->isStrictRead()); + else + { + $rseqid = 0; + $fname = null; + $mtype = 0; + + $this->input_->readMessageBegin($fname, $mtype, $rseqid); + if ($mtype == TMessageType::EXCEPTION) { + $x = new TApplicationException(); + $x->read($this->input_); + $this->input_->readMessageEnd(); + throw $x; + } + $result = new \metastore\ThriftHiveMetastore_alter_wm_trigger_result(); + $result->read($this->input_); + $this->input_->readMessageEnd(); + } + if ($result->success !== null) { + return $result->success; + } + if ($result->o1 !== null) { + throw $result->o1; + } + if ($result->o2 !== null) { + throw $result->o2; + } + if ($result->o3 !== null) { + throw $result->o3; + } + throw new \Exception("alter_wm_trigger failed: unknown result"); + } + + public function drop_wm_trigger(\metastore\WMDropTriggerRequest $request) + { + $this->send_drop_wm_trigger($request); + return $this->recv_drop_wm_trigger(); + } + + public function send_drop_wm_trigger(\metastore\WMDropTriggerRequest $request) + { + $args = new \metastore\ThriftHiveMetastore_drop_wm_trigger_args(); + $args->request = $request; + $bin_accel = ($this->output_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_write_binary'); + if ($bin_accel) + { + thrift_protocol_write_binary($this->output_, 'drop_wm_trigger', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite()); + } + else + { + $this->output_->writeMessageBegin('drop_wm_trigger', TMessageType::CALL, $this->seqid_); + $args->write($this->output_); + $this->output_->writeMessageEnd(); + $this->output_->getTransport()->flush(); + } + } + + public function recv_drop_wm_trigger() + { + $bin_accel = ($this->input_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_read_binary'); + if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\metastore\ThriftHiveMetastore_drop_wm_trigger_result', $this->input_->isStrictRead()); + else + { + $rseqid = 0; + $fname = null; + $mtype = 0; + + $this->input_->readMessageBegin($fname, $mtype, $rseqid); + if ($mtype == TMessageType::EXCEPTION) { + $x = new TApplicationException(); + $x->read($this->input_); + $this->input_->readMessageEnd(); + throw $x; + } + $result = new \metastore\ThriftHiveMetastore_drop_wm_trigger_result(); + $result->read($this->input_); + $this->input_->readMessageEnd(); + } + if ($result->success !== null) { + return $result->success; + } + if ($result->o1 !== null) { + throw $result->o1; + } + if ($result->o2 !== null) { + throw $result->o2; + } + if ($result->o3 !== null) { + throw $result->o3; + } + throw new \Exception("drop_wm_trigger failed: unknown result"); + } + + public function get_triggers_for_resourceplan(\metastore\WMGetTriggersForResourePlanRequest $request) + { + $this->send_get_triggers_for_resourceplan($request); + return $this->recv_get_triggers_for_resourceplan(); + } + + public function send_get_triggers_for_resourceplan(\metastore\WMGetTriggersForResourePlanRequest $request) + { + $args = new \metastore\ThriftHiveMetastore_get_triggers_for_resourceplan_args(); + $args->request = $request; + $bin_accel = ($this->output_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_write_binary'); + if ($bin_accel) + { + thrift_protocol_write_binary($this->output_, 'get_triggers_for_resourceplan', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite()); + } + else + { + $this->output_->writeMessageBegin('get_triggers_for_resourceplan', TMessageType::CALL, $this->seqid_); + $args->write($this->output_); + $this->output_->writeMessageEnd(); + $this->output_->getTransport()->flush(); + } + } + + public function recv_get_triggers_for_resourceplan() + { + $bin_accel = ($this->input_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_read_binary'); + if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\metastore\ThriftHiveMetastore_get_triggers_for_resourceplan_result', $this->input_->isStrictRead()); + else + { + $rseqid = 0; + $fname = null; + $mtype = 0; + + $this->input_->readMessageBegin($fname, $mtype, $rseqid); + if ($mtype == TMessageType::EXCEPTION) { + $x = new TApplicationException(); + $x->read($this->input_); + $this->input_->readMessageEnd(); + throw $x; + } + $result = new \metastore\ThriftHiveMetastore_get_triggers_for_resourceplan_result(); + $result->read($this->input_); + $this->input_->readMessageEnd(); + } + if ($result->success !== null) { + return $result->success; + } + if ($result->o1 !== null) { + throw $result->o1; + } + if ($result->o2 !== null) { + throw $result->o2; + } + throw new \Exception("get_triggers_for_resourceplan failed: unknown result"); + } + } // HELPER FUNCTIONS AND STRUCTURES @@ -11978,14 +12250,14 @@ class ThriftHiveMetastore_get_databases_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size659 = 0; - $_etype662 = 0; - $xfer += $input->readListBegin($_etype662, $_size659); - for ($_i663 = 0; $_i663 < $_size659; ++$_i663) + $_size666 = 0; + $_etype669 = 0; + $xfer += $input->readListBegin($_etype669, $_size666); + for ($_i670 = 0; $_i670 < $_size666; ++$_i670) { - $elem664 = null; - $xfer += $input->readString($elem664); - $this->success []= $elem664; + $elem671 = null; + $xfer += $input->readString($elem671); + $this->success []= $elem671; } $xfer += $input->readListEnd(); } else { @@ -12021,9 +12293,9 @@ class ThriftHiveMetastore_get_databases_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter665) + foreach ($this->success as $iter672) { - $xfer += $output->writeString($iter665); + $xfer += $output->writeString($iter672); } } $output->writeListEnd(); @@ -12154,14 +12426,14 @@ class ThriftHiveMetastore_get_all_databases_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size666 = 0; - $_etype669 = 0; - $xfer += $input->readListBegin($_etype669, $_size666); - for ($_i670 = 0; $_i670 < $_size666; ++$_i670) + $_size673 = 0; + $_etype676 = 0; + $xfer += $input->readListBegin($_etype676, $_size673); + for ($_i677 = 0; $_i677 < $_size673; ++$_i677) { - $elem671 = null; - $xfer += $input->readString($elem671); - $this->success []= $elem671; + $elem678 = null; + $xfer += $input->readString($elem678); + $this->success []= $elem678; } $xfer += $input->readListEnd(); } else { @@ -12197,9 +12469,9 @@ class ThriftHiveMetastore_get_all_databases_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter672) + foreach ($this->success as $iter679) { - $xfer += $output->writeString($iter672); + $xfer += $output->writeString($iter679); } } $output->writeListEnd(); @@ -13200,18 +13472,18 @@ class ThriftHiveMetastore_get_type_all_result { case 0: if ($ftype == TType::MAP) { $this->success = array(); - $_size673 = 0; - $_ktype674 = 0; - $_vtype675 = 0; - $xfer += $input->readMapBegin($_ktype674, $_vtype675, $_size673); - for ($_i677 = 0; $_i677 < $_size673; ++$_i677) + $_size680 = 0; + $_ktype681 = 0; + $_vtype682 = 0; + $xfer += $input->readMapBegin($_ktype681, $_vtype682, $_size680); + for ($_i684 = 0; $_i684 < $_size680; ++$_i684) { - $key678 = ''; - $val679 = new \metastore\Type(); - $xfer += $input->readString($key678); - $val679 = new \metastore\Type(); - $xfer += $val679->read($input); - $this->success[$key678] = $val679; + $key685 = ''; + $val686 = new \metastore\Type(); + $xfer += $input->readString($key685); + $val686 = new \metastore\Type(); + $xfer += $val686->read($input); + $this->success[$key685] = $val686; } $xfer += $input->readMapEnd(); } else { @@ -13247,10 +13519,10 @@ class ThriftHiveMetastore_get_type_all_result { { $output->writeMapBegin(TType::STRING, TType::STRUCT, count($this->success)); { - foreach ($this->success as $kiter680 => $viter681) + foreach ($this->success as $kiter687 => $viter688) { - $xfer += $output->writeString($kiter680); - $xfer += $viter681->write($output); + $xfer += $output->writeString($kiter687); + $xfer += $viter688->write($output); } } $output->writeMapEnd(); @@ -13454,15 +13726,15 @@ class ThriftHiveMetastore_get_fields_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size682 = 0; - $_etype685 = 0; - $xfer += $input->readListBegin($_etype685, $_size682); - for ($_i686 = 0; $_i686 < $_size682; ++$_i686) + $_size689 = 0; + $_etype692 = 0; + $xfer += $input->readListBegin($_etype692, $_size689); + for ($_i693 = 0; $_i693 < $_size689; ++$_i693) { - $elem687 = null; - $elem687 = new \metastore\FieldSchema(); - $xfer += $elem687->read($input); - $this->success []= $elem687; + $elem694 = null; + $elem694 = new \metastore\FieldSchema(); + $xfer += $elem694->read($input); + $this->success []= $elem694; } $xfer += $input->readListEnd(); } else { @@ -13514,9 +13786,9 @@ class ThriftHiveMetastore_get_fields_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter688) + foreach ($this->success as $iter695) { - $xfer += $iter688->write($output); + $xfer += $iter695->write($output); } } $output->writeListEnd(); @@ -13758,15 +14030,15 @@ class ThriftHiveMetastore_get_fields_with_environment_context_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size689 = 0; - $_etype692 = 0; - $xfer += $input->readListBegin($_etype692, $_size689); - for ($_i693 = 0; $_i693 < $_size689; ++$_i693) + $_size696 = 0; + $_etype699 = 0; + $xfer += $input->readListBegin($_etype699, $_size696); + for ($_i700 = 0; $_i700 < $_size696; ++$_i700) { - $elem694 = null; - $elem694 = new \metastore\FieldSchema(); - $xfer += $elem694->read($input); - $this->success []= $elem694; + $elem701 = null; + $elem701 = new \metastore\FieldSchema(); + $xfer += $elem701->read($input); + $this->success []= $elem701; } $xfer += $input->readListEnd(); } else { @@ -13818,9 +14090,9 @@ class ThriftHiveMetastore_get_fields_with_environment_context_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter695) + foreach ($this->success as $iter702) { - $xfer += $iter695->write($output); + $xfer += $iter702->write($output); } } $output->writeListEnd(); @@ -14034,15 +14306,15 @@ class ThriftHiveMetastore_get_schema_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size696 = 0; - $_etype699 = 0; - $xfer += $input->readListBegin($_etype699, $_size696); - for ($_i700 = 0; $_i700 < $_size696; ++$_i700) + $_size703 = 0; + $_etype706 = 0; + $xfer += $input->readListBegin($_etype706, $_size703); + for ($_i707 = 0; $_i707 < $_size703; ++$_i707) { - $elem701 = null; - $elem701 = new \metastore\FieldSchema(); - $xfer += $elem701->read($input); - $this->success []= $elem701; + $elem708 = null; + $elem708 = new \metastore\FieldSchema(); + $xfer += $elem708->read($input); + $this->success []= $elem708; } $xfer += $input->readListEnd(); } else { @@ -14094,9 +14366,9 @@ class ThriftHiveMetastore_get_schema_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter702) + foreach ($this->success as $iter709) { - $xfer += $iter702->write($output); + $xfer += $iter709->write($output); } } $output->writeListEnd(); @@ -14338,15 +14610,15 @@ class ThriftHiveMetastore_get_schema_with_environment_context_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size703 = 0; - $_etype706 = 0; - $xfer += $input->readListBegin($_etype706, $_size703); - for ($_i707 = 0; $_i707 < $_size703; ++$_i707) + $_size710 = 0; + $_etype713 = 0; + $xfer += $input->readListBegin($_etype713, $_size710); + for ($_i714 = 0; $_i714 < $_size710; ++$_i714) { - $elem708 = null; - $elem708 = new \metastore\FieldSchema(); - $xfer += $elem708->read($input); - $this->success []= $elem708; + $elem715 = null; + $elem715 = new \metastore\FieldSchema(); + $xfer += $elem715->read($input); + $this->success []= $elem715; } $xfer += $input->readListEnd(); } else { @@ -14398,9 +14670,9 @@ class ThriftHiveMetastore_get_schema_with_environment_context_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter709) + foreach ($this->success as $iter716) { - $xfer += $iter709->write($output); + $xfer += $iter716->write($output); } } $output->writeListEnd(); @@ -15040,15 +15312,15 @@ class ThriftHiveMetastore_create_table_with_constraints_args { case 2: if ($ftype == TType::LST) { $this->primaryKeys = array(); - $_size710 = 0; - $_etype713 = 0; - $xfer += $input->readListBegin($_etype713, $_size710); - for ($_i714 = 0; $_i714 < $_size710; ++$_i714) + $_size717 = 0; + $_etype720 = 0; + $xfer += $input->readListBegin($_etype720, $_size717); + for ($_i721 = 0; $_i721 < $_size717; ++$_i721) { - $elem715 = null; - $elem715 = new \metastore\SQLPrimaryKey(); - $xfer += $elem715->read($input); - $this->primaryKeys []= $elem715; + $elem722 = null; + $elem722 = new \metastore\SQLPrimaryKey(); + $xfer += $elem722->read($input); + $this->primaryKeys []= $elem722; } $xfer += $input->readListEnd(); } else { @@ -15058,15 +15330,15 @@ class ThriftHiveMetastore_create_table_with_constraints_args { case 3: if ($ftype == TType::LST) { $this->foreignKeys = array(); - $_size716 = 0; - $_etype719 = 0; - $xfer += $input->readListBegin($_etype719, $_size716); - for ($_i720 = 0; $_i720 < $_size716; ++$_i720) + $_size723 = 0; + $_etype726 = 0; + $xfer += $input->readListBegin($_etype726, $_size723); + for ($_i727 = 0; $_i727 < $_size723; ++$_i727) { - $elem721 = null; - $elem721 = new \metastore\SQLForeignKey(); - $xfer += $elem721->read($input); - $this->foreignKeys []= $elem721; + $elem728 = null; + $elem728 = new \metastore\SQLForeignKey(); + $xfer += $elem728->read($input); + $this->foreignKeys []= $elem728; } $xfer += $input->readListEnd(); } else { @@ -15076,15 +15348,15 @@ class ThriftHiveMetastore_create_table_with_constraints_args { case 4: if ($ftype == TType::LST) { $this->uniqueConstraints = array(); - $_size722 = 0; - $_etype725 = 0; - $xfer += $input->readListBegin($_etype725, $_size722); - for ($_i726 = 0; $_i726 < $_size722; ++$_i726) + $_size729 = 0; + $_etype732 = 0; + $xfer += $input->readListBegin($_etype732, $_size729); + for ($_i733 = 0; $_i733 < $_size729; ++$_i733) { - $elem727 = null; - $elem727 = new \metastore\SQLUniqueConstraint(); - $xfer += $elem727->read($input); - $this->uniqueConstraints []= $elem727; + $elem734 = null; + $elem734 = new \metastore\SQLUniqueConstraint(); + $xfer += $elem734->read($input); + $this->uniqueConstraints []= $elem734; } $xfer += $input->readListEnd(); } else { @@ -15094,15 +15366,15 @@ class ThriftHiveMetastore_create_table_with_constraints_args { case 5: if ($ftype == TType::LST) { $this->notNullConstraints = array(); - $_size728 = 0; - $_etype731 = 0; - $xfer += $input->readListBegin($_etype731, $_size728); - for ($_i732 = 0; $_i732 < $_size728; ++$_i732) + $_size735 = 0; + $_etype738 = 0; + $xfer += $input->readListBegin($_etype738, $_size735); + for ($_i739 = 0; $_i739 < $_size735; ++$_i739) { - $elem733 = null; - $elem733 = new \metastore\SQLNotNullConstraint(); - $xfer += $elem733->read($input); - $this->notNullConstraints []= $elem733; + $elem740 = null; + $elem740 = new \metastore\SQLNotNullConstraint(); + $xfer += $elem740->read($input); + $this->notNullConstraints []= $elem740; } $xfer += $input->readListEnd(); } else { @@ -15138,9 +15410,9 @@ class ThriftHiveMetastore_create_table_with_constraints_args { { $output->writeListBegin(TType::STRUCT, count($this->primaryKeys)); { - foreach ($this->primaryKeys as $iter734) + foreach ($this->primaryKeys as $iter741) { - $xfer += $iter734->write($output); + $xfer += $iter741->write($output); } } $output->writeListEnd(); @@ -15155,9 +15427,9 @@ class ThriftHiveMetastore_create_table_with_constraints_args { { $output->writeListBegin(TType::STRUCT, count($this->foreignKeys)); { - foreach ($this->foreignKeys as $iter735) + foreach ($this->foreignKeys as $iter742) { - $xfer += $iter735->write($output); + $xfer += $iter742->write($output); } } $output->writeListEnd(); @@ -15172,9 +15444,9 @@ class ThriftHiveMetastore_create_table_with_constraints_args { { $output->writeListBegin(TType::STRUCT, count($this->uniqueConstraints)); { - foreach ($this->uniqueConstraints as $iter736) + foreach ($this->uniqueConstraints as $iter743) { - $xfer += $iter736->write($output); + $xfer += $iter743->write($output); } } $output->writeListEnd(); @@ -15189,9 +15461,9 @@ class ThriftHiveMetastore_create_table_with_constraints_args { { $output->writeListBegin(TType::STRUCT, count($this->notNullConstraints)); { - foreach ($this->notNullConstraints as $iter737) + foreach ($this->notNullConstraints as $iter744) { - $xfer += $iter737->write($output); + $xfer += $iter744->write($output); } } $output->writeListEnd(); @@ -16827,14 +17099,14 @@ class ThriftHiveMetastore_truncate_table_args { case 3: if ($ftype == TType::LST) { $this->partNames = array(); - $_size738 = 0; - $_etype741 = 0; - $xfer += $input->readListBegin($_etype741, $_size738); - for ($_i742 = 0; $_i742 < $_size738; ++$_i742) + $_size745 = 0; + $_etype748 = 0; + $xfer += $input->readListBegin($_etype748, $_size745); + for ($_i749 = 0; $_i749 < $_size745; ++$_i749) { - $elem743 = null; - $xfer += $input->readString($elem743); - $this->partNames []= $elem743; + $elem750 = null; + $xfer += $input->readString($elem750); + $this->partNames []= $elem750; } $xfer += $input->readListEnd(); } else { @@ -16872,9 +17144,9 @@ class ThriftHiveMetastore_truncate_table_args { { $output->writeListBegin(TType::STRING, count($this->partNames)); { - foreach ($this->partNames as $iter744) + foreach ($this->partNames as $iter751) { - $xfer += $output->writeString($iter744); + $xfer += $output->writeString($iter751); } } $output->writeListEnd(); @@ -17125,14 +17397,14 @@ class ThriftHiveMetastore_get_tables_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size745 = 0; - $_etype748 = 0; - $xfer += $input->readListBegin($_etype748, $_size745); - for ($_i749 = 0; $_i749 < $_size745; ++$_i749) + $_size752 = 0; + $_etype755 = 0; + $xfer += $input->readListBegin($_etype755, $_size752); + for ($_i756 = 0; $_i756 < $_size752; ++$_i756) { - $elem750 = null; - $xfer += $input->readString($elem750); - $this->success []= $elem750; + $elem757 = null; + $xfer += $input->readString($elem757); + $this->success []= $elem757; } $xfer += $input->readListEnd(); } else { @@ -17168,9 +17440,9 @@ class ThriftHiveMetastore_get_tables_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter751) + foreach ($this->success as $iter758) { - $xfer += $output->writeString($iter751); + $xfer += $output->writeString($iter758); } } $output->writeListEnd(); @@ -17372,14 +17644,14 @@ class ThriftHiveMetastore_get_tables_by_type_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size752 = 0; - $_etype755 = 0; - $xfer += $input->readListBegin($_etype755, $_size752); - for ($_i756 = 0; $_i756 < $_size752; ++$_i756) + $_size759 = 0; + $_etype762 = 0; + $xfer += $input->readListBegin($_etype762, $_size759); + for ($_i763 = 0; $_i763 < $_size759; ++$_i763) { - $elem757 = null; - $xfer += $input->readString($elem757); - $this->success []= $elem757; + $elem764 = null; + $xfer += $input->readString($elem764); + $this->success []= $elem764; } $xfer += $input->readListEnd(); } else { @@ -17415,9 +17687,9 @@ class ThriftHiveMetastore_get_tables_by_type_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter758) + foreach ($this->success as $iter765) { - $xfer += $output->writeString($iter758); + $xfer += $output->writeString($iter765); } } $output->writeListEnd(); @@ -17522,14 +17794,14 @@ class ThriftHiveMetastore_get_table_meta_args { case 3: if ($ftype == TType::LST) { $this->tbl_types = array(); - $_size759 = 0; - $_etype762 = 0; - $xfer += $input->readListBegin($_etype762, $_size759); - for ($_i763 = 0; $_i763 < $_size759; ++$_i763) + $_size766 = 0; + $_etype769 = 0; + $xfer += $input->readListBegin($_etype769, $_size766); + for ($_i770 = 0; $_i770 < $_size766; ++$_i770) { - $elem764 = null; - $xfer += $input->readString($elem764); - $this->tbl_types []= $elem764; + $elem771 = null; + $xfer += $input->readString($elem771); + $this->tbl_types []= $elem771; } $xfer += $input->readListEnd(); } else { @@ -17567,9 +17839,9 @@ class ThriftHiveMetastore_get_table_meta_args { { $output->writeListBegin(TType::STRING, count($this->tbl_types)); { - foreach ($this->tbl_types as $iter765) + foreach ($this->tbl_types as $iter772) { - $xfer += $output->writeString($iter765); + $xfer += $output->writeString($iter772); } } $output->writeListEnd(); @@ -17646,15 +17918,15 @@ class ThriftHiveMetastore_get_table_meta_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size766 = 0; - $_etype769 = 0; - $xfer += $input->readListBegin($_etype769, $_size766); - for ($_i770 = 0; $_i770 < $_size766; ++$_i770) + $_size773 = 0; + $_etype776 = 0; + $xfer += $input->readListBegin($_etype776, $_size773); + for ($_i777 = 0; $_i777 < $_size773; ++$_i777) { - $elem771 = null; - $elem771 = new \metastore\TableMeta(); - $xfer += $elem771->read($input); - $this->success []= $elem771; + $elem778 = null; + $elem778 = new \metastore\TableMeta(); + $xfer += $elem778->read($input); + $this->success []= $elem778; } $xfer += $input->readListEnd(); } else { @@ -17690,9 +17962,9 @@ class ThriftHiveMetastore_get_table_meta_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter772) + foreach ($this->success as $iter779) { - $xfer += $iter772->write($output); + $xfer += $iter779->write($output); } } $output->writeListEnd(); @@ -17848,14 +18120,14 @@ class ThriftHiveMetastore_get_all_tables_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size773 = 0; - $_etype776 = 0; - $xfer += $input->readListBegin($_etype776, $_size773); - for ($_i777 = 0; $_i777 < $_size773; ++$_i777) + $_size780 = 0; + $_etype783 = 0; + $xfer += $input->readListBegin($_etype783, $_size780); + for ($_i784 = 0; $_i784 < $_size780; ++$_i784) { - $elem778 = null; - $xfer += $input->readString($elem778); - $this->success []= $elem778; + $elem785 = null; + $xfer += $input->readString($elem785); + $this->success []= $elem785; } $xfer += $input->readListEnd(); } else { @@ -17891,9 +18163,9 @@ class ThriftHiveMetastore_get_all_tables_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter779) + foreach ($this->success as $iter786) { - $xfer += $output->writeString($iter779); + $xfer += $output->writeString($iter786); } } $output->writeListEnd(); @@ -18208,14 +18480,14 @@ class ThriftHiveMetastore_get_table_objects_by_name_args { case 2: if ($ftype == TType::LST) { $this->tbl_names = array(); - $_size780 = 0; - $_etype783 = 0; - $xfer += $input->readListBegin($_etype783, $_size780); - for ($_i784 = 0; $_i784 < $_size780; ++$_i784) + $_size787 = 0; + $_etype790 = 0; + $xfer += $input->readListBegin($_etype790, $_size787); + for ($_i791 = 0; $_i791 < $_size787; ++$_i791) { - $elem785 = null; - $xfer += $input->readString($elem785); - $this->tbl_names []= $elem785; + $elem792 = null; + $xfer += $input->readString($elem792); + $this->tbl_names []= $elem792; } $xfer += $input->readListEnd(); } else { @@ -18248,9 +18520,9 @@ class ThriftHiveMetastore_get_table_objects_by_name_args { { $output->writeListBegin(TType::STRING, count($this->tbl_names)); { - foreach ($this->tbl_names as $iter786) + foreach ($this->tbl_names as $iter793) { - $xfer += $output->writeString($iter786); + $xfer += $output->writeString($iter793); } } $output->writeListEnd(); @@ -18315,15 +18587,15 @@ class ThriftHiveMetastore_get_table_objects_by_name_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size787 = 0; - $_etype790 = 0; - $xfer += $input->readListBegin($_etype790, $_size787); - for ($_i791 = 0; $_i791 < $_size787; ++$_i791) + $_size794 = 0; + $_etype797 = 0; + $xfer += $input->readListBegin($_etype797, $_size794); + for ($_i798 = 0; $_i798 < $_size794; ++$_i798) { - $elem792 = null; - $elem792 = new \metastore\Table(); - $xfer += $elem792->read($input); - $this->success []= $elem792; + $elem799 = null; + $elem799 = new \metastore\Table(); + $xfer += $elem799->read($input); + $this->success []= $elem799; } $xfer += $input->readListEnd(); } else { @@ -18351,9 +18623,9 @@ class ThriftHiveMetastore_get_table_objects_by_name_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter793) + foreach ($this->success as $iter800) { - $xfer += $iter793->write($output); + $xfer += $iter800->write($output); } } $output->writeListEnd(); @@ -19019,14 +19291,14 @@ class ThriftHiveMetastore_get_table_names_by_filter_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size794 = 0; - $_etype797 = 0; - $xfer += $input->readListBegin($_etype797, $_size794); - for ($_i798 = 0; $_i798 < $_size794; ++$_i798) + $_size801 = 0; + $_etype804 = 0; + $xfer += $input->readListBegin($_etype804, $_size801); + for ($_i805 = 0; $_i805 < $_size801; ++$_i805) { - $elem799 = null; - $xfer += $input->readString($elem799); - $this->success []= $elem799; + $elem806 = null; + $xfer += $input->readString($elem806); + $this->success []= $elem806; } $xfer += $input->readListEnd(); } else { @@ -19078,9 +19350,9 @@ class ThriftHiveMetastore_get_table_names_by_filter_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter800) + foreach ($this->success as $iter807) { - $xfer += $output->writeString($iter800); + $xfer += $output->writeString($iter807); } } $output->writeListEnd(); @@ -20393,15 +20665,15 @@ class ThriftHiveMetastore_add_partitions_args { case 1: if ($ftype == TType::LST) { $this->new_parts = array(); - $_size801 = 0; - $_etype804 = 0; - $xfer += $input->readListBegin($_etype804, $_size801); - for ($_i805 = 0; $_i805 < $_size801; ++$_i805) + $_size808 = 0; + $_etype811 = 0; + $xfer += $input->readListBegin($_etype811, $_size808); + for ($_i812 = 0; $_i812 < $_size808; ++$_i812) { - $elem806 = null; - $elem806 = new \metastore\Partition(); - $xfer += $elem806->read($input); - $this->new_parts []= $elem806; + $elem813 = null; + $elem813 = new \metastore\Partition(); + $xfer += $elem813->read($input); + $this->new_parts []= $elem813; } $xfer += $input->readListEnd(); } else { @@ -20429,9 +20701,9 @@ class ThriftHiveMetastore_add_partitions_args { { $output->writeListBegin(TType::STRUCT, count($this->new_parts)); { - foreach ($this->new_parts as $iter807) + foreach ($this->new_parts as $iter814) { - $xfer += $iter807->write($output); + $xfer += $iter814->write($output); } } $output->writeListEnd(); @@ -20646,15 +20918,15 @@ class ThriftHiveMetastore_add_partitions_pspec_args { case 1: if ($ftype == TType::LST) { $this->new_parts = array(); - $_size808 = 0; - $_etype811 = 0; - $xfer += $input->readListBegin($_etype811, $_size808); - for ($_i812 = 0; $_i812 < $_size808; ++$_i812) + $_size815 = 0; + $_etype818 = 0; + $xfer += $input->readListBegin($_etype818, $_size815); + for ($_i819 = 0; $_i819 < $_size815; ++$_i819) { - $elem813 = null; - $elem813 = new \metastore\PartitionSpec(); - $xfer += $elem813->read($input); - $this->new_parts []= $elem813; + $elem820 = null; + $elem820 = new \metastore\PartitionSpec(); + $xfer += $elem820->read($input); + $this->new_parts []= $elem820; } $xfer += $input->readListEnd(); } else { @@ -20682,9 +20954,9 @@ class ThriftHiveMetastore_add_partitions_pspec_args { { $output->writeListBegin(TType::STRUCT, count($this->new_parts)); { - foreach ($this->new_parts as $iter814) + foreach ($this->new_parts as $iter821) { - $xfer += $iter814->write($output); + $xfer += $iter821->write($output); } } $output->writeListEnd(); @@ -20934,14 +21206,14 @@ class ThriftHiveMetastore_append_partition_args { case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size815 = 0; - $_etype818 = 0; - $xfer += $input->readListBegin($_etype818, $_size815); - for ($_i819 = 0; $_i819 < $_size815; ++$_i819) + $_size822 = 0; + $_etype825 = 0; + $xfer += $input->readListBegin($_etype825, $_size822); + for ($_i826 = 0; $_i826 < $_size822; ++$_i826) { - $elem820 = null; - $xfer += $input->readString($elem820); - $this->part_vals []= $elem820; + $elem827 = null; + $xfer += $input->readString($elem827); + $this->part_vals []= $elem827; } $xfer += $input->readListEnd(); } else { @@ -20979,9 +21251,9 @@ class ThriftHiveMetastore_append_partition_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter821) + foreach ($this->part_vals as $iter828) { - $xfer += $output->writeString($iter821); + $xfer += $output->writeString($iter828); } } $output->writeListEnd(); @@ -21483,14 +21755,14 @@ class ThriftHiveMetastore_append_partition_with_environment_context_args { case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size822 = 0; - $_etype825 = 0; - $xfer += $input->readListBegin($_etype825, $_size822); - for ($_i826 = 0; $_i826 < $_size822; ++$_i826) + $_size829 = 0; + $_etype832 = 0; + $xfer += $input->readListBegin($_etype832, $_size829); + for ($_i833 = 0; $_i833 < $_size829; ++$_i833) { - $elem827 = null; - $xfer += $input->readString($elem827); - $this->part_vals []= $elem827; + $elem834 = null; + $xfer += $input->readString($elem834); + $this->part_vals []= $elem834; } $xfer += $input->readListEnd(); } else { @@ -21536,9 +21808,9 @@ class ThriftHiveMetastore_append_partition_with_environment_context_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter828) + foreach ($this->part_vals as $iter835) { - $xfer += $output->writeString($iter828); + $xfer += $output->writeString($iter835); } } $output->writeListEnd(); @@ -22392,14 +22664,14 @@ class ThriftHiveMetastore_drop_partition_args { case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size829 = 0; - $_etype832 = 0; - $xfer += $input->readListBegin($_etype832, $_size829); - for ($_i833 = 0; $_i833 < $_size829; ++$_i833) + $_size836 = 0; + $_etype839 = 0; + $xfer += $input->readListBegin($_etype839, $_size836); + for ($_i840 = 0; $_i840 < $_size836; ++$_i840) { - $elem834 = null; - $xfer += $input->readString($elem834); - $this->part_vals []= $elem834; + $elem841 = null; + $xfer += $input->readString($elem841); + $this->part_vals []= $elem841; } $xfer += $input->readListEnd(); } else { @@ -22444,9 +22716,9 @@ class ThriftHiveMetastore_drop_partition_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter835) + foreach ($this->part_vals as $iter842) { - $xfer += $output->writeString($iter835); + $xfer += $output->writeString($iter842); } } $output->writeListEnd(); @@ -22699,14 +22971,14 @@ class ThriftHiveMetastore_drop_partition_with_environment_context_args { case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size836 = 0; - $_etype839 = 0; - $xfer += $input->readListBegin($_etype839, $_size836); - for ($_i840 = 0; $_i840 < $_size836; ++$_i840) + $_size843 = 0; + $_etype846 = 0; + $xfer += $input->readListBegin($_etype846, $_size843); + for ($_i847 = 0; $_i847 < $_size843; ++$_i847) { - $elem841 = null; - $xfer += $input->readString($elem841); - $this->part_vals []= $elem841; + $elem848 = null; + $xfer += $input->readString($elem848); + $this->part_vals []= $elem848; } $xfer += $input->readListEnd(); } else { @@ -22759,9 +23031,9 @@ class ThriftHiveMetastore_drop_partition_with_environment_context_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter842) + foreach ($this->part_vals as $iter849) { - $xfer += $output->writeString($iter842); + $xfer += $output->writeString($iter849); } } $output->writeListEnd(); @@ -23775,14 +24047,14 @@ class ThriftHiveMetastore_get_partition_args { case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size843 = 0; - $_etype846 = 0; - $xfer += $input->readListBegin($_etype846, $_size843); - for ($_i847 = 0; $_i847 < $_size843; ++$_i847) + $_size850 = 0; + $_etype853 = 0; + $xfer += $input->readListBegin($_etype853, $_size850); + for ($_i854 = 0; $_i854 < $_size850; ++$_i854) { - $elem848 = null; - $xfer += $input->readString($elem848); - $this->part_vals []= $elem848; + $elem855 = null; + $xfer += $input->readString($elem855); + $this->part_vals []= $elem855; } $xfer += $input->readListEnd(); } else { @@ -23820,9 +24092,9 @@ class ThriftHiveMetastore_get_partition_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter849) + foreach ($this->part_vals as $iter856) { - $xfer += $output->writeString($iter849); + $xfer += $output->writeString($iter856); } } $output->writeListEnd(); @@ -24064,17 +24336,17 @@ class ThriftHiveMetastore_exchange_partition_args { case 1: if ($ftype == TType::MAP) { $this->partitionSpecs = array(); - $_size850 = 0; - $_ktype851 = 0; - $_vtype852 = 0; - $xfer += $input->readMapBegin($_ktype851, $_vtype852, $_size850); - for ($_i854 = 0; $_i854 < $_size850; ++$_i854) + $_size857 = 0; + $_ktype858 = 0; + $_vtype859 = 0; + $xfer += $input->readMapBegin($_ktype858, $_vtype859, $_size857); + for ($_i861 = 0; $_i861 < $_size857; ++$_i861) { - $key855 = ''; - $val856 = ''; - $xfer += $input->readString($key855); - $xfer += $input->readString($val856); - $this->partitionSpecs[$key855] = $val856; + $key862 = ''; + $val863 = ''; + $xfer += $input->readString($key862); + $xfer += $input->readString($val863); + $this->partitionSpecs[$key862] = $val863; } $xfer += $input->readMapEnd(); } else { @@ -24130,10 +24402,10 @@ class ThriftHiveMetastore_exchange_partition_args { { $output->writeMapBegin(TType::STRING, TType::STRING, count($this->partitionSpecs)); { - foreach ($this->partitionSpecs as $kiter857 => $viter858) + foreach ($this->partitionSpecs as $kiter864 => $viter865) { - $xfer += $output->writeString($kiter857); - $xfer += $output->writeString($viter858); + $xfer += $output->writeString($kiter864); + $xfer += $output->writeString($viter865); } } $output->writeMapEnd(); @@ -24445,17 +24717,17 @@ class ThriftHiveMetastore_exchange_partitions_args { case 1: if ($ftype == TType::MAP) { $this->partitionSpecs = array(); - $_size859 = 0; - $_ktype860 = 0; - $_vtype861 = 0; - $xfer += $input->readMapBegin($_ktype860, $_vtype861, $_size859); - for ($_i863 = 0; $_i863 < $_size859; ++$_i863) + $_size866 = 0; + $_ktype867 = 0; + $_vtype868 = 0; + $xfer += $input->readMapBegin($_ktype867, $_vtype868, $_size866); + for ($_i870 = 0; $_i870 < $_size866; ++$_i870) { - $key864 = ''; - $val865 = ''; - $xfer += $input->readString($key864); - $xfer += $input->readString($val865); - $this->partitionSpecs[$key864] = $val865; + $key871 = ''; + $val872 = ''; + $xfer += $input->readString($key871); + $xfer += $input->readString($val872); + $this->partitionSpecs[$key871] = $val872; } $xfer += $input->readMapEnd(); } else { @@ -24511,10 +24783,10 @@ class ThriftHiveMetastore_exchange_partitions_args { { $output->writeMapBegin(TType::STRING, TType::STRING, count($this->partitionSpecs)); { - foreach ($this->partitionSpecs as $kiter866 => $viter867) + foreach ($this->partitionSpecs as $kiter873 => $viter874) { - $xfer += $output->writeString($kiter866); - $xfer += $output->writeString($viter867); + $xfer += $output->writeString($kiter873); + $xfer += $output->writeString($viter874); } } $output->writeMapEnd(); @@ -24647,15 +24919,15 @@ class ThriftHiveMetastore_exchange_partitions_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size868 = 0; - $_etype871 = 0; - $xfer += $input->readListBegin($_etype871, $_size868); - for ($_i872 = 0; $_i872 < $_size868; ++$_i872) + $_size875 = 0; + $_etype878 = 0; + $xfer += $input->readListBegin($_etype878, $_size875); + for ($_i879 = 0; $_i879 < $_size875; ++$_i879) { - $elem873 = null; - $elem873 = new \metastore\Partition(); - $xfer += $elem873->read($input); - $this->success []= $elem873; + $elem880 = null; + $elem880 = new \metastore\Partition(); + $xfer += $elem880->read($input); + $this->success []= $elem880; } $xfer += $input->readListEnd(); } else { @@ -24715,9 +24987,9 @@ class ThriftHiveMetastore_exchange_partitions_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter874) + foreach ($this->success as $iter881) { - $xfer += $iter874->write($output); + $xfer += $iter881->write($output); } } $output->writeListEnd(); @@ -24863,14 +25135,14 @@ class ThriftHiveMetastore_get_partition_with_auth_args { case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size875 = 0; - $_etype878 = 0; - $xfer += $input->readListBegin($_etype878, $_size875); - for ($_i879 = 0; $_i879 < $_size875; ++$_i879) + $_size882 = 0; + $_etype885 = 0; + $xfer += $input->readListBegin($_etype885, $_size882); + for ($_i886 = 0; $_i886 < $_size882; ++$_i886) { - $elem880 = null; - $xfer += $input->readString($elem880); - $this->part_vals []= $elem880; + $elem887 = null; + $xfer += $input->readString($elem887); + $this->part_vals []= $elem887; } $xfer += $input->readListEnd(); } else { @@ -24887,14 +25159,14 @@ class ThriftHiveMetastore_get_partition_with_auth_args { case 5: if ($ftype == TType::LST) { $this->group_names = array(); - $_size881 = 0; - $_etype884 = 0; - $xfer += $input->readListBegin($_etype884, $_size881); - for ($_i885 = 0; $_i885 < $_size881; ++$_i885) + $_size888 = 0; + $_etype891 = 0; + $xfer += $input->readListBegin($_etype891, $_size888); + for ($_i892 = 0; $_i892 < $_size888; ++$_i892) { - $elem886 = null; - $xfer += $input->readString($elem886); - $this->group_names []= $elem886; + $elem893 = null; + $xfer += $input->readString($elem893); + $this->group_names []= $elem893; } $xfer += $input->readListEnd(); } else { @@ -24932,9 +25204,9 @@ class ThriftHiveMetastore_get_partition_with_auth_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter887) + foreach ($this->part_vals as $iter894) { - $xfer += $output->writeString($iter887); + $xfer += $output->writeString($iter894); } } $output->writeListEnd(); @@ -24954,9 +25226,9 @@ class ThriftHiveMetastore_get_partition_with_auth_args { { $output->writeListBegin(TType::STRING, count($this->group_names)); { - foreach ($this->group_names as $iter888) + foreach ($this->group_names as $iter895) { - $xfer += $output->writeString($iter888); + $xfer += $output->writeString($iter895); } } $output->writeListEnd(); @@ -25547,15 +25819,15 @@ class ThriftHiveMetastore_get_partitions_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size889 = 0; - $_etype892 = 0; - $xfer += $input->readListBegin($_etype892, $_size889); - for ($_i893 = 0; $_i893 < $_size889; ++$_i893) + $_size896 = 0; + $_etype899 = 0; + $xfer += $input->readListBegin($_etype899, $_size896); + for ($_i900 = 0; $_i900 < $_size896; ++$_i900) { - $elem894 = null; - $elem894 = new \metastore\Partition(); - $xfer += $elem894->read($input); - $this->success []= $elem894; + $elem901 = null; + $elem901 = new \metastore\Partition(); + $xfer += $elem901->read($input); + $this->success []= $elem901; } $xfer += $input->readListEnd(); } else { @@ -25599,9 +25871,9 @@ class ThriftHiveMetastore_get_partitions_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter895) + foreach ($this->success as $iter902) { - $xfer += $iter895->write($output); + $xfer += $iter902->write($output); } } $output->writeListEnd(); @@ -25747,14 +26019,14 @@ class ThriftHiveMetastore_get_partitions_with_auth_args { case 5: if ($ftype == TType::LST) { $this->group_names = array(); - $_size896 = 0; - $_etype899 = 0; - $xfer += $input->readListBegin($_etype899, $_size896); - for ($_i900 = 0; $_i900 < $_size896; ++$_i900) + $_size903 = 0; + $_etype906 = 0; + $xfer += $input->readListBegin($_etype906, $_size903); + for ($_i907 = 0; $_i907 < $_size903; ++$_i907) { - $elem901 = null; - $xfer += $input->readString($elem901); - $this->group_names []= $elem901; + $elem908 = null; + $xfer += $input->readString($elem908); + $this->group_names []= $elem908; } $xfer += $input->readListEnd(); } else { @@ -25802,9 +26074,9 @@ class ThriftHiveMetastore_get_partitions_with_auth_args { { $output->writeListBegin(TType::STRING, count($this->group_names)); { - foreach ($this->group_names as $iter902) + foreach ($this->group_names as $iter909) { - $xfer += $output->writeString($iter902); + $xfer += $output->writeString($iter909); } } $output->writeListEnd(); @@ -25893,15 +26165,15 @@ class ThriftHiveMetastore_get_partitions_with_auth_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size903 = 0; - $_etype906 = 0; - $xfer += $input->readListBegin($_etype906, $_size903); - for ($_i907 = 0; $_i907 < $_size903; ++$_i907) + $_size910 = 0; + $_etype913 = 0; + $xfer += $input->readListBegin($_etype913, $_size910); + for ($_i914 = 0; $_i914 < $_size910; ++$_i914) { - $elem908 = null; - $elem908 = new \metastore\Partition(); - $xfer += $elem908->read($input); - $this->success []= $elem908; + $elem915 = null; + $elem915 = new \metastore\Partition(); + $xfer += $elem915->read($input); + $this->success []= $elem915; } $xfer += $input->readListEnd(); } else { @@ -25945,9 +26217,9 @@ class ThriftHiveMetastore_get_partitions_with_auth_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter909) + foreach ($this->success as $iter916) { - $xfer += $iter909->write($output); + $xfer += $iter916->write($output); } } $output->writeListEnd(); @@ -26167,15 +26439,15 @@ class ThriftHiveMetastore_get_partitions_pspec_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size910 = 0; - $_etype913 = 0; - $xfer += $input->readListBegin($_etype913, $_size910); - for ($_i914 = 0; $_i914 < $_size910; ++$_i914) + $_size917 = 0; + $_etype920 = 0; + $xfer += $input->readListBegin($_etype920, $_size917); + for ($_i921 = 0; $_i921 < $_size917; ++$_i921) { - $elem915 = null; - $elem915 = new \metastore\PartitionSpec(); - $xfer += $elem915->read($input); - $this->success []= $elem915; + $elem922 = null; + $elem922 = new \metastore\PartitionSpec(); + $xfer += $elem922->read($input); + $this->success []= $elem922; } $xfer += $input->readListEnd(); } else { @@ -26219,9 +26491,9 @@ class ThriftHiveMetastore_get_partitions_pspec_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter916) + foreach ($this->success as $iter923) { - $xfer += $iter916->write($output); + $xfer += $iter923->write($output); } } $output->writeListEnd(); @@ -26440,14 +26712,14 @@ class ThriftHiveMetastore_get_partition_names_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size917 = 0; - $_etype920 = 0; - $xfer += $input->readListBegin($_etype920, $_size917); - for ($_i921 = 0; $_i921 < $_size917; ++$_i921) + $_size924 = 0; + $_etype927 = 0; + $xfer += $input->readListBegin($_etype927, $_size924); + for ($_i928 = 0; $_i928 < $_size924; ++$_i928) { - $elem922 = null; - $xfer += $input->readString($elem922); - $this->success []= $elem922; + $elem929 = null; + $xfer += $input->readString($elem929); + $this->success []= $elem929; } $xfer += $input->readListEnd(); } else { @@ -26491,9 +26763,9 @@ class ThriftHiveMetastore_get_partition_names_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter923) + foreach ($this->success as $iter930) { - $xfer += $output->writeString($iter923); + $xfer += $output->writeString($iter930); } } $output->writeListEnd(); @@ -26824,14 +27096,14 @@ class ThriftHiveMetastore_get_partitions_ps_args { case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size924 = 0; - $_etype927 = 0; - $xfer += $input->readListBegin($_etype927, $_size924); - for ($_i928 = 0; $_i928 < $_size924; ++$_i928) + $_size931 = 0; + $_etype934 = 0; + $xfer += $input->readListBegin($_etype934, $_size931); + for ($_i935 = 0; $_i935 < $_size931; ++$_i935) { - $elem929 = null; - $xfer += $input->readString($elem929); - $this->part_vals []= $elem929; + $elem936 = null; + $xfer += $input->readString($elem936); + $this->part_vals []= $elem936; } $xfer += $input->readListEnd(); } else { @@ -26876,9 +27148,9 @@ class ThriftHiveMetastore_get_partitions_ps_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter930) + foreach ($this->part_vals as $iter937) { - $xfer += $output->writeString($iter930); + $xfer += $output->writeString($iter937); } } $output->writeListEnd(); @@ -26972,15 +27244,15 @@ class ThriftHiveMetastore_get_partitions_ps_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size931 = 0; - $_etype934 = 0; - $xfer += $input->readListBegin($_etype934, $_size931); - for ($_i935 = 0; $_i935 < $_size931; ++$_i935) + $_size938 = 0; + $_etype941 = 0; + $xfer += $input->readListBegin($_etype941, $_size938); + for ($_i942 = 0; $_i942 < $_size938; ++$_i942) { - $elem936 = null; - $elem936 = new \metastore\Partition(); - $xfer += $elem936->read($input); - $this->success []= $elem936; + $elem943 = null; + $elem943 = new \metastore\Partition(); + $xfer += $elem943->read($input); + $this->success []= $elem943; } $xfer += $input->readListEnd(); } else { @@ -27024,9 +27296,9 @@ class ThriftHiveMetastore_get_partitions_ps_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter937) + foreach ($this->success as $iter944) { - $xfer += $iter937->write($output); + $xfer += $iter944->write($output); } } $output->writeListEnd(); @@ -27173,14 +27445,14 @@ class ThriftHiveMetastore_get_partitions_ps_with_auth_args { case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size938 = 0; - $_etype941 = 0; - $xfer += $input->readListBegin($_etype941, $_size938); - for ($_i942 = 0; $_i942 < $_size938; ++$_i942) + $_size945 = 0; + $_etype948 = 0; + $xfer += $input->readListBegin($_etype948, $_size945); + for ($_i949 = 0; $_i949 < $_size945; ++$_i949) { - $elem943 = null; - $xfer += $input->readString($elem943); - $this->part_vals []= $elem943; + $elem950 = null; + $xfer += $input->readString($elem950); + $this->part_vals []= $elem950; } $xfer += $input->readListEnd(); } else { @@ -27204,14 +27476,14 @@ class ThriftHiveMetastore_get_partitions_ps_with_auth_args { case 6: if ($ftype == TType::LST) { $this->group_names = array(); - $_size944 = 0; - $_etype947 = 0; - $xfer += $input->readListBegin($_etype947, $_size944); - for ($_i948 = 0; $_i948 < $_size944; ++$_i948) + $_size951 = 0; + $_etype954 = 0; + $xfer += $input->readListBegin($_etype954, $_size951); + for ($_i955 = 0; $_i955 < $_size951; ++$_i955) { - $elem949 = null; - $xfer += $input->readString($elem949); - $this->group_names []= $elem949; + $elem956 = null; + $xfer += $input->readString($elem956); + $this->group_names []= $elem956; } $xfer += $input->readListEnd(); } else { @@ -27249,9 +27521,9 @@ class ThriftHiveMetastore_get_partitions_ps_with_auth_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter950) + foreach ($this->part_vals as $iter957) { - $xfer += $output->writeString($iter950); + $xfer += $output->writeString($iter957); } } $output->writeListEnd(); @@ -27276,9 +27548,9 @@ class ThriftHiveMetastore_get_partitions_ps_with_auth_args { { $output->writeListBegin(TType::STRING, count($this->group_names)); { - foreach ($this->group_names as $iter951) + foreach ($this->group_names as $iter958) { - $xfer += $output->writeString($iter951); + $xfer += $output->writeString($iter958); } } $output->writeListEnd(); @@ -27367,15 +27639,15 @@ class ThriftHiveMetastore_get_partitions_ps_with_auth_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size952 = 0; - $_etype955 = 0; - $xfer += $input->readListBegin($_etype955, $_size952); - for ($_i956 = 0; $_i956 < $_size952; ++$_i956) + $_size959 = 0; + $_etype962 = 0; + $xfer += $input->readListBegin($_etype962, $_size959); + for ($_i963 = 0; $_i963 < $_size959; ++$_i963) { - $elem957 = null; - $elem957 = new \metastore\Partition(); - $xfer += $elem957->read($input); - $this->success []= $elem957; + $elem964 = null; + $elem964 = new \metastore\Partition(); + $xfer += $elem964->read($input); + $this->success []= $elem964; } $xfer += $input->readListEnd(); } else { @@ -27419,9 +27691,9 @@ class ThriftHiveMetastore_get_partitions_ps_with_auth_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter958) + foreach ($this->success as $iter965) { - $xfer += $iter958->write($output); + $xfer += $iter965->write($output); } } $output->writeListEnd(); @@ -27542,14 +27814,14 @@ class ThriftHiveMetastore_get_partition_names_ps_args { case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size959 = 0; - $_etype962 = 0; - $xfer += $input->readListBegin($_etype962, $_size959); - for ($_i963 = 0; $_i963 < $_size959; ++$_i963) + $_size966 = 0; + $_etype969 = 0; + $xfer += $input->readListBegin($_etype969, $_size966); + for ($_i970 = 0; $_i970 < $_size966; ++$_i970) { - $elem964 = null; - $xfer += $input->readString($elem964); - $this->part_vals []= $elem964; + $elem971 = null; + $xfer += $input->readString($elem971); + $this->part_vals []= $elem971; } $xfer += $input->readListEnd(); } else { @@ -27594,9 +27866,9 @@ class ThriftHiveMetastore_get_partition_names_ps_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter965) + foreach ($this->part_vals as $iter972) { - $xfer += $output->writeString($iter965); + $xfer += $output->writeString($iter972); } } $output->writeListEnd(); @@ -27689,14 +27961,14 @@ class ThriftHiveMetastore_get_partition_names_ps_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size966 = 0; - $_etype969 = 0; - $xfer += $input->readListBegin($_etype969, $_size966); - for ($_i970 = 0; $_i970 < $_size966; ++$_i970) + $_size973 = 0; + $_etype976 = 0; + $xfer += $input->readListBegin($_etype976, $_size973); + for ($_i977 = 0; $_i977 < $_size973; ++$_i977) { - $elem971 = null; - $xfer += $input->readString($elem971); - $this->success []= $elem971; + $elem978 = null; + $xfer += $input->readString($elem978); + $this->success []= $elem978; } $xfer += $input->readListEnd(); } else { @@ -27740,9 +28012,9 @@ class ThriftHiveMetastore_get_partition_names_ps_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter972) + foreach ($this->success as $iter979) { - $xfer += $output->writeString($iter972); + $xfer += $output->writeString($iter979); } } $output->writeListEnd(); @@ -27985,15 +28257,15 @@ class ThriftHiveMetastore_get_partitions_by_filter_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size973 = 0; - $_etype976 = 0; - $xfer += $input->readListBegin($_etype976, $_size973); - for ($_i977 = 0; $_i977 < $_size973; ++$_i977) + $_size980 = 0; + $_etype983 = 0; + $xfer += $input->readListBegin($_etype983, $_size980); + for ($_i984 = 0; $_i984 < $_size980; ++$_i984) { - $elem978 = null; - $elem978 = new \metastore\Partition(); - $xfer += $elem978->read($input); - $this->success []= $elem978; + $elem985 = null; + $elem985 = new \metastore\Partition(); + $xfer += $elem985->read($input); + $this->success []= $elem985; } $xfer += $input->readListEnd(); } else { @@ -28037,9 +28309,9 @@ class ThriftHiveMetastore_get_partitions_by_filter_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter979) + foreach ($this->success as $iter986) { - $xfer += $iter979->write($output); + $xfer += $iter986->write($output); } } $output->writeListEnd(); @@ -28282,15 +28554,15 @@ class ThriftHiveMetastore_get_part_specs_by_filter_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size980 = 0; - $_etype983 = 0; - $xfer += $input->readListBegin($_etype983, $_size980); - for ($_i984 = 0; $_i984 < $_size980; ++$_i984) + $_size987 = 0; + $_etype990 = 0; + $xfer += $input->readListBegin($_etype990, $_size987); + for ($_i991 = 0; $_i991 < $_size987; ++$_i991) { - $elem985 = null; - $elem985 = new \metastore\PartitionSpec(); - $xfer += $elem985->read($input); - $this->success []= $elem985; + $elem992 = null; + $elem992 = new \metastore\PartitionSpec(); + $xfer += $elem992->read($input); + $this->success []= $elem992; } $xfer += $input->readListEnd(); } else { @@ -28334,9 +28606,9 @@ class ThriftHiveMetastore_get_part_specs_by_filter_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter986) + foreach ($this->success as $iter993) { - $xfer += $iter986->write($output); + $xfer += $iter993->write($output); } } $output->writeListEnd(); @@ -28902,14 +29174,14 @@ class ThriftHiveMetastore_get_partitions_by_names_args { case 3: if ($ftype == TType::LST) { $this->names = array(); - $_size987 = 0; - $_etype990 = 0; - $xfer += $input->readListBegin($_etype990, $_size987); - for ($_i991 = 0; $_i991 < $_size987; ++$_i991) + $_size994 = 0; + $_etype997 = 0; + $xfer += $input->readListBegin($_etype997, $_size994); + for ($_i998 = 0; $_i998 < $_size994; ++$_i998) { - $elem992 = null; - $xfer += $input->readString($elem992); - $this->names []= $elem992; + $elem999 = null; + $xfer += $input->readString($elem999); + $this->names []= $elem999; } $xfer += $input->readListEnd(); } else { @@ -28947,9 +29219,9 @@ class ThriftHiveMetastore_get_partitions_by_names_args { { $output->writeListBegin(TType::STRING, count($this->names)); { - foreach ($this->names as $iter993) + foreach ($this->names as $iter1000) { - $xfer += $output->writeString($iter993); + $xfer += $output->writeString($iter1000); } } $output->writeListEnd(); @@ -29038,15 +29310,15 @@ class ThriftHiveMetastore_get_partitions_by_names_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size994 = 0; - $_etype997 = 0; - $xfer += $input->readListBegin($_etype997, $_size994); - for ($_i998 = 0; $_i998 < $_size994; ++$_i998) + $_size1001 = 0; + $_etype1004 = 0; + $xfer += $input->readListBegin($_etype1004, $_size1001); + for ($_i1005 = 0; $_i1005 < $_size1001; ++$_i1005) { - $elem999 = null; - $elem999 = new \metastore\Partition(); - $xfer += $elem999->read($input); - $this->success []= $elem999; + $elem1006 = null; + $elem1006 = new \metastore\Partition(); + $xfer += $elem1006->read($input); + $this->success []= $elem1006; } $xfer += $input->readListEnd(); } else { @@ -29090,9 +29362,9 @@ class ThriftHiveMetastore_get_partitions_by_names_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter1000) + foreach ($this->success as $iter1007) { - $xfer += $iter1000->write($output); + $xfer += $iter1007->write($output); } } $output->writeListEnd(); @@ -29431,15 +29703,15 @@ class ThriftHiveMetastore_alter_partitions_args { case 3: if ($ftype == TType::LST) { $this->new_parts = array(); - $_size1001 = 0; - $_etype1004 = 0; - $xfer += $input->readListBegin($_etype1004, $_size1001); - for ($_i1005 = 0; $_i1005 < $_size1001; ++$_i1005) + $_size1008 = 0; + $_etype1011 = 0; + $xfer += $input->readListBegin($_etype1011, $_size1008); + for ($_i1012 = 0; $_i1012 < $_size1008; ++$_i1012) { - $elem1006 = null; - $elem1006 = new \metastore\Partition(); - $xfer += $elem1006->read($input); - $this->new_parts []= $elem1006; + $elem1013 = null; + $elem1013 = new \metastore\Partition(); + $xfer += $elem1013->read($input); + $this->new_parts []= $elem1013; } $xfer += $input->readListEnd(); } else { @@ -29477,9 +29749,9 @@ class ThriftHiveMetastore_alter_partitions_args { { $output->writeListBegin(TType::STRUCT, count($this->new_parts)); { - foreach ($this->new_parts as $iter1007) + foreach ($this->new_parts as $iter1014) { - $xfer += $iter1007->write($output); + $xfer += $iter1014->write($output); } } $output->writeListEnd(); @@ -29694,15 +29966,15 @@ class ThriftHiveMetastore_alter_partitions_with_environment_context_args { case 3: if ($ftype == TType::LST) { $this->new_parts = array(); - $_size1008 = 0; - $_etype1011 = 0; - $xfer += $input->readListBegin($_etype1011, $_size1008); - for ($_i1012 = 0; $_i1012 < $_size1008; ++$_i1012) + $_size1015 = 0; + $_etype1018 = 0; + $xfer += $input->readListBegin($_etype1018, $_size1015); + for ($_i1019 = 0; $_i1019 < $_size1015; ++$_i1019) { - $elem1013 = null; - $elem1013 = new \metastore\Partition(); - $xfer += $elem1013->read($input); - $this->new_parts []= $elem1013; + $elem1020 = null; + $elem1020 = new \metastore\Partition(); + $xfer += $elem1020->read($input); + $this->new_parts []= $elem1020; } $xfer += $input->readListEnd(); } else { @@ -29748,9 +30020,9 @@ class ThriftHiveMetastore_alter_partitions_with_environment_context_args { { $output->writeListBegin(TType::STRUCT, count($this->new_parts)); { - foreach ($this->new_parts as $iter1014) + foreach ($this->new_parts as $iter1021) { - $xfer += $iter1014->write($output); + $xfer += $iter1021->write($output); } } $output->writeListEnd(); @@ -30228,14 +30500,14 @@ class ThriftHiveMetastore_rename_partition_args { case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size1015 = 0; - $_etype1018 = 0; - $xfer += $input->readListBegin($_etype1018, $_size1015); - for ($_i1019 = 0; $_i1019 < $_size1015; ++$_i1019) + $_size1022 = 0; + $_etype1025 = 0; + $xfer += $input->readListBegin($_etype1025, $_size1022); + for ($_i1026 = 0; $_i1026 < $_size1022; ++$_i1026) { - $elem1020 = null; - $xfer += $input->readString($elem1020); - $this->part_vals []= $elem1020; + $elem1027 = null; + $xfer += $input->readString($elem1027); + $this->part_vals []= $elem1027; } $xfer += $input->readListEnd(); } else { @@ -30281,9 +30553,9 @@ class ThriftHiveMetastore_rename_partition_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter1021) + foreach ($this->part_vals as $iter1028) { - $xfer += $output->writeString($iter1021); + $xfer += $output->writeString($iter1028); } } $output->writeListEnd(); @@ -30468,14 +30740,14 @@ class ThriftHiveMetastore_partition_name_has_valid_characters_args { case 1: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size1022 = 0; - $_etype1025 = 0; - $xfer += $input->readListBegin($_etype1025, $_size1022); - for ($_i1026 = 0; $_i1026 < $_size1022; ++$_i1026) + $_size1029 = 0; + $_etype1032 = 0; + $xfer += $input->readListBegin($_etype1032, $_size1029); + for ($_i1033 = 0; $_i1033 < $_size1029; ++$_i1033) { - $elem1027 = null; - $xfer += $input->readString($elem1027); - $this->part_vals []= $elem1027; + $elem1034 = null; + $xfer += $input->readString($elem1034); + $this->part_vals []= $elem1034; } $xfer += $input->readListEnd(); } else { @@ -30510,9 +30782,9 @@ class ThriftHiveMetastore_partition_name_has_valid_characters_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter1028) + foreach ($this->part_vals as $iter1035) { - $xfer += $output->writeString($iter1028); + $xfer += $output->writeString($iter1035); } } $output->writeListEnd(); @@ -30966,14 +31238,14 @@ class ThriftHiveMetastore_partition_name_to_vals_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size1029 = 0; - $_etype1032 = 0; - $xfer += $input->readListBegin($_etype1032, $_size1029); - for ($_i1033 = 0; $_i1033 < $_size1029; ++$_i1033) + $_size1036 = 0; + $_etype1039 = 0; + $xfer += $input->readListBegin($_etype1039, $_size1036); + for ($_i1040 = 0; $_i1040 < $_size1036; ++$_i1040) { - $elem1034 = null; - $xfer += $input->readString($elem1034); - $this->success []= $elem1034; + $elem1041 = null; + $xfer += $input->readString($elem1041); + $this->success []= $elem1041; } $xfer += $input->readListEnd(); } else { @@ -31009,9 +31281,9 @@ class ThriftHiveMetastore_partition_name_to_vals_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter1035) + foreach ($this->success as $iter1042) { - $xfer += $output->writeString($iter1035); + $xfer += $output->writeString($iter1042); } } $output->writeListEnd(); @@ -31171,17 +31443,17 @@ class ThriftHiveMetastore_partition_name_to_spec_result { case 0: if ($ftype == TType::MAP) { $this->success = array(); - $_size1036 = 0; - $_ktype1037 = 0; - $_vtype1038 = 0; - $xfer += $input->readMapBegin($_ktype1037, $_vtype1038, $_size1036); - for ($_i1040 = 0; $_i1040 < $_size1036; ++$_i1040) + $_size1043 = 0; + $_ktype1044 = 0; + $_vtype1045 = 0; + $xfer += $input->readMapBegin($_ktype1044, $_vtype1045, $_size1043); + for ($_i1047 = 0; $_i1047 < $_size1043; ++$_i1047) { - $key1041 = ''; - $val1042 = ''; - $xfer += $input->readString($key1041); - $xfer += $input->readString($val1042); - $this->success[$key1041] = $val1042; + $key1048 = ''; + $val1049 = ''; + $xfer += $input->readString($key1048); + $xfer += $input->readString($val1049); + $this->success[$key1048] = $val1049; } $xfer += $input->readMapEnd(); } else { @@ -31217,10 +31489,10 @@ class ThriftHiveMetastore_partition_name_to_spec_result { { $output->writeMapBegin(TType::STRING, TType::STRING, count($this->success)); { - foreach ($this->success as $kiter1043 => $viter1044) + foreach ($this->success as $kiter1050 => $viter1051) { - $xfer += $output->writeString($kiter1043); - $xfer += $output->writeString($viter1044); + $xfer += $output->writeString($kiter1050); + $xfer += $output->writeString($viter1051); } } $output->writeMapEnd(); @@ -31340,17 +31612,17 @@ class ThriftHiveMetastore_markPartitionForEvent_args { case 3: if ($ftype == TType::MAP) { $this->part_vals = array(); - $_size1045 = 0; - $_ktype1046 = 0; - $_vtype1047 = 0; - $xfer += $input->readMapBegin($_ktype1046, $_vtype1047, $_size1045); - for ($_i1049 = 0; $_i1049 < $_size1045; ++$_i1049) + $_size1052 = 0; + $_ktype1053 = 0; + $_vtype1054 = 0; + $xfer += $input->readMapBegin($_ktype1053, $_vtype1054, $_size1052); + for ($_i1056 = 0; $_i1056 < $_size1052; ++$_i1056) { - $key1050 = ''; - $val1051 = ''; - $xfer += $input->readString($key1050); - $xfer += $input->readString($val1051); - $this->part_vals[$key1050] = $val1051; + $key1057 = ''; + $val1058 = ''; + $xfer += $input->readString($key1057); + $xfer += $input->readString($val1058); + $this->part_vals[$key1057] = $val1058; } $xfer += $input->readMapEnd(); } else { @@ -31395,10 +31667,10 @@ class ThriftHiveMetastore_markPartitionForEvent_args { { $output->writeMapBegin(TType::STRING, TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $kiter1052 => $viter1053) + foreach ($this->part_vals as $kiter1059 => $viter1060) { - $xfer += $output->writeString($kiter1052); - $xfer += $output->writeString($viter1053); + $xfer += $output->writeString($kiter1059); + $xfer += $output->writeString($viter1060); } } $output->writeMapEnd(); @@ -31720,17 +31992,17 @@ class ThriftHiveMetastore_isPartitionMarkedForEvent_args { case 3: if ($ftype == TType::MAP) { $this->part_vals = array(); - $_size1054 = 0; - $_ktype1055 = 0; - $_vtype1056 = 0; - $xfer += $input->readMapBegin($_ktype1055, $_vtype1056, $_size1054); - for ($_i1058 = 0; $_i1058 < $_size1054; ++$_i1058) + $_size1061 = 0; + $_ktype1062 = 0; + $_vtype1063 = 0; + $xfer += $input->readMapBegin($_ktype1062, $_vtype1063, $_size1061); + for ($_i1065 = 0; $_i1065 < $_size1061; ++$_i1065) { - $key1059 = ''; - $val1060 = ''; - $xfer += $input->readString($key1059); - $xfer += $input->readString($val1060); - $this->part_vals[$key1059] = $val1060; + $key1066 = ''; + $val1067 = ''; + $xfer += $input->readString($key1066); + $xfer += $input->readString($val1067); + $this->part_vals[$key1066] = $val1067; } $xfer += $input->readMapEnd(); } else { @@ -31775,10 +32047,10 @@ class ThriftHiveMetastore_isPartitionMarkedForEvent_args { { $output->writeMapBegin(TType::STRING, TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $kiter1061 => $viter1062) + foreach ($this->part_vals as $kiter1068 => $viter1069) { - $xfer += $output->writeString($kiter1061); - $xfer += $output->writeString($viter1062); + $xfer += $output->writeString($kiter1068); + $xfer += $output->writeString($viter1069); } } $output->writeMapEnd(); @@ -33252,15 +33524,15 @@ class ThriftHiveMetastore_get_indexes_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size1063 = 0; - $_etype1066 = 0; - $xfer += $input->readListBegin($_etype1066, $_size1063); - for ($_i1067 = 0; $_i1067 < $_size1063; ++$_i1067) + $_size1070 = 0; + $_etype1073 = 0; + $xfer += $input->readListBegin($_etype1073, $_size1070); + for ($_i1074 = 0; $_i1074 < $_size1070; ++$_i1074) { - $elem1068 = null; - $elem1068 = new \metastore\Index(); - $xfer += $elem1068->read($input); - $this->success []= $elem1068; + $elem1075 = null; + $elem1075 = new \metastore\Index(); + $xfer += $elem1075->read($input); + $this->success []= $elem1075; } $xfer += $input->readListEnd(); } else { @@ -33304,9 +33576,9 @@ class ThriftHiveMetastore_get_indexes_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter1069) + foreach ($this->success as $iter1076) { - $xfer += $iter1069->write($output); + $xfer += $iter1076->write($output); } } $output->writeListEnd(); @@ -33513,14 +33785,14 @@ class ThriftHiveMetastore_get_index_names_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size1070 = 0; - $_etype1073 = 0; - $xfer += $input->readListBegin($_etype1073, $_size1070); - for ($_i1074 = 0; $_i1074 < $_size1070; ++$_i1074) + $_size1077 = 0; + $_etype1080 = 0; + $xfer += $input->readListBegin($_etype1080, $_size1077); + for ($_i1081 = 0; $_i1081 < $_size1077; ++$_i1081) { - $elem1075 = null; - $xfer += $input->readString($elem1075); - $this->success []= $elem1075; + $elem1082 = null; + $xfer += $input->readString($elem1082); + $this->success []= $elem1082; } $xfer += $input->readListEnd(); } else { @@ -33556,9 +33828,9 @@ class ThriftHiveMetastore_get_index_names_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter1076) + foreach ($this->success as $iter1083) { - $xfer += $output->writeString($iter1076); + $xfer += $output->writeString($iter1083); } } $output->writeListEnd(); @@ -37872,14 +38144,14 @@ class ThriftHiveMetastore_get_functions_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size1077 = 0; - $_etype1080 = 0; - $xfer += $input->readListBegin($_etype1080, $_size1077); - for ($_i1081 = 0; $_i1081 < $_size1077; ++$_i1081) + $_size1084 = 0; + $_etype1087 = 0; + $xfer += $input->readListBegin($_etype1087, $_size1084); + for ($_i1088 = 0; $_i1088 < $_size1084; ++$_i1088) { - $elem1082 = null; - $xfer += $input->readString($elem1082); - $this->success []= $elem1082; + $elem1089 = null; + $xfer += $input->readString($elem1089); + $this->success []= $elem1089; } $xfer += $input->readListEnd(); } else { @@ -37915,9 +38187,9 @@ class ThriftHiveMetastore_get_functions_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter1083) + foreach ($this->success as $iter1090) { - $xfer += $output->writeString($iter1083); + $xfer += $output->writeString($iter1090); } } $output->writeListEnd(); @@ -38786,14 +39058,14 @@ class ThriftHiveMetastore_get_role_names_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size1084 = 0; - $_etype1087 = 0; - $xfer += $input->readListBegin($_etype1087, $_size1084); - for ($_i1088 = 0; $_i1088 < $_size1084; ++$_i1088) + $_size1091 = 0; + $_etype1094 = 0; + $xfer += $input->readListBegin($_etype1094, $_size1091); + for ($_i1095 = 0; $_i1095 < $_size1091; ++$_i1095) { - $elem1089 = null; - $xfer += $input->readString($elem1089); - $this->success []= $elem1089; + $elem1096 = null; + $xfer += $input->readString($elem1096); + $this->success []= $elem1096; } $xfer += $input->readListEnd(); } else { @@ -38829,9 +39101,9 @@ class ThriftHiveMetastore_get_role_names_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter1090) + foreach ($this->success as $iter1097) { - $xfer += $output->writeString($iter1090); + $xfer += $output->writeString($iter1097); } } $output->writeListEnd(); @@ -39522,15 +39794,15 @@ class ThriftHiveMetastore_list_roles_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size1091 = 0; - $_etype1094 = 0; - $xfer += $input->readListBegin($_etype1094, $_size1091); - for ($_i1095 = 0; $_i1095 < $_size1091; ++$_i1095) + $_size1098 = 0; + $_etype1101 = 0; + $xfer += $input->readListBegin($_etype1101, $_size1098); + for ($_i1102 = 0; $_i1102 < $_size1098; ++$_i1102) { - $elem1096 = null; - $elem1096 = new \metastore\Role(); - $xfer += $elem1096->read($input); - $this->success []= $elem1096; + $elem1103 = null; + $elem1103 = new \metastore\Role(); + $xfer += $elem1103->read($input); + $this->success []= $elem1103; } $xfer += $input->readListEnd(); } else { @@ -39566,9 +39838,9 @@ class ThriftHiveMetastore_list_roles_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter1097) + foreach ($this->success as $iter1104) { - $xfer += $iter1097->write($output); + $xfer += $iter1104->write($output); } } $output->writeListEnd(); @@ -40230,14 +40502,14 @@ class ThriftHiveMetastore_get_privilege_set_args { case 3: if ($ftype == TType::LST) { $this->group_names = array(); - $_size1098 = 0; - $_etype1101 = 0; - $xfer += $input->readListBegin($_etype1101, $_size1098); - for ($_i1102 = 0; $_i1102 < $_size1098; ++$_i1102) + $_size1105 = 0; + $_etype1108 = 0; + $xfer += $input->readListBegin($_etype1108, $_size1105); + for ($_i1109 = 0; $_i1109 < $_size1105; ++$_i1109) { - $elem1103 = null; - $xfer += $input->readString($elem1103); - $this->group_names []= $elem1103; + $elem1110 = null; + $xfer += $input->readString($elem1110); + $this->group_names []= $elem1110; } $xfer += $input->readListEnd(); } else { @@ -40278,9 +40550,9 @@ class ThriftHiveMetastore_get_privilege_set_args { { $output->writeListBegin(TType::STRING, count($this->group_names)); { - foreach ($this->group_names as $iter1104) + foreach ($this->group_names as $iter1111) { - $xfer += $output->writeString($iter1104); + $xfer += $output->writeString($iter1111); } } $output->writeListEnd(); @@ -40588,15 +40860,15 @@ class ThriftHiveMetastore_list_privileges_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size1105 = 0; - $_etype1108 = 0; - $xfer += $input->readListBegin($_etype1108, $_size1105); - for ($_i1109 = 0; $_i1109 < $_size1105; ++$_i1109) + $_size1112 = 0; + $_etype1115 = 0; + $xfer += $input->readListBegin($_etype1115, $_size1112); + for ($_i1116 = 0; $_i1116 < $_size1112; ++$_i1116) { - $elem1110 = null; - $elem1110 = new \metastore\HiveObjectPrivilege(); - $xfer += $elem1110->read($input); - $this->success []= $elem1110; + $elem1117 = null; + $elem1117 = new \metastore\HiveObjectPrivilege(); + $xfer += $elem1117->read($input); + $this->success []= $elem1117; } $xfer += $input->readListEnd(); } else { @@ -40632,9 +40904,9 @@ class ThriftHiveMetastore_list_privileges_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter1111) + foreach ($this->success as $iter1118) { - $xfer += $iter1111->write($output); + $xfer += $iter1118->write($output); } } $output->writeListEnd(); @@ -41266,14 +41538,14 @@ class ThriftHiveMetastore_set_ugi_args { case 2: if ($ftype == TType::LST) { $this->group_names = array(); - $_size1112 = 0; - $_etype1115 = 0; - $xfer += $input->readListBegin($_etype1115, $_size1112); - for ($_i1116 = 0; $_i1116 < $_size1112; ++$_i1116) + $_size1119 = 0; + $_etype1122 = 0; + $xfer += $input->readListBegin($_etype1122, $_size1119); + for ($_i1123 = 0; $_i1123 < $_size1119; ++$_i1123) { - $elem1117 = null; - $xfer += $input->readString($elem1117); - $this->group_names []= $elem1117; + $elem1124 = null; + $xfer += $input->readString($elem1124); + $this->group_names []= $elem1124; } $xfer += $input->readListEnd(); } else { @@ -41306,9 +41578,9 @@ class ThriftHiveMetastore_set_ugi_args { { $output->writeListBegin(TType::STRING, count($this->group_names)); { - foreach ($this->group_names as $iter1118) + foreach ($this->group_names as $iter1125) { - $xfer += $output->writeString($iter1118); + $xfer += $output->writeString($iter1125); } } $output->writeListEnd(); @@ -41384,14 +41656,14 @@ class ThriftHiveMetastore_set_ugi_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size1119 = 0; - $_etype1122 = 0; - $xfer += $input->readListBegin($_etype1122, $_size1119); - for ($_i1123 = 0; $_i1123 < $_size1119; ++$_i1123) + $_size1126 = 0; + $_etype1129 = 0; + $xfer += $input->readListBegin($_etype1129, $_size1126); + for ($_i1130 = 0; $_i1130 < $_size1126; ++$_i1130) { - $elem1124 = null; - $xfer += $input->readString($elem1124); - $this->success []= $elem1124; + $elem1131 = null; + $xfer += $input->readString($elem1131); + $this->success []= $elem1131; } $xfer += $input->readListEnd(); } else { @@ -41427,9 +41699,9 @@ class ThriftHiveMetastore_set_ugi_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter1125) + foreach ($this->success as $iter1132) { - $xfer += $output->writeString($iter1125); + $xfer += $output->writeString($iter1132); } } $output->writeListEnd(); @@ -42546,14 +42818,14 @@ class ThriftHiveMetastore_get_all_token_identifiers_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size1126 = 0; - $_etype1129 = 0; - $xfer += $input->readListBegin($_etype1129, $_size1126); - for ($_i1130 = 0; $_i1130 < $_size1126; ++$_i1130) + $_size1133 = 0; + $_etype1136 = 0; + $xfer += $input->readListBegin($_etype1136, $_size1133); + for ($_i1137 = 0; $_i1137 < $_size1133; ++$_i1137) { - $elem1131 = null; - $xfer += $input->readString($elem1131); - $this->success []= $elem1131; + $elem1138 = null; + $xfer += $input->readString($elem1138); + $this->success []= $elem1138; } $xfer += $input->readListEnd(); } else { @@ -42581,9 +42853,9 @@ class ThriftHiveMetastore_get_all_token_identifiers_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter1132) + foreach ($this->success as $iter1139) { - $xfer += $output->writeString($iter1132); + $xfer += $output->writeString($iter1139); } } $output->writeListEnd(); @@ -43222,14 +43494,14 @@ class ThriftHiveMetastore_get_master_keys_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size1133 = 0; - $_etype1136 = 0; - $xfer += $input->readListBegin($_etype1136, $_size1133); - for ($_i1137 = 0; $_i1137 < $_size1133; ++$_i1137) + $_size1140 = 0; + $_etype1143 = 0; + $xfer += $input->readListBegin($_etype1143, $_size1140); + for ($_i1144 = 0; $_i1144 < $_size1140; ++$_i1144) { - $elem1138 = null; - $xfer += $input->readString($elem1138); - $this->success []= $elem1138; + $elem1145 = null; + $xfer += $input->readString($elem1145); + $this->success []= $elem1145; } $xfer += $input->readListEnd(); } else { @@ -43257,9 +43529,9 @@ class ThriftHiveMetastore_get_master_keys_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter1139) + foreach ($this->success as $iter1146) { - $xfer += $output->writeString($iter1139); + $xfer += $output->writeString($iter1146); } } $output->writeListEnd(); @@ -48055,11 +48327,1086 @@ class ThriftHiveMetastore_create_resource_plan_result { } -class ThriftHiveMetastore_get_resource_plan_args { +class ThriftHiveMetastore_get_resource_plan_args { + static $_TSPEC; + + /** + * @var \metastore\WMGetResourcePlanRequest + */ + public $request = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'request', + 'type' => TType::STRUCT, + 'class' => '\metastore\WMGetResourcePlanRequest', + ), + ); + } + if (is_array($vals)) { + if (isset($vals['request'])) { + $this->request = $vals['request']; + } + } + } + + public function getName() { + return 'ThriftHiveMetastore_get_resource_plan_args'; + } + + public function read($input) + { + $xfer = 0; + $fname = null; + $ftype = 0; + $fid = 0; + $xfer += $input->readStructBegin($fname); + while (true) + { + $xfer += $input->readFieldBegin($fname, $ftype, $fid); + if ($ftype == TType::STOP) { + break; + } + switch ($fid) + { + case 1: + if ($ftype == TType::STRUCT) { + $this->request = new \metastore\WMGetResourcePlanRequest(); + $xfer += $this->request->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + default: + $xfer += $input->skip($ftype); + break; + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; + } + + public function write($output) { + $xfer = 0; + $xfer += $output->writeStructBegin('ThriftHiveMetastore_get_resource_plan_args'); + if ($this->request !== null) { + if (!is_object($this->request)) { + throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); + } + $xfer += $output->writeFieldBegin('request', TType::STRUCT, 1); + $xfer += $this->request->write($output); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class ThriftHiveMetastore_get_resource_plan_result { + static $_TSPEC; + + /** + * @var \metastore\WMGetResourcePlanResponse + */ + public $success = null; + /** + * @var \metastore\NoSuchObjectException + */ + public $o1 = null; + /** + * @var \metastore\MetaException + */ + public $o2 = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 0 => array( + 'var' => 'success', + 'type' => TType::STRUCT, + 'class' => '\metastore\WMGetResourcePlanResponse', + ), + 1 => array( + 'var' => 'o1', + 'type' => TType::STRUCT, + 'class' => '\metastore\NoSuchObjectException', + ), + 2 => array( + 'var' => 'o2', + 'type' => TType::STRUCT, + 'class' => '\metastore\MetaException', + ), + ); + } + if (is_array($vals)) { + if (isset($vals['success'])) { + $this->success = $vals['success']; + } + if (isset($vals['o1'])) { + $this->o1 = $vals['o1']; + } + if (isset($vals['o2'])) { + $this->o2 = $vals['o2']; + } + } + } + + public function getName() { + return 'ThriftHiveMetastore_get_resource_plan_result'; + } + + public function read($input) + { + $xfer = 0; + $fname = null; + $ftype = 0; + $fid = 0; + $xfer += $input->readStructBegin($fname); + while (true) + { + $xfer += $input->readFieldBegin($fname, $ftype, $fid); + if ($ftype == TType::STOP) { + break; + } + switch ($fid) + { + case 0: + if ($ftype == TType::STRUCT) { + $this->success = new \metastore\WMGetResourcePlanResponse(); + $xfer += $this->success->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + case 1: + if ($ftype == TType::STRUCT) { + $this->o1 = new \metastore\NoSuchObjectException(); + $xfer += $this->o1->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + case 2: + if ($ftype == TType::STRUCT) { + $this->o2 = new \metastore\MetaException(); + $xfer += $this->o2->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + default: + $xfer += $input->skip($ftype); + break; + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; + } + + public function write($output) { + $xfer = 0; + $xfer += $output->writeStructBegin('ThriftHiveMetastore_get_resource_plan_result'); + if ($this->success !== null) { + if (!is_object($this->success)) { + throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); + } + $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0); + $xfer += $this->success->write($output); + $xfer += $output->writeFieldEnd(); + } + if ($this->o1 !== null) { + $xfer += $output->writeFieldBegin('o1', TType::STRUCT, 1); + $xfer += $this->o1->write($output); + $xfer += $output->writeFieldEnd(); + } + if ($this->o2 !== null) { + $xfer += $output->writeFieldBegin('o2', TType::STRUCT, 2); + $xfer += $this->o2->write($output); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class ThriftHiveMetastore_get_all_resource_plans_args { + static $_TSPEC; + + /** + * @var \metastore\WMGetAllResourcePlanRequest + */ + public $request = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'request', + 'type' => TType::STRUCT, + 'class' => '\metastore\WMGetAllResourcePlanRequest', + ), + ); + } + if (is_array($vals)) { + if (isset($vals['request'])) { + $this->request = $vals['request']; + } + } + } + + public function getName() { + return 'ThriftHiveMetastore_get_all_resource_plans_args'; + } + + public function read($input) + { + $xfer = 0; + $fname = null; + $ftype = 0; + $fid = 0; + $xfer += $input->readStructBegin($fname); + while (true) + { + $xfer += $input->readFieldBegin($fname, $ftype, $fid); + if ($ftype == TType::STOP) { + break; + } + switch ($fid) + { + case 1: + if ($ftype == TType::STRUCT) { + $this->request = new \metastore\WMGetAllResourcePlanRequest(); + $xfer += $this->request->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + default: + $xfer += $input->skip($ftype); + break; + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; + } + + public function write($output) { + $xfer = 0; + $xfer += $output->writeStructBegin('ThriftHiveMetastore_get_all_resource_plans_args'); + if ($this->request !== null) { + if (!is_object($this->request)) { + throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); + } + $xfer += $output->writeFieldBegin('request', TType::STRUCT, 1); + $xfer += $this->request->write($output); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class ThriftHiveMetastore_get_all_resource_plans_result { + static $_TSPEC; + + /** + * @var \metastore\WMGetAllResourcePlanResponse + */ + public $success = null; + /** + * @var \metastore\MetaException + */ + public $o1 = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 0 => array( + 'var' => 'success', + 'type' => TType::STRUCT, + 'class' => '\metastore\WMGetAllResourcePlanResponse', + ), + 1 => array( + 'var' => 'o1', + 'type' => TType::STRUCT, + 'class' => '\metastore\MetaException', + ), + ); + } + if (is_array($vals)) { + if (isset($vals['success'])) { + $this->success = $vals['success']; + } + if (isset($vals['o1'])) { + $this->o1 = $vals['o1']; + } + } + } + + public function getName() { + return 'ThriftHiveMetastore_get_all_resource_plans_result'; + } + + public function read($input) + { + $xfer = 0; + $fname = null; + $ftype = 0; + $fid = 0; + $xfer += $input->readStructBegin($fname); + while (true) + { + $xfer += $input->readFieldBegin($fname, $ftype, $fid); + if ($ftype == TType::STOP) { + break; + } + switch ($fid) + { + case 0: + if ($ftype == TType::STRUCT) { + $this->success = new \metastore\WMGetAllResourcePlanResponse(); + $xfer += $this->success->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + case 1: + if ($ftype == TType::STRUCT) { + $this->o1 = new \metastore\MetaException(); + $xfer += $this->o1->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + default: + $xfer += $input->skip($ftype); + break; + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; + } + + public function write($output) { + $xfer = 0; + $xfer += $output->writeStructBegin('ThriftHiveMetastore_get_all_resource_plans_result'); + if ($this->success !== null) { + if (!is_object($this->success)) { + throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); + } + $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0); + $xfer += $this->success->write($output); + $xfer += $output->writeFieldEnd(); + } + if ($this->o1 !== null) { + $xfer += $output->writeFieldBegin('o1', TType::STRUCT, 1); + $xfer += $this->o1->write($output); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class ThriftHiveMetastore_alter_resource_plan_args { + static $_TSPEC; + + /** + * @var \metastore\WMAlterResourcePlanRequest + */ + public $request = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'request', + 'type' => TType::STRUCT, + 'class' => '\metastore\WMAlterResourcePlanRequest', + ), + ); + } + if (is_array($vals)) { + if (isset($vals['request'])) { + $this->request = $vals['request']; + } + } + } + + public function getName() { + return 'ThriftHiveMetastore_alter_resource_plan_args'; + } + + public function read($input) + { + $xfer = 0; + $fname = null; + $ftype = 0; + $fid = 0; + $xfer += $input->readStructBegin($fname); + while (true) + { + $xfer += $input->readFieldBegin($fname, $ftype, $fid); + if ($ftype == TType::STOP) { + break; + } + switch ($fid) + { + case 1: + if ($ftype == TType::STRUCT) { + $this->request = new \metastore\WMAlterResourcePlanRequest(); + $xfer += $this->request->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + default: + $xfer += $input->skip($ftype); + break; + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; + } + + public function write($output) { + $xfer = 0; + $xfer += $output->writeStructBegin('ThriftHiveMetastore_alter_resource_plan_args'); + if ($this->request !== null) { + if (!is_object($this->request)) { + throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); + } + $xfer += $output->writeFieldBegin('request', TType::STRUCT, 1); + $xfer += $this->request->write($output); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class ThriftHiveMetastore_alter_resource_plan_result { + static $_TSPEC; + + /** + * @var \metastore\WMAlterResourcePlanResponse + */ + public $success = null; + /** + * @var \metastore\NoSuchObjectException + */ + public $o1 = null; + /** + * @var \metastore\InvalidOperationException + */ + public $o2 = null; + /** + * @var \metastore\MetaException + */ + public $o3 = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 0 => array( + 'var' => 'success', + 'type' => TType::STRUCT, + 'class' => '\metastore\WMAlterResourcePlanResponse', + ), + 1 => array( + 'var' => 'o1', + 'type' => TType::STRUCT, + 'class' => '\metastore\NoSuchObjectException', + ), + 2 => array( + 'var' => 'o2', + 'type' => TType::STRUCT, + 'class' => '\metastore\InvalidOperationException', + ), + 3 => array( + 'var' => 'o3', + 'type' => TType::STRUCT, + 'class' => '\metastore\MetaException', + ), + ); + } + if (is_array($vals)) { + if (isset($vals['success'])) { + $this->success = $vals['success']; + } + if (isset($vals['o1'])) { + $this->o1 = $vals['o1']; + } + if (isset($vals['o2'])) { + $this->o2 = $vals['o2']; + } + if (isset($vals['o3'])) { + $this->o3 = $vals['o3']; + } + } + } + + public function getName() { + return 'ThriftHiveMetastore_alter_resource_plan_result'; + } + + public function read($input) + { + $xfer = 0; + $fname = null; + $ftype = 0; + $fid = 0; + $xfer += $input->readStructBegin($fname); + while (true) + { + $xfer += $input->readFieldBegin($fname, $ftype, $fid); + if ($ftype == TType::STOP) { + break; + } + switch ($fid) + { + case 0: + if ($ftype == TType::STRUCT) { + $this->success = new \metastore\WMAlterResourcePlanResponse(); + $xfer += $this->success->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + case 1: + if ($ftype == TType::STRUCT) { + $this->o1 = new \metastore\NoSuchObjectException(); + $xfer += $this->o1->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + case 2: + if ($ftype == TType::STRUCT) { + $this->o2 = new \metastore\InvalidOperationException(); + $xfer += $this->o2->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + case 3: + if ($ftype == TType::STRUCT) { + $this->o3 = new \metastore\MetaException(); + $xfer += $this->o3->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + default: + $xfer += $input->skip($ftype); + break; + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; + } + + public function write($output) { + $xfer = 0; + $xfer += $output->writeStructBegin('ThriftHiveMetastore_alter_resource_plan_result'); + if ($this->success !== null) { + if (!is_object($this->success)) { + throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); + } + $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0); + $xfer += $this->success->write($output); + $xfer += $output->writeFieldEnd(); + } + if ($this->o1 !== null) { + $xfer += $output->writeFieldBegin('o1', TType::STRUCT, 1); + $xfer += $this->o1->write($output); + $xfer += $output->writeFieldEnd(); + } + if ($this->o2 !== null) { + $xfer += $output->writeFieldBegin('o2', TType::STRUCT, 2); + $xfer += $this->o2->write($output); + $xfer += $output->writeFieldEnd(); + } + if ($this->o3 !== null) { + $xfer += $output->writeFieldBegin('o3', TType::STRUCT, 3); + $xfer += $this->o3->write($output); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class ThriftHiveMetastore_validate_resource_plan_args { + static $_TSPEC; + + /** + * @var \metastore\WMValidateResourcePlanRequest + */ + public $request = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'request', + 'type' => TType::STRUCT, + 'class' => '\metastore\WMValidateResourcePlanRequest', + ), + ); + } + if (is_array($vals)) { + if (isset($vals['request'])) { + $this->request = $vals['request']; + } + } + } + + public function getName() { + return 'ThriftHiveMetastore_validate_resource_plan_args'; + } + + public function read($input) + { + $xfer = 0; + $fname = null; + $ftype = 0; + $fid = 0; + $xfer += $input->readStructBegin($fname); + while (true) + { + $xfer += $input->readFieldBegin($fname, $ftype, $fid); + if ($ftype == TType::STOP) { + break; + } + switch ($fid) + { + case 1: + if ($ftype == TType::STRUCT) { + $this->request = new \metastore\WMValidateResourcePlanRequest(); + $xfer += $this->request->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + default: + $xfer += $input->skip($ftype); + break; + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; + } + + public function write($output) { + $xfer = 0; + $xfer += $output->writeStructBegin('ThriftHiveMetastore_validate_resource_plan_args'); + if ($this->request !== null) { + if (!is_object($this->request)) { + throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); + } + $xfer += $output->writeFieldBegin('request', TType::STRUCT, 1); + $xfer += $this->request->write($output); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class ThriftHiveMetastore_validate_resource_plan_result { + static $_TSPEC; + + /** + * @var \metastore\WMValidateResourcePlanResponse + */ + public $success = null; + /** + * @var \metastore\NoSuchObjectException + */ + public $o1 = null; + /** + * @var \metastore\MetaException + */ + public $o2 = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 0 => array( + 'var' => 'success', + 'type' => TType::STRUCT, + 'class' => '\metastore\WMValidateResourcePlanResponse', + ), + 1 => array( + 'var' => 'o1', + 'type' => TType::STRUCT, + 'class' => '\metastore\NoSuchObjectException', + ), + 2 => array( + 'var' => 'o2', + 'type' => TType::STRUCT, + 'class' => '\metastore\MetaException', + ), + ); + } + if (is_array($vals)) { + if (isset($vals['success'])) { + $this->success = $vals['success']; + } + if (isset($vals['o1'])) { + $this->o1 = $vals['o1']; + } + if (isset($vals['o2'])) { + $this->o2 = $vals['o2']; + } + } + } + + public function getName() { + return 'ThriftHiveMetastore_validate_resource_plan_result'; + } + + public function read($input) + { + $xfer = 0; + $fname = null; + $ftype = 0; + $fid = 0; + $xfer += $input->readStructBegin($fname); + while (true) + { + $xfer += $input->readFieldBegin($fname, $ftype, $fid); + if ($ftype == TType::STOP) { + break; + } + switch ($fid) + { + case 0: + if ($ftype == TType::STRUCT) { + $this->success = new \metastore\WMValidateResourcePlanResponse(); + $xfer += $this->success->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + case 1: + if ($ftype == TType::STRUCT) { + $this->o1 = new \metastore\NoSuchObjectException(); + $xfer += $this->o1->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + case 2: + if ($ftype == TType::STRUCT) { + $this->o2 = new \metastore\MetaException(); + $xfer += $this->o2->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + default: + $xfer += $input->skip($ftype); + break; + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; + } + + public function write($output) { + $xfer = 0; + $xfer += $output->writeStructBegin('ThriftHiveMetastore_validate_resource_plan_result'); + if ($this->success !== null) { + if (!is_object($this->success)) { + throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); + } + $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0); + $xfer += $this->success->write($output); + $xfer += $output->writeFieldEnd(); + } + if ($this->o1 !== null) { + $xfer += $output->writeFieldBegin('o1', TType::STRUCT, 1); + $xfer += $this->o1->write($output); + $xfer += $output->writeFieldEnd(); + } + if ($this->o2 !== null) { + $xfer += $output->writeFieldBegin('o2', TType::STRUCT, 2); + $xfer += $this->o2->write($output); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class ThriftHiveMetastore_drop_resource_plan_args { + static $_TSPEC; + + /** + * @var \metastore\WMDropResourcePlanRequest + */ + public $request = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'request', + 'type' => TType::STRUCT, + 'class' => '\metastore\WMDropResourcePlanRequest', + ), + ); + } + if (is_array($vals)) { + if (isset($vals['request'])) { + $this->request = $vals['request']; + } + } + } + + public function getName() { + return 'ThriftHiveMetastore_drop_resource_plan_args'; + } + + public function read($input) + { + $xfer = 0; + $fname = null; + $ftype = 0; + $fid = 0; + $xfer += $input->readStructBegin($fname); + while (true) + { + $xfer += $input->readFieldBegin($fname, $ftype, $fid); + if ($ftype == TType::STOP) { + break; + } + switch ($fid) + { + case 1: + if ($ftype == TType::STRUCT) { + $this->request = new \metastore\WMDropResourcePlanRequest(); + $xfer += $this->request->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + default: + $xfer += $input->skip($ftype); + break; + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; + } + + public function write($output) { + $xfer = 0; + $xfer += $output->writeStructBegin('ThriftHiveMetastore_drop_resource_plan_args'); + if ($this->request !== null) { + if (!is_object($this->request)) { + throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); + } + $xfer += $output->writeFieldBegin('request', TType::STRUCT, 1); + $xfer += $this->request->write($output); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class ThriftHiveMetastore_drop_resource_plan_result { + static $_TSPEC; + + /** + * @var \metastore\WMDropResourcePlanResponse + */ + public $success = null; + /** + * @var \metastore\NoSuchObjectException + */ + public $o1 = null; + /** + * @var \metastore\InvalidOperationException + */ + public $o2 = null; + /** + * @var \metastore\MetaException + */ + public $o3 = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 0 => array( + 'var' => 'success', + 'type' => TType::STRUCT, + 'class' => '\metastore\WMDropResourcePlanResponse', + ), + 1 => array( + 'var' => 'o1', + 'type' => TType::STRUCT, + 'class' => '\metastore\NoSuchObjectException', + ), + 2 => array( + 'var' => 'o2', + 'type' => TType::STRUCT, + 'class' => '\metastore\InvalidOperationException', + ), + 3 => array( + 'var' => 'o3', + 'type' => TType::STRUCT, + 'class' => '\metastore\MetaException', + ), + ); + } + if (is_array($vals)) { + if (isset($vals['success'])) { + $this->success = $vals['success']; + } + if (isset($vals['o1'])) { + $this->o1 = $vals['o1']; + } + if (isset($vals['o2'])) { + $this->o2 = $vals['o2']; + } + if (isset($vals['o3'])) { + $this->o3 = $vals['o3']; + } + } + } + + public function getName() { + return 'ThriftHiveMetastore_drop_resource_plan_result'; + } + + public function read($input) + { + $xfer = 0; + $fname = null; + $ftype = 0; + $fid = 0; + $xfer += $input->readStructBegin($fname); + while (true) + { + $xfer += $input->readFieldBegin($fname, $ftype, $fid); + if ($ftype == TType::STOP) { + break; + } + switch ($fid) + { + case 0: + if ($ftype == TType::STRUCT) { + $this->success = new \metastore\WMDropResourcePlanResponse(); + $xfer += $this->success->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + case 1: + if ($ftype == TType::STRUCT) { + $this->o1 = new \metastore\NoSuchObjectException(); + $xfer += $this->o1->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + case 2: + if ($ftype == TType::STRUCT) { + $this->o2 = new \metastore\InvalidOperationException(); + $xfer += $this->o2->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + case 3: + if ($ftype == TType::STRUCT) { + $this->o3 = new \metastore\MetaException(); + $xfer += $this->o3->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + default: + $xfer += $input->skip($ftype); + break; + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; + } + + public function write($output) { + $xfer = 0; + $xfer += $output->writeStructBegin('ThriftHiveMetastore_drop_resource_plan_result'); + if ($this->success !== null) { + if (!is_object($this->success)) { + throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); + } + $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0); + $xfer += $this->success->write($output); + $xfer += $output->writeFieldEnd(); + } + if ($this->o1 !== null) { + $xfer += $output->writeFieldBegin('o1', TType::STRUCT, 1); + $xfer += $this->o1->write($output); + $xfer += $output->writeFieldEnd(); + } + if ($this->o2 !== null) { + $xfer += $output->writeFieldBegin('o2', TType::STRUCT, 2); + $xfer += $this->o2->write($output); + $xfer += $output->writeFieldEnd(); + } + if ($this->o3 !== null) { + $xfer += $output->writeFieldBegin('o3', TType::STRUCT, 3); + $xfer += $this->o3->write($output); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class ThriftHiveMetastore_create_wm_trigger_args { static $_TSPEC; /** - * @var \metastore\WMGetResourcePlanRequest + * @var \metastore\WMCreateTriggerRequest */ public $request = null; @@ -48069,7 +49416,7 @@ class ThriftHiveMetastore_get_resource_plan_args { 1 => array( 'var' => 'request', 'type' => TType::STRUCT, - 'class' => '\metastore\WMGetResourcePlanRequest', + 'class' => '\metastore\WMCreateTriggerRequest', ), ); } @@ -48081,7 +49428,7 @@ class ThriftHiveMetastore_get_resource_plan_args { } public function getName() { - return 'ThriftHiveMetastore_get_resource_plan_args'; + return 'ThriftHiveMetastore_create_wm_trigger_args'; } public function read($input) @@ -48101,7 +49448,7 @@ class ThriftHiveMetastore_get_resource_plan_args { { case 1: if ($ftype == TType::STRUCT) { - $this->request = new \metastore\WMGetResourcePlanRequest(); + $this->request = new \metastore\WMCreateTriggerRequest(); $xfer += $this->request->read($input); } else { $xfer += $input->skip($ftype); @@ -48119,7 +49466,7 @@ class ThriftHiveMetastore_get_resource_plan_args { public function write($output) { $xfer = 0; - $xfer += $output->writeStructBegin('ThriftHiveMetastore_get_resource_plan_args'); + $xfer += $output->writeStructBegin('ThriftHiveMetastore_create_wm_trigger_args'); if ($this->request !== null) { if (!is_object($this->request)) { throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); @@ -48135,21 +49482,29 @@ class ThriftHiveMetastore_get_resource_plan_args { } -class ThriftHiveMetastore_get_resource_plan_result { +class ThriftHiveMetastore_create_wm_trigger_result { static $_TSPEC; /** - * @var \metastore\WMGetResourcePlanResponse + * @var \metastore\WMCreateTriggerResponse */ public $success = null; /** - * @var \metastore\NoSuchObjectException + * @var \metastore\AlreadyExistsException */ public $o1 = null; /** - * @var \metastore\MetaException + * @var \metastore\NoSuchObjectException */ public $o2 = null; + /** + * @var \metastore\InvalidObjectException + */ + public $o3 = null; + /** + * @var \metastore\MetaException + */ + public $o4 = null; public function __construct($vals=null) { if (!isset(self::$_TSPEC)) { @@ -48157,16 +49512,26 @@ class ThriftHiveMetastore_get_resource_plan_result { 0 => array( 'var' => 'success', 'type' => TType::STRUCT, - 'class' => '\metastore\WMGetResourcePlanResponse', + 'class' => '\metastore\WMCreateTriggerResponse', ), 1 => array( 'var' => 'o1', 'type' => TType::STRUCT, - 'class' => '\metastore\NoSuchObjectException', + 'class' => '\metastore\AlreadyExistsException', ), 2 => array( 'var' => 'o2', 'type' => TType::STRUCT, + 'class' => '\metastore\NoSuchObjectException', + ), + 3 => array( + 'var' => 'o3', + 'type' => TType::STRUCT, + 'class' => '\metastore\InvalidObjectException', + ), + 4 => array( + 'var' => 'o4', + 'type' => TType::STRUCT, 'class' => '\metastore\MetaException', ), ); @@ -48181,11 +49546,17 @@ class ThriftHiveMetastore_get_resource_plan_result { if (isset($vals['o2'])) { $this->o2 = $vals['o2']; } + if (isset($vals['o3'])) { + $this->o3 = $vals['o3']; + } + if (isset($vals['o4'])) { + $this->o4 = $vals['o4']; + } } } public function getName() { - return 'ThriftHiveMetastore_get_resource_plan_result'; + return 'ThriftHiveMetastore_create_wm_trigger_result'; } public function read($input) @@ -48205,7 +49576,7 @@ class ThriftHiveMetastore_get_resource_plan_result { { case 0: if ($ftype == TType::STRUCT) { - $this->success = new \metastore\WMGetResourcePlanResponse(); + $this->success = new \metastore\WMCreateTriggerResponse(); $xfer += $this->success->read($input); } else { $xfer += $input->skip($ftype); @@ -48213,7 +49584,7 @@ class ThriftHiveMetastore_get_resource_plan_result { break; case 1: if ($ftype == TType::STRUCT) { - $this->o1 = new \metastore\NoSuchObjectException(); + $this->o1 = new \metastore\AlreadyExistsException(); $xfer += $this->o1->read($input); } else { $xfer += $input->skip($ftype); @@ -48221,198 +49592,24 @@ class ThriftHiveMetastore_get_resource_plan_result { break; case 2: if ($ftype == TType::STRUCT) { - $this->o2 = new \metastore\MetaException(); + $this->o2 = new \metastore\NoSuchObjectException(); $xfer += $this->o2->read($input); } else { $xfer += $input->skip($ftype); } break; - default: - $xfer += $input->skip($ftype); - break; - } - $xfer += $input->readFieldEnd(); - } - $xfer += $input->readStructEnd(); - return $xfer; - } - - public function write($output) { - $xfer = 0; - $xfer += $output->writeStructBegin('ThriftHiveMetastore_get_resource_plan_result'); - if ($this->success !== null) { - if (!is_object($this->success)) { - throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); - } - $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0); - $xfer += $this->success->write($output); - $xfer += $output->writeFieldEnd(); - } - if ($this->o1 !== null) { - $xfer += $output->writeFieldBegin('o1', TType::STRUCT, 1); - $xfer += $this->o1->write($output); - $xfer += $output->writeFieldEnd(); - } - if ($this->o2 !== null) { - $xfer += $output->writeFieldBegin('o2', TType::STRUCT, 2); - $xfer += $this->o2->write($output); - $xfer += $output->writeFieldEnd(); - } - $xfer += $output->writeFieldStop(); - $xfer += $output->writeStructEnd(); - return $xfer; - } - -} - -class ThriftHiveMetastore_get_all_resource_plans_args { - static $_TSPEC; - - /** - * @var \metastore\WMGetAllResourcePlanRequest - */ - public $request = null; - - public function __construct($vals=null) { - if (!isset(self::$_TSPEC)) { - self::$_TSPEC = array( - 1 => array( - 'var' => 'request', - 'type' => TType::STRUCT, - 'class' => '\metastore\WMGetAllResourcePlanRequest', - ), - ); - } - if (is_array($vals)) { - if (isset($vals['request'])) { - $this->request = $vals['request']; - } - } - } - - public function getName() { - return 'ThriftHiveMetastore_get_all_resource_plans_args'; - } - - public function read($input) - { - $xfer = 0; - $fname = null; - $ftype = 0; - $fid = 0; - $xfer += $input->readStructBegin($fname); - while (true) - { - $xfer += $input->readFieldBegin($fname, $ftype, $fid); - if ($ftype == TType::STOP) { - break; - } - switch ($fid) - { - case 1: - if ($ftype == TType::STRUCT) { - $this->request = new \metastore\WMGetAllResourcePlanRequest(); - $xfer += $this->request->read($input); - } else { - $xfer += $input->skip($ftype); - } - break; - default: - $xfer += $input->skip($ftype); - break; - } - $xfer += $input->readFieldEnd(); - } - $xfer += $input->readStructEnd(); - return $xfer; - } - - public function write($output) { - $xfer = 0; - $xfer += $output->writeStructBegin('ThriftHiveMetastore_get_all_resource_plans_args'); - if ($this->request !== null) { - if (!is_object($this->request)) { - throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); - } - $xfer += $output->writeFieldBegin('request', TType::STRUCT, 1); - $xfer += $this->request->write($output); - $xfer += $output->writeFieldEnd(); - } - $xfer += $output->writeFieldStop(); - $xfer += $output->writeStructEnd(); - return $xfer; - } - -} - -class ThriftHiveMetastore_get_all_resource_plans_result { - static $_TSPEC; - - /** - * @var \metastore\WMGetAllResourcePlanResponse - */ - public $success = null; - /** - * @var \metastore\MetaException - */ - public $o1 = null; - - public function __construct($vals=null) { - if (!isset(self::$_TSPEC)) { - self::$_TSPEC = array( - 0 => array( - 'var' => 'success', - 'type' => TType::STRUCT, - 'class' => '\metastore\WMGetAllResourcePlanResponse', - ), - 1 => array( - 'var' => 'o1', - 'type' => TType::STRUCT, - 'class' => '\metastore\MetaException', - ), - ); - } - if (is_array($vals)) { - if (isset($vals['success'])) { - $this->success = $vals['success']; - } - if (isset($vals['o1'])) { - $this->o1 = $vals['o1']; - } - } - } - - public function getName() { - return 'ThriftHiveMetastore_get_all_resource_plans_result'; - } - - public function read($input) - { - $xfer = 0; - $fname = null; - $ftype = 0; - $fid = 0; - $xfer += $input->readStructBegin($fname); - while (true) - { - $xfer += $input->readFieldBegin($fname, $ftype, $fid); - if ($ftype == TType::STOP) { - break; - } - switch ($fid) - { - case 0: + case 3: if ($ftype == TType::STRUCT) { - $this->success = new \metastore\WMGetAllResourcePlanResponse(); - $xfer += $this->success->read($input); + $this->o3 = new \metastore\InvalidObjectException(); + $xfer += $this->o3->read($input); } else { $xfer += $input->skip($ftype); } break; - case 1: + case 4: if ($ftype == TType::STRUCT) { - $this->o1 = new \metastore\MetaException(); - $xfer += $this->o1->read($input); + $this->o4 = new \metastore\MetaException(); + $xfer += $this->o4->read($input); } else { $xfer += $input->skip($ftype); } @@ -48429,7 +49626,7 @@ class ThriftHiveMetastore_get_all_resource_plans_result { public function write($output) { $xfer = 0; - $xfer += $output->writeStructBegin('ThriftHiveMetastore_get_all_resource_plans_result'); + $xfer += $output->writeStructBegin('ThriftHiveMetastore_create_wm_trigger_result'); if ($this->success !== null) { if (!is_object($this->success)) { throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); @@ -48443,6 +49640,21 @@ class ThriftHiveMetastore_get_all_resource_plans_result { $xfer += $this->o1->write($output); $xfer += $output->writeFieldEnd(); } + if ($this->o2 !== null) { + $xfer += $output->writeFieldBegin('o2', TType::STRUCT, 2); + $xfer += $this->o2->write($output); + $xfer += $output->writeFieldEnd(); + } + if ($this->o3 !== null) { + $xfer += $output->writeFieldBegin('o3', TType::STRUCT, 3); + $xfer += $this->o3->write($output); + $xfer += $output->writeFieldEnd(); + } + if ($this->o4 !== null) { + $xfer += $output->writeFieldBegin('o4', TType::STRUCT, 4); + $xfer += $this->o4->write($output); + $xfer += $output->writeFieldEnd(); + } $xfer += $output->writeFieldStop(); $xfer += $output->writeStructEnd(); return $xfer; @@ -48450,11 +49662,11 @@ class ThriftHiveMetastore_get_all_resource_plans_result { } -class ThriftHiveMetastore_alter_resource_plan_args { +class ThriftHiveMetastore_alter_wm_trigger_args { static $_TSPEC; /** - * @var \metastore\WMAlterResourcePlanRequest + * @var \metastore\WMAlterTriggerRequest */ public $request = null; @@ -48464,7 +49676,7 @@ class ThriftHiveMetastore_alter_resource_plan_args { 1 => array( 'var' => 'request', 'type' => TType::STRUCT, - 'class' => '\metastore\WMAlterResourcePlanRequest', + 'class' => '\metastore\WMAlterTriggerRequest', ), ); } @@ -48476,7 +49688,7 @@ class ThriftHiveMetastore_alter_resource_plan_args { } public function getName() { - return 'ThriftHiveMetastore_alter_resource_plan_args'; + return 'ThriftHiveMetastore_alter_wm_trigger_args'; } public function read($input) @@ -48496,7 +49708,7 @@ class ThriftHiveMetastore_alter_resource_plan_args { { case 1: if ($ftype == TType::STRUCT) { - $this->request = new \metastore\WMAlterResourcePlanRequest(); + $this->request = new \metastore\WMAlterTriggerRequest(); $xfer += $this->request->read($input); } else { $xfer += $input->skip($ftype); @@ -48514,7 +49726,7 @@ class ThriftHiveMetastore_alter_resource_plan_args { public function write($output) { $xfer = 0; - $xfer += $output->writeStructBegin('ThriftHiveMetastore_alter_resource_plan_args'); + $xfer += $output->writeStructBegin('ThriftHiveMetastore_alter_wm_trigger_args'); if ($this->request !== null) { if (!is_object($this->request)) { throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); @@ -48530,11 +49742,11 @@ class ThriftHiveMetastore_alter_resource_plan_args { } -class ThriftHiveMetastore_alter_resource_plan_result { +class ThriftHiveMetastore_alter_wm_trigger_result { static $_TSPEC; /** - * @var \metastore\WMAlterResourcePlanResponse + * @var \metastore\WMAlterTriggerResponse */ public $success = null; /** @@ -48542,7 +49754,7 @@ class ThriftHiveMetastore_alter_resource_plan_result { */ public $o1 = null; /** - * @var \metastore\InvalidOperationException + * @var \metastore\InvalidObjectException */ public $o2 = null; /** @@ -48556,7 +49768,7 @@ class ThriftHiveMetastore_alter_resource_plan_result { 0 => array( 'var' => 'success', 'type' => TType::STRUCT, - 'class' => '\metastore\WMAlterResourcePlanResponse', + 'class' => '\metastore\WMAlterTriggerResponse', ), 1 => array( 'var' => 'o1', @@ -48566,7 +49778,7 @@ class ThriftHiveMetastore_alter_resource_plan_result { 2 => array( 'var' => 'o2', 'type' => TType::STRUCT, - 'class' => '\metastore\InvalidOperationException', + 'class' => '\metastore\InvalidObjectException', ), 3 => array( 'var' => 'o3', @@ -48592,7 +49804,7 @@ class ThriftHiveMetastore_alter_resource_plan_result { } public function getName() { - return 'ThriftHiveMetastore_alter_resource_plan_result'; + return 'ThriftHiveMetastore_alter_wm_trigger_result'; } public function read($input) @@ -48612,7 +49824,7 @@ class ThriftHiveMetastore_alter_resource_plan_result { { case 0: if ($ftype == TType::STRUCT) { - $this->success = new \metastore\WMAlterResourcePlanResponse(); + $this->success = new \metastore\WMAlterTriggerResponse(); $xfer += $this->success->read($input); } else { $xfer += $input->skip($ftype); @@ -48628,7 +49840,7 @@ class ThriftHiveMetastore_alter_resource_plan_result { break; case 2: if ($ftype == TType::STRUCT) { - $this->o2 = new \metastore\InvalidOperationException(); + $this->o2 = new \metastore\InvalidObjectException(); $xfer += $this->o2->read($input); } else { $xfer += $input->skip($ftype); @@ -48654,7 +49866,7 @@ class ThriftHiveMetastore_alter_resource_plan_result { public function write($output) { $xfer = 0; - $xfer += $output->writeStructBegin('ThriftHiveMetastore_alter_resource_plan_result'); + $xfer += $output->writeStructBegin('ThriftHiveMetastore_alter_wm_trigger_result'); if ($this->success !== null) { if (!is_object($this->success)) { throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); @@ -48685,11 +49897,11 @@ class ThriftHiveMetastore_alter_resource_plan_result { } -class ThriftHiveMetastore_validate_resource_plan_args { +class ThriftHiveMetastore_drop_wm_trigger_args { static $_TSPEC; /** - * @var \metastore\WMValidateResourcePlanRequest + * @var \metastore\WMDropTriggerRequest */ public $request = null; @@ -48699,7 +49911,7 @@ class ThriftHiveMetastore_validate_resource_plan_args { 1 => array( 'var' => 'request', 'type' => TType::STRUCT, - 'class' => '\metastore\WMValidateResourcePlanRequest', + 'class' => '\metastore\WMDropTriggerRequest', ), ); } @@ -48711,7 +49923,7 @@ class ThriftHiveMetastore_validate_resource_plan_args { } public function getName() { - return 'ThriftHiveMetastore_validate_resource_plan_args'; + return 'ThriftHiveMetastore_drop_wm_trigger_args'; } public function read($input) @@ -48731,7 +49943,7 @@ class ThriftHiveMetastore_validate_resource_plan_args { { case 1: if ($ftype == TType::STRUCT) { - $this->request = new \metastore\WMValidateResourcePlanRequest(); + $this->request = new \metastore\WMDropTriggerRequest(); $xfer += $this->request->read($input); } else { $xfer += $input->skip($ftype); @@ -48749,7 +49961,7 @@ class ThriftHiveMetastore_validate_resource_plan_args { public function write($output) { $xfer = 0; - $xfer += $output->writeStructBegin('ThriftHiveMetastore_validate_resource_plan_args'); + $xfer += $output->writeStructBegin('ThriftHiveMetastore_drop_wm_trigger_args'); if ($this->request !== null) { if (!is_object($this->request)) { throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); @@ -48765,11 +49977,11 @@ class ThriftHiveMetastore_validate_resource_plan_args { } -class ThriftHiveMetastore_validate_resource_plan_result { +class ThriftHiveMetastore_drop_wm_trigger_result { static $_TSPEC; /** - * @var \metastore\WMValidateResourcePlanResponse + * @var \metastore\WMDropTriggerResponse */ public $success = null; /** @@ -48777,9 +49989,13 @@ class ThriftHiveMetastore_validate_resource_plan_result { */ public $o1 = null; /** - * @var \metastore\MetaException + * @var \metastore\InvalidOperationException */ public $o2 = null; + /** + * @var \metastore\MetaException + */ + public $o3 = null; public function __construct($vals=null) { if (!isset(self::$_TSPEC)) { @@ -48787,7 +50003,7 @@ class ThriftHiveMetastore_validate_resource_plan_result { 0 => array( 'var' => 'success', 'type' => TType::STRUCT, - 'class' => '\metastore\WMValidateResourcePlanResponse', + 'class' => '\metastore\WMDropTriggerResponse', ), 1 => array( 'var' => 'o1', @@ -48797,6 +50013,11 @@ class ThriftHiveMetastore_validate_resource_plan_result { 2 => array( 'var' => 'o2', 'type' => TType::STRUCT, + 'class' => '\metastore\InvalidOperationException', + ), + 3 => array( + 'var' => 'o3', + 'type' => TType::STRUCT, 'class' => '\metastore\MetaException', ), ); @@ -48811,11 +50032,14 @@ class ThriftHiveMetastore_validate_resource_plan_result { if (isset($vals['o2'])) { $this->o2 = $vals['o2']; } + if (isset($vals['o3'])) { + $this->o3 = $vals['o3']; + } } } public function getName() { - return 'ThriftHiveMetastore_validate_resource_plan_result'; + return 'ThriftHiveMetastore_drop_wm_trigger_result'; } public function read($input) @@ -48835,7 +50059,7 @@ class ThriftHiveMetastore_validate_resource_plan_result { { case 0: if ($ftype == TType::STRUCT) { - $this->success = new \metastore\WMValidateResourcePlanResponse(); + $this->success = new \metastore\WMDropTriggerResponse(); $xfer += $this->success->read($input); } else { $xfer += $input->skip($ftype); @@ -48851,12 +50075,20 @@ class ThriftHiveMetastore_validate_resource_plan_result { break; case 2: if ($ftype == TType::STRUCT) { - $this->o2 = new \metastore\MetaException(); + $this->o2 = new \metastore\InvalidOperationException(); $xfer += $this->o2->read($input); } else { $xfer += $input->skip($ftype); } break; + case 3: + if ($ftype == TType::STRUCT) { + $this->o3 = new \metastore\MetaException(); + $xfer += $this->o3->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; default: $xfer += $input->skip($ftype); break; @@ -48869,7 +50101,7 @@ class ThriftHiveMetastore_validate_resource_plan_result { public function write($output) { $xfer = 0; - $xfer += $output->writeStructBegin('ThriftHiveMetastore_validate_resource_plan_result'); + $xfer += $output->writeStructBegin('ThriftHiveMetastore_drop_wm_trigger_result'); if ($this->success !== null) { if (!is_object($this->success)) { throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); @@ -48888,6 +50120,11 @@ class ThriftHiveMetastore_validate_resource_plan_result { $xfer += $this->o2->write($output); $xfer += $output->writeFieldEnd(); } + if ($this->o3 !== null) { + $xfer += $output->writeFieldBegin('o3', TType::STRUCT, 3); + $xfer += $this->o3->write($output); + $xfer += $output->writeFieldEnd(); + } $xfer += $output->writeFieldStop(); $xfer += $output->writeStructEnd(); return $xfer; @@ -48895,11 +50132,11 @@ class ThriftHiveMetastore_validate_resource_plan_result { } -class ThriftHiveMetastore_drop_resource_plan_args { +class ThriftHiveMetastore_get_triggers_for_resourceplan_args { static $_TSPEC; /** - * @var \metastore\WMDropResourcePlanRequest + * @var \metastore\WMGetTriggersForResourePlanRequest */ public $request = null; @@ -48909,7 +50146,7 @@ class ThriftHiveMetastore_drop_resource_plan_args { 1 => array( 'var' => 'request', 'type' => TType::STRUCT, - 'class' => '\metastore\WMDropResourcePlanRequest', + 'class' => '\metastore\WMGetTriggersForResourePlanRequest', ), ); } @@ -48921,7 +50158,7 @@ class ThriftHiveMetastore_drop_resource_plan_args { } public function getName() { - return 'ThriftHiveMetastore_drop_resource_plan_args'; + return 'ThriftHiveMetastore_get_triggers_for_resourceplan_args'; } public function read($input) @@ -48941,7 +50178,7 @@ class ThriftHiveMetastore_drop_resource_plan_args { { case 1: if ($ftype == TType::STRUCT) { - $this->request = new \metastore\WMDropResourcePlanRequest(); + $this->request = new \metastore\WMGetTriggersForResourePlanRequest(); $xfer += $this->request->read($input); } else { $xfer += $input->skip($ftype); @@ -48959,7 +50196,7 @@ class ThriftHiveMetastore_drop_resource_plan_args { public function write($output) { $xfer = 0; - $xfer += $output->writeStructBegin('ThriftHiveMetastore_drop_resource_plan_args'); + $xfer += $output->writeStructBegin('ThriftHiveMetastore_get_triggers_for_resourceplan_args'); if ($this->request !== null) { if (!is_object($this->request)) { throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); @@ -48975,25 +50212,21 @@ class ThriftHiveMetastore_drop_resource_plan_args { } -class ThriftHiveMetastore_drop_resource_plan_result { +class ThriftHiveMetastore_get_triggers_for_resourceplan_result { static $_TSPEC; /** - * @var \metastore\WMDropResourcePlanResponse + * @var \metastore\WMGetTriggersForResourePlanResponse */ public $success = null; /** * @var \metastore\NoSuchObjectException */ public $o1 = null; - /** - * @var \metastore\InvalidOperationException - */ - public $o2 = null; /** * @var \metastore\MetaException */ - public $o3 = null; + public $o2 = null; public function __construct($vals=null) { if (!isset(self::$_TSPEC)) { @@ -49001,7 +50234,7 @@ class ThriftHiveMetastore_drop_resource_plan_result { 0 => array( 'var' => 'success', 'type' => TType::STRUCT, - 'class' => '\metastore\WMDropResourcePlanResponse', + 'class' => '\metastore\WMGetTriggersForResourePlanResponse', ), 1 => array( 'var' => 'o1', @@ -49011,11 +50244,6 @@ class ThriftHiveMetastore_drop_resource_plan_result { 2 => array( 'var' => 'o2', 'type' => TType::STRUCT, - 'class' => '\metastore\InvalidOperationException', - ), - 3 => array( - 'var' => 'o3', - 'type' => TType::STRUCT, 'class' => '\metastore\MetaException', ), ); @@ -49030,14 +50258,11 @@ class ThriftHiveMetastore_drop_resource_plan_result { if (isset($vals['o2'])) { $this->o2 = $vals['o2']; } - if (isset($vals['o3'])) { - $this->o3 = $vals['o3']; - } } } public function getName() { - return 'ThriftHiveMetastore_drop_resource_plan_result'; + return 'ThriftHiveMetastore_get_triggers_for_resourceplan_result'; } public function read($input) @@ -49057,7 +50282,7 @@ class ThriftHiveMetastore_drop_resource_plan_result { { case 0: if ($ftype == TType::STRUCT) { - $this->success = new \metastore\WMDropResourcePlanResponse(); + $this->success = new \metastore\WMGetTriggersForResourePlanResponse(); $xfer += $this->success->read($input); } else { $xfer += $input->skip($ftype); @@ -49073,20 +50298,12 @@ class ThriftHiveMetastore_drop_resource_plan_result { break; case 2: if ($ftype == TType::STRUCT) { - $this->o2 = new \metastore\InvalidOperationException(); + $this->o2 = new \metastore\MetaException(); $xfer += $this->o2->read($input); } else { $xfer += $input->skip($ftype); } break; - case 3: - if ($ftype == TType::STRUCT) { - $this->o3 = new \metastore\MetaException(); - $xfer += $this->o3->read($input); - } else { - $xfer += $input->skip($ftype); - } - break; default: $xfer += $input->skip($ftype); break; @@ -49099,7 +50316,7 @@ class ThriftHiveMetastore_drop_resource_plan_result { public function write($output) { $xfer = 0; - $xfer += $output->writeStructBegin('ThriftHiveMetastore_drop_resource_plan_result'); + $xfer += $output->writeStructBegin('ThriftHiveMetastore_get_triggers_for_resourceplan_result'); if ($this->success !== null) { if (!is_object($this->success)) { throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); @@ -49118,11 +50335,6 @@ class ThriftHiveMetastore_drop_resource_plan_result { $xfer += $this->o2->write($output); $xfer += $output->writeFieldEnd(); } - if ($this->o3 !== null) { - $xfer += $output->writeFieldBegin('o3', TType::STRUCT, 3); - $xfer += $this->o3->write($output); - $xfer += $output->writeFieldEnd(); - } $xfer += $output->writeFieldStop(); $xfer += $output->writeStructEnd(); return $xfer; diff --git standalone-metastore/src/gen/thrift/gen-php/metastore/Types.php standalone-metastore/src/gen/thrift/gen-php/metastore/Types.php index 5ff6bb6e67..55498bd484 100644 --- standalone-metastore/src/gen/thrift/gen-php/metastore/Types.php +++ standalone-metastore/src/gen/thrift/gen-php/metastore/Types.php @@ -20764,7 +20764,7 @@ class WMTrigger { /** * @var string */ - public $poolName = null; + public $triggerName = null; /** * @var string */ @@ -20782,7 +20782,7 @@ class WMTrigger { 'type' => TType::STRING, ), 2 => array( - 'var' => 'poolName', + 'var' => 'triggerName', 'type' => TType::STRING, ), 3 => array( @@ -20799,8 +20799,8 @@ class WMTrigger { if (isset($vals['resourcePlanName'])) { $this->resourcePlanName = $vals['resourcePlanName']; } - if (isset($vals['poolName'])) { - $this->poolName = $vals['poolName']; + if (isset($vals['triggerName'])) { + $this->triggerName = $vals['triggerName']; } if (isset($vals['triggerExpression'])) { $this->triggerExpression = $vals['triggerExpression']; @@ -20839,7 +20839,7 @@ class WMTrigger { break; case 2: if ($ftype == TType::STRING) { - $xfer += $input->readString($this->poolName); + $xfer += $input->readString($this->triggerName); } else { $xfer += $input->skip($ftype); } @@ -20876,9 +20876,9 @@ class WMTrigger { $xfer += $output->writeString($this->resourcePlanName); $xfer += $output->writeFieldEnd(); } - if ($this->poolName !== null) { - $xfer += $output->writeFieldBegin('poolName', TType::STRING, 2); - $xfer += $output->writeString($this->poolName); + if ($this->triggerName !== null) { + $xfer += $output->writeFieldBegin('triggerName', TType::STRING, 2); + $xfer += $output->writeString($this->triggerName); $xfer += $output->writeFieldEnd(); } if ($this->triggerExpression !== null) { @@ -21931,6 +21931,592 @@ class WMDropResourcePlanResponse { } +class WMCreateTriggerRequest { + static $_TSPEC; + + /** + * @var \metastore\WMTrigger + */ + public $trigger = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'trigger', + 'type' => TType::STRUCT, + 'class' => '\metastore\WMTrigger', + ), + ); + } + if (is_array($vals)) { + if (isset($vals['trigger'])) { + $this->trigger = $vals['trigger']; + } + } + } + + public function getName() { + return 'WMCreateTriggerRequest'; + } + + public function read($input) + { + $xfer = 0; + $fname = null; + $ftype = 0; + $fid = 0; + $xfer += $input->readStructBegin($fname); + while (true) + { + $xfer += $input->readFieldBegin($fname, $ftype, $fid); + if ($ftype == TType::STOP) { + break; + } + switch ($fid) + { + case 1: + if ($ftype == TType::STRUCT) { + $this->trigger = new \metastore\WMTrigger(); + $xfer += $this->trigger->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + default: + $xfer += $input->skip($ftype); + break; + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; + } + + public function write($output) { + $xfer = 0; + $xfer += $output->writeStructBegin('WMCreateTriggerRequest'); + if ($this->trigger !== null) { + if (!is_object($this->trigger)) { + throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); + } + $xfer += $output->writeFieldBegin('trigger', TType::STRUCT, 1); + $xfer += $this->trigger->write($output); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class WMCreateTriggerResponse { + static $_TSPEC; + + + public function __construct() { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + ); + } + } + + public function getName() { + return 'WMCreateTriggerResponse'; + } + + public function read($input) + { + $xfer = 0; + $fname = null; + $ftype = 0; + $fid = 0; + $xfer += $input->readStructBegin($fname); + while (true) + { + $xfer += $input->readFieldBegin($fname, $ftype, $fid); + if ($ftype == TType::STOP) { + break; + } + switch ($fid) + { + default: + $xfer += $input->skip($ftype); + break; + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; + } + + public function write($output) { + $xfer = 0; + $xfer += $output->writeStructBegin('WMCreateTriggerResponse'); + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class WMAlterTriggerRequest { + static $_TSPEC; + + /** + * @var \metastore\WMTrigger + */ + public $trigger = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'trigger', + 'type' => TType::STRUCT, + 'class' => '\metastore\WMTrigger', + ), + ); + } + if (is_array($vals)) { + if (isset($vals['trigger'])) { + $this->trigger = $vals['trigger']; + } + } + } + + public function getName() { + return 'WMAlterTriggerRequest'; + } + + public function read($input) + { + $xfer = 0; + $fname = null; + $ftype = 0; + $fid = 0; + $xfer += $input->readStructBegin($fname); + while (true) + { + $xfer += $input->readFieldBegin($fname, $ftype, $fid); + if ($ftype == TType::STOP) { + break; + } + switch ($fid) + { + case 1: + if ($ftype == TType::STRUCT) { + $this->trigger = new \metastore\WMTrigger(); + $xfer += $this->trigger->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + default: + $xfer += $input->skip($ftype); + break; + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; + } + + public function write($output) { + $xfer = 0; + $xfer += $output->writeStructBegin('WMAlterTriggerRequest'); + if ($this->trigger !== null) { + if (!is_object($this->trigger)) { + throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); + } + $xfer += $output->writeFieldBegin('trigger', TType::STRUCT, 1); + $xfer += $this->trigger->write($output); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class WMAlterTriggerResponse { + static $_TSPEC; + + + public function __construct() { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + ); + } + } + + public function getName() { + return 'WMAlterTriggerResponse'; + } + + public function read($input) + { + $xfer = 0; + $fname = null; + $ftype = 0; + $fid = 0; + $xfer += $input->readStructBegin($fname); + while (true) + { + $xfer += $input->readFieldBegin($fname, $ftype, $fid); + if ($ftype == TType::STOP) { + break; + } + switch ($fid) + { + default: + $xfer += $input->skip($ftype); + break; + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; + } + + public function write($output) { + $xfer = 0; + $xfer += $output->writeStructBegin('WMAlterTriggerResponse'); + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class WMDropTriggerRequest { + static $_TSPEC; + + /** + * @var string + */ + public $resourcePlanName = null; + /** + * @var string + */ + public $triggerName = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'resourcePlanName', + 'type' => TType::STRING, + ), + 2 => array( + 'var' => 'triggerName', + 'type' => TType::STRING, + ), + ); + } + if (is_array($vals)) { + if (isset($vals['resourcePlanName'])) { + $this->resourcePlanName = $vals['resourcePlanName']; + } + if (isset($vals['triggerName'])) { + $this->triggerName = $vals['triggerName']; + } + } + } + + public function getName() { + return 'WMDropTriggerRequest'; + } + + public function read($input) + { + $xfer = 0; + $fname = null; + $ftype = 0; + $fid = 0; + $xfer += $input->readStructBegin($fname); + while (true) + { + $xfer += $input->readFieldBegin($fname, $ftype, $fid); + if ($ftype == TType::STOP) { + break; + } + switch ($fid) + { + case 1: + if ($ftype == TType::STRING) { + $xfer += $input->readString($this->resourcePlanName); + } else { + $xfer += $input->skip($ftype); + } + break; + case 2: + if ($ftype == TType::STRING) { + $xfer += $input->readString($this->triggerName); + } else { + $xfer += $input->skip($ftype); + } + break; + default: + $xfer += $input->skip($ftype); + break; + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; + } + + public function write($output) { + $xfer = 0; + $xfer += $output->writeStructBegin('WMDropTriggerRequest'); + if ($this->resourcePlanName !== null) { + $xfer += $output->writeFieldBegin('resourcePlanName', TType::STRING, 1); + $xfer += $output->writeString($this->resourcePlanName); + $xfer += $output->writeFieldEnd(); + } + if ($this->triggerName !== null) { + $xfer += $output->writeFieldBegin('triggerName', TType::STRING, 2); + $xfer += $output->writeString($this->triggerName); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class WMDropTriggerResponse { + static $_TSPEC; + + + public function __construct() { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + ); + } + } + + public function getName() { + return 'WMDropTriggerResponse'; + } + + public function read($input) + { + $xfer = 0; + $fname = null; + $ftype = 0; + $fid = 0; + $xfer += $input->readStructBegin($fname); + while (true) + { + $xfer += $input->readFieldBegin($fname, $ftype, $fid); + if ($ftype == TType::STOP) { + break; + } + switch ($fid) + { + default: + $xfer += $input->skip($ftype); + break; + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; + } + + public function write($output) { + $xfer = 0; + $xfer += $output->writeStructBegin('WMDropTriggerResponse'); + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class WMGetTriggersForResourePlanRequest { + static $_TSPEC; + + /** + * @var string + */ + public $resourcePlanName = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'resourcePlanName', + 'type' => TType::STRING, + ), + ); + } + if (is_array($vals)) { + if (isset($vals['resourcePlanName'])) { + $this->resourcePlanName = $vals['resourcePlanName']; + } + } + } + + public function getName() { + return 'WMGetTriggersForResourePlanRequest'; + } + + public function read($input) + { + $xfer = 0; + $fname = null; + $ftype = 0; + $fid = 0; + $xfer += $input->readStructBegin($fname); + while (true) + { + $xfer += $input->readFieldBegin($fname, $ftype, $fid); + if ($ftype == TType::STOP) { + break; + } + switch ($fid) + { + case 1: + if ($ftype == TType::STRING) { + $xfer += $input->readString($this->resourcePlanName); + } else { + $xfer += $input->skip($ftype); + } + break; + default: + $xfer += $input->skip($ftype); + break; + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; + } + + public function write($output) { + $xfer = 0; + $xfer += $output->writeStructBegin('WMGetTriggersForResourePlanRequest'); + if ($this->resourcePlanName !== null) { + $xfer += $output->writeFieldBegin('resourcePlanName', TType::STRING, 1); + $xfer += $output->writeString($this->resourcePlanName); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class WMGetTriggersForResourePlanResponse { + static $_TSPEC; + + /** + * @var \metastore\WMTrigger[] + */ + public $triggers = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'triggers', + 'type' => TType::LST, + 'etype' => TType::STRUCT, + 'elem' => array( + 'type' => TType::STRUCT, + 'class' => '\metastore\WMTrigger', + ), + ), + ); + } + if (is_array($vals)) { + if (isset($vals['triggers'])) { + $this->triggers = $vals['triggers']; + } + } + } + + public function getName() { + return 'WMGetTriggersForResourePlanResponse'; + } + + public function read($input) + { + $xfer = 0; + $fname = null; + $ftype = 0; + $fid = 0; + $xfer += $input->readStructBegin($fname); + while (true) + { + $xfer += $input->readFieldBegin($fname, $ftype, $fid); + if ($ftype == TType::STOP) { + break; + } + switch ($fid) + { + case 1: + if ($ftype == TType::LST) { + $this->triggers = array(); + $_size659 = 0; + $_etype662 = 0; + $xfer += $input->readListBegin($_etype662, $_size659); + for ($_i663 = 0; $_i663 < $_size659; ++$_i663) + { + $elem664 = null; + $elem664 = new \metastore\WMTrigger(); + $xfer += $elem664->read($input); + $this->triggers []= $elem664; + } + $xfer += $input->readListEnd(); + } else { + $xfer += $input->skip($ftype); + } + break; + default: + $xfer += $input->skip($ftype); + break; + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; + } + + public function write($output) { + $xfer = 0; + $xfer += $output->writeStructBegin('WMGetTriggersForResourePlanResponse'); + if ($this->triggers !== null) { + if (!is_array($this->triggers)) { + throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); + } + $xfer += $output->writeFieldBegin('triggers', TType::LST, 1); + { + $output->writeListBegin(TType::STRUCT, count($this->triggers)); + { + foreach ($this->triggers as $iter665) + { + $xfer += $iter665->write($output); + } + } + $output->writeListEnd(); + } + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + class MetaException extends TException { static $_TSPEC; diff --git standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote index 5e677240be..7dc34dd7fa 100755 --- standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote +++ standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote @@ -192,6 +192,10 @@ if len(sys.argv) <= 1 or sys.argv[1] == '--help': print(' WMAlterResourcePlanResponse alter_resource_plan(WMAlterResourcePlanRequest request)') print(' WMValidateResourcePlanResponse validate_resource_plan(WMValidateResourcePlanRequest request)') print(' WMDropResourcePlanResponse drop_resource_plan(WMDropResourcePlanRequest request)') + print(' WMCreateTriggerResponse create_wm_trigger(WMCreateTriggerRequest request)') + print(' WMAlterTriggerResponse alter_wm_trigger(WMAlterTriggerRequest request)') + print(' WMDropTriggerResponse drop_wm_trigger(WMDropTriggerRequest request)') + print(' WMGetTriggersForResourePlanResponse get_triggers_for_resourceplan(WMGetTriggersForResourePlanRequest request)') print(' string getName()') print(' string getVersion()') print(' fb_status getStatus()') @@ -1269,6 +1273,30 @@ elif cmd == 'drop_resource_plan': sys.exit(1) pp.pprint(client.drop_resource_plan(eval(args[0]),)) +elif cmd == 'create_wm_trigger': + if len(args) != 1: + print('create_wm_trigger requires 1 args') + sys.exit(1) + pp.pprint(client.create_wm_trigger(eval(args[0]),)) + +elif cmd == 'alter_wm_trigger': + if len(args) != 1: + print('alter_wm_trigger requires 1 args') + sys.exit(1) + pp.pprint(client.alter_wm_trigger(eval(args[0]),)) + +elif cmd == 'drop_wm_trigger': + if len(args) != 1: + print('drop_wm_trigger requires 1 args') + sys.exit(1) + pp.pprint(client.drop_wm_trigger(eval(args[0]),)) + +elif cmd == 'get_triggers_for_resourceplan': + if len(args) != 1: + print('get_triggers_for_resourceplan requires 1 args') + sys.exit(1) + pp.pprint(client.get_triggers_for_resourceplan(eval(args[0]),)) + elif cmd == 'getName': if len(args) != 0: print('getName requires 0 args') diff --git standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py index 08864b7309..e627952444 100644 --- standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py +++ standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py @@ -1335,6 +1335,34 @@ def drop_resource_plan(self, request): """ pass + def create_wm_trigger(self, request): + """ + Parameters: + - request + """ + pass + + def alter_wm_trigger(self, request): + """ + Parameters: + - request + """ + pass + + def drop_wm_trigger(self, request): + """ + Parameters: + - request + """ + pass + + def get_triggers_for_resourceplan(self, request): + """ + Parameters: + - request + """ + pass + class Client(fb303.FacebookService.Client, Iface): """ @@ -7383,6 +7411,154 @@ def recv_drop_resource_plan(self): raise result.o3 raise TApplicationException(TApplicationException.MISSING_RESULT, "drop_resource_plan failed: unknown result") + def create_wm_trigger(self, request): + """ + Parameters: + - request + """ + self.send_create_wm_trigger(request) + return self.recv_create_wm_trigger() + + def send_create_wm_trigger(self, request): + self._oprot.writeMessageBegin('create_wm_trigger', TMessageType.CALL, self._seqid) + args = create_wm_trigger_args() + args.request = request + args.write(self._oprot) + self._oprot.writeMessageEnd() + self._oprot.trans.flush() + + def recv_create_wm_trigger(self): + iprot = self._iprot + (fname, mtype, rseqid) = iprot.readMessageBegin() + if mtype == TMessageType.EXCEPTION: + x = TApplicationException() + x.read(iprot) + iprot.readMessageEnd() + raise x + result = create_wm_trigger_result() + result.read(iprot) + 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 + if result.o4 is not None: + raise result.o4 + raise TApplicationException(TApplicationException.MISSING_RESULT, "create_wm_trigger failed: unknown result") + + def alter_wm_trigger(self, request): + """ + Parameters: + - request + """ + self.send_alter_wm_trigger(request) + return self.recv_alter_wm_trigger() + + def send_alter_wm_trigger(self, request): + self._oprot.writeMessageBegin('alter_wm_trigger', TMessageType.CALL, self._seqid) + args = alter_wm_trigger_args() + args.request = request + args.write(self._oprot) + self._oprot.writeMessageEnd() + self._oprot.trans.flush() + + def recv_alter_wm_trigger(self): + iprot = self._iprot + (fname, mtype, rseqid) = iprot.readMessageBegin() + if mtype == TMessageType.EXCEPTION: + x = TApplicationException() + x.read(iprot) + iprot.readMessageEnd() + raise x + result = alter_wm_trigger_result() + result.read(iprot) + 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, "alter_wm_trigger failed: unknown result") + + def drop_wm_trigger(self, request): + """ + Parameters: + - request + """ + self.send_drop_wm_trigger(request) + return self.recv_drop_wm_trigger() + + def send_drop_wm_trigger(self, request): + self._oprot.writeMessageBegin('drop_wm_trigger', TMessageType.CALL, self._seqid) + args = drop_wm_trigger_args() + args.request = request + args.write(self._oprot) + self._oprot.writeMessageEnd() + self._oprot.trans.flush() + + def recv_drop_wm_trigger(self): + iprot = self._iprot + (fname, mtype, rseqid) = iprot.readMessageBegin() + if mtype == TMessageType.EXCEPTION: + x = TApplicationException() + x.read(iprot) + iprot.readMessageEnd() + raise x + result = drop_wm_trigger_result() + result.read(iprot) + 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_wm_trigger failed: unknown result") + + def get_triggers_for_resourceplan(self, request): + """ + Parameters: + - request + """ + self.send_get_triggers_for_resourceplan(request) + return self.recv_get_triggers_for_resourceplan() + + def send_get_triggers_for_resourceplan(self, request): + self._oprot.writeMessageBegin('get_triggers_for_resourceplan', TMessageType.CALL, self._seqid) + args = get_triggers_for_resourceplan_args() + args.request = request + args.write(self._oprot) + self._oprot.writeMessageEnd() + self._oprot.trans.flush() + + def recv_get_triggers_for_resourceplan(self): + iprot = self._iprot + (fname, mtype, rseqid) = iprot.readMessageBegin() + if mtype == TMessageType.EXCEPTION: + x = TApplicationException() + x.read(iprot) + iprot.readMessageEnd() + raise x + result = get_triggers_for_resourceplan_result() + result.read(iprot) + 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_triggers_for_resourceplan failed: unknown result") + class Processor(fb303.FacebookService.Processor, Iface, TProcessor): def __init__(self, handler): @@ -7555,6 +7731,10 @@ def __init__(self, handler): self._processMap["alter_resource_plan"] = Processor.process_alter_resource_plan self._processMap["validate_resource_plan"] = Processor.process_validate_resource_plan self._processMap["drop_resource_plan"] = Processor.process_drop_resource_plan + self._processMap["create_wm_trigger"] = Processor.process_create_wm_trigger + self._processMap["alter_wm_trigger"] = Processor.process_alter_wm_trigger + self._processMap["drop_wm_trigger"] = Processor.process_drop_wm_trigger + self._processMap["get_triggers_for_resourceplan"] = Processor.process_get_triggers_for_resourceplan def process(self, iprot, oprot): (name, type, seqid) = iprot.readMessageBegin() @@ -11672,6 +11852,118 @@ def process_drop_resource_plan(self, seqid, iprot, oprot): oprot.writeMessageEnd() oprot.trans.flush() + def process_create_wm_trigger(self, seqid, iprot, oprot): + args = create_wm_trigger_args() + args.read(iprot) + iprot.readMessageEnd() + result = create_wm_trigger_result() + try: + result.success = self._handler.create_wm_trigger(args.request) + msg_type = TMessageType.REPLY + except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): + raise + except AlreadyExistsException as o1: + msg_type = TMessageType.REPLY + result.o1 = o1 + except NoSuchObjectException as o2: + msg_type = TMessageType.REPLY + result.o2 = o2 + except InvalidObjectException as o3: + msg_type = TMessageType.REPLY + result.o3 = o3 + except MetaException as o4: + msg_type = TMessageType.REPLY + result.o4 = o4 + except Exception as ex: + msg_type = TMessageType.EXCEPTION + logging.exception(ex) + result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') + oprot.writeMessageBegin("create_wm_trigger", msg_type, seqid) + result.write(oprot) + oprot.writeMessageEnd() + oprot.trans.flush() + + def process_alter_wm_trigger(self, seqid, iprot, oprot): + args = alter_wm_trigger_args() + args.read(iprot) + iprot.readMessageEnd() + result = alter_wm_trigger_result() + try: + result.success = self._handler.alter_wm_trigger(args.request) + msg_type = TMessageType.REPLY + except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): + raise + except NoSuchObjectException as o1: + msg_type = TMessageType.REPLY + result.o1 = o1 + except InvalidObjectException as o2: + msg_type = TMessageType.REPLY + result.o2 = o2 + except MetaException as o3: + msg_type = TMessageType.REPLY + result.o3 = o3 + except Exception as ex: + msg_type = TMessageType.EXCEPTION + logging.exception(ex) + result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') + oprot.writeMessageBegin("alter_wm_trigger", msg_type, seqid) + result.write(oprot) + oprot.writeMessageEnd() + oprot.trans.flush() + + def process_drop_wm_trigger(self, seqid, iprot, oprot): + args = drop_wm_trigger_args() + args.read(iprot) + iprot.readMessageEnd() + result = drop_wm_trigger_result() + try: + result.success = self._handler.drop_wm_trigger(args.request) + msg_type = TMessageType.REPLY + except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): + raise + except NoSuchObjectException as o1: + msg_type = TMessageType.REPLY + result.o1 = o1 + except InvalidOperationException as o2: + msg_type = TMessageType.REPLY + result.o2 = o2 + except MetaException as o3: + msg_type = TMessageType.REPLY + result.o3 = o3 + except Exception as ex: + msg_type = TMessageType.EXCEPTION + logging.exception(ex) + result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') + oprot.writeMessageBegin("drop_wm_trigger", msg_type, seqid) + result.write(oprot) + oprot.writeMessageEnd() + oprot.trans.flush() + + def process_get_triggers_for_resourceplan(self, seqid, iprot, oprot): + args = get_triggers_for_resourceplan_args() + args.read(iprot) + iprot.readMessageEnd() + result = get_triggers_for_resourceplan_result() + try: + result.success = self._handler.get_triggers_for_resourceplan(args.request) + msg_type = TMessageType.REPLY + except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): + raise + except NoSuchObjectException as o1: + msg_type = TMessageType.REPLY + result.o1 = o1 + except MetaException as o2: + msg_type = TMessageType.REPLY + result.o2 = o2 + except Exception as ex: + msg_type = TMessageType.EXCEPTION + logging.exception(ex) + result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') + oprot.writeMessageBegin("get_triggers_for_resourceplan", msg_type, seqid) + result.write(oprot) + oprot.writeMessageEnd() + oprot.trans.flush() + # HELPER FUNCTIONS AND STRUCTURES @@ -12558,10 +12850,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype660, _size657) = iprot.readListBegin() - for _i661 in xrange(_size657): - _elem662 = iprot.readString() - self.success.append(_elem662) + (_etype667, _size664) = iprot.readListBegin() + for _i668 in xrange(_size664): + _elem669 = iprot.readString() + self.success.append(_elem669) iprot.readListEnd() else: iprot.skip(ftype) @@ -12584,8 +12876,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter663 in self.success: - oprot.writeString(iter663) + for iter670 in self.success: + oprot.writeString(iter670) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -12690,10 +12982,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype667, _size664) = iprot.readListBegin() - for _i668 in xrange(_size664): - _elem669 = iprot.readString() - self.success.append(_elem669) + (_etype674, _size671) = iprot.readListBegin() + for _i675 in xrange(_size671): + _elem676 = iprot.readString() + self.success.append(_elem676) iprot.readListEnd() else: iprot.skip(ftype) @@ -12716,8 +13008,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter670 in self.success: - oprot.writeString(iter670) + for iter677 in self.success: + oprot.writeString(iter677) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -13487,12 +13779,12 @@ def read(self, iprot): if fid == 0: if ftype == TType.MAP: self.success = {} - (_ktype672, _vtype673, _size671 ) = iprot.readMapBegin() - for _i675 in xrange(_size671): - _key676 = iprot.readString() - _val677 = Type() - _val677.read(iprot) - self.success[_key676] = _val677 + (_ktype679, _vtype680, _size678 ) = iprot.readMapBegin() + for _i682 in xrange(_size678): + _key683 = iprot.readString() + _val684 = Type() + _val684.read(iprot) + self.success[_key683] = _val684 iprot.readMapEnd() else: iprot.skip(ftype) @@ -13515,9 +13807,9 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.MAP, 0) oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success)) - for kiter678,viter679 in self.success.items(): - oprot.writeString(kiter678) - viter679.write(oprot) + for kiter685,viter686 in self.success.items(): + oprot.writeString(kiter685) + viter686.write(oprot) oprot.writeMapEnd() oprot.writeFieldEnd() if self.o2 is not None: @@ -13660,11 +13952,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype683, _size680) = iprot.readListBegin() - for _i684 in xrange(_size680): - _elem685 = FieldSchema() - _elem685.read(iprot) - self.success.append(_elem685) + (_etype690, _size687) = iprot.readListBegin() + for _i691 in xrange(_size687): + _elem692 = FieldSchema() + _elem692.read(iprot) + self.success.append(_elem692) iprot.readListEnd() else: iprot.skip(ftype) @@ -13699,8 +13991,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter686 in self.success: - iter686.write(oprot) + for iter693 in self.success: + iter693.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -13867,11 +14159,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype690, _size687) = iprot.readListBegin() - for _i691 in xrange(_size687): - _elem692 = FieldSchema() - _elem692.read(iprot) - self.success.append(_elem692) + (_etype697, _size694) = iprot.readListBegin() + for _i698 in xrange(_size694): + _elem699 = FieldSchema() + _elem699.read(iprot) + self.success.append(_elem699) iprot.readListEnd() else: iprot.skip(ftype) @@ -13906,8 +14198,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter693 in self.success: - iter693.write(oprot) + for iter700 in self.success: + iter700.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -14060,11 +14352,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype697, _size694) = iprot.readListBegin() - for _i698 in xrange(_size694): - _elem699 = FieldSchema() - _elem699.read(iprot) - self.success.append(_elem699) + (_etype704, _size701) = iprot.readListBegin() + for _i705 in xrange(_size701): + _elem706 = FieldSchema() + _elem706.read(iprot) + self.success.append(_elem706) iprot.readListEnd() else: iprot.skip(ftype) @@ -14099,8 +14391,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter700 in self.success: - iter700.write(oprot) + for iter707 in self.success: + iter707.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -14267,11 +14559,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype704, _size701) = iprot.readListBegin() - for _i705 in xrange(_size701): - _elem706 = FieldSchema() - _elem706.read(iprot) - self.success.append(_elem706) + (_etype711, _size708) = iprot.readListBegin() + for _i712 in xrange(_size708): + _elem713 = FieldSchema() + _elem713.read(iprot) + self.success.append(_elem713) iprot.readListEnd() else: iprot.skip(ftype) @@ -14306,8 +14598,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter707 in self.success: - iter707.write(oprot) + for iter714 in self.success: + iter714.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -14754,44 +15046,44 @@ def read(self, iprot): elif fid == 2: if ftype == TType.LIST: self.primaryKeys = [] - (_etype711, _size708) = iprot.readListBegin() - for _i712 in xrange(_size708): - _elem713 = SQLPrimaryKey() - _elem713.read(iprot) - self.primaryKeys.append(_elem713) + (_etype718, _size715) = iprot.readListBegin() + for _i719 in xrange(_size715): + _elem720 = SQLPrimaryKey() + _elem720.read(iprot) + self.primaryKeys.append(_elem720) iprot.readListEnd() else: iprot.skip(ftype) elif fid == 3: if ftype == TType.LIST: self.foreignKeys = [] - (_etype717, _size714) = iprot.readListBegin() - for _i718 in xrange(_size714): - _elem719 = SQLForeignKey() - _elem719.read(iprot) - self.foreignKeys.append(_elem719) + (_etype724, _size721) = iprot.readListBegin() + for _i725 in xrange(_size721): + _elem726 = SQLForeignKey() + _elem726.read(iprot) + self.foreignKeys.append(_elem726) iprot.readListEnd() else: iprot.skip(ftype) elif fid == 4: if ftype == TType.LIST: self.uniqueConstraints = [] - (_etype723, _size720) = iprot.readListBegin() - for _i724 in xrange(_size720): - _elem725 = SQLUniqueConstraint() - _elem725.read(iprot) - self.uniqueConstraints.append(_elem725) + (_etype730, _size727) = iprot.readListBegin() + for _i731 in xrange(_size727): + _elem732 = SQLUniqueConstraint() + _elem732.read(iprot) + self.uniqueConstraints.append(_elem732) iprot.readListEnd() else: iprot.skip(ftype) elif fid == 5: if ftype == TType.LIST: self.notNullConstraints = [] - (_etype729, _size726) = iprot.readListBegin() - for _i730 in xrange(_size726): - _elem731 = SQLNotNullConstraint() - _elem731.read(iprot) - self.notNullConstraints.append(_elem731) + (_etype736, _size733) = iprot.readListBegin() + for _i737 in xrange(_size733): + _elem738 = SQLNotNullConstraint() + _elem738.read(iprot) + self.notNullConstraints.append(_elem738) iprot.readListEnd() else: iprot.skip(ftype) @@ -14812,29 +15104,29 @@ def write(self, oprot): if self.primaryKeys is not None: oprot.writeFieldBegin('primaryKeys', TType.LIST, 2) oprot.writeListBegin(TType.STRUCT, len(self.primaryKeys)) - for iter732 in self.primaryKeys: - iter732.write(oprot) + for iter739 in self.primaryKeys: + iter739.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.foreignKeys is not None: oprot.writeFieldBegin('foreignKeys', TType.LIST, 3) oprot.writeListBegin(TType.STRUCT, len(self.foreignKeys)) - for iter733 in self.foreignKeys: - iter733.write(oprot) + for iter740 in self.foreignKeys: + iter740.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.uniqueConstraints is not None: oprot.writeFieldBegin('uniqueConstraints', TType.LIST, 4) oprot.writeListBegin(TType.STRUCT, len(self.uniqueConstraints)) - for iter734 in self.uniqueConstraints: - iter734.write(oprot) + for iter741 in self.uniqueConstraints: + iter741.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.notNullConstraints is not None: oprot.writeFieldBegin('notNullConstraints', TType.LIST, 5) oprot.writeListBegin(TType.STRUCT, len(self.notNullConstraints)) - for iter735 in self.notNullConstraints: - iter735.write(oprot) + for iter742 in self.notNullConstraints: + iter742.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -16100,10 +16392,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.partNames = [] - (_etype739, _size736) = iprot.readListBegin() - for _i740 in xrange(_size736): - _elem741 = iprot.readString() - self.partNames.append(_elem741) + (_etype746, _size743) = iprot.readListBegin() + for _i747 in xrange(_size743): + _elem748 = iprot.readString() + self.partNames.append(_elem748) iprot.readListEnd() else: iprot.skip(ftype) @@ -16128,8 +16420,8 @@ def write(self, oprot): if self.partNames is not None: oprot.writeFieldBegin('partNames', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.partNames)) - for iter742 in self.partNames: - oprot.writeString(iter742) + for iter749 in self.partNames: + oprot.writeString(iter749) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -16329,10 +16621,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype746, _size743) = iprot.readListBegin() - for _i747 in xrange(_size743): - _elem748 = iprot.readString() - self.success.append(_elem748) + (_etype753, _size750) = iprot.readListBegin() + for _i754 in xrange(_size750): + _elem755 = iprot.readString() + self.success.append(_elem755) iprot.readListEnd() else: iprot.skip(ftype) @@ -16355,8 +16647,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter749 in self.success: - oprot.writeString(iter749) + for iter756 in self.success: + oprot.writeString(iter756) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -16506,10 +16798,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype753, _size750) = iprot.readListBegin() - for _i754 in xrange(_size750): - _elem755 = iprot.readString() - self.success.append(_elem755) + (_etype760, _size757) = iprot.readListBegin() + for _i761 in xrange(_size757): + _elem762 = iprot.readString() + self.success.append(_elem762) iprot.readListEnd() else: iprot.skip(ftype) @@ -16532,8 +16824,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter756 in self.success: - oprot.writeString(iter756) + for iter763 in self.success: + oprot.writeString(iter763) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -16606,10 +16898,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.tbl_types = [] - (_etype760, _size757) = iprot.readListBegin() - for _i761 in xrange(_size757): - _elem762 = iprot.readString() - self.tbl_types.append(_elem762) + (_etype767, _size764) = iprot.readListBegin() + for _i768 in xrange(_size764): + _elem769 = iprot.readString() + self.tbl_types.append(_elem769) iprot.readListEnd() else: iprot.skip(ftype) @@ -16634,8 +16926,8 @@ def write(self, oprot): if self.tbl_types is not None: oprot.writeFieldBegin('tbl_types', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.tbl_types)) - for iter763 in self.tbl_types: - oprot.writeString(iter763) + for iter770 in self.tbl_types: + oprot.writeString(iter770) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -16691,11 +16983,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype767, _size764) = iprot.readListBegin() - for _i768 in xrange(_size764): - _elem769 = TableMeta() - _elem769.read(iprot) - self.success.append(_elem769) + (_etype774, _size771) = iprot.readListBegin() + for _i775 in xrange(_size771): + _elem776 = TableMeta() + _elem776.read(iprot) + self.success.append(_elem776) iprot.readListEnd() else: iprot.skip(ftype) @@ -16718,8 +17010,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter770 in self.success: - iter770.write(oprot) + for iter777 in self.success: + iter777.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -16843,10 +17135,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype774, _size771) = iprot.readListBegin() - for _i775 in xrange(_size771): - _elem776 = iprot.readString() - self.success.append(_elem776) + (_etype781, _size778) = iprot.readListBegin() + for _i782 in xrange(_size778): + _elem783 = iprot.readString() + self.success.append(_elem783) iprot.readListEnd() else: iprot.skip(ftype) @@ -16869,8 +17161,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter777 in self.success: - oprot.writeString(iter777) + for iter784 in self.success: + oprot.writeString(iter784) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -17106,10 +17398,10 @@ def read(self, iprot): elif fid == 2: if ftype == TType.LIST: self.tbl_names = [] - (_etype781, _size778) = iprot.readListBegin() - for _i782 in xrange(_size778): - _elem783 = iprot.readString() - self.tbl_names.append(_elem783) + (_etype788, _size785) = iprot.readListBegin() + for _i789 in xrange(_size785): + _elem790 = iprot.readString() + self.tbl_names.append(_elem790) iprot.readListEnd() else: iprot.skip(ftype) @@ -17130,8 +17422,8 @@ def write(self, oprot): if self.tbl_names is not None: oprot.writeFieldBegin('tbl_names', TType.LIST, 2) oprot.writeListBegin(TType.STRING, len(self.tbl_names)) - for iter784 in self.tbl_names: - oprot.writeString(iter784) + for iter791 in self.tbl_names: + oprot.writeString(iter791) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -17183,11 +17475,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype788, _size785) = iprot.readListBegin() - for _i789 in xrange(_size785): - _elem790 = Table() - _elem790.read(iprot) - self.success.append(_elem790) + (_etype795, _size792) = iprot.readListBegin() + for _i796 in xrange(_size792): + _elem797 = Table() + _elem797.read(iprot) + self.success.append(_elem797) iprot.readListEnd() else: iprot.skip(ftype) @@ -17204,8 +17496,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter791 in self.success: - iter791.write(oprot) + for iter798 in self.success: + iter798.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -17688,10 +17980,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype795, _size792) = iprot.readListBegin() - for _i796 in xrange(_size792): - _elem797 = iprot.readString() - self.success.append(_elem797) + (_etype802, _size799) = iprot.readListBegin() + for _i803 in xrange(_size799): + _elem804 = iprot.readString() + self.success.append(_elem804) iprot.readListEnd() else: iprot.skip(ftype) @@ -17726,8 +18018,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter798 in self.success: - oprot.writeString(iter798) + for iter805 in self.success: + oprot.writeString(iter805) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -18697,11 +18989,11 @@ def read(self, iprot): if fid == 1: if ftype == TType.LIST: self.new_parts = [] - (_etype802, _size799) = iprot.readListBegin() - for _i803 in xrange(_size799): - _elem804 = Partition() - _elem804.read(iprot) - self.new_parts.append(_elem804) + (_etype809, _size806) = iprot.readListBegin() + for _i810 in xrange(_size806): + _elem811 = Partition() + _elem811.read(iprot) + self.new_parts.append(_elem811) iprot.readListEnd() else: iprot.skip(ftype) @@ -18718,8 +19010,8 @@ def write(self, oprot): if self.new_parts is not None: oprot.writeFieldBegin('new_parts', TType.LIST, 1) oprot.writeListBegin(TType.STRUCT, len(self.new_parts)) - for iter805 in self.new_parts: - iter805.write(oprot) + for iter812 in self.new_parts: + iter812.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -18877,11 +19169,11 @@ def read(self, iprot): if fid == 1: if ftype == TType.LIST: self.new_parts = [] - (_etype809, _size806) = iprot.readListBegin() - for _i810 in xrange(_size806): - _elem811 = PartitionSpec() - _elem811.read(iprot) - self.new_parts.append(_elem811) + (_etype816, _size813) = iprot.readListBegin() + for _i817 in xrange(_size813): + _elem818 = PartitionSpec() + _elem818.read(iprot) + self.new_parts.append(_elem818) iprot.readListEnd() else: iprot.skip(ftype) @@ -18898,8 +19190,8 @@ def write(self, oprot): if self.new_parts is not None: oprot.writeFieldBegin('new_parts', TType.LIST, 1) oprot.writeListBegin(TType.STRUCT, len(self.new_parts)) - for iter812 in self.new_parts: - iter812.write(oprot) + for iter819 in self.new_parts: + iter819.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -19073,10 +19365,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype816, _size813) = iprot.readListBegin() - for _i817 in xrange(_size813): - _elem818 = iprot.readString() - self.part_vals.append(_elem818) + (_etype823, _size820) = iprot.readListBegin() + for _i824 in xrange(_size820): + _elem825 = iprot.readString() + self.part_vals.append(_elem825) iprot.readListEnd() else: iprot.skip(ftype) @@ -19101,8 +19393,8 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter819 in self.part_vals: - oprot.writeString(iter819) + for iter826 in self.part_vals: + oprot.writeString(iter826) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -19455,10 +19747,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype823, _size820) = iprot.readListBegin() - for _i824 in xrange(_size820): - _elem825 = iprot.readString() - self.part_vals.append(_elem825) + (_etype830, _size827) = iprot.readListBegin() + for _i831 in xrange(_size827): + _elem832 = iprot.readString() + self.part_vals.append(_elem832) iprot.readListEnd() else: iprot.skip(ftype) @@ -19489,8 +19781,8 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter826 in self.part_vals: - oprot.writeString(iter826) + for iter833 in self.part_vals: + oprot.writeString(iter833) oprot.writeListEnd() oprot.writeFieldEnd() if self.environment_context is not None: @@ -20085,10 +20377,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype830, _size827) = iprot.readListBegin() - for _i831 in xrange(_size827): - _elem832 = iprot.readString() - self.part_vals.append(_elem832) + (_etype837, _size834) = iprot.readListBegin() + for _i838 in xrange(_size834): + _elem839 = iprot.readString() + self.part_vals.append(_elem839) iprot.readListEnd() else: iprot.skip(ftype) @@ -20118,8 +20410,8 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter833 in self.part_vals: - oprot.writeString(iter833) + for iter840 in self.part_vals: + oprot.writeString(iter840) oprot.writeListEnd() oprot.writeFieldEnd() if self.deleteData is not None: @@ -20292,10 +20584,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype837, _size834) = iprot.readListBegin() - for _i838 in xrange(_size834): - _elem839 = iprot.readString() - self.part_vals.append(_elem839) + (_etype844, _size841) = iprot.readListBegin() + for _i845 in xrange(_size841): + _elem846 = iprot.readString() + self.part_vals.append(_elem846) iprot.readListEnd() else: iprot.skip(ftype) @@ -20331,8 +20623,8 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter840 in self.part_vals: - oprot.writeString(iter840) + for iter847 in self.part_vals: + oprot.writeString(iter847) oprot.writeListEnd() oprot.writeFieldEnd() if self.deleteData is not None: @@ -21069,10 +21361,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype844, _size841) = iprot.readListBegin() - for _i845 in xrange(_size841): - _elem846 = iprot.readString() - self.part_vals.append(_elem846) + (_etype851, _size848) = iprot.readListBegin() + for _i852 in xrange(_size848): + _elem853 = iprot.readString() + self.part_vals.append(_elem853) iprot.readListEnd() else: iprot.skip(ftype) @@ -21097,8 +21389,8 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter847 in self.part_vals: - oprot.writeString(iter847) + for iter854 in self.part_vals: + oprot.writeString(iter854) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -21257,11 +21549,11 @@ def read(self, iprot): if fid == 1: if ftype == TType.MAP: self.partitionSpecs = {} - (_ktype849, _vtype850, _size848 ) = iprot.readMapBegin() - for _i852 in xrange(_size848): - _key853 = iprot.readString() - _val854 = iprot.readString() - self.partitionSpecs[_key853] = _val854 + (_ktype856, _vtype857, _size855 ) = iprot.readMapBegin() + for _i859 in xrange(_size855): + _key860 = iprot.readString() + _val861 = iprot.readString() + self.partitionSpecs[_key860] = _val861 iprot.readMapEnd() else: iprot.skip(ftype) @@ -21298,9 +21590,9 @@ def write(self, oprot): if self.partitionSpecs is not None: oprot.writeFieldBegin('partitionSpecs', TType.MAP, 1) oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.partitionSpecs)) - for kiter855,viter856 in self.partitionSpecs.items(): - oprot.writeString(kiter855) - oprot.writeString(viter856) + for kiter862,viter863 in self.partitionSpecs.items(): + oprot.writeString(kiter862) + oprot.writeString(viter863) oprot.writeMapEnd() oprot.writeFieldEnd() if self.source_db is not None: @@ -21505,11 +21797,11 @@ def read(self, iprot): if fid == 1: if ftype == TType.MAP: self.partitionSpecs = {} - (_ktype858, _vtype859, _size857 ) = iprot.readMapBegin() - for _i861 in xrange(_size857): - _key862 = iprot.readString() - _val863 = iprot.readString() - self.partitionSpecs[_key862] = _val863 + (_ktype865, _vtype866, _size864 ) = iprot.readMapBegin() + for _i868 in xrange(_size864): + _key869 = iprot.readString() + _val870 = iprot.readString() + self.partitionSpecs[_key869] = _val870 iprot.readMapEnd() else: iprot.skip(ftype) @@ -21546,9 +21838,9 @@ def write(self, oprot): if self.partitionSpecs is not None: oprot.writeFieldBegin('partitionSpecs', TType.MAP, 1) oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.partitionSpecs)) - for kiter864,viter865 in self.partitionSpecs.items(): - oprot.writeString(kiter864) - oprot.writeString(viter865) + for kiter871,viter872 in self.partitionSpecs.items(): + oprot.writeString(kiter871) + oprot.writeString(viter872) oprot.writeMapEnd() oprot.writeFieldEnd() if self.source_db is not None: @@ -21631,11 +21923,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype869, _size866) = iprot.readListBegin() - for _i870 in xrange(_size866): - _elem871 = Partition() - _elem871.read(iprot) - self.success.append(_elem871) + (_etype876, _size873) = iprot.readListBegin() + for _i877 in xrange(_size873): + _elem878 = Partition() + _elem878.read(iprot) + self.success.append(_elem878) iprot.readListEnd() else: iprot.skip(ftype) @@ -21676,8 +21968,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter872 in self.success: - iter872.write(oprot) + for iter879 in self.success: + iter879.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -21771,10 +22063,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype876, _size873) = iprot.readListBegin() - for _i877 in xrange(_size873): - _elem878 = iprot.readString() - self.part_vals.append(_elem878) + (_etype883, _size880) = iprot.readListBegin() + for _i884 in xrange(_size880): + _elem885 = iprot.readString() + self.part_vals.append(_elem885) iprot.readListEnd() else: iprot.skip(ftype) @@ -21786,10 +22078,10 @@ def read(self, iprot): elif fid == 5: if ftype == TType.LIST: self.group_names = [] - (_etype882, _size879) = iprot.readListBegin() - for _i883 in xrange(_size879): - _elem884 = iprot.readString() - self.group_names.append(_elem884) + (_etype889, _size886) = iprot.readListBegin() + for _i890 in xrange(_size886): + _elem891 = iprot.readString() + self.group_names.append(_elem891) iprot.readListEnd() else: iprot.skip(ftype) @@ -21814,8 +22106,8 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter885 in self.part_vals: - oprot.writeString(iter885) + for iter892 in self.part_vals: + oprot.writeString(iter892) oprot.writeListEnd() oprot.writeFieldEnd() if self.user_name is not None: @@ -21825,8 +22117,8 @@ def write(self, oprot): if self.group_names is not None: oprot.writeFieldBegin('group_names', TType.LIST, 5) oprot.writeListBegin(TType.STRING, len(self.group_names)) - for iter886 in self.group_names: - oprot.writeString(iter886) + for iter893 in self.group_names: + oprot.writeString(iter893) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -22255,11 +22547,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype890, _size887) = iprot.readListBegin() - for _i891 in xrange(_size887): - _elem892 = Partition() - _elem892.read(iprot) - self.success.append(_elem892) + (_etype897, _size894) = iprot.readListBegin() + for _i898 in xrange(_size894): + _elem899 = Partition() + _elem899.read(iprot) + self.success.append(_elem899) iprot.readListEnd() else: iprot.skip(ftype) @@ -22288,8 +22580,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter893 in self.success: - iter893.write(oprot) + for iter900 in self.success: + iter900.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -22383,10 +22675,10 @@ def read(self, iprot): elif fid == 5: if ftype == TType.LIST: self.group_names = [] - (_etype897, _size894) = iprot.readListBegin() - for _i898 in xrange(_size894): - _elem899 = iprot.readString() - self.group_names.append(_elem899) + (_etype904, _size901) = iprot.readListBegin() + for _i905 in xrange(_size901): + _elem906 = iprot.readString() + self.group_names.append(_elem906) iprot.readListEnd() else: iprot.skip(ftype) @@ -22419,8 +22711,8 @@ def write(self, oprot): if self.group_names is not None: oprot.writeFieldBegin('group_names', TType.LIST, 5) oprot.writeListBegin(TType.STRING, len(self.group_names)) - for iter900 in self.group_names: - oprot.writeString(iter900) + for iter907 in self.group_names: + oprot.writeString(iter907) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -22481,11 +22773,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype904, _size901) = iprot.readListBegin() - for _i905 in xrange(_size901): - _elem906 = Partition() - _elem906.read(iprot) - self.success.append(_elem906) + (_etype911, _size908) = iprot.readListBegin() + for _i912 in xrange(_size908): + _elem913 = Partition() + _elem913.read(iprot) + self.success.append(_elem913) iprot.readListEnd() else: iprot.skip(ftype) @@ -22514,8 +22806,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter907 in self.success: - iter907.write(oprot) + for iter914 in self.success: + iter914.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -22673,11 +22965,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype911, _size908) = iprot.readListBegin() - for _i912 in xrange(_size908): - _elem913 = PartitionSpec() - _elem913.read(iprot) - self.success.append(_elem913) + (_etype918, _size915) = iprot.readListBegin() + for _i919 in xrange(_size915): + _elem920 = PartitionSpec() + _elem920.read(iprot) + self.success.append(_elem920) iprot.readListEnd() else: iprot.skip(ftype) @@ -22706,8 +22998,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter914 in self.success: - iter914.write(oprot) + for iter921 in self.success: + iter921.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -22865,10 +23157,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype918, _size915) = iprot.readListBegin() - for _i919 in xrange(_size915): - _elem920 = iprot.readString() - self.success.append(_elem920) + (_etype925, _size922) = iprot.readListBegin() + for _i926 in xrange(_size922): + _elem927 = iprot.readString() + self.success.append(_elem927) iprot.readListEnd() else: iprot.skip(ftype) @@ -22897,8 +23189,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter921 in self.success: - oprot.writeString(iter921) + for iter928 in self.success: + oprot.writeString(iter928) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -23138,10 +23430,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype925, _size922) = iprot.readListBegin() - for _i926 in xrange(_size922): - _elem927 = iprot.readString() - self.part_vals.append(_elem927) + (_etype932, _size929) = iprot.readListBegin() + for _i933 in xrange(_size929): + _elem934 = iprot.readString() + self.part_vals.append(_elem934) iprot.readListEnd() else: iprot.skip(ftype) @@ -23171,8 +23463,8 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter928 in self.part_vals: - oprot.writeString(iter928) + for iter935 in self.part_vals: + oprot.writeString(iter935) oprot.writeListEnd() oprot.writeFieldEnd() if self.max_parts is not None: @@ -23236,11 +23528,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype932, _size929) = iprot.readListBegin() - for _i933 in xrange(_size929): - _elem934 = Partition() - _elem934.read(iprot) - self.success.append(_elem934) + (_etype939, _size936) = iprot.readListBegin() + for _i940 in xrange(_size936): + _elem941 = Partition() + _elem941.read(iprot) + self.success.append(_elem941) iprot.readListEnd() else: iprot.skip(ftype) @@ -23269,8 +23561,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter935 in self.success: - iter935.write(oprot) + for iter942 in self.success: + iter942.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -23357,10 +23649,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype939, _size936) = iprot.readListBegin() - for _i940 in xrange(_size936): - _elem941 = iprot.readString() - self.part_vals.append(_elem941) + (_etype946, _size943) = iprot.readListBegin() + for _i947 in xrange(_size943): + _elem948 = iprot.readString() + self.part_vals.append(_elem948) iprot.readListEnd() else: iprot.skip(ftype) @@ -23377,10 +23669,10 @@ def read(self, iprot): elif fid == 6: if ftype == TType.LIST: self.group_names = [] - (_etype945, _size942) = iprot.readListBegin() - for _i946 in xrange(_size942): - _elem947 = iprot.readString() - self.group_names.append(_elem947) + (_etype952, _size949) = iprot.readListBegin() + for _i953 in xrange(_size949): + _elem954 = iprot.readString() + self.group_names.append(_elem954) iprot.readListEnd() else: iprot.skip(ftype) @@ -23405,8 +23697,8 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter948 in self.part_vals: - oprot.writeString(iter948) + for iter955 in self.part_vals: + oprot.writeString(iter955) oprot.writeListEnd() oprot.writeFieldEnd() if self.max_parts is not None: @@ -23420,8 +23712,8 @@ def write(self, oprot): if self.group_names is not None: oprot.writeFieldBegin('group_names', TType.LIST, 6) oprot.writeListBegin(TType.STRING, len(self.group_names)) - for iter949 in self.group_names: - oprot.writeString(iter949) + for iter956 in self.group_names: + oprot.writeString(iter956) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -23483,11 +23775,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype953, _size950) = iprot.readListBegin() - for _i954 in xrange(_size950): - _elem955 = Partition() - _elem955.read(iprot) - self.success.append(_elem955) + (_etype960, _size957) = iprot.readListBegin() + for _i961 in xrange(_size957): + _elem962 = Partition() + _elem962.read(iprot) + self.success.append(_elem962) iprot.readListEnd() else: iprot.skip(ftype) @@ -23516,8 +23808,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter956 in self.success: - iter956.write(oprot) + for iter963 in self.success: + iter963.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -23598,10 +23890,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype960, _size957) = iprot.readListBegin() - for _i961 in xrange(_size957): - _elem962 = iprot.readString() - self.part_vals.append(_elem962) + (_etype967, _size964) = iprot.readListBegin() + for _i968 in xrange(_size964): + _elem969 = iprot.readString() + self.part_vals.append(_elem969) iprot.readListEnd() else: iprot.skip(ftype) @@ -23631,8 +23923,8 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter963 in self.part_vals: - oprot.writeString(iter963) + for iter970 in self.part_vals: + oprot.writeString(iter970) oprot.writeListEnd() oprot.writeFieldEnd() if self.max_parts is not None: @@ -23696,10 +23988,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype967, _size964) = iprot.readListBegin() - for _i968 in xrange(_size964): - _elem969 = iprot.readString() - self.success.append(_elem969) + (_etype974, _size971) = iprot.readListBegin() + for _i975 in xrange(_size971): + _elem976 = iprot.readString() + self.success.append(_elem976) iprot.readListEnd() else: iprot.skip(ftype) @@ -23728,8 +24020,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter970 in self.success: - oprot.writeString(iter970) + for iter977 in self.success: + oprot.writeString(iter977) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -23900,11 +24192,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype974, _size971) = iprot.readListBegin() - for _i975 in xrange(_size971): - _elem976 = Partition() - _elem976.read(iprot) - self.success.append(_elem976) + (_etype981, _size978) = iprot.readListBegin() + for _i982 in xrange(_size978): + _elem983 = Partition() + _elem983.read(iprot) + self.success.append(_elem983) iprot.readListEnd() else: iprot.skip(ftype) @@ -23933,8 +24225,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter977 in self.success: - iter977.write(oprot) + for iter984 in self.success: + iter984.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -24105,11 +24397,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype981, _size978) = iprot.readListBegin() - for _i982 in xrange(_size978): - _elem983 = PartitionSpec() - _elem983.read(iprot) - self.success.append(_elem983) + (_etype988, _size985) = iprot.readListBegin() + for _i989 in xrange(_size985): + _elem990 = PartitionSpec() + _elem990.read(iprot) + self.success.append(_elem990) iprot.readListEnd() else: iprot.skip(ftype) @@ -24138,8 +24430,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter984 in self.success: - iter984.write(oprot) + for iter991 in self.success: + iter991.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -24559,10 +24851,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.names = [] - (_etype988, _size985) = iprot.readListBegin() - for _i989 in xrange(_size985): - _elem990 = iprot.readString() - self.names.append(_elem990) + (_etype995, _size992) = iprot.readListBegin() + for _i996 in xrange(_size992): + _elem997 = iprot.readString() + self.names.append(_elem997) iprot.readListEnd() else: iprot.skip(ftype) @@ -24587,8 +24879,8 @@ def write(self, oprot): if self.names is not None: oprot.writeFieldBegin('names', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.names)) - for iter991 in self.names: - oprot.writeString(iter991) + for iter998 in self.names: + oprot.writeString(iter998) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -24647,11 +24939,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype995, _size992) = iprot.readListBegin() - for _i996 in xrange(_size992): - _elem997 = Partition() - _elem997.read(iprot) - self.success.append(_elem997) + (_etype1002, _size999) = iprot.readListBegin() + for _i1003 in xrange(_size999): + _elem1004 = Partition() + _elem1004.read(iprot) + self.success.append(_elem1004) iprot.readListEnd() else: iprot.skip(ftype) @@ -24680,8 +24972,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter998 in self.success: - iter998.write(oprot) + for iter1005 in self.success: + iter1005.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -24931,11 +25223,11 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.new_parts = [] - (_etype1002, _size999) = iprot.readListBegin() - for _i1003 in xrange(_size999): - _elem1004 = Partition() - _elem1004.read(iprot) - self.new_parts.append(_elem1004) + (_etype1009, _size1006) = iprot.readListBegin() + for _i1010 in xrange(_size1006): + _elem1011 = Partition() + _elem1011.read(iprot) + self.new_parts.append(_elem1011) iprot.readListEnd() else: iprot.skip(ftype) @@ -24960,8 +25252,8 @@ def write(self, oprot): if self.new_parts is not None: oprot.writeFieldBegin('new_parts', TType.LIST, 3) oprot.writeListBegin(TType.STRUCT, len(self.new_parts)) - for iter1005 in self.new_parts: - iter1005.write(oprot) + for iter1012 in self.new_parts: + iter1012.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -25114,11 +25406,11 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.new_parts = [] - (_etype1009, _size1006) = iprot.readListBegin() - for _i1010 in xrange(_size1006): - _elem1011 = Partition() - _elem1011.read(iprot) - self.new_parts.append(_elem1011) + (_etype1016, _size1013) = iprot.readListBegin() + for _i1017 in xrange(_size1013): + _elem1018 = Partition() + _elem1018.read(iprot) + self.new_parts.append(_elem1018) iprot.readListEnd() else: iprot.skip(ftype) @@ -25149,8 +25441,8 @@ def write(self, oprot): if self.new_parts is not None: oprot.writeFieldBegin('new_parts', TType.LIST, 3) oprot.writeListBegin(TType.STRUCT, len(self.new_parts)) - for iter1012 in self.new_parts: - iter1012.write(oprot) + for iter1019 in self.new_parts: + iter1019.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.environment_context is not None: @@ -25494,10 +25786,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype1016, _size1013) = iprot.readListBegin() - for _i1017 in xrange(_size1013): - _elem1018 = iprot.readString() - self.part_vals.append(_elem1018) + (_etype1023, _size1020) = iprot.readListBegin() + for _i1024 in xrange(_size1020): + _elem1025 = iprot.readString() + self.part_vals.append(_elem1025) iprot.readListEnd() else: iprot.skip(ftype) @@ -25528,8 +25820,8 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter1019 in self.part_vals: - oprot.writeString(iter1019) + for iter1026 in self.part_vals: + oprot.writeString(iter1026) oprot.writeListEnd() oprot.writeFieldEnd() if self.new_part is not None: @@ -25671,10 +25963,10 @@ def read(self, iprot): if fid == 1: if ftype == TType.LIST: self.part_vals = [] - (_etype1023, _size1020) = iprot.readListBegin() - for _i1024 in xrange(_size1020): - _elem1025 = iprot.readString() - self.part_vals.append(_elem1025) + (_etype1030, _size1027) = iprot.readListBegin() + for _i1031 in xrange(_size1027): + _elem1032 = iprot.readString() + self.part_vals.append(_elem1032) iprot.readListEnd() else: iprot.skip(ftype) @@ -25696,8 +25988,8 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 1) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter1026 in self.part_vals: - oprot.writeString(iter1026) + for iter1033 in self.part_vals: + oprot.writeString(iter1033) oprot.writeListEnd() oprot.writeFieldEnd() if self.throw_exception is not None: @@ -26055,10 +26347,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1030, _size1027) = iprot.readListBegin() - for _i1031 in xrange(_size1027): - _elem1032 = iprot.readString() - self.success.append(_elem1032) + (_etype1037, _size1034) = iprot.readListBegin() + for _i1038 in xrange(_size1034): + _elem1039 = iprot.readString() + self.success.append(_elem1039) iprot.readListEnd() else: iprot.skip(ftype) @@ -26081,8 +26373,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter1033 in self.success: - oprot.writeString(iter1033) + for iter1040 in self.success: + oprot.writeString(iter1040) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -26206,11 +26498,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.MAP: self.success = {} - (_ktype1035, _vtype1036, _size1034 ) = iprot.readMapBegin() - for _i1038 in xrange(_size1034): - _key1039 = iprot.readString() - _val1040 = iprot.readString() - self.success[_key1039] = _val1040 + (_ktype1042, _vtype1043, _size1041 ) = iprot.readMapBegin() + for _i1045 in xrange(_size1041): + _key1046 = iprot.readString() + _val1047 = iprot.readString() + self.success[_key1046] = _val1047 iprot.readMapEnd() else: iprot.skip(ftype) @@ -26233,9 +26525,9 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.MAP, 0) oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success)) - for kiter1041,viter1042 in self.success.items(): - oprot.writeString(kiter1041) - oprot.writeString(viter1042) + for kiter1048,viter1049 in self.success.items(): + oprot.writeString(kiter1048) + oprot.writeString(viter1049) oprot.writeMapEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -26311,11 +26603,11 @@ def read(self, iprot): elif fid == 3: if ftype == TType.MAP: self.part_vals = {} - (_ktype1044, _vtype1045, _size1043 ) = iprot.readMapBegin() - for _i1047 in xrange(_size1043): - _key1048 = iprot.readString() - _val1049 = iprot.readString() - self.part_vals[_key1048] = _val1049 + (_ktype1051, _vtype1052, _size1050 ) = iprot.readMapBegin() + for _i1054 in xrange(_size1050): + _key1055 = iprot.readString() + _val1056 = iprot.readString() + self.part_vals[_key1055] = _val1056 iprot.readMapEnd() else: iprot.skip(ftype) @@ -26345,9 +26637,9 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.MAP, 3) oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.part_vals)) - for kiter1050,viter1051 in self.part_vals.items(): - oprot.writeString(kiter1050) - oprot.writeString(viter1051) + for kiter1057,viter1058 in self.part_vals.items(): + oprot.writeString(kiter1057) + oprot.writeString(viter1058) oprot.writeMapEnd() oprot.writeFieldEnd() if self.eventType is not None: @@ -26561,11 +26853,11 @@ def read(self, iprot): elif fid == 3: if ftype == TType.MAP: self.part_vals = {} - (_ktype1053, _vtype1054, _size1052 ) = iprot.readMapBegin() - for _i1056 in xrange(_size1052): - _key1057 = iprot.readString() - _val1058 = iprot.readString() - self.part_vals[_key1057] = _val1058 + (_ktype1060, _vtype1061, _size1059 ) = iprot.readMapBegin() + for _i1063 in xrange(_size1059): + _key1064 = iprot.readString() + _val1065 = iprot.readString() + self.part_vals[_key1064] = _val1065 iprot.readMapEnd() else: iprot.skip(ftype) @@ -26595,9 +26887,9 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.MAP, 3) oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.part_vals)) - for kiter1059,viter1060 in self.part_vals.items(): - oprot.writeString(kiter1059) - oprot.writeString(viter1060) + for kiter1066,viter1067 in self.part_vals.items(): + oprot.writeString(kiter1066) + oprot.writeString(viter1067) oprot.writeMapEnd() oprot.writeFieldEnd() if self.eventType is not None: @@ -27652,11 +27944,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1064, _size1061) = iprot.readListBegin() - for _i1065 in xrange(_size1061): - _elem1066 = Index() - _elem1066.read(iprot) - self.success.append(_elem1066) + (_etype1071, _size1068) = iprot.readListBegin() + for _i1072 in xrange(_size1068): + _elem1073 = Index() + _elem1073.read(iprot) + self.success.append(_elem1073) iprot.readListEnd() else: iprot.skip(ftype) @@ -27685,346 +27977,10 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter1067 in self.success: - iter1067.write(oprot) - oprot.writeListEnd() - 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 __hash__(self): - value = 17 - value = (value * 31) ^ hash(self.success) - value = (value * 31) ^ hash(self.o1) - value = (value * 31) ^ hash(self.o2) - return value - - def __repr__(self): - L = ['%s=%r' % (key, value) - for key, value in self.__dict__.iteritems()] - return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) - - def __eq__(self, other): - return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ - - def __ne__(self, other): - return not (self == other) - -class get_index_names_args: - """ - Attributes: - - db_name - - tbl_name - - max_indexes - """ - - thrift_spec = ( - None, # 0 - (1, TType.STRING, 'db_name', None, None, ), # 1 - (2, TType.STRING, 'tbl_name', None, None, ), # 2 - (3, TType.I16, 'max_indexes', None, -1, ), # 3 - ) - - def __init__(self, db_name=None, tbl_name=None, max_indexes=thrift_spec[3][4],): - self.db_name = db_name - self.tbl_name = tbl_name - self.max_indexes = max_indexes - - 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.db_name = iprot.readString() - else: - iprot.skip(ftype) - elif fid == 2: - if ftype == TType.STRING: - self.tbl_name = iprot.readString() - else: - iprot.skip(ftype) - elif fid == 3: - if ftype == TType.I16: - self.max_indexes = iprot.readI16() - 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_index_names_args') - if self.db_name is not None: - oprot.writeFieldBegin('db_name', TType.STRING, 1) - oprot.writeString(self.db_name) - oprot.writeFieldEnd() - if self.tbl_name is not None: - oprot.writeFieldBegin('tbl_name', TType.STRING, 2) - oprot.writeString(self.tbl_name) - oprot.writeFieldEnd() - if self.max_indexes is not None: - oprot.writeFieldBegin('max_indexes', TType.I16, 3) - oprot.writeI16(self.max_indexes) - oprot.writeFieldEnd() - oprot.writeFieldStop() - oprot.writeStructEnd() - - def validate(self): - return - - - def __hash__(self): - value = 17 - value = (value * 31) ^ hash(self.db_name) - value = (value * 31) ^ hash(self.tbl_name) - value = (value * 31) ^ hash(self.max_indexes) - return value - - def __repr__(self): - L = ['%s=%r' % (key, value) - for key, value in self.__dict__.iteritems()] - return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) - - def __eq__(self, other): - return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ - - def __ne__(self, other): - return not (self == other) - -class get_index_names_result: - """ - Attributes: - - success - - o2 - """ - - thrift_spec = ( - (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0 - (1, TType.STRUCT, 'o2', (MetaException, MetaException.thrift_spec), None, ), # 1 - ) - - def __init__(self, success=None, o2=None,): - self.success = success - 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.LIST: - self.success = [] - (_etype1071, _size1068) = iprot.readListBegin() - for _i1072 in xrange(_size1068): - _elem1073 = iprot.readString() - self.success.append(_elem1073) - iprot.readListEnd() - else: - iprot.skip(ftype) - elif fid == 1: - if ftype == TType.STRUCT: - self.o2 = MetaException() - 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_index_names_result') - if self.success is not None: - oprot.writeFieldBegin('success', TType.LIST, 0) - oprot.writeListBegin(TType.STRING, len(self.success)) for iter1074 in self.success: - oprot.writeString(iter1074) + iter1074.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() - if self.o2 is not None: - oprot.writeFieldBegin('o2', TType.STRUCT, 1) - self.o2.write(oprot) - oprot.writeFieldEnd() - oprot.writeFieldStop() - oprot.writeStructEnd() - - def validate(self): - return - - - def __hash__(self): - value = 17 - value = (value * 31) ^ hash(self.success) - value = (value * 31) ^ hash(self.o2) - return value - - def __repr__(self): - L = ['%s=%r' % (key, value) - for key, value in self.__dict__.iteritems()] - return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) - - def __eq__(self, other): - return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ - - def __ne__(self, other): - return not (self == other) - -class get_primary_keys_args: - """ - Attributes: - - request - """ - - thrift_spec = ( - None, # 0 - (1, TType.STRUCT, 'request', (PrimaryKeysRequest, PrimaryKeysRequest.thrift_spec), None, ), # 1 - ) - - def __init__(self, request=None,): - self.request = request - - 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.request = PrimaryKeysRequest() - self.request.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_primary_keys_args') - if self.request is not None: - oprot.writeFieldBegin('request', TType.STRUCT, 1) - self.request.write(oprot) - oprot.writeFieldEnd() - oprot.writeFieldStop() - oprot.writeStructEnd() - - def validate(self): - return - - - def __hash__(self): - value = 17 - value = (value * 31) ^ hash(self.request) - return value - - def __repr__(self): - L = ['%s=%r' % (key, value) - for key, value in self.__dict__.iteritems()] - return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) - - def __eq__(self, other): - return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ - - def __ne__(self, other): - return not (self == other) - -class get_primary_keys_result: - """ - Attributes: - - success - - o1 - - o2 - """ - - thrift_spec = ( - (0, TType.STRUCT, 'success', (PrimaryKeysResponse, PrimaryKeysResponse.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 = PrimaryKeysResponse() - 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_primary_keys_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) @@ -28058,7 +28014,184 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class get_foreign_keys_args: +class get_index_names_args: + """ + Attributes: + - db_name + - tbl_name + - max_indexes + """ + + thrift_spec = ( + None, # 0 + (1, TType.STRING, 'db_name', None, None, ), # 1 + (2, TType.STRING, 'tbl_name', None, None, ), # 2 + (3, TType.I16, 'max_indexes', None, -1, ), # 3 + ) + + def __init__(self, db_name=None, tbl_name=None, max_indexes=thrift_spec[3][4],): + self.db_name = db_name + self.tbl_name = tbl_name + self.max_indexes = max_indexes + + 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.db_name = iprot.readString() + else: + iprot.skip(ftype) + elif fid == 2: + if ftype == TType.STRING: + self.tbl_name = iprot.readString() + else: + iprot.skip(ftype) + elif fid == 3: + if ftype == TType.I16: + self.max_indexes = iprot.readI16() + 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_index_names_args') + if self.db_name is not None: + oprot.writeFieldBegin('db_name', TType.STRING, 1) + oprot.writeString(self.db_name) + oprot.writeFieldEnd() + if self.tbl_name is not None: + oprot.writeFieldBegin('tbl_name', TType.STRING, 2) + oprot.writeString(self.tbl_name) + oprot.writeFieldEnd() + if self.max_indexes is not None: + oprot.writeFieldBegin('max_indexes', TType.I16, 3) + oprot.writeI16(self.max_indexes) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.db_name) + value = (value * 31) ^ hash(self.tbl_name) + value = (value * 31) ^ hash(self.max_indexes) + return value + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + +class get_index_names_result: + """ + Attributes: + - success + - o2 + """ + + thrift_spec = ( + (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0 + (1, TType.STRUCT, 'o2', (MetaException, MetaException.thrift_spec), None, ), # 1 + ) + + def __init__(self, success=None, o2=None,): + self.success = success + 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.LIST: + self.success = [] + (_etype1078, _size1075) = iprot.readListBegin() + for _i1079 in xrange(_size1075): + _elem1080 = iprot.readString() + self.success.append(_elem1080) + iprot.readListEnd() + else: + iprot.skip(ftype) + elif fid == 1: + if ftype == TType.STRUCT: + self.o2 = MetaException() + 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_index_names_result') + if self.success is not None: + oprot.writeFieldBegin('success', TType.LIST, 0) + oprot.writeListBegin(TType.STRING, len(self.success)) + for iter1081 in self.success: + oprot.writeString(iter1081) + oprot.writeListEnd() + oprot.writeFieldEnd() + if self.o2 is not None: + oprot.writeFieldBegin('o2', TType.STRUCT, 1) + self.o2.write(oprot) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.success) + value = (value * 31) ^ hash(self.o2) + return value + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + +class get_primary_keys_args: """ Attributes: - request @@ -28066,7 +28199,7 @@ class get_foreign_keys_args: thrift_spec = ( None, # 0 - (1, TType.STRUCT, 'request', (ForeignKeysRequest, ForeignKeysRequest.thrift_spec), None, ), # 1 + (1, TType.STRUCT, 'request', (PrimaryKeysRequest, PrimaryKeysRequest.thrift_spec), None, ), # 1 ) def __init__(self, request=None,): @@ -28083,7 +28216,7 @@ def read(self, iprot): break if fid == 1: if ftype == TType.STRUCT: - self.request = ForeignKeysRequest() + self.request = PrimaryKeysRequest() self.request.read(iprot) else: iprot.skip(ftype) @@ -28096,7 +28229,7 @@ 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_foreign_keys_args') + oprot.writeStructBegin('get_primary_keys_args') if self.request is not None: oprot.writeFieldBegin('request', TType.STRUCT, 1) self.request.write(oprot) @@ -28124,7 +28257,7 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class get_foreign_keys_result: +class get_primary_keys_result: """ Attributes: - success @@ -28133,7 +28266,7 @@ class get_foreign_keys_result: """ thrift_spec = ( - (0, TType.STRUCT, 'success', (ForeignKeysResponse, ForeignKeysResponse.thrift_spec), None, ), # 0 + (0, TType.STRUCT, 'success', (PrimaryKeysResponse, PrimaryKeysResponse.thrift_spec), None, ), # 0 (1, TType.STRUCT, 'o1', (MetaException, MetaException.thrift_spec), None, ), # 1 (2, TType.STRUCT, 'o2', (NoSuchObjectException, NoSuchObjectException.thrift_spec), None, ), # 2 ) @@ -28154,7 +28287,7 @@ def read(self, iprot): break if fid == 0: if ftype == TType.STRUCT: - self.success = ForeignKeysResponse() + self.success = PrimaryKeysResponse() self.success.read(iprot) else: iprot.skip(ftype) @@ -28179,7 +28312,7 @@ 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_foreign_keys_result') + oprot.writeStructBegin('get_primary_keys_result') if self.success is not None: oprot.writeFieldBegin('success', TType.STRUCT, 0) self.success.write(oprot) @@ -28217,7 +28350,7 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class get_unique_constraints_args: +class get_foreign_keys_args: """ Attributes: - request @@ -28225,7 +28358,7 @@ class get_unique_constraints_args: thrift_spec = ( None, # 0 - (1, TType.STRUCT, 'request', (UniqueConstraintsRequest, UniqueConstraintsRequest.thrift_spec), None, ), # 1 + (1, TType.STRUCT, 'request', (ForeignKeysRequest, ForeignKeysRequest.thrift_spec), None, ), # 1 ) def __init__(self, request=None,): @@ -28242,7 +28375,7 @@ def read(self, iprot): break if fid == 1: if ftype == TType.STRUCT: - self.request = UniqueConstraintsRequest() + self.request = ForeignKeysRequest() self.request.read(iprot) else: iprot.skip(ftype) @@ -28255,7 +28388,7 @@ 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_unique_constraints_args') + oprot.writeStructBegin('get_foreign_keys_args') if self.request is not None: oprot.writeFieldBegin('request', TType.STRUCT, 1) self.request.write(oprot) @@ -28283,7 +28416,7 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class get_unique_constraints_result: +class get_foreign_keys_result: """ Attributes: - success @@ -28292,7 +28425,7 @@ class get_unique_constraints_result: """ thrift_spec = ( - (0, TType.STRUCT, 'success', (UniqueConstraintsResponse, UniqueConstraintsResponse.thrift_spec), None, ), # 0 + (0, TType.STRUCT, 'success', (ForeignKeysResponse, ForeignKeysResponse.thrift_spec), None, ), # 0 (1, TType.STRUCT, 'o1', (MetaException, MetaException.thrift_spec), None, ), # 1 (2, TType.STRUCT, 'o2', (NoSuchObjectException, NoSuchObjectException.thrift_spec), None, ), # 2 ) @@ -28313,7 +28446,7 @@ def read(self, iprot): break if fid == 0: if ftype == TType.STRUCT: - self.success = UniqueConstraintsResponse() + self.success = ForeignKeysResponse() self.success.read(iprot) else: iprot.skip(ftype) @@ -28338,7 +28471,7 @@ 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_unique_constraints_result') + oprot.writeStructBegin('get_foreign_keys_result') if self.success is not None: oprot.writeFieldBegin('success', TType.STRUCT, 0) self.success.write(oprot) @@ -28376,7 +28509,7 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class get_not_null_constraints_args: +class get_unique_constraints_args: """ Attributes: - request @@ -28384,7 +28517,7 @@ class get_not_null_constraints_args: thrift_spec = ( None, # 0 - (1, TType.STRUCT, 'request', (NotNullConstraintsRequest, NotNullConstraintsRequest.thrift_spec), None, ), # 1 + (1, TType.STRUCT, 'request', (UniqueConstraintsRequest, UniqueConstraintsRequest.thrift_spec), None, ), # 1 ) def __init__(self, request=None,): @@ -28401,7 +28534,7 @@ def read(self, iprot): break if fid == 1: if ftype == TType.STRUCT: - self.request = NotNullConstraintsRequest() + self.request = UniqueConstraintsRequest() self.request.read(iprot) else: iprot.skip(ftype) @@ -28414,7 +28547,7 @@ 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_not_null_constraints_args') + oprot.writeStructBegin('get_unique_constraints_args') if self.request is not None: oprot.writeFieldBegin('request', TType.STRUCT, 1) self.request.write(oprot) @@ -28442,7 +28575,7 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class get_not_null_constraints_result: +class get_unique_constraints_result: """ Attributes: - success @@ -28451,7 +28584,7 @@ class get_not_null_constraints_result: """ thrift_spec = ( - (0, TType.STRUCT, 'success', (NotNullConstraintsResponse, NotNullConstraintsResponse.thrift_spec), None, ), # 0 + (0, TType.STRUCT, 'success', (UniqueConstraintsResponse, UniqueConstraintsResponse.thrift_spec), None, ), # 0 (1, TType.STRUCT, 'o1', (MetaException, MetaException.thrift_spec), None, ), # 1 (2, TType.STRUCT, 'o2', (NoSuchObjectException, NoSuchObjectException.thrift_spec), None, ), # 2 ) @@ -28472,7 +28605,7 @@ def read(self, iprot): break if fid == 0: if ftype == TType.STRUCT: - self.success = NotNullConstraintsResponse() + self.success = UniqueConstraintsResponse() self.success.read(iprot) else: iprot.skip(ftype) @@ -28497,7 +28630,7 @@ 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_not_null_constraints_result') + oprot.writeStructBegin('get_unique_constraints_result') if self.success is not None: oprot.writeFieldBegin('success', TType.STRUCT, 0) self.success.write(oprot) @@ -28535,19 +28668,19 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class update_table_column_statistics_args: +class get_not_null_constraints_args: """ Attributes: - - stats_obj + - request """ thrift_spec = ( None, # 0 - (1, TType.STRUCT, 'stats_obj', (ColumnStatistics, ColumnStatistics.thrift_spec), None, ), # 1 + (1, TType.STRUCT, 'request', (NotNullConstraintsRequest, NotNullConstraintsRequest.thrift_spec), None, ), # 1 ) - def __init__(self, stats_obj=None,): - self.stats_obj = stats_obj + def __init__(self, request=None,): + self.request = request 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: @@ -28560,8 +28693,8 @@ def read(self, iprot): break if fid == 1: if ftype == TType.STRUCT: - self.stats_obj = ColumnStatistics() - self.stats_obj.read(iprot) + self.request = NotNullConstraintsRequest() + self.request.read(iprot) else: iprot.skip(ftype) else: @@ -28573,10 +28706,10 @@ 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('update_table_column_statistics_args') - if self.stats_obj is not None: - oprot.writeFieldBegin('stats_obj', TType.STRUCT, 1) - self.stats_obj.write(oprot) + oprot.writeStructBegin('get_not_null_constraints_args') + if self.request is not None: + oprot.writeFieldBegin('request', TType.STRUCT, 1) + self.request.write(oprot) oprot.writeFieldEnd() oprot.writeFieldStop() oprot.writeStructEnd() @@ -28587,7 +28720,7 @@ def validate(self): def __hash__(self): value = 17 - value = (value * 31) ^ hash(self.stats_obj) + value = (value * 31) ^ hash(self.request) return value def __repr__(self): @@ -28601,30 +28734,24 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class update_table_column_statistics_result: +class get_not_null_constraints_result: """ Attributes: - success - o1 - o2 - - o3 - - o4 """ thrift_spec = ( - (0, TType.BOOL, 'success', None, None, ), # 0 - (1, TType.STRUCT, 'o1', (NoSuchObjectException, NoSuchObjectException.thrift_spec), None, ), # 1 - (2, TType.STRUCT, 'o2', (InvalidObjectException, InvalidObjectException.thrift_spec), None, ), # 2 - (3, TType.STRUCT, 'o3', (MetaException, MetaException.thrift_spec), None, ), # 3 - (4, TType.STRUCT, 'o4', (InvalidInputException, InvalidInputException.thrift_spec), None, ), # 4 + (0, TType.STRUCT, 'success', (NotNullConstraintsResponse, NotNullConstraintsResponse.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, o3=None, o4=None,): + def __init__(self, success=None, o1=None, o2=None,): self.success = success 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: @@ -28636,34 +28763,23 @@ def read(self, iprot): if ftype == TType.STOP: break if fid == 0: - if ftype == TType.BOOL: - self.success = iprot.readBool() + if ftype == TType.STRUCT: + self.success = NotNullConstraintsResponse() + self.success.read(iprot) else: iprot.skip(ftype) elif fid == 1: if ftype == TType.STRUCT: - self.o1 = NoSuchObjectException() + self.o1 = MetaException() self.o1.read(iprot) else: iprot.skip(ftype) elif fid == 2: if ftype == TType.STRUCT: - self.o2 = InvalidObjectException() + self.o2 = NoSuchObjectException() 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) - elif fid == 4: - if ftype == TType.STRUCT: - self.o4 = InvalidInputException() - self.o4.read(iprot) - else: - iprot.skip(ftype) else: iprot.skip(ftype) iprot.readFieldEnd() @@ -28673,10 +28789,10 @@ 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('update_table_column_statistics_result') + oprot.writeStructBegin('get_not_null_constraints_result') if self.success is not None: - oprot.writeFieldBegin('success', TType.BOOL, 0) - oprot.writeBool(self.success) + oprot.writeFieldBegin('success', TType.STRUCT, 0) + self.success.write(oprot) oprot.writeFieldEnd() if self.o1 is not None: oprot.writeFieldBegin('o1', TType.STRUCT, 1) @@ -28686,14 +28802,6 @@ def write(self, oprot): 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() @@ -28706,8 +28814,6 @@ def __hash__(self): value = (value * 31) ^ hash(self.success) value = (value * 31) ^ hash(self.o1) value = (value * 31) ^ hash(self.o2) - value = (value * 31) ^ hash(self.o3) - value = (value * 31) ^ hash(self.o4) return value def __repr__(self): @@ -28721,7 +28827,7 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class update_partition_column_statistics_args: +class update_table_column_statistics_args: """ Attributes: - stats_obj @@ -28759,7 +28865,7 @@ 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('update_partition_column_statistics_args') + oprot.writeStructBegin('update_table_column_statistics_args') if self.stats_obj is not None: oprot.writeFieldBegin('stats_obj', TType.STRUCT, 1) self.stats_obj.write(oprot) @@ -28787,7 +28893,7 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class update_partition_column_statistics_result: +class update_table_column_statistics_result: """ Attributes: - success @@ -28859,7 +28965,7 @@ 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('update_partition_column_statistics_result') + oprot.writeStructBegin('update_table_column_statistics_result') if self.success is not None: oprot.writeFieldBegin('success', TType.BOOL, 0) oprot.writeBool(self.success) @@ -28907,25 +29013,19 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class get_table_column_statistics_args: +class update_partition_column_statistics_args: """ Attributes: - - db_name - - tbl_name - - col_name + - stats_obj """ thrift_spec = ( None, # 0 - (1, TType.STRING, 'db_name', None, None, ), # 1 - (2, TType.STRING, 'tbl_name', None, None, ), # 2 - (3, TType.STRING, 'col_name', None, None, ), # 3 + (1, TType.STRUCT, 'stats_obj', (ColumnStatistics, ColumnStatistics.thrift_spec), None, ), # 1 ) - def __init__(self, db_name=None, tbl_name=None, col_name=None,): - self.db_name = db_name - self.tbl_name = tbl_name - self.col_name = col_name + def __init__(self, stats_obj=None,): + self.stats_obj = stats_obj 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: @@ -28937,18 +29037,9 @@ def read(self, iprot): if ftype == TType.STOP: break if fid == 1: - if ftype == TType.STRING: - self.db_name = iprot.readString() - else: - iprot.skip(ftype) - elif fid == 2: - if ftype == TType.STRING: - self.tbl_name = iprot.readString() - else: - iprot.skip(ftype) - elif fid == 3: - if ftype == TType.STRING: - self.col_name = iprot.readString() + if ftype == TType.STRUCT: + self.stats_obj = ColumnStatistics() + self.stats_obj.read(iprot) else: iprot.skip(ftype) else: @@ -28960,18 +29051,10 @@ 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_table_column_statistics_args') - if self.db_name is not None: - oprot.writeFieldBegin('db_name', TType.STRING, 1) - oprot.writeString(self.db_name) - oprot.writeFieldEnd() - if self.tbl_name is not None: - oprot.writeFieldBegin('tbl_name', TType.STRING, 2) - oprot.writeString(self.tbl_name) - oprot.writeFieldEnd() - if self.col_name is not None: - oprot.writeFieldBegin('col_name', TType.STRING, 3) - oprot.writeString(self.col_name) + oprot.writeStructBegin('update_partition_column_statistics_args') + if self.stats_obj is not None: + oprot.writeFieldBegin('stats_obj', TType.STRUCT, 1) + self.stats_obj.write(oprot) oprot.writeFieldEnd() oprot.writeFieldStop() oprot.writeStructEnd() @@ -28982,9 +29065,7 @@ def validate(self): def __hash__(self): value = 17 - value = (value * 31) ^ hash(self.db_name) - value = (value * 31) ^ hash(self.tbl_name) - value = (value * 31) ^ hash(self.col_name) + value = (value * 31) ^ hash(self.stats_obj) return value def __repr__(self): @@ -28998,7 +29079,7 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class get_table_column_statistics_result: +class update_partition_column_statistics_result: """ Attributes: - success @@ -29009,11 +29090,11 @@ class get_table_column_statistics_result: """ thrift_spec = ( - (0, TType.STRUCT, 'success', (ColumnStatistics, ColumnStatistics.thrift_spec), None, ), # 0 + (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', (InvalidInputException, InvalidInputException.thrift_spec), None, ), # 3 - (4, TType.STRUCT, 'o4', (InvalidObjectException, InvalidObjectException.thrift_spec), None, ), # 4 + (2, TType.STRUCT, 'o2', (InvalidObjectException, InvalidObjectException.thrift_spec), None, ), # 2 + (3, TType.STRUCT, 'o3', (MetaException, MetaException.thrift_spec), None, ), # 3 + (4, TType.STRUCT, 'o4', (InvalidInputException, InvalidInputException.thrift_spec), None, ), # 4 ) def __init__(self, success=None, o1=None, o2=None, o3=None, o4=None,): @@ -29033,9 +29114,8 @@ def read(self, iprot): if ftype == TType.STOP: break if fid == 0: - if ftype == TType.STRUCT: - self.success = ColumnStatistics() - self.success.read(iprot) + if ftype == TType.BOOL: + self.success = iprot.readBool() else: iprot.skip(ftype) elif fid == 1: @@ -29046,19 +29126,19 @@ def read(self, iprot): iprot.skip(ftype) elif fid == 2: if ftype == TType.STRUCT: - self.o2 = MetaException() + self.o2 = InvalidObjectException() self.o2.read(iprot) else: iprot.skip(ftype) elif fid == 3: if ftype == TType.STRUCT: - self.o3 = InvalidInputException() + self.o3 = MetaException() self.o3.read(iprot) else: iprot.skip(ftype) elif fid == 4: if ftype == TType.STRUCT: - self.o4 = InvalidObjectException() + self.o4 = InvalidInputException() self.o4.read(iprot) else: iprot.skip(ftype) @@ -29071,10 +29151,10 @@ 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_table_column_statistics_result') + oprot.writeStructBegin('update_partition_column_statistics_result') if self.success is not None: - oprot.writeFieldBegin('success', TType.STRUCT, 0) - self.success.write(oprot) + oprot.writeFieldBegin('success', TType.BOOL, 0) + oprot.writeBool(self.success) oprot.writeFieldEnd() if self.o1 is not None: oprot.writeFieldBegin('o1', TType.STRUCT, 1) @@ -29119,12 +29199,11 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class get_partition_column_statistics_args: +class get_table_column_statistics_args: """ Attributes: - db_name - tbl_name - - part_name - col_name """ @@ -29132,14 +29211,12 @@ class get_partition_column_statistics_args: None, # 0 (1, TType.STRING, 'db_name', None, None, ), # 1 (2, TType.STRING, 'tbl_name', None, None, ), # 2 - (3, TType.STRING, 'part_name', None, None, ), # 3 - (4, TType.STRING, 'col_name', None, None, ), # 4 + (3, TType.STRING, 'col_name', None, None, ), # 3 ) - def __init__(self, db_name=None, tbl_name=None, part_name=None, col_name=None,): + def __init__(self, db_name=None, tbl_name=None, col_name=None,): self.db_name = db_name self.tbl_name = tbl_name - self.part_name = part_name self.col_name = col_name def read(self, iprot): @@ -29162,11 +29239,6 @@ def read(self, iprot): else: iprot.skip(ftype) elif fid == 3: - if ftype == TType.STRING: - self.part_name = iprot.readString() - else: - iprot.skip(ftype) - elif fid == 4: if ftype == TType.STRING: self.col_name = iprot.readString() else: @@ -29180,7 +29252,7 @@ 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_partition_column_statistics_args') + oprot.writeStructBegin('get_table_column_statistics_args') if self.db_name is not None: oprot.writeFieldBegin('db_name', TType.STRING, 1) oprot.writeString(self.db_name) @@ -29189,12 +29261,8 @@ def write(self, oprot): oprot.writeFieldBegin('tbl_name', TType.STRING, 2) oprot.writeString(self.tbl_name) oprot.writeFieldEnd() - if self.part_name is not None: - oprot.writeFieldBegin('part_name', TType.STRING, 3) - oprot.writeString(self.part_name) - oprot.writeFieldEnd() if self.col_name is not None: - oprot.writeFieldBegin('col_name', TType.STRING, 4) + oprot.writeFieldBegin('col_name', TType.STRING, 3) oprot.writeString(self.col_name) oprot.writeFieldEnd() oprot.writeFieldStop() @@ -29208,7 +29276,6 @@ def __hash__(self): value = 17 value = (value * 31) ^ hash(self.db_name) value = (value * 31) ^ hash(self.tbl_name) - value = (value * 31) ^ hash(self.part_name) value = (value * 31) ^ hash(self.col_name) return value @@ -29223,7 +29290,7 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class get_partition_column_statistics_result: +class get_table_column_statistics_result: """ Attributes: - success @@ -29296,7 +29363,7 @@ 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_partition_column_statistics_result') + oprot.writeStructBegin('get_table_column_statistics_result') if self.success is not None: oprot.writeFieldBegin('success', TType.STRUCT, 0) self.success.write(oprot) @@ -29344,19 +29411,28 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class get_table_statistics_req_args: +class get_partition_column_statistics_args: """ Attributes: - - request + - db_name + - tbl_name + - part_name + - col_name """ thrift_spec = ( None, # 0 - (1, TType.STRUCT, 'request', (TableStatsRequest, TableStatsRequest.thrift_spec), None, ), # 1 + (1, TType.STRING, 'db_name', None, None, ), # 1 + (2, TType.STRING, 'tbl_name', None, None, ), # 2 + (3, TType.STRING, 'part_name', None, None, ), # 3 + (4, TType.STRING, 'col_name', None, None, ), # 4 ) - def __init__(self, request=None,): - self.request = request + def __init__(self, db_name=None, tbl_name=None, part_name=None, col_name=None,): + self.db_name = db_name + self.tbl_name = tbl_name + self.part_name = part_name + self.col_name = col_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: @@ -29368,92 +29444,23 @@ def read(self, iprot): if ftype == TType.STOP: break if fid == 1: - if ftype == TType.STRUCT: - self.request = TableStatsRequest() - self.request.read(iprot) + if ftype == TType.STRING: + self.db_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_table_statistics_req_args') - if self.request is not None: - oprot.writeFieldBegin('request', TType.STRUCT, 1) - self.request.write(oprot) - oprot.writeFieldEnd() - oprot.writeFieldStop() - oprot.writeStructEnd() - - def validate(self): - return - - - def __hash__(self): - value = 17 - value = (value * 31) ^ hash(self.request) - return value - - def __repr__(self): - L = ['%s=%r' % (key, value) - for key, value in self.__dict__.iteritems()] - return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) - - def __eq__(self, other): - return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ - - def __ne__(self, other): - return not (self == other) - -class get_table_statistics_req_result: - """ - Attributes: - - success - - o1 - - o2 - """ - - thrift_spec = ( - (0, TType.STRUCT, 'success', (TableStatsResult, TableStatsResult.thrift_spec), None, ), # 0 - (1, TType.STRUCT, 'o1', (NoSuchObjectException, NoSuchObjectException.thrift_spec), None, ), # 1 - (2, TType.STRUCT, 'o2', (MetaException, MetaException.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 = TableStatsResult() - self.success.read(iprot) + elif fid == 2: + if ftype == TType.STRING: + self.tbl_name = iprot.readString() else: iprot.skip(ftype) - elif fid == 1: - if ftype == TType.STRUCT: - self.o1 = NoSuchObjectException() - self.o1.read(iprot) + elif fid == 3: + if ftype == TType.STRING: + self.part_name = iprot.readString() else: iprot.skip(ftype) - elif fid == 2: - if ftype == TType.STRUCT: - self.o2 = MetaException() - self.o2.read(iprot) + elif fid == 4: + if ftype == TType.STRING: + self.col_name = iprot.readString() else: iprot.skip(ftype) else: @@ -29465,86 +29472,22 @@ 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_table_statistics_req_result') - if self.success is not None: - oprot.writeFieldBegin('success', TType.STRUCT, 0) - self.success.write(oprot) + oprot.writeStructBegin('get_partition_column_statistics_args') + if self.db_name is not None: + oprot.writeFieldBegin('db_name', TType.STRING, 1) + oprot.writeString(self.db_name) oprot.writeFieldEnd() - if self.o1 is not None: - oprot.writeFieldBegin('o1', TType.STRUCT, 1) - self.o1.write(oprot) + if self.tbl_name is not None: + oprot.writeFieldBegin('tbl_name', TType.STRING, 2) + oprot.writeString(self.tbl_name) oprot.writeFieldEnd() - if self.o2 is not None: - oprot.writeFieldBegin('o2', TType.STRUCT, 2) - self.o2.write(oprot) + if self.part_name is not None: + oprot.writeFieldBegin('part_name', TType.STRING, 3) + oprot.writeString(self.part_name) oprot.writeFieldEnd() - oprot.writeFieldStop() - oprot.writeStructEnd() - - def validate(self): - return - - - def __hash__(self): - value = 17 - value = (value * 31) ^ hash(self.success) - value = (value * 31) ^ hash(self.o1) - value = (value * 31) ^ hash(self.o2) - return value - - def __repr__(self): - L = ['%s=%r' % (key, value) - for key, value in self.__dict__.iteritems()] - return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) - - def __eq__(self, other): - return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ - - def __ne__(self, other): - return not (self == other) - -class get_partitions_statistics_req_args: - """ - Attributes: - - request - """ - - thrift_spec = ( - None, # 0 - (1, TType.STRUCT, 'request', (PartitionsStatsRequest, PartitionsStatsRequest.thrift_spec), None, ), # 1 - ) - - def __init__(self, request=None,): - self.request = request - - 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.request = PartitionsStatsRequest() - self.request.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_partitions_statistics_req_args') - if self.request is not None: - oprot.writeFieldBegin('request', TType.STRUCT, 1) - self.request.write(oprot) + if self.col_name is not None: + oprot.writeFieldBegin('col_name', TType.STRING, 4) + oprot.writeString(self.col_name) oprot.writeFieldEnd() oprot.writeFieldStop() oprot.writeStructEnd() @@ -29555,7 +29498,10 @@ def validate(self): def __hash__(self): value = 17 - value = (value * 31) ^ hash(self.request) + value = (value * 31) ^ hash(self.db_name) + value = (value * 31) ^ hash(self.tbl_name) + value = (value * 31) ^ hash(self.part_name) + value = (value * 31) ^ hash(self.col_name) return value def __repr__(self): @@ -29569,24 +29515,30 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class get_partitions_statistics_req_result: +class get_partition_column_statistics_result: """ Attributes: - success - o1 - o2 + - o3 + - o4 """ thrift_spec = ( - (0, TType.STRUCT, 'success', (PartitionsStatsResult, PartitionsStatsResult.thrift_spec), None, ), # 0 + (0, TType.STRUCT, 'success', (ColumnStatistics, ColumnStatistics.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', (InvalidInputException, InvalidInputException.thrift_spec), None, ), # 3 + (4, TType.STRUCT, 'o4', (InvalidObjectException, InvalidObjectException.thrift_spec), None, ), # 4 ) - def __init__(self, success=None, o1=None, o2=None,): + def __init__(self, success=None, o1=None, o2=None, o3=None, o4=None,): self.success = success 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: @@ -29599,7 +29551,7 @@ def read(self, iprot): break if fid == 0: if ftype == TType.STRUCT: - self.success = PartitionsStatsResult() + self.success = ColumnStatistics() self.success.read(iprot) else: iprot.skip(ftype) @@ -29615,6 +29567,18 @@ def read(self, iprot): self.o2.read(iprot) else: iprot.skip(ftype) + elif fid == 3: + if ftype == TType.STRUCT: + self.o3 = InvalidInputException() + self.o3.read(iprot) + else: + iprot.skip(ftype) + elif fid == 4: + if ftype == TType.STRUCT: + self.o4 = InvalidObjectException() + self.o4.read(iprot) + else: + iprot.skip(ftype) else: iprot.skip(ftype) iprot.readFieldEnd() @@ -29624,7 +29588,7 @@ 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_partitions_statistics_req_result') + oprot.writeStructBegin('get_partition_column_statistics_result') if self.success is not None: oprot.writeFieldBegin('success', TType.STRUCT, 0) self.success.write(oprot) @@ -29637,6 +29601,14 @@ def write(self, oprot): 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() @@ -29649,6 +29621,8 @@ def __hash__(self): value = (value * 31) ^ hash(self.success) value = (value * 31) ^ hash(self.o1) value = (value * 31) ^ hash(self.o2) + value = (value * 31) ^ hash(self.o3) + value = (value * 31) ^ hash(self.o4) return value def __repr__(self): @@ -29662,7 +29636,7 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class get_aggr_stats_for_args: +class get_table_statistics_req_args: """ Attributes: - request @@ -29670,7 +29644,7 @@ class get_aggr_stats_for_args: thrift_spec = ( None, # 0 - (1, TType.STRUCT, 'request', (PartitionsStatsRequest, PartitionsStatsRequest.thrift_spec), None, ), # 1 + (1, TType.STRUCT, 'request', (TableStatsRequest, TableStatsRequest.thrift_spec), None, ), # 1 ) def __init__(self, request=None,): @@ -29687,7 +29661,7 @@ def read(self, iprot): break if fid == 1: if ftype == TType.STRUCT: - self.request = PartitionsStatsRequest() + self.request = TableStatsRequest() self.request.read(iprot) else: iprot.skip(ftype) @@ -29700,7 +29674,7 @@ 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_aggr_stats_for_args') + oprot.writeStructBegin('get_table_statistics_req_args') if self.request is not None: oprot.writeFieldBegin('request', TType.STRUCT, 1) self.request.write(oprot) @@ -29728,7 +29702,7 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class get_aggr_stats_for_result: +class get_table_statistics_req_result: """ Attributes: - success @@ -29737,7 +29711,7 @@ class get_aggr_stats_for_result: """ thrift_spec = ( - (0, TType.STRUCT, 'success', (AggrStats, AggrStats.thrift_spec), None, ), # 0 + (0, TType.STRUCT, 'success', (TableStatsResult, TableStatsResult.thrift_spec), None, ), # 0 (1, TType.STRUCT, 'o1', (NoSuchObjectException, NoSuchObjectException.thrift_spec), None, ), # 1 (2, TType.STRUCT, 'o2', (MetaException, MetaException.thrift_spec), None, ), # 2 ) @@ -29758,7 +29732,7 @@ def read(self, iprot): break if fid == 0: if ftype == TType.STRUCT: - self.success = AggrStats() + self.success = TableStatsResult() self.success.read(iprot) else: iprot.skip(ftype) @@ -29783,7 +29757,7 @@ 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_aggr_stats_for_result') + oprot.writeStructBegin('get_table_statistics_req_result') if self.success is not None: oprot.writeFieldBegin('success', TType.STRUCT, 0) self.success.write(oprot) @@ -29821,7 +29795,7 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class set_aggr_stats_for_args: +class get_partitions_statistics_req_args: """ Attributes: - request @@ -29829,7 +29803,7 @@ class set_aggr_stats_for_args: thrift_spec = ( None, # 0 - (1, TType.STRUCT, 'request', (SetPartitionsStatsRequest, SetPartitionsStatsRequest.thrift_spec), None, ), # 1 + (1, TType.STRUCT, 'request', (PartitionsStatsRequest, PartitionsStatsRequest.thrift_spec), None, ), # 1 ) def __init__(self, request=None,): @@ -29846,7 +29820,7 @@ def read(self, iprot): break if fid == 1: if ftype == TType.STRUCT: - self.request = SetPartitionsStatsRequest() + self.request = PartitionsStatsRequest() self.request.read(iprot) else: iprot.skip(ftype) @@ -29859,7 +29833,7 @@ 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('set_aggr_stats_for_args') + oprot.writeStructBegin('get_partitions_statistics_req_args') if self.request is not None: oprot.writeFieldBegin('request', TType.STRUCT, 1) self.request.write(oprot) @@ -29887,30 +29861,24 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class set_aggr_stats_for_result: +class get_partitions_statistics_req_result: """ Attributes: - success - o1 - o2 - - o3 - - o4 """ thrift_spec = ( - (0, TType.BOOL, 'success', None, None, ), # 0 + (0, TType.STRUCT, 'success', (PartitionsStatsResult, PartitionsStatsResult.thrift_spec), None, ), # 0 (1, TType.STRUCT, 'o1', (NoSuchObjectException, NoSuchObjectException.thrift_spec), None, ), # 1 - (2, TType.STRUCT, 'o2', (InvalidObjectException, InvalidObjectException.thrift_spec), None, ), # 2 - (3, TType.STRUCT, 'o3', (MetaException, MetaException.thrift_spec), None, ), # 3 - (4, TType.STRUCT, 'o4', (InvalidInputException, InvalidInputException.thrift_spec), None, ), # 4 + (2, TType.STRUCT, 'o2', (MetaException, MetaException.thrift_spec), None, ), # 2 ) - def __init__(self, success=None, o1=None, o2=None, o3=None, o4=None,): + def __init__(self, success=None, o1=None, o2=None,): self.success = success 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: @@ -29922,8 +29890,9 @@ def read(self, iprot): if ftype == TType.STOP: break if fid == 0: - if ftype == TType.BOOL: - self.success = iprot.readBool() + if ftype == TType.STRUCT: + self.success = PartitionsStatsResult() + self.success.read(iprot) else: iprot.skip(ftype) elif fid == 1: @@ -29934,22 +29903,10 @@ def read(self, iprot): iprot.skip(ftype) elif fid == 2: if ftype == TType.STRUCT: - self.o2 = InvalidObjectException() + self.o2 = MetaException() 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) - elif fid == 4: - if ftype == TType.STRUCT: - self.o4 = InvalidInputException() - self.o4.read(iprot) - else: - iprot.skip(ftype) else: iprot.skip(ftype) iprot.readFieldEnd() @@ -29959,10 +29916,10 @@ 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('set_aggr_stats_for_result') + oprot.writeStructBegin('get_partitions_statistics_req_result') if self.success is not None: - oprot.writeFieldBegin('success', TType.BOOL, 0) - oprot.writeBool(self.success) + oprot.writeFieldBegin('success', TType.STRUCT, 0) + self.success.write(oprot) oprot.writeFieldEnd() if self.o1 is not None: oprot.writeFieldBegin('o1', TType.STRUCT, 1) @@ -29972,14 +29929,6 @@ def write(self, oprot): 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() @@ -29992,8 +29941,6 @@ def __hash__(self): value = (value * 31) ^ hash(self.success) value = (value * 31) ^ hash(self.o1) value = (value * 31) ^ hash(self.o2) - value = (value * 31) ^ hash(self.o3) - value = (value * 31) ^ hash(self.o4) return value def __repr__(self): @@ -30007,28 +29954,19 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class delete_partition_column_statistics_args: +class get_aggr_stats_for_args: """ Attributes: - - db_name - - tbl_name - - part_name - - col_name + - request """ thrift_spec = ( None, # 0 - (1, TType.STRING, 'db_name', None, None, ), # 1 - (2, TType.STRING, 'tbl_name', None, None, ), # 2 - (3, TType.STRING, 'part_name', None, None, ), # 3 - (4, TType.STRING, 'col_name', None, None, ), # 4 + (1, TType.STRUCT, 'request', (PartitionsStatsRequest, PartitionsStatsRequest.thrift_spec), None, ), # 1 ) - def __init__(self, db_name=None, tbl_name=None, part_name=None, col_name=None,): - self.db_name = db_name - self.tbl_name = tbl_name - self.part_name = part_name - self.col_name = col_name + def __init__(self, request=None,): + self.request = request 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: @@ -30040,23 +29978,92 @@ def read(self, iprot): if ftype == TType.STOP: break if fid == 1: - if ftype == TType.STRING: - self.db_name = iprot.readString() + if ftype == TType.STRUCT: + self.request = PartitionsStatsRequest() + self.request.read(iprot) else: iprot.skip(ftype) - elif fid == 2: - if ftype == TType.STRING: - self.tbl_name = iprot.readString() + 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_aggr_stats_for_args') + if self.request is not None: + oprot.writeFieldBegin('request', TType.STRUCT, 1) + self.request.write(oprot) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.request) + return value + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + +class get_aggr_stats_for_result: + """ + Attributes: + - success + - o1 + - o2 + """ + + thrift_spec = ( + (0, TType.STRUCT, 'success', (AggrStats, AggrStats.thrift_spec), None, ), # 0 + (1, TType.STRUCT, 'o1', (NoSuchObjectException, NoSuchObjectException.thrift_spec), None, ), # 1 + (2, TType.STRUCT, 'o2', (MetaException, MetaException.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 = AggrStats() + self.success.read(iprot) else: iprot.skip(ftype) - elif fid == 3: - if ftype == TType.STRING: - self.part_name = iprot.readString() + elif fid == 1: + if ftype == TType.STRUCT: + self.o1 = NoSuchObjectException() + self.o1.read(iprot) else: iprot.skip(ftype) - elif fid == 4: - if ftype == TType.STRING: - self.col_name = iprot.readString() + elif fid == 2: + if ftype == TType.STRUCT: + self.o2 = MetaException() + self.o2.read(iprot) else: iprot.skip(ftype) else: @@ -30068,22 +30075,86 @@ 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('delete_partition_column_statistics_args') - if self.db_name is not None: - oprot.writeFieldBegin('db_name', TType.STRING, 1) - oprot.writeString(self.db_name) + oprot.writeStructBegin('get_aggr_stats_for_result') + if self.success is not None: + oprot.writeFieldBegin('success', TType.STRUCT, 0) + self.success.write(oprot) oprot.writeFieldEnd() - if self.tbl_name is not None: - oprot.writeFieldBegin('tbl_name', TType.STRING, 2) - oprot.writeString(self.tbl_name) + if self.o1 is not None: + oprot.writeFieldBegin('o1', TType.STRUCT, 1) + self.o1.write(oprot) oprot.writeFieldEnd() - if self.part_name is not None: - oprot.writeFieldBegin('part_name', TType.STRING, 3) - oprot.writeString(self.part_name) + if self.o2 is not None: + oprot.writeFieldBegin('o2', TType.STRUCT, 2) + self.o2.write(oprot) oprot.writeFieldEnd() - if self.col_name is not None: - oprot.writeFieldBegin('col_name', TType.STRING, 4) - oprot.writeString(self.col_name) + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.success) + value = (value * 31) ^ hash(self.o1) + value = (value * 31) ^ hash(self.o2) + return value + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + +class set_aggr_stats_for_args: + """ + Attributes: + - request + """ + + thrift_spec = ( + None, # 0 + (1, TType.STRUCT, 'request', (SetPartitionsStatsRequest, SetPartitionsStatsRequest.thrift_spec), None, ), # 1 + ) + + def __init__(self, request=None,): + self.request = request + + 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.request = SetPartitionsStatsRequest() + self.request.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('set_aggr_stats_for_args') + if self.request is not None: + oprot.writeFieldBegin('request', TType.STRUCT, 1) + self.request.write(oprot) oprot.writeFieldEnd() oprot.writeFieldStop() oprot.writeStructEnd() @@ -30094,10 +30165,7 @@ def validate(self): def __hash__(self): value = 17 - value = (value * 31) ^ hash(self.db_name) - value = (value * 31) ^ hash(self.tbl_name) - value = (value * 31) ^ hash(self.part_name) - value = (value * 31) ^ hash(self.col_name) + value = (value * 31) ^ hash(self.request) return value def __repr__(self): @@ -30111,7 +30179,7 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class delete_partition_column_statistics_result: +class set_aggr_stats_for_result: """ Attributes: - success @@ -30124,8 +30192,8 @@ class delete_partition_column_statistics_result: 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', (InvalidObjectException, InvalidObjectException.thrift_spec), None, ), # 3 + (2, TType.STRUCT, 'o2', (InvalidObjectException, InvalidObjectException.thrift_spec), None, ), # 2 + (3, TType.STRUCT, 'o3', (MetaException, MetaException.thrift_spec), None, ), # 3 (4, TType.STRUCT, 'o4', (InvalidInputException, InvalidInputException.thrift_spec), None, ), # 4 ) @@ -30158,13 +30226,13 @@ def read(self, iprot): iprot.skip(ftype) elif fid == 2: if ftype == TType.STRUCT: - self.o2 = MetaException() + self.o2 = InvalidObjectException() self.o2.read(iprot) else: iprot.skip(ftype) elif fid == 3: if ftype == TType.STRUCT: - self.o3 = InvalidObjectException() + self.o3 = MetaException() self.o3.read(iprot) else: iprot.skip(ftype) @@ -30183,7 +30251,7 @@ 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('delete_partition_column_statistics_result') + oprot.writeStructBegin('set_aggr_stats_for_result') if self.success is not None: oprot.writeFieldBegin('success', TType.BOOL, 0) oprot.writeBool(self.success) @@ -30231,11 +30299,12 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class delete_table_column_statistics_args: +class delete_partition_column_statistics_args: """ Attributes: - db_name - tbl_name + - part_name - col_name """ @@ -30243,12 +30312,14 @@ class delete_table_column_statistics_args: None, # 0 (1, TType.STRING, 'db_name', None, None, ), # 1 (2, TType.STRING, 'tbl_name', None, None, ), # 2 - (3, TType.STRING, 'col_name', None, None, ), # 3 + (3, TType.STRING, 'part_name', None, None, ), # 3 + (4, TType.STRING, 'col_name', None, None, ), # 4 ) - def __init__(self, db_name=None, tbl_name=None, col_name=None,): + def __init__(self, db_name=None, tbl_name=None, part_name=None, col_name=None,): self.db_name = db_name self.tbl_name = tbl_name + self.part_name = part_name self.col_name = col_name def read(self, iprot): @@ -30271,6 +30342,11 @@ def read(self, iprot): else: iprot.skip(ftype) elif fid == 3: + if ftype == TType.STRING: + self.part_name = iprot.readString() + else: + iprot.skip(ftype) + elif fid == 4: if ftype == TType.STRING: self.col_name = iprot.readString() else: @@ -30284,7 +30360,7 @@ 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('delete_table_column_statistics_args') + oprot.writeStructBegin('delete_partition_column_statistics_args') if self.db_name is not None: oprot.writeFieldBegin('db_name', TType.STRING, 1) oprot.writeString(self.db_name) @@ -30293,8 +30369,12 @@ def write(self, oprot): oprot.writeFieldBegin('tbl_name', TType.STRING, 2) oprot.writeString(self.tbl_name) oprot.writeFieldEnd() + if self.part_name is not None: + oprot.writeFieldBegin('part_name', TType.STRING, 3) + oprot.writeString(self.part_name) + oprot.writeFieldEnd() if self.col_name is not None: - oprot.writeFieldBegin('col_name', TType.STRING, 3) + oprot.writeFieldBegin('col_name', TType.STRING, 4) oprot.writeString(self.col_name) oprot.writeFieldEnd() oprot.writeFieldStop() @@ -30308,6 +30388,7 @@ def __hash__(self): value = 17 value = (value * 31) ^ hash(self.db_name) value = (value * 31) ^ hash(self.tbl_name) + value = (value * 31) ^ hash(self.part_name) value = (value * 31) ^ hash(self.col_name) return value @@ -30322,7 +30403,218 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class delete_table_column_statistics_result: +class delete_partition_column_statistics_result: + """ + Attributes: + - success + - o1 + - o2 + - o3 + - o4 + """ + + 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', (InvalidObjectException, InvalidObjectException.thrift_spec), None, ), # 3 + (4, TType.STRUCT, 'o4', (InvalidInputException, InvalidInputException.thrift_spec), None, ), # 4 + ) + + def __init__(self, success=None, o1=None, o2=None, o3=None, o4=None,): + self.success = success + 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 == 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 = InvalidObjectException() + self.o3.read(iprot) + else: + iprot.skip(ftype) + elif fid == 4: + if ftype == TType.STRUCT: + self.o4 = InvalidInputException() + 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('delete_partition_column_statistics_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() + 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 __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.success) + value = (value * 31) ^ hash(self.o1) + value = (value * 31) ^ hash(self.o2) + value = (value * 31) ^ hash(self.o3) + value = (value * 31) ^ hash(self.o4) + return value + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + +class delete_table_column_statistics_args: + """ + Attributes: + - db_name + - tbl_name + - col_name + """ + + thrift_spec = ( + None, # 0 + (1, TType.STRING, 'db_name', None, None, ), # 1 + (2, TType.STRING, 'tbl_name', None, None, ), # 2 + (3, TType.STRING, 'col_name', None, None, ), # 3 + ) + + def __init__(self, db_name=None, tbl_name=None, col_name=None,): + self.db_name = db_name + self.tbl_name = tbl_name + self.col_name = col_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.db_name = iprot.readString() + else: + iprot.skip(ftype) + elif fid == 2: + if ftype == TType.STRING: + self.tbl_name = iprot.readString() + else: + iprot.skip(ftype) + elif fid == 3: + if ftype == TType.STRING: + self.col_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('delete_table_column_statistics_args') + if self.db_name is not None: + oprot.writeFieldBegin('db_name', TType.STRING, 1) + oprot.writeString(self.db_name) + oprot.writeFieldEnd() + if self.tbl_name is not None: + oprot.writeFieldBegin('tbl_name', TType.STRING, 2) + oprot.writeString(self.tbl_name) + oprot.writeFieldEnd() + if self.col_name is not None: + oprot.writeFieldBegin('col_name', TType.STRING, 3) + oprot.writeString(self.col_name) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.db_name) + value = (value * 31) ^ hash(self.tbl_name) + value = (value * 31) ^ hash(self.col_name) + return value + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + +class delete_table_column_statistics_result: """ Attributes: - success @@ -31052,10 +31344,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1078, _size1075) = iprot.readListBegin() - for _i1079 in xrange(_size1075): - _elem1080 = iprot.readString() - self.success.append(_elem1080) + (_etype1085, _size1082) = iprot.readListBegin() + for _i1086 in xrange(_size1082): + _elem1087 = iprot.readString() + self.success.append(_elem1087) iprot.readListEnd() else: iprot.skip(ftype) @@ -31078,8 +31370,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter1081 in self.success: - oprot.writeString(iter1081) + for iter1088 in self.success: + oprot.writeString(iter1088) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -31767,10 +32059,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1085, _size1082) = iprot.readListBegin() - for _i1086 in xrange(_size1082): - _elem1087 = iprot.readString() - self.success.append(_elem1087) + (_etype1092, _size1089) = iprot.readListBegin() + for _i1093 in xrange(_size1089): + _elem1094 = iprot.readString() + self.success.append(_elem1094) iprot.readListEnd() else: iprot.skip(ftype) @@ -31793,8 +32085,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter1088 in self.success: - oprot.writeString(iter1088) + for iter1095 in self.success: + oprot.writeString(iter1095) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -32308,11 +32600,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1092, _size1089) = iprot.readListBegin() - for _i1093 in xrange(_size1089): - _elem1094 = Role() - _elem1094.read(iprot) - self.success.append(_elem1094) + (_etype1099, _size1096) = iprot.readListBegin() + for _i1100 in xrange(_size1096): + _elem1101 = Role() + _elem1101.read(iprot) + self.success.append(_elem1101) iprot.readListEnd() else: iprot.skip(ftype) @@ -32335,8 +32627,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter1095 in self.success: - iter1095.write(oprot) + for iter1102 in self.success: + iter1102.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -32845,10 +33137,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.group_names = [] - (_etype1099, _size1096) = iprot.readListBegin() - for _i1100 in xrange(_size1096): - _elem1101 = iprot.readString() - self.group_names.append(_elem1101) + (_etype1106, _size1103) = iprot.readListBegin() + for _i1107 in xrange(_size1103): + _elem1108 = iprot.readString() + self.group_names.append(_elem1108) iprot.readListEnd() else: iprot.skip(ftype) @@ -32873,8 +33165,8 @@ def write(self, oprot): if self.group_names is not None: oprot.writeFieldBegin('group_names', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.group_names)) - for iter1102 in self.group_names: - oprot.writeString(iter1102) + for iter1109 in self.group_names: + oprot.writeString(iter1109) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -33101,11 +33393,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1106, _size1103) = iprot.readListBegin() - for _i1107 in xrange(_size1103): - _elem1108 = HiveObjectPrivilege() - _elem1108.read(iprot) - self.success.append(_elem1108) + (_etype1113, _size1110) = iprot.readListBegin() + for _i1114 in xrange(_size1110): + _elem1115 = HiveObjectPrivilege() + _elem1115.read(iprot) + self.success.append(_elem1115) iprot.readListEnd() else: iprot.skip(ftype) @@ -33128,8 +33420,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter1109 in self.success: - iter1109.write(oprot) + for iter1116 in self.success: + iter1116.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -33627,10 +33919,10 @@ def read(self, iprot): elif fid == 2: if ftype == TType.LIST: self.group_names = [] - (_etype1113, _size1110) = iprot.readListBegin() - for _i1114 in xrange(_size1110): - _elem1115 = iprot.readString() - self.group_names.append(_elem1115) + (_etype1120, _size1117) = iprot.readListBegin() + for _i1121 in xrange(_size1117): + _elem1122 = iprot.readString() + self.group_names.append(_elem1122) iprot.readListEnd() else: iprot.skip(ftype) @@ -33651,8 +33943,8 @@ def write(self, oprot): if self.group_names is not None: oprot.writeFieldBegin('group_names', TType.LIST, 2) oprot.writeListBegin(TType.STRING, len(self.group_names)) - for iter1116 in self.group_names: - oprot.writeString(iter1116) + for iter1123 in self.group_names: + oprot.writeString(iter1123) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -33707,10 +33999,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1120, _size1117) = iprot.readListBegin() - for _i1121 in xrange(_size1117): - _elem1122 = iprot.readString() - self.success.append(_elem1122) + (_etype1127, _size1124) = iprot.readListBegin() + for _i1128 in xrange(_size1124): + _elem1129 = iprot.readString() + self.success.append(_elem1129) iprot.readListEnd() else: iprot.skip(ftype) @@ -33733,8 +34025,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter1123 in self.success: - oprot.writeString(iter1123) + for iter1130 in self.success: + oprot.writeString(iter1130) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -34666,10 +34958,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1127, _size1124) = iprot.readListBegin() - for _i1128 in xrange(_size1124): - _elem1129 = iprot.readString() - self.success.append(_elem1129) + (_etype1134, _size1131) = iprot.readListBegin() + for _i1135 in xrange(_size1131): + _elem1136 = iprot.readString() + self.success.append(_elem1136) iprot.readListEnd() else: iprot.skip(ftype) @@ -34686,8 +34978,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter1130 in self.success: - oprot.writeString(iter1130) + for iter1137 in self.success: + oprot.writeString(iter1137) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -35214,10 +35506,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1134, _size1131) = iprot.readListBegin() - for _i1135 in xrange(_size1131): - _elem1136 = iprot.readString() - self.success.append(_elem1136) + (_etype1141, _size1138) = iprot.readListBegin() + for _i1142 in xrange(_size1138): + _elem1143 = iprot.readString() + self.success.append(_elem1143) iprot.readListEnd() else: iprot.skip(ftype) @@ -35234,8 +35526,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter1137 in self.success: - oprot.writeString(iter1137) + for iter1144 in self.success: + oprot.writeString(iter1144) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -39059,19 +39351,828 @@ def read(self, iprot): break if fid == 0: if ftype == TType.STRUCT: - self.success = WMCreateResourcePlanResponse() + self.success = WMCreateResourcePlanResponse() + self.success.read(iprot) + else: + iprot.skip(ftype) + elif 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_resource_plan_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() + 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 __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.success) + value = (value * 31) ^ hash(self.o1) + value = (value * 31) ^ hash(self.o2) + value = (value * 31) ^ hash(self.o3) + return value + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + +class get_resource_plan_args: + """ + Attributes: + - request + """ + + thrift_spec = ( + None, # 0 + (1, TType.STRUCT, 'request', (WMGetResourcePlanRequest, WMGetResourcePlanRequest.thrift_spec), None, ), # 1 + ) + + def __init__(self, request=None,): + self.request = request + + 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.request = WMGetResourcePlanRequest() + self.request.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_resource_plan_args') + if self.request is not None: + oprot.writeFieldBegin('request', TType.STRUCT, 1) + self.request.write(oprot) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.request) + return value + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + +class get_resource_plan_result: + """ + Attributes: + - success + - o1 + - o2 + """ + + thrift_spec = ( + (0, TType.STRUCT, 'success', (WMGetResourcePlanResponse, WMGetResourcePlanResponse.thrift_spec), None, ), # 0 + (1, TType.STRUCT, 'o1', (NoSuchObjectException, NoSuchObjectException.thrift_spec), None, ), # 1 + (2, TType.STRUCT, 'o2', (MetaException, MetaException.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 = WMGetResourcePlanResponse() + self.success.read(iprot) + 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) + 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_resource_plan_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 __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.success) + value = (value * 31) ^ hash(self.o1) + value = (value * 31) ^ hash(self.o2) + return value + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + +class get_all_resource_plans_args: + """ + Attributes: + - request + """ + + thrift_spec = ( + None, # 0 + (1, TType.STRUCT, 'request', (WMGetAllResourcePlanRequest, WMGetAllResourcePlanRequest.thrift_spec), None, ), # 1 + ) + + def __init__(self, request=None,): + self.request = request + + 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.request = WMGetAllResourcePlanRequest() + self.request.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_all_resource_plans_args') + if self.request is not None: + oprot.writeFieldBegin('request', TType.STRUCT, 1) + self.request.write(oprot) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.request) + return value + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + +class get_all_resource_plans_result: + """ + Attributes: + - success + - o1 + """ + + thrift_spec = ( + (0, TType.STRUCT, 'success', (WMGetAllResourcePlanResponse, WMGetAllResourcePlanResponse.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.STRUCT: + self.success = WMGetAllResourcePlanResponse() + 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) + 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_all_resource_plans_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() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.success) + value = (value * 31) ^ hash(self.o1) + return value + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + +class alter_resource_plan_args: + """ + Attributes: + - request + """ + + thrift_spec = ( + None, # 0 + (1, TType.STRUCT, 'request', (WMAlterResourcePlanRequest, WMAlterResourcePlanRequest.thrift_spec), None, ), # 1 + ) + + def __init__(self, request=None,): + self.request = request + + 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.request = WMAlterResourcePlanRequest() + self.request.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_resource_plan_args') + if self.request is not None: + oprot.writeFieldBegin('request', TType.STRUCT, 1) + self.request.write(oprot) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.request) + return value + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + +class alter_resource_plan_result: + """ + Attributes: + - success + - o1 + - o2 + - o3 + """ + + thrift_spec = ( + (0, TType.STRUCT, 'success', (WMAlterResourcePlanResponse, WMAlterResourcePlanResponse.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, 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.STRUCT: + self.success = WMAlterResourcePlanResponse() + self.success.read(iprot) + 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 = 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('alter_resource_plan_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() + 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 __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.success) + value = (value * 31) ^ hash(self.o1) + value = (value * 31) ^ hash(self.o2) + value = (value * 31) ^ hash(self.o3) + return value + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + +class validate_resource_plan_args: + """ + Attributes: + - request + """ + + thrift_spec = ( + None, # 0 + (1, TType.STRUCT, 'request', (WMValidateResourcePlanRequest, WMValidateResourcePlanRequest.thrift_spec), None, ), # 1 + ) + + def __init__(self, request=None,): + self.request = request + + 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.request = WMValidateResourcePlanRequest() + self.request.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('validate_resource_plan_args') + if self.request is not None: + oprot.writeFieldBegin('request', TType.STRUCT, 1) + self.request.write(oprot) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.request) + return value + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + +class validate_resource_plan_result: + """ + Attributes: + - success + - o1 + - o2 + """ + + thrift_spec = ( + (0, TType.STRUCT, 'success', (WMValidateResourcePlanResponse, WMValidateResourcePlanResponse.thrift_spec), None, ), # 0 + (1, TType.STRUCT, 'o1', (NoSuchObjectException, NoSuchObjectException.thrift_spec), None, ), # 1 + (2, TType.STRUCT, 'o2', (MetaException, MetaException.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 = WMValidateResourcePlanResponse() + self.success.read(iprot) + 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) + 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('validate_resource_plan_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 __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.success) + value = (value * 31) ^ hash(self.o1) + value = (value * 31) ^ hash(self.o2) + return value + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + +class drop_resource_plan_args: + """ + Attributes: + - request + """ + + thrift_spec = ( + None, # 0 + (1, TType.STRUCT, 'request', (WMDropResourcePlanRequest, WMDropResourcePlanRequest.thrift_spec), None, ), # 1 + ) + + def __init__(self, request=None,): + self.request = request + + 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.request = WMDropResourcePlanRequest() + self.request.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_resource_plan_args') + if self.request is not None: + oprot.writeFieldBegin('request', TType.STRUCT, 1) + self.request.write(oprot) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.request) + return value + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + +class drop_resource_plan_result: + """ + Attributes: + - success + - o1 + - o2 + - o3 + """ + + thrift_spec = ( + (0, TType.STRUCT, 'success', (WMDropResourcePlanResponse, WMDropResourcePlanResponse.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, 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.STRUCT: + self.success = WMDropResourcePlanResponse() self.success.read(iprot) else: iprot.skip(ftype) elif fid == 1: if ftype == TType.STRUCT: - self.o1 = AlreadyExistsException() + self.o1 = NoSuchObjectException() self.o1.read(iprot) else: iprot.skip(ftype) elif fid == 2: if ftype == TType.STRUCT: - self.o2 = InvalidObjectException() + self.o2 = InvalidOperationException() self.o2.read(iprot) else: iprot.skip(ftype) @@ -39090,7 +40191,7 @@ 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_resource_plan_result') + oprot.writeStructBegin('drop_resource_plan_result') if self.success is not None: oprot.writeFieldBegin('success', TType.STRUCT, 0) self.success.write(oprot) @@ -39133,7 +40234,7 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class get_resource_plan_args: +class create_wm_trigger_args: """ Attributes: - request @@ -39141,7 +40242,7 @@ class get_resource_plan_args: thrift_spec = ( None, # 0 - (1, TType.STRUCT, 'request', (WMGetResourcePlanRequest, WMGetResourcePlanRequest.thrift_spec), None, ), # 1 + (1, TType.STRUCT, 'request', (WMCreateTriggerRequest, WMCreateTriggerRequest.thrift_spec), None, ), # 1 ) def __init__(self, request=None,): @@ -39158,7 +40259,7 @@ def read(self, iprot): break if fid == 1: if ftype == TType.STRUCT: - self.request = WMGetResourcePlanRequest() + self.request = WMCreateTriggerRequest() self.request.read(iprot) else: iprot.skip(ftype) @@ -39171,7 +40272,7 @@ 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_resource_plan_args') + oprot.writeStructBegin('create_wm_trigger_args') if self.request is not None: oprot.writeFieldBegin('request', TType.STRUCT, 1) self.request.write(oprot) @@ -39199,24 +40300,30 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class get_resource_plan_result: +class create_wm_trigger_result: """ Attributes: - success - o1 - o2 + - o3 + - o4 """ thrift_spec = ( - (0, TType.STRUCT, 'success', (WMGetResourcePlanResponse, WMGetResourcePlanResponse.thrift_spec), None, ), # 0 - (1, TType.STRUCT, 'o1', (NoSuchObjectException, NoSuchObjectException.thrift_spec), None, ), # 1 - (2, TType.STRUCT, 'o2', (MetaException, MetaException.thrift_spec), None, ), # 2 + (0, TType.STRUCT, 'success', (WMCreateTriggerResponse, WMCreateTriggerResponse.thrift_spec), None, ), # 0 + (1, TType.STRUCT, 'o1', (AlreadyExistsException, AlreadyExistsException.thrift_spec), None, ), # 1 + (2, TType.STRUCT, 'o2', (NoSuchObjectException, NoSuchObjectException.thrift_spec), None, ), # 2 + (3, TType.STRUCT, 'o3', (InvalidObjectException, InvalidObjectException.thrift_spec), None, ), # 3 + (4, TType.STRUCT, 'o4', (MetaException, MetaException.thrift_spec), None, ), # 4 ) - def __init__(self, success=None, o1=None, o2=None,): + def __init__(self, success=None, o1=None, o2=None, o3=None, o4=None,): self.success = success 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: @@ -39229,170 +40336,32 @@ def read(self, iprot): break if fid == 0: if ftype == TType.STRUCT: - self.success = WMGetResourcePlanResponse() + self.success = WMCreateTriggerResponse() self.success.read(iprot) else: iprot.skip(ftype) elif fid == 1: if ftype == TType.STRUCT: - self.o1 = NoSuchObjectException() + self.o1 = AlreadyExistsException() self.o1.read(iprot) else: iprot.skip(ftype) elif fid == 2: if ftype == TType.STRUCT: - self.o2 = MetaException() + 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_resource_plan_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 __hash__(self): - value = 17 - value = (value * 31) ^ hash(self.success) - value = (value * 31) ^ hash(self.o1) - value = (value * 31) ^ hash(self.o2) - return value - - def __repr__(self): - L = ['%s=%r' % (key, value) - for key, value in self.__dict__.iteritems()] - return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) - - def __eq__(self, other): - return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ - - def __ne__(self, other): - return not (self == other) - -class get_all_resource_plans_args: - """ - Attributes: - - request - """ - - thrift_spec = ( - None, # 0 - (1, TType.STRUCT, 'request', (WMGetAllResourcePlanRequest, WMGetAllResourcePlanRequest.thrift_spec), None, ), # 1 - ) - - def __init__(self, request=None,): - self.request = request - - 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.request = WMGetAllResourcePlanRequest() - self.request.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_all_resource_plans_args') - if self.request is not None: - oprot.writeFieldBegin('request', TType.STRUCT, 1) - self.request.write(oprot) - oprot.writeFieldEnd() - oprot.writeFieldStop() - oprot.writeStructEnd() - - def validate(self): - return - - - def __hash__(self): - value = 17 - value = (value * 31) ^ hash(self.request) - return value - - def __repr__(self): - L = ['%s=%r' % (key, value) - for key, value in self.__dict__.iteritems()] - return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) - - def __eq__(self, other): - return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ - - def __ne__(self, other): - return not (self == other) - -class get_all_resource_plans_result: - """ - Attributes: - - success - - o1 - """ - - thrift_spec = ( - (0, TType.STRUCT, 'success', (WMGetAllResourcePlanResponse, WMGetAllResourcePlanResponse.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: + elif fid == 3: if ftype == TType.STRUCT: - self.success = WMGetAllResourcePlanResponse() - self.success.read(iprot) + self.o3 = InvalidObjectException() + self.o3.read(iprot) else: iprot.skip(ftype) - elif fid == 1: + elif fid == 4: if ftype == TType.STRUCT: - self.o1 = MetaException() - self.o1.read(iprot) + self.o4 = MetaException() + self.o4.read(iprot) else: iprot.skip(ftype) else: @@ -39404,7 +40373,7 @@ 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_all_resource_plans_result') + oprot.writeStructBegin('create_wm_trigger_result') if self.success is not None: oprot.writeFieldBegin('success', TType.STRUCT, 0) self.success.write(oprot) @@ -39413,6 +40382,18 @@ def write(self, oprot): 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() @@ -39424,6 +40405,9 @@ def __hash__(self): value = 17 value = (value * 31) ^ hash(self.success) value = (value * 31) ^ hash(self.o1) + value = (value * 31) ^ hash(self.o2) + value = (value * 31) ^ hash(self.o3) + value = (value * 31) ^ hash(self.o4) return value def __repr__(self): @@ -39437,7 +40421,7 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class alter_resource_plan_args: +class alter_wm_trigger_args: """ Attributes: - request @@ -39445,7 +40429,7 @@ class alter_resource_plan_args: thrift_spec = ( None, # 0 - (1, TType.STRUCT, 'request', (WMAlterResourcePlanRequest, WMAlterResourcePlanRequest.thrift_spec), None, ), # 1 + (1, TType.STRUCT, 'request', (WMAlterTriggerRequest, WMAlterTriggerRequest.thrift_spec), None, ), # 1 ) def __init__(self, request=None,): @@ -39462,7 +40446,7 @@ def read(self, iprot): break if fid == 1: if ftype == TType.STRUCT: - self.request = WMAlterResourcePlanRequest() + self.request = WMAlterTriggerRequest() self.request.read(iprot) else: iprot.skip(ftype) @@ -39475,7 +40459,7 @@ 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_resource_plan_args') + oprot.writeStructBegin('alter_wm_trigger_args') if self.request is not None: oprot.writeFieldBegin('request', TType.STRUCT, 1) self.request.write(oprot) @@ -39503,7 +40487,7 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class alter_resource_plan_result: +class alter_wm_trigger_result: """ Attributes: - success @@ -39513,9 +40497,9 @@ class alter_resource_plan_result: """ thrift_spec = ( - (0, TType.STRUCT, 'success', (WMAlterResourcePlanResponse, WMAlterResourcePlanResponse.thrift_spec), None, ), # 0 + (0, TType.STRUCT, 'success', (WMAlterTriggerResponse, WMAlterTriggerResponse.thrift_spec), None, ), # 0 (1, TType.STRUCT, 'o1', (NoSuchObjectException, NoSuchObjectException.thrift_spec), None, ), # 1 - (2, TType.STRUCT, 'o2', (InvalidOperationException, InvalidOperationException.thrift_spec), None, ), # 2 + (2, TType.STRUCT, 'o2', (InvalidObjectException, InvalidObjectException.thrift_spec), None, ), # 2 (3, TType.STRUCT, 'o3', (MetaException, MetaException.thrift_spec), None, ), # 3 ) @@ -39536,7 +40520,7 @@ def read(self, iprot): break if fid == 0: if ftype == TType.STRUCT: - self.success = WMAlterResourcePlanResponse() + self.success = WMAlterTriggerResponse() self.success.read(iprot) else: iprot.skip(ftype) @@ -39548,7 +40532,7 @@ def read(self, iprot): iprot.skip(ftype) elif fid == 2: if ftype == TType.STRUCT: - self.o2 = InvalidOperationException() + self.o2 = InvalidObjectException() self.o2.read(iprot) else: iprot.skip(ftype) @@ -39567,7 +40551,7 @@ 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_resource_plan_result') + oprot.writeStructBegin('alter_wm_trigger_result') if self.success is not None: oprot.writeFieldBegin('success', TType.STRUCT, 0) self.success.write(oprot) @@ -39610,7 +40594,7 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class validate_resource_plan_args: +class drop_wm_trigger_args: """ Attributes: - request @@ -39618,7 +40602,7 @@ class validate_resource_plan_args: thrift_spec = ( None, # 0 - (1, TType.STRUCT, 'request', (WMValidateResourcePlanRequest, WMValidateResourcePlanRequest.thrift_spec), None, ), # 1 + (1, TType.STRUCT, 'request', (WMDropTriggerRequest, WMDropTriggerRequest.thrift_spec), None, ), # 1 ) def __init__(self, request=None,): @@ -39635,7 +40619,7 @@ def read(self, iprot): break if fid == 1: if ftype == TType.STRUCT: - self.request = WMValidateResourcePlanRequest() + self.request = WMDropTriggerRequest() self.request.read(iprot) else: iprot.skip(ftype) @@ -39648,7 +40632,7 @@ 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('validate_resource_plan_args') + oprot.writeStructBegin('drop_wm_trigger_args') if self.request is not None: oprot.writeFieldBegin('request', TType.STRUCT, 1) self.request.write(oprot) @@ -39676,24 +40660,27 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class validate_resource_plan_result: +class drop_wm_trigger_result: """ Attributes: - success - o1 - o2 + - o3 """ thrift_spec = ( - (0, TType.STRUCT, 'success', (WMValidateResourcePlanResponse, WMValidateResourcePlanResponse.thrift_spec), None, ), # 0 + (0, TType.STRUCT, 'success', (WMDropTriggerResponse, WMDropTriggerResponse.thrift_spec), None, ), # 0 (1, TType.STRUCT, 'o1', (NoSuchObjectException, NoSuchObjectException.thrift_spec), None, ), # 1 - (2, TType.STRUCT, 'o2', (MetaException, MetaException.thrift_spec), None, ), # 2 + (2, TType.STRUCT, 'o2', (InvalidOperationException, InvalidOperationException.thrift_spec), None, ), # 2 + (3, TType.STRUCT, 'o3', (MetaException, MetaException.thrift_spec), None, ), # 3 ) - def __init__(self, success=None, o1=None, o2=None,): + 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: @@ -39706,7 +40693,7 @@ def read(self, iprot): break if fid == 0: if ftype == TType.STRUCT: - self.success = WMValidateResourcePlanResponse() + self.success = WMDropTriggerResponse() self.success.read(iprot) else: iprot.skip(ftype) @@ -39718,10 +40705,16 @@ def read(self, iprot): iprot.skip(ftype) elif fid == 2: if ftype == TType.STRUCT: - self.o2 = MetaException() + 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() @@ -39731,7 +40724,7 @@ 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('validate_resource_plan_result') + oprot.writeStructBegin('drop_wm_trigger_result') if self.success is not None: oprot.writeFieldBegin('success', TType.STRUCT, 0) self.success.write(oprot) @@ -39744,6 +40737,10 @@ def write(self, oprot): 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() @@ -39756,6 +40753,7 @@ def __hash__(self): value = (value * 31) ^ hash(self.success) value = (value * 31) ^ hash(self.o1) value = (value * 31) ^ hash(self.o2) + value = (value * 31) ^ hash(self.o3) return value def __repr__(self): @@ -39769,7 +40767,7 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class drop_resource_plan_args: +class get_triggers_for_resourceplan_args: """ Attributes: - request @@ -39777,7 +40775,7 @@ class drop_resource_plan_args: thrift_spec = ( None, # 0 - (1, TType.STRUCT, 'request', (WMDropResourcePlanRequest, WMDropResourcePlanRequest.thrift_spec), None, ), # 1 + (1, TType.STRUCT, 'request', (WMGetTriggersForResourePlanRequest, WMGetTriggersForResourePlanRequest.thrift_spec), None, ), # 1 ) def __init__(self, request=None,): @@ -39794,7 +40792,7 @@ def read(self, iprot): break if fid == 1: if ftype == TType.STRUCT: - self.request = WMDropResourcePlanRequest() + self.request = WMGetTriggersForResourePlanRequest() self.request.read(iprot) else: iprot.skip(ftype) @@ -39807,7 +40805,7 @@ 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_resource_plan_args') + oprot.writeStructBegin('get_triggers_for_resourceplan_args') if self.request is not None: oprot.writeFieldBegin('request', TType.STRUCT, 1) self.request.write(oprot) @@ -39835,27 +40833,24 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class drop_resource_plan_result: +class get_triggers_for_resourceplan_result: """ Attributes: - success - o1 - o2 - - o3 """ thrift_spec = ( - (0, TType.STRUCT, 'success', (WMDropResourcePlanResponse, WMDropResourcePlanResponse.thrift_spec), None, ), # 0 + (0, TType.STRUCT, 'success', (WMGetTriggersForResourePlanResponse, WMGetTriggersForResourePlanResponse.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 + (2, TType.STRUCT, 'o2', (MetaException, MetaException.thrift_spec), None, ), # 2 ) - def __init__(self, success=None, o1=None, o2=None, o3=None,): + def __init__(self, success=None, o1=None, o2=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: @@ -39868,7 +40863,7 @@ def read(self, iprot): break if fid == 0: if ftype == TType.STRUCT: - self.success = WMDropResourcePlanResponse() + self.success = WMGetTriggersForResourePlanResponse() self.success.read(iprot) else: iprot.skip(ftype) @@ -39880,16 +40875,10 @@ def read(self, iprot): iprot.skip(ftype) elif fid == 2: if ftype == TType.STRUCT: - self.o2 = InvalidOperationException() + self.o2 = MetaException() 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() @@ -39899,7 +40888,7 @@ 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_resource_plan_result') + oprot.writeStructBegin('get_triggers_for_resourceplan_result') if self.success is not None: oprot.writeFieldBegin('success', TType.STRUCT, 0) self.success.write(oprot) @@ -39912,10 +40901,6 @@ def write(self, oprot): 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() @@ -39928,7 +40913,6 @@ def __hash__(self): value = (value * 31) ^ hash(self.success) value = (value * 31) ^ hash(self.o1) value = (value * 31) ^ hash(self.o2) - value = (value * 31) ^ hash(self.o3) return value def __repr__(self): diff --git standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py index e7ae989887..b97b78ae0c 100644 --- standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py +++ standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py @@ -14653,7 +14653,7 @@ class WMTrigger: """ Attributes: - resourcePlanName - - poolName + - triggerName - triggerExpression - actionExpression """ @@ -14661,14 +14661,14 @@ class WMTrigger: thrift_spec = ( None, # 0 (1, TType.STRING, 'resourcePlanName', None, None, ), # 1 - (2, TType.STRING, 'poolName', None, None, ), # 2 + (2, TType.STRING, 'triggerName', None, None, ), # 2 (3, TType.STRING, 'triggerExpression', None, None, ), # 3 (4, TType.STRING, 'actionExpression', None, None, ), # 4 ) - def __init__(self, resourcePlanName=None, poolName=None, triggerExpression=None, actionExpression=None,): + def __init__(self, resourcePlanName=None, triggerName=None, triggerExpression=None, actionExpression=None,): self.resourcePlanName = resourcePlanName - self.poolName = poolName + self.triggerName = triggerName self.triggerExpression = triggerExpression self.actionExpression = actionExpression @@ -14688,7 +14688,7 @@ def read(self, iprot): iprot.skip(ftype) elif fid == 2: if ftype == TType.STRING: - self.poolName = iprot.readString() + self.triggerName = iprot.readString() else: iprot.skip(ftype) elif fid == 3: @@ -14715,9 +14715,9 @@ def write(self, oprot): oprot.writeFieldBegin('resourcePlanName', TType.STRING, 1) oprot.writeString(self.resourcePlanName) oprot.writeFieldEnd() - if self.poolName is not None: - oprot.writeFieldBegin('poolName', TType.STRING, 2) - oprot.writeString(self.poolName) + if self.triggerName is not None: + oprot.writeFieldBegin('triggerName', TType.STRING, 2) + oprot.writeString(self.triggerName) oprot.writeFieldEnd() if self.triggerExpression is not None: oprot.writeFieldBegin('triggerExpression', TType.STRING, 3) @@ -14733,15 +14733,15 @@ def write(self, oprot): def validate(self): if self.resourcePlanName is None: raise TProtocol.TProtocolException(message='Required field resourcePlanName is unset!') - if self.poolName is None: - raise TProtocol.TProtocolException(message='Required field poolName is unset!') + if self.triggerName is None: + raise TProtocol.TProtocolException(message='Required field triggerName is unset!') return def __hash__(self): value = 17 value = (value * 31) ^ hash(self.resourcePlanName) - value = (value * 31) ^ hash(self.poolName) + value = (value * 31) ^ hash(self.triggerName) value = (value * 31) ^ hash(self.triggerExpression) value = (value * 31) ^ hash(self.actionExpression) return value @@ -15609,6 +15609,493 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) +class WMCreateTriggerRequest: + """ + Attributes: + - trigger + """ + + thrift_spec = ( + None, # 0 + (1, TType.STRUCT, 'trigger', (WMTrigger, WMTrigger.thrift_spec), None, ), # 1 + ) + + def __init__(self, trigger=None,): + self.trigger = trigger + + 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.trigger = WMTrigger() + self.trigger.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('WMCreateTriggerRequest') + if self.trigger is not None: + oprot.writeFieldBegin('trigger', TType.STRUCT, 1) + self.trigger.write(oprot) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.trigger) + return value + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + +class WMCreateTriggerResponse: + + 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('WMCreateTriggerResponse') + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + return value + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + +class WMAlterTriggerRequest: + """ + Attributes: + - trigger + """ + + thrift_spec = ( + None, # 0 + (1, TType.STRUCT, 'trigger', (WMTrigger, WMTrigger.thrift_spec), None, ), # 1 + ) + + def __init__(self, trigger=None,): + self.trigger = trigger + + 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.trigger = WMTrigger() + self.trigger.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('WMAlterTriggerRequest') + if self.trigger is not None: + oprot.writeFieldBegin('trigger', TType.STRUCT, 1) + self.trigger.write(oprot) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.trigger) + return value + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + +class WMAlterTriggerResponse: + + 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('WMAlterTriggerResponse') + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + return value + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + +class WMDropTriggerRequest: + """ + Attributes: + - resourcePlanName + - triggerName + """ + + thrift_spec = ( + None, # 0 + (1, TType.STRING, 'resourcePlanName', None, None, ), # 1 + (2, TType.STRING, 'triggerName', None, None, ), # 2 + ) + + def __init__(self, resourcePlanName=None, triggerName=None,): + self.resourcePlanName = resourcePlanName + self.triggerName = triggerName + + 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.resourcePlanName = iprot.readString() + else: + iprot.skip(ftype) + elif fid == 2: + if ftype == TType.STRING: + self.triggerName = 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('WMDropTriggerRequest') + if self.resourcePlanName is not None: + oprot.writeFieldBegin('resourcePlanName', TType.STRING, 1) + oprot.writeString(self.resourcePlanName) + oprot.writeFieldEnd() + if self.triggerName is not None: + oprot.writeFieldBegin('triggerName', TType.STRING, 2) + oprot.writeString(self.triggerName) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.resourcePlanName) + value = (value * 31) ^ hash(self.triggerName) + return value + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + +class WMDropTriggerResponse: + + 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('WMDropTriggerResponse') + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + return value + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + +class WMGetTriggersForResourePlanRequest: + """ + Attributes: + - resourcePlanName + """ + + thrift_spec = ( + None, # 0 + (1, TType.STRING, 'resourcePlanName', None, None, ), # 1 + ) + + def __init__(self, resourcePlanName=None,): + self.resourcePlanName = resourcePlanName + + 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.resourcePlanName = 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('WMGetTriggersForResourePlanRequest') + if self.resourcePlanName is not None: + oprot.writeFieldBegin('resourcePlanName', TType.STRING, 1) + oprot.writeString(self.resourcePlanName) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.resourcePlanName) + return value + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + +class WMGetTriggersForResourePlanResponse: + """ + Attributes: + - triggers + """ + + thrift_spec = ( + None, # 0 + (1, TType.LIST, 'triggers', (TType.STRUCT,(WMTrigger, WMTrigger.thrift_spec)), None, ), # 1 + ) + + def __init__(self, triggers=None,): + self.triggers = triggers + + 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.LIST: + self.triggers = [] + (_etype660, _size657) = iprot.readListBegin() + for _i661 in xrange(_size657): + _elem662 = WMTrigger() + _elem662.read(iprot) + self.triggers.append(_elem662) + iprot.readListEnd() + 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('WMGetTriggersForResourePlanResponse') + if self.triggers is not None: + oprot.writeFieldBegin('triggers', TType.LIST, 1) + oprot.writeListBegin(TType.STRUCT, len(self.triggers)) + for iter663 in self.triggers: + iter663.write(oprot) + oprot.writeListEnd() + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.triggers) + return value + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + class MetaException(TException): """ Attributes: diff --git standalone-metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb standalone-metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb index c41f2093c9..31516d6f5d 100644 --- standalone-metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb +++ standalone-metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb @@ -3308,13 +3308,13 @@ end class WMTrigger include ::Thrift::Struct, ::Thrift::Struct_Union RESOURCEPLANNAME = 1 - POOLNAME = 2 + TRIGGERNAME = 2 TRIGGEREXPRESSION = 3 ACTIONEXPRESSION = 4 FIELDS = { RESOURCEPLANNAME => {:type => ::Thrift::Types::STRING, :name => 'resourcePlanName'}, - POOLNAME => {:type => ::Thrift::Types::STRING, :name => 'poolName'}, + TRIGGERNAME => {:type => ::Thrift::Types::STRING, :name => 'triggerName'}, TRIGGEREXPRESSION => {:type => ::Thrift::Types::STRING, :name => 'triggerExpression', :optional => true}, ACTIONEXPRESSION => {:type => ::Thrift::Types::STRING, :name => 'actionExpression', :optional => true} } @@ -3323,7 +3323,7 @@ class WMTrigger def validate raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Required field resourcePlanName is unset!') unless @resourcePlanName - raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Required field poolName is unset!') unless @poolName + raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Required field triggerName is unset!') unless @triggerName end ::Thrift::Struct.generate_accessors self @@ -3546,6 +3546,133 @@ class WMDropResourcePlanResponse ::Thrift::Struct.generate_accessors self end +class WMCreateTriggerRequest + include ::Thrift::Struct, ::Thrift::Struct_Union + TRIGGER = 1 + + FIELDS = { + TRIGGER => {:type => ::Thrift::Types::STRUCT, :name => 'trigger', :class => ::WMTrigger, :optional => true} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self +end + +class WMCreateTriggerResponse + include ::Thrift::Struct, ::Thrift::Struct_Union + + FIELDS = { + + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self +end + +class WMAlterTriggerRequest + include ::Thrift::Struct, ::Thrift::Struct_Union + TRIGGER = 1 + + FIELDS = { + TRIGGER => {:type => ::Thrift::Types::STRUCT, :name => 'trigger', :class => ::WMTrigger, :optional => true} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self +end + +class WMAlterTriggerResponse + include ::Thrift::Struct, ::Thrift::Struct_Union + + FIELDS = { + + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self +end + +class WMDropTriggerRequest + include ::Thrift::Struct, ::Thrift::Struct_Union + RESOURCEPLANNAME = 1 + TRIGGERNAME = 2 + + FIELDS = { + RESOURCEPLANNAME => {:type => ::Thrift::Types::STRING, :name => 'resourcePlanName', :optional => true}, + TRIGGERNAME => {:type => ::Thrift::Types::STRING, :name => 'triggerName', :optional => true} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self +end + +class WMDropTriggerResponse + include ::Thrift::Struct, ::Thrift::Struct_Union + + FIELDS = { + + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self +end + +class WMGetTriggersForResourePlanRequest + include ::Thrift::Struct, ::Thrift::Struct_Union + RESOURCEPLANNAME = 1 + + FIELDS = { + RESOURCEPLANNAME => {:type => ::Thrift::Types::STRING, :name => 'resourcePlanName', :optional => true} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self +end + +class WMGetTriggersForResourePlanResponse + include ::Thrift::Struct, ::Thrift::Struct_Union + TRIGGERS = 1 + + FIELDS = { + TRIGGERS => {:type => ::Thrift::Types::LIST, :name => 'triggers', :element => {:type => ::Thrift::Types::STRUCT, :class => ::WMTrigger}, :optional => true} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self +end + class MetaException < ::Thrift::Exception include ::Thrift::Struct, ::Thrift::Struct_Union def initialize(message=nil) diff --git standalone-metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb standalone-metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb index 92f71a5cf8..cf4c40c55f 100644 --- standalone-metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb +++ standalone-metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb @@ -2797,6 +2797,78 @@ module ThriftHiveMetastore raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'drop_resource_plan failed: unknown result') end + def create_wm_trigger(request) + send_create_wm_trigger(request) + return recv_create_wm_trigger() + end + + def send_create_wm_trigger(request) + send_message('create_wm_trigger', Create_wm_trigger_args, :request => request) + end + + def recv_create_wm_trigger() + result = receive_message(Create_wm_trigger_result) + return result.success unless result.success.nil? + raise result.o1 unless result.o1.nil? + raise result.o2 unless result.o2.nil? + raise result.o3 unless result.o3.nil? + raise result.o4 unless result.o4.nil? + raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'create_wm_trigger failed: unknown result') + end + + def alter_wm_trigger(request) + send_alter_wm_trigger(request) + return recv_alter_wm_trigger() + end + + def send_alter_wm_trigger(request) + send_message('alter_wm_trigger', Alter_wm_trigger_args, :request => request) + end + + def recv_alter_wm_trigger() + result = receive_message(Alter_wm_trigger_result) + return result.success unless result.success.nil? + raise result.o1 unless result.o1.nil? + raise result.o2 unless result.o2.nil? + raise result.o3 unless result.o3.nil? + raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'alter_wm_trigger failed: unknown result') + end + + def drop_wm_trigger(request) + send_drop_wm_trigger(request) + return recv_drop_wm_trigger() + end + + def send_drop_wm_trigger(request) + send_message('drop_wm_trigger', Drop_wm_trigger_args, :request => request) + end + + def recv_drop_wm_trigger() + result = receive_message(Drop_wm_trigger_result) + return result.success unless result.success.nil? + raise result.o1 unless result.o1.nil? + raise result.o2 unless result.o2.nil? + raise result.o3 unless result.o3.nil? + raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'drop_wm_trigger failed: unknown result') + end + + def get_triggers_for_resourceplan(request) + send_get_triggers_for_resourceplan(request) + return recv_get_triggers_for_resourceplan() + end + + def send_get_triggers_for_resourceplan(request) + send_message('get_triggers_for_resourceplan', Get_triggers_for_resourceplan_args, :request => request) + end + + def recv_get_triggers_for_resourceplan() + result = receive_message(Get_triggers_for_resourceplan_result) + return result.success unless result.success.nil? + raise result.o1 unless result.o1.nil? + raise result.o2 unless result.o2.nil? + raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'get_triggers_for_resourceplan failed: unknown result') + end + end class Processor < ::FacebookService::Processor @@ -4870,6 +4942,66 @@ module ThriftHiveMetastore write_result(result, oprot, 'drop_resource_plan', seqid) end + def process_create_wm_trigger(seqid, iprot, oprot) + args = read_args(iprot, Create_wm_trigger_args) + result = Create_wm_trigger_result.new() + begin + result.success = @handler.create_wm_trigger(args.request) + rescue ::AlreadyExistsException => o1 + result.o1 = o1 + rescue ::NoSuchObjectException => o2 + result.o2 = o2 + rescue ::InvalidObjectException => o3 + result.o3 = o3 + rescue ::MetaException => o4 + result.o4 = o4 + end + write_result(result, oprot, 'create_wm_trigger', seqid) + end + + def process_alter_wm_trigger(seqid, iprot, oprot) + args = read_args(iprot, Alter_wm_trigger_args) + result = Alter_wm_trigger_result.new() + begin + result.success = @handler.alter_wm_trigger(args.request) + rescue ::NoSuchObjectException => o1 + result.o1 = o1 + rescue ::InvalidObjectException => o2 + result.o2 = o2 + rescue ::MetaException => o3 + result.o3 = o3 + end + write_result(result, oprot, 'alter_wm_trigger', seqid) + end + + def process_drop_wm_trigger(seqid, iprot, oprot) + args = read_args(iprot, Drop_wm_trigger_args) + result = Drop_wm_trigger_result.new() + begin + result.success = @handler.drop_wm_trigger(args.request) + rescue ::NoSuchObjectException => o1 + result.o1 = o1 + rescue ::InvalidOperationException => o2 + result.o2 = o2 + rescue ::MetaException => o3 + result.o3 = o3 + end + write_result(result, oprot, 'drop_wm_trigger', seqid) + end + + def process_get_triggers_for_resourceplan(seqid, iprot, oprot) + args = read_args(iprot, Get_triggers_for_resourceplan_args) + result = Get_triggers_for_resourceplan_result.new() + begin + result.success = @handler.get_triggers_for_resourceplan(args.request) + rescue ::NoSuchObjectException => o1 + result.o1 = o1 + rescue ::MetaException => o2 + result.o2 = o2 + end + write_result(result, oprot, 'get_triggers_for_resourceplan', seqid) + end + end # HELPER FUNCTIONS AND STRUCTURES @@ -11145,5 +11277,157 @@ module ThriftHiveMetastore ::Thrift::Struct.generate_accessors self end + class Create_wm_trigger_args + include ::Thrift::Struct, ::Thrift::Struct_Union + REQUEST = 1 + + FIELDS = { + REQUEST => {:type => ::Thrift::Types::STRUCT, :name => 'request', :class => ::WMCreateTriggerRequest} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Create_wm_trigger_result + include ::Thrift::Struct, ::Thrift::Struct_Union + SUCCESS = 0 + O1 = 1 + O2 = 2 + O3 = 3 + O4 = 4 + + FIELDS = { + SUCCESS => {:type => ::Thrift::Types::STRUCT, :name => 'success', :class => ::WMCreateTriggerResponse}, + O1 => {:type => ::Thrift::Types::STRUCT, :name => 'o1', :class => ::AlreadyExistsException}, + O2 => {:type => ::Thrift::Types::STRUCT, :name => 'o2', :class => ::NoSuchObjectException}, + O3 => {:type => ::Thrift::Types::STRUCT, :name => 'o3', :class => ::InvalidObjectException}, + O4 => {:type => ::Thrift::Types::STRUCT, :name => 'o4', :class => ::MetaException} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Alter_wm_trigger_args + include ::Thrift::Struct, ::Thrift::Struct_Union + REQUEST = 1 + + FIELDS = { + REQUEST => {:type => ::Thrift::Types::STRUCT, :name => 'request', :class => ::WMAlterTriggerRequest} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Alter_wm_trigger_result + include ::Thrift::Struct, ::Thrift::Struct_Union + SUCCESS = 0 + O1 = 1 + O2 = 2 + O3 = 3 + + FIELDS = { + SUCCESS => {:type => ::Thrift::Types::STRUCT, :name => 'success', :class => ::WMAlterTriggerResponse}, + O1 => {:type => ::Thrift::Types::STRUCT, :name => 'o1', :class => ::NoSuchObjectException}, + O2 => {:type => ::Thrift::Types::STRUCT, :name => 'o2', :class => ::InvalidObjectException}, + O3 => {:type => ::Thrift::Types::STRUCT, :name => 'o3', :class => ::MetaException} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Drop_wm_trigger_args + include ::Thrift::Struct, ::Thrift::Struct_Union + REQUEST = 1 + + FIELDS = { + REQUEST => {:type => ::Thrift::Types::STRUCT, :name => 'request', :class => ::WMDropTriggerRequest} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Drop_wm_trigger_result + include ::Thrift::Struct, ::Thrift::Struct_Union + SUCCESS = 0 + O1 = 1 + O2 = 2 + O3 = 3 + + FIELDS = { + SUCCESS => {:type => ::Thrift::Types::STRUCT, :name => 'success', :class => ::WMDropTriggerResponse}, + O1 => {:type => ::Thrift::Types::STRUCT, :name => 'o1', :class => ::NoSuchObjectException}, + O2 => {:type => ::Thrift::Types::STRUCT, :name => 'o2', :class => ::InvalidOperationException}, + O3 => {:type => ::Thrift::Types::STRUCT, :name => 'o3', :class => ::MetaException} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Get_triggers_for_resourceplan_args + include ::Thrift::Struct, ::Thrift::Struct_Union + REQUEST = 1 + + FIELDS = { + REQUEST => {:type => ::Thrift::Types::STRUCT, :name => 'request', :class => ::WMGetTriggersForResourePlanRequest} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Get_triggers_for_resourceplan_result + include ::Thrift::Struct, ::Thrift::Struct_Union + SUCCESS = 0 + O1 = 1 + O2 = 2 + + FIELDS = { + SUCCESS => {:type => ::Thrift::Types::STRUCT, :name => 'success', :class => ::WMGetTriggersForResourePlanResponse}, + O1 => {:type => ::Thrift::Types::STRUCT, :name => 'o1', :class => ::NoSuchObjectException}, + O2 => {:type => ::Thrift::Types::STRUCT, :name => 'o2', :class => ::MetaException} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + end diff --git standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/ObjectStore.java standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/ObjectStore.java index 3deef0ee96..8767a1489e 100644 --- standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/ObjectStore.java +++ standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/ObjectStore.java @@ -78,6 +78,7 @@ import org.apache.hadoop.hive.common.StatsSetupConst; import org.apache.hadoop.hive.metastore.MetaStoreDirectSql.SqlFilterForPushdown; import org.apache.hadoop.hive.metastore.api.AggrStats; +import org.apache.hadoop.hive.metastore.api.AlreadyExistsException; import org.apache.hadoop.hive.metastore.api.ColumnStatistics; import org.apache.hadoop.hive.metastore.api.ColumnStatisticsDesc; import org.apache.hadoop.hive.metastore.api.ColumnStatisticsObj; @@ -113,6 +114,7 @@ import org.apache.hadoop.hive.metastore.api.PrivilegeGrantInfo; import org.apache.hadoop.hive.metastore.api.WMResourcePlan; import org.apache.hadoop.hive.metastore.api.WMResourcePlanStatus; +import org.apache.hadoop.hive.metastore.api.WMTrigger; import org.apache.hadoop.hive.metastore.api.ResourceType; import org.apache.hadoop.hive.metastore.api.ResourceUri; import org.apache.hadoop.hive.metastore.api.Role; @@ -155,6 +157,7 @@ import org.apache.hadoop.hive.metastore.model.MPartitionEvent; import org.apache.hadoop.hive.metastore.model.MPartitionPrivilege; import org.apache.hadoop.hive.metastore.model.MWMResourcePlan; +import org.apache.hadoop.hive.metastore.model.MWMTrigger; import org.apache.hadoop.hive.metastore.model.MWMResourcePlan.Status; import org.apache.hadoop.hive.metastore.model.MResourceUri; import org.apache.hadoop.hive.metastore.model.MRole; @@ -192,14 +195,8 @@ import org.slf4j.LoggerFactory; import com.google.common.annotations.VisibleForTesting; -import com.google.common.base.Supplier; -import com.google.common.base.Suppliers; -import com.google.common.collect.ArrayListMultimap; import com.google.common.collect.Lists; import com.google.common.collect.Maps; -import com.google.common.collect.Multimap; -import com.google.common.collect.SortedSetMultimap; -import com.google.common.collect.TreeMultimap; /** @@ -9467,17 +9464,33 @@ Properties getProp() { return prop; } + private void checkForConstraintException(Exception e, String msg) throws AlreadyExistsException { + Throwable ex = e; + while (ex != null) { + if (ex instanceof SQLIntegrityConstraintViolationException) { + LOG.error(msg, e); + throw new AlreadyExistsException(msg); + } + ex = ex.getCause(); + } + } + @Override - public void createResourcePlan(WMResourcePlan resourcePlan) throws MetaException { + public void createResourcePlan(WMResourcePlan resourcePlan) + throws AlreadyExistsException, MetaException { boolean commited = false; String rpName = normalizeIdentifier(resourcePlan.getName()); Integer queryParallelism = resourcePlan.isSetQueryParallelism() ? resourcePlan.getQueryParallelism() : null; - MWMResourcePlan rp = new MWMResourcePlan(rpName, queryParallelism, MWMResourcePlan.Status.DISABLED); + MWMResourcePlan rp = new MWMResourcePlan(rpName, queryParallelism, + MWMResourcePlan.Status.DISABLED); try { openTransaction(); pm.makePersistent(rp); commited = commitTransaction(); + } catch (Exception e) { + checkForConstraintException(e, "Resource plan already exists: "); + throw e; } finally { if (!commited) { rollbackTransaction(); @@ -9500,24 +9513,28 @@ private WMResourcePlan fromMResourcePlan(MWMResourcePlan mplan) { @Override public WMResourcePlan getResourcePlan(String name) throws NoSuchObjectException { - WMResourcePlan resourcePlan = null; + return fromMResourcePlan(getMWMResourcePlan(name)); + } + + public MWMResourcePlan getMWMResourcePlan(String name) throws NoSuchObjectException { + MWMResourcePlan resourcePlan; boolean commited = false; Query query = null; + + name = normalizeIdentifier(name); try { openTransaction(); - name = normalizeIdentifier(name); query = pm.newQuery(MWMResourcePlan.class, "name == rpname"); query.declareParameters("java.lang.String rpname"); query.setUnique(true); - MWMResourcePlan mResourcePlan = (MWMResourcePlan) query.execute(name); - pm.retrieve(mResourcePlan); - resourcePlan = fromMResourcePlan(mResourcePlan); + resourcePlan = (MWMResourcePlan) query.execute(name); + pm.retrieve(resourcePlan); commited = commitTransaction(); } finally { rollbackAndCleanup(commited, query); } if (resourcePlan == null) { - throw new NoSuchObjectException("There is no resource plan named " + name); + throw new NoSuchObjectException("There is no resource plan named: " + name); } return resourcePlan; } @@ -9546,7 +9563,8 @@ public WMResourcePlan getResourcePlan(String name) throws NoSuchObjectException @Override public void alterResourcePlan(String name, WMResourcePlan resourcePlan) - throws NoSuchObjectException, InvalidOperationException, MetaException { + throws AlreadyExistsException, NoSuchObjectException, InvalidOperationException, + MetaException { name = normalizeIdentifier(name); boolean commited = false; Query query = null; @@ -9568,18 +9586,10 @@ public void alterResourcePlan(String name, WMResourcePlan resourcePlan) if (resourcePlan.isSetStatus()) { switchStatus(name, mResourcePlan, resourcePlan.getStatus().name()); } - try { - commited = commitTransaction(); - } catch (Exception e) { - Throwable ex = e; - while (ex != null) { - if (ex instanceof SQLIntegrityConstraintViolationException) { - throw new InvalidOperationException("Resource plan should be unique"); - } - ex = ex.getCause(); - } - throw e; - } + commited = commitTransaction(); + } catch (Exception e) { + checkForConstraintException(e, "Resource plan name should be unique: "); + throw e; } finally { rollbackAndCleanup(commited, query); } @@ -9686,4 +9696,117 @@ public void dropResourcePlan(String name) throws NoSuchObjectException, MetaExce rollbackAndCleanup(commited, query); } } + + @Override + public void createWMTrigger(WMTrigger trigger) + throws AlreadyExistsException, NoSuchObjectException, InvalidOperationException, + MetaException { + boolean commited = false; + try { + openTransaction(); + MWMResourcePlan resourcePlan = getMWMResourcePlan( + normalizeIdentifier(trigger.getResourcePlanName())); + if (resourcePlan.getStatus() != MWMResourcePlan.Status.DISABLED) { + throw new InvalidOperationException("Resource plan must be disabled to edit it."); + } + MWMTrigger mTrigger = new MWMTrigger(resourcePlan, + normalizeIdentifier(trigger.getTriggerName()), trigger.getTriggerExpression(), + trigger.getActionExpression(), null); + pm.makePersistent(mTrigger); + commited = commitTransaction(); + } catch (Exception e) { + checkForConstraintException(e, "Trigger already exists, use alter: "); + throw e; + } finally { + rollbackAndCleanup(commited, (Query)null); + } + } + + @Override + public void alterWMTrigger(WMTrigger trigger) + throws NoSuchObjectException, InvalidOperationException, MetaException { + boolean commited = false; + Query query = null; + try { + openTransaction(); + MWMResourcePlan resourcePlan = getMWMResourcePlan( + normalizeIdentifier(trigger.getResourcePlanName())); + if (resourcePlan.getStatus() != MWMResourcePlan.Status.DISABLED) { + throw new InvalidOperationException("Resource plan must be disabled to edit it."); + } + + // Get the MWMTrigger object from DN + query = pm.newQuery(MWMTrigger.class, "resourcePlan == rp && name == triggerName"); + query.declareParameters("MWMResourcePlan rp, java.lang.String triggerName"); + query.setUnique(true); + MWMTrigger mTrigger = (MWMTrigger) query.execute(resourcePlan, trigger.getTriggerName()); + pm.retrieve(mTrigger); + + // Update the object. + mTrigger.setTriggerExpression(trigger.getTriggerExpression()); + mTrigger.setActionExpression(mTrigger.getActionExpression()); + commited = commitTransaction(); + } finally { + rollbackAndCleanup(commited, query); + } + } + + @Override + public void dropWMTrigger(String resourcePlanName, String triggerName) + throws NoSuchObjectException, InvalidOperationException, MetaException { + resourcePlanName = normalizeIdentifier(resourcePlanName); + triggerName = normalizeIdentifier(triggerName); + + boolean commited = false; + Query query = null; + try { + openTransaction(); + MWMResourcePlan resourcePlan = getMWMResourcePlan(resourcePlanName); + if (resourcePlan.getStatus() != MWMResourcePlan.Status.DISABLED) { + throw new InvalidOperationException("Resource plan must be disabled to edit it."); + } + query = pm.newQuery(MWMTrigger.class, "resourcePlan == rp && name == triggerName"); + query.declareParameters("MWMResourcePlan rp, java.lang.String triggerName"); + if (query.deletePersistentAll(resourcePlan, triggerName) == 0) { + throw new NoSuchObjectException("Cannot delete trigger: " + triggerName); + } + commited = commitTransaction(); + } finally { + rollbackAndCleanup(commited, query); + } + } + + @Override + public List getTriggersForResourcePlan(String resourcePlanName) + throws NoSuchObjectException, MetaException { + List triggers = new ArrayList(); + boolean commited = false; + Query query = null; + try { + openTransaction(); + MWMResourcePlan resourcePlan = getMWMResourcePlan(resourcePlanName); + query = pm.newQuery(MWMTrigger.class, "resourcePlan == rp"); + query.declareParameters("MWMResourcePlan rp"); + List mTriggers = (List) query.execute(resourcePlan); + pm.retrieveAll(mTriggers); + commited = commitTransaction(); + if (mTriggers != null) { + for (MWMTrigger trigger : mTriggers) { + triggers.add(fromMWMTrigger(trigger, resourcePlanName)); + } + } + } finally { + rollbackAndCleanup(commited, query); + } + return triggers; + } + + private WMTrigger fromMWMTrigger(MWMTrigger mTrigger, String resourcePlanName) { + WMTrigger trigger = new WMTrigger(); + trigger.setResourcePlanName(resourcePlanName); + trigger.setTriggerName(mTrigger.getName()); + trigger.setTriggerExpression(mTrigger.getTriggerExpression()); + trigger.setActionExpression(mTrigger.getActionExpression()); + return trigger; + } } diff --git standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/RawStore.java standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/RawStore.java index c96d5d5514..a99b8e123e 100644 --- standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/RawStore.java +++ standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/RawStore.java @@ -29,6 +29,7 @@ import org.apache.hadoop.classification.InterfaceStability; import org.apache.hadoop.conf.Configurable; import org.apache.hadoop.hive.metastore.api.AggrStats; +import org.apache.hadoop.hive.metastore.api.AlreadyExistsException; import org.apache.hadoop.hive.metastore.api.ColumnStatistics; import org.apache.hadoop.hive.metastore.api.ColumnStatisticsObj; import org.apache.hadoop.hive.metastore.api.CurrentNotificationEventId; @@ -56,6 +57,7 @@ import org.apache.hadoop.hive.metastore.api.PrincipalType; import org.apache.hadoop.hive.metastore.api.PrivilegeBag; import org.apache.hadoop.hive.metastore.api.WMResourcePlan; +import org.apache.hadoop.hive.metastore.api.WMTrigger; import org.apache.hadoop.hive.metastore.api.Role; import org.apache.hadoop.hive.metastore.api.RolePrincipalGrant; import org.apache.hadoop.hive.metastore.api.SQLForeignKey; @@ -747,17 +749,32 @@ void getFileMetadataByExpr(List fileIds, FileMetadataExprType type, byte[] */ String getMetastoreDbUuid() throws MetaException; - void createResourcePlan(WMResourcePlan resourcePlan) throws MetaException; + void createResourcePlan(WMResourcePlan resourcePlan) + throws AlreadyExistsException, MetaException; WMResourcePlan getResourcePlan(String name) throws NoSuchObjectException, MetaException; List getAllResourcePlans() throws MetaException; void alterResourcePlan(String name, WMResourcePlan resourcePlan) - throws NoSuchObjectException, InvalidOperationException, MetaException; + throws AlreadyExistsException, NoSuchObjectException, InvalidOperationException, + MetaException; boolean validateResourcePlan(String name) throws NoSuchObjectException, InvalidObjectException, MetaException; void dropResourcePlan(String name) throws NoSuchObjectException, MetaException; + + void createWMTrigger(WMTrigger trigger) + throws AlreadyExistsException, NoSuchObjectException, InvalidOperationException, + MetaException; + + void alterWMTrigger(WMTrigger trigger) + throws NoSuchObjectException, InvalidOperationException, MetaException; + + void dropWMTrigger(String resourcePlanName, String triggerName) + throws NoSuchObjectException, InvalidOperationException, MetaException; + + List getTriggersForResourcePlan(String resourcePlanName) + throws NoSuchObjectException, MetaException; } diff --git standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/cache/CachedStore.java standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/cache/CachedStore.java index 96b18d6e34..e13dcd20a3 100644 --- standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/cache/CachedStore.java +++ standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/cache/CachedStore.java @@ -19,14 +19,9 @@ import java.nio.ByteBuffer; import java.util.ArrayList; -import java.util.ArrayList; -import java.util.HashMap; import java.util.HashMap; import java.util.LinkedList; -import java.util.LinkedList; import java.util.List; -import java.util.List; -import java.util.Map; import java.util.Map; import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; @@ -47,6 +42,7 @@ import org.apache.hadoop.hive.metastore.TableType; import org.apache.hadoop.hive.metastore.Warehouse; import org.apache.hadoop.hive.metastore.api.AggrStats; +import org.apache.hadoop.hive.metastore.api.AlreadyExistsException; import org.apache.hadoop.hive.metastore.api.ColumnStatistics; import org.apache.hadoop.hive.metastore.api.ColumnStatisticsDesc; import org.apache.hadoop.hive.metastore.api.ColumnStatisticsObj; @@ -75,6 +71,7 @@ import org.apache.hadoop.hive.metastore.api.PrincipalType; import org.apache.hadoop.hive.metastore.api.PrivilegeBag; import org.apache.hadoop.hive.metastore.api.WMResourcePlan; +import org.apache.hadoop.hive.metastore.api.WMTrigger; import org.apache.hadoop.hive.metastore.api.Role; import org.apache.hadoop.hive.metastore.api.RolePrincipalGrant; import org.apache.hadoop.hive.metastore.api.SQLForeignKey; @@ -2243,7 +2240,8 @@ void setInitializedForTest() { } @Override - public void createResourcePlan(WMResourcePlan resourcePlan) throws MetaException { + public void createResourcePlan(WMResourcePlan resourcePlan) + throws AlreadyExistsException, MetaException { rawStore.createResourcePlan(resourcePlan); } @@ -2259,7 +2257,8 @@ public WMResourcePlan getResourcePlan(String name) throws NoSuchObjectException, @Override public void alterResourcePlan(String name, WMResourcePlan resourcePlan) - throws NoSuchObjectException, InvalidOperationException, MetaException { + throws AlreadyExistsException, NoSuchObjectException, InvalidOperationException, + MetaException { rawStore.alterResourcePlan(name, resourcePlan); } @@ -2273,4 +2272,29 @@ public boolean validateResourcePlan(String name) public void dropResourcePlan(String name) throws NoSuchObjectException, MetaException { rawStore.dropResourcePlan(name); } + + @Override + public void createWMTrigger(WMTrigger trigger) + throws AlreadyExistsException, MetaException, NoSuchObjectException, + InvalidOperationException { + rawStore.createWMTrigger(trigger); + } + + @Override + public void alterWMTrigger(WMTrigger trigger) + throws NoSuchObjectException, InvalidOperationException, MetaException { + rawStore.alterWMTrigger(trigger); + } + + @Override + public void dropWMTrigger(String resourcePlanName, String triggerName) + throws NoSuchObjectException, InvalidOperationException, MetaException { + rawStore.dropWMTrigger(resourcePlanName, triggerName); + } + + @Override + public List getTriggersForResourcePlan(String resourcePlanName) + throws NoSuchObjectException, MetaException { + return rawStore.getTriggersForResourcePlan(resourcePlanName); + } } diff --git standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/model/MWMResourcePlan.java standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/model/MWMResourcePlan.java index 3ff924fe00..27a1bd8f25 100644 --- standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/model/MWMResourcePlan.java +++ standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/model/MWMResourcePlan.java @@ -18,7 +18,7 @@ package org.apache.hadoop.hive.metastore.model; -import java.util.List; +import java.util.Set; /** * Storage class for ResourcePlan. @@ -27,9 +27,9 @@ private String name; private Integer queryParallelism; private Status status; - private List pools; - private List triggers; - private List mappings; + private Set pools; + private Set triggers; + private Set mappings; public enum Status { ACTIVE, @@ -69,27 +69,27 @@ public void setStatus(Status status) { this.status = status; } - public List getPools() { + public Set getPools() { return pools; } - public void setPools(List pools) { + public void setPools(Set pools) { this.pools = pools; } - public List getTriggers() { + public Set getTriggers() { return triggers; } - public void setTriggers(List triggers) { + public void setTriggers(Set triggers) { this.triggers = triggers; } - public List getMappings() { + public Set getMappings() { return mappings; } - public void setMappings(List mappings) { + public void setMappings(Set mappings) { this.mappings = mappings; } } diff --git standalone-metastore/src/main/thrift/hive_metastore.thrift standalone-metastore/src/main/thrift/hive_metastore.thrift index 1d455463a6..60531457b7 100644 --- standalone-metastore/src/main/thrift/hive_metastore.thrift +++ standalone-metastore/src/main/thrift/hive_metastore.thrift @@ -1056,7 +1056,7 @@ struct WMPool { struct WMTrigger { 1: required string resourcePlanName; - 2: required string poolName; + 2: required string triggerName; 3: optional string triggerExpression; 4: optional string actionExpression; } @@ -1116,6 +1116,37 @@ struct WMDropResourcePlanRequest { struct WMDropResourcePlanResponse { } +struct WMCreateTriggerRequest { + 1: optional WMTrigger trigger; +} + +struct WMCreateTriggerResponse { +} + +struct WMAlterTriggerRequest { + 1: optional WMTrigger trigger; +} + +struct WMAlterTriggerResponse { +} + +struct WMDropTriggerRequest { + 1: optional string resourcePlanName; + 2: optional string triggerName; +} + +struct WMDropTriggerResponse { +} + +struct WMGetTriggersForResourePlanRequest { + 1: optional string resourcePlanName; +} + +struct WMGetTriggersForResourePlanResponse { + 1: optional list triggers; +} + + // Exceptions. exception MetaException { @@ -1699,6 +1730,18 @@ service ThriftHiveMetastore extends fb303.FacebookService WMDropResourcePlanResponse drop_resource_plan(1:WMDropResourcePlanRequest request) throws(1:NoSuchObjectException o1, 2:InvalidOperationException o2, 3:MetaException o3) + + WMCreateTriggerResponse create_wm_trigger(1:WMCreateTriggerRequest request) + throws(1:AlreadyExistsException o1, 2:NoSuchObjectException o2, 3:InvalidObjectException o3, 4:MetaException o4) + + WMAlterTriggerResponse alter_wm_trigger(1:WMAlterTriggerRequest request) + throws(1:NoSuchObjectException o1, 2:InvalidObjectException o2, 3:MetaException o3) + + WMDropTriggerResponse drop_wm_trigger(1:WMDropTriggerRequest request) + throws(1:NoSuchObjectException o1, 2:InvalidOperationException o2, 3:MetaException o3) + + WMGetTriggersForResourePlanResponse get_triggers_for_resourceplan(1:WMGetTriggersForResourePlanRequest request) + throws(1:NoSuchObjectException o1, 2:MetaException o2) } // * Note about the DDL_TIME: When creating or altering a table or a partition,