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 5a627ce6bc..5a95fcb830 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 @@ -72,6 +72,8 @@ import org.apache.hadoop.hive.metastore.api.UnknownDBException; import org.apache.hadoop.hive.metastore.api.UnknownPartitionException; import org.apache.hadoop.hive.metastore.api.UnknownTableException; +import org.apache.hadoop.hive.metastore.api.WMMapping; +import org.apache.hadoop.hive.metastore.api.WMPool; import org.apache.hadoop.hive.metastore.partition.spec.PartitionSpecProxy; import org.apache.thrift.TException; @@ -1036,4 +1038,43 @@ public void dropWMTrigger(String resourcePlanName, String triggerName) throws NoSuchObjectException, MetaException { return objectStore.getTriggersForResourcePlan(resourcePlanName); } + + @Override + public void createOrUpdatePool(WMPool pool, String newPoolPath, boolean update) + throws AlreadyExistsException, NoSuchObjectException, InvalidOperationException, + MetaException { + objectStore.createOrUpdatePool(pool, newPoolPath, update); + } + + @Override + public void dropWMPool(String resourcePlanName, String poolPath) + throws NoSuchObjectException, InvalidOperationException, MetaException { + objectStore.dropWMPool(resourcePlanName, poolPath); + } + + @Override + public void createOrUpdateWMMapping(WMMapping mapping, boolean update) + throws AlreadyExistsException, NoSuchObjectException, InvalidOperationException, + MetaException { + objectStore.createOrUpdateWMMapping(mapping, update); + } + + @Override + public void dropWMMapping(WMMapping mapping) + throws NoSuchObjectException, InvalidOperationException, MetaException { + objectStore.dropWMMapping(mapping); + } + + @Override + public void createWMTriggerToPoolMapping(String resourcePlanName, String triggerName, + String poolPath) throws AlreadyExistsException, NoSuchObjectException, + InvalidOperationException, MetaException { + objectStore.createWMTriggerToPoolMapping(resourcePlanName, triggerName, poolPath); + } + + @Override + public void dropWMTriggerToPoolMapping(String resourcePlanName, String triggerName, + String poolPath) throws NoSuchObjectException, InvalidOperationException, MetaException { + objectStore.dropWMTriggerToPoolMapping(resourcePlanName, triggerName, poolPath); + } } diff --git metastore/scripts/upgrade/derby/046-HIVE-17566.derby.sql metastore/scripts/upgrade/derby/046-HIVE-17566.derby.sql index 16190dc0a1..5f10d32f9d 100644 --- metastore/scripts/upgrade/derby/046-HIVE-17566.derby.sql +++ metastore/scripts/upgrade/derby/046-HIVE-17566.derby.sql @@ -2,11 +2,10 @@ CREATE TABLE "APP"."WM_RESOURCEPLAN" (RP_ID BIGINT NOT NULL, NAME VARCHAR(128) N CREATE UNIQUE INDEX "APP"."UNIQUE_WM_RESOURCEPLAN" ON "APP"."WM_RESOURCEPLAN" ("NAME"); ALTER TABLE "APP"."WM_RESOURCEPLAN" ADD CONSTRAINT "WM_RESOURCEPLAN_PK" PRIMARY KEY ("RP_ID"); -CREATE TABLE "APP"."WM_POOL" (POOL_ID BIGINT NOT NULL, RP_ID BIGINT NOT NULL, PATH VARCHAR(1024) NOT NULL, PARENT_POOL_ID BIGINT, ALLOC_FRACTION DOUBLE, QUERY_PARALLELISM INTEGER); +CREATE TABLE "APP"."WM_POOL" (POOL_ID BIGINT NOT NULL, RP_ID BIGINT NOT NULL, PATH VARCHAR(1024) NOT NULL, ALLOC_FRACTION DOUBLE, QUERY_PARALLELISM INTEGER, SCHEDULING_POLICY VARCHAR(128)); CREATE UNIQUE INDEX "APP"."UNIQUE_WM_POOL" ON "APP"."WM_POOL" ("RP_ID", "PATH"); ALTER TABLE "APP"."WM_POOL" ADD CONSTRAINT "WM_POOL_PK" PRIMARY KEY ("POOL_ID"); ALTER TABLE "APP"."WM_POOL" ADD CONSTRAINT "WM_POOL_FK1" FOREIGN KEY ("RP_ID") REFERENCES "APP"."WM_RESOURCEPLAN" ("RP_ID") ON DELETE NO ACTION ON UPDATE NO ACTION; -ALTER TABLE "APP"."WM_POOL" ADD CONSTRAINT "WM_POOL_FK2" FOREIGN KEY ("PARENT_POOL_ID") REFERENCES "APP"."WM_POOL" ("POOL_ID") ON DELETE NO ACTION ON UPDATE NO ACTION; CREATE TABLE "APP"."WM_TRIGGER" (TRIGGER_ID BIGINT NOT NULL, RP_ID BIGINT NOT NULL, NAME VARCHAR(128) NOT NULL, TRIGGER_EXPRESSION VARCHAR(1024), ACTION_EXPRESSION VARCHAR(1024)); CREATE UNIQUE INDEX "APP"."UNIQUE_WM_TRIGGER" ON "APP"."WM_TRIGGER" ("RP_ID", "NAME"); diff --git metastore/scripts/upgrade/derby/hive-schema-3.0.0.derby.sql metastore/scripts/upgrade/derby/hive-schema-3.0.0.derby.sql index 4c35380af4..94a6d52736 100644 --- metastore/scripts/upgrade/derby/hive-schema-3.0.0.derby.sql +++ metastore/scripts/upgrade/derby/hive-schema-3.0.0.derby.sql @@ -112,7 +112,7 @@ CREATE TABLE "APP"."METASTORE_DB_PROPERTIES" ("PROPERTY_KEY" VARCHAR(255) NOT NU CREATE TABLE "APP"."WM_RESOURCEPLAN" (RP_ID INTEGER NOT NULL, NAME VARCHAR(128) NOT NULL, QUERY_PARALLELISM INTEGER, STATUS VARCHAR(20) NOT NULL); -CREATE TABLE "APP"."WM_POOL" (POOL_ID INTEGER NOT NULL, RP_ID INTEGER NOT NULL, PATH VARCHAR(1024) NOT NULL, PARENT_POOL_ID INTEGER, ALLOC_FRACTION DOUBLE, QUERY_PARALLELISM INTEGER); +CREATE TABLE "APP"."WM_POOL" (POOL_ID INTEGER NOT NULL, RP_ID INTEGER NOT NULL, PATH VARCHAR(1024) NOT NULL, ALLOC_FRACTION DOUBLE, QUERY_PARALLELISM INTEGER, SCHEDULING_POLICY VARCHAR(128)); CREATE TABLE "APP"."WM_TRIGGER" (TRIGGER_ID INTEGER NOT NULL, RP_ID INTEGER NOT NULL, NAME VARCHAR(128) NOT NULL, TRIGGER_EXPRESSION VARCHAR(1024), ACTION_EXPRESSION VARCHAR(1024)); @@ -356,8 +356,6 @@ ALTER TABLE "APP"."WM_POOL" ADD CONSTRAINT "WM_POOL_PK" PRIMARY KEY ("POOL_ID"); ALTER TABLE "APP"."WM_POOL" ADD CONSTRAINT "WM_POOL_FK1" FOREIGN KEY ("RP_ID") REFERENCES "APP"."WM_RESOURCEPLAN" ("RP_ID") ON DELETE NO ACTION ON UPDATE NO ACTION; -ALTER TABLE "APP"."WM_POOL" ADD CONSTRAINT "WM_POOL_FK2" FOREIGN KEY ("PARENT_POOL_ID") REFERENCES "APP"."WM_POOL" ("POOL_ID") ON DELETE NO ACTION ON UPDATE NO ACTION; - ALTER TABLE "APP"."WM_TRIGGER" ADD CONSTRAINT "WM_TRIGGER_PK" PRIMARY KEY ("TRIGGER_ID"); ALTER TABLE "APP"."WM_TRIGGER" ADD CONSTRAINT "WM_TRIGGER_FK1" FOREIGN KEY ("RP_ID") REFERENCES "APP"."WM_RESOURCEPLAN" ("RP_ID") ON DELETE NO ACTION ON UPDATE NO ACTION; 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 c1578fcda9..df1915de56 100644 --- metastore/scripts/upgrade/hive/hive-schema-3.0.0.hive.sql +++ metastore/scripts/upgrade/hive/hive-schema-3.0.0.hive.sql @@ -987,6 +987,31 @@ ON t.RP_ID = r.RP_ID" ); +CREATE TABLE IF NOT EXISTS `WM_POOLS` ( + `RP_NAME` string, + `PATH` string, + `ALLOC_FRACTION` double, + `QUERY_PARALLELISM` int, + `SCHEDULING_POLICY` string +) +STORED BY 'org.apache.hive.storage.jdbc.JdbcStorageHandler' +TBLPROPERTIES ( +"hive.sql.database.type" = "METASTORE", +"hive.sql.query" = +"SELECT + WM_RESOURCEPLAN.NAME, + WM_POOL.PATH, + WM_POOL.ALLOC_FRACTION, + WM_POOL.QUERY_PARALLELISM, + WM_POOL.SCHEDULING_POLICY +FROM + WM_POOL +JOIN + WM_RESOURCEPLAN +ON + WM_POOL.RP_ID = WM_RESOURCEPLAN.RP_ID" +); + DROP DATABASE IF EXISTS INFORMATION_SCHEMA; CREATE DATABASE INFORMATION_SCHEMA; diff --git metastore/scripts/upgrade/mssql/031-HIVE-17566.mssql.sql metastore/scripts/upgrade/mssql/031-HIVE-17566.mssql.sql index 0ee0f758f1..3b8f5fd771 100644 --- metastore/scripts/upgrade/mssql/031-HIVE-17566.mssql.sql +++ metastore/scripts/upgrade/mssql/031-HIVE-17566.mssql.sql @@ -16,16 +16,15 @@ CREATE TABLE WM_POOL POOL_ID bigint NOT NULL, RP_ID bigint NOT NULL, PATH nvarchar(1024) NOT NULL, - PARENT_POOL_ID bigint, ALLOC_FRACTION DOUBLE, - QUERY_PARALLELISM int + QUERY_PARALLELISM int, + SCHEDULING_POLICY nvarchar(128) ); ALTER TABLE WM_POOL ADD CONSTRAINT WM_POOL_PK PRIMARY KEY (POOL_ID); CREATE UNIQUE INDEX UNIQUE_WM_POOL ON WM_POOL (RP_ID, "NAME"); ALTER TABLE WM_POOL ADD CONSTRAINT WM_POOL_FK1 FOREIGN KEY (RP_ID) REFERENCES WM_RESOURCEPLAN (RP_ID); -ALTER TABLE WM_POOL ADD CONSTRAINT WM_POOL_FK2 FOREIGN KEY (PARENT_POOL_ID) REFERENCES WM_POOL (POOL_ID); CREATE TABLE WM_TRIGGER diff --git metastore/scripts/upgrade/mssql/hive-schema-3.0.0.mssql.sql metastore/scripts/upgrade/mssql/hive-schema-3.0.0.mssql.sql index 86f3e5c4a9..bdde44ded4 100644 --- metastore/scripts/upgrade/mssql/hive-schema-3.0.0.mssql.sql +++ metastore/scripts/upgrade/mssql/hive-schema-3.0.0.mssql.sql @@ -612,9 +612,9 @@ CREATE TABLE WM_POOL POOL_ID bigint NOT NULL, RP_ID bigint NOT NULL, PATH nvarchar(1024) NOT NULL, - PARENT_POOL_ID bigint, ALLOC_FRACTION DOUBLE, - QUERY_PARALLELISM int + QUERY_PARALLELISM int, + SCHEDULING_POLICY nvarchar(128) ); ALTER TABLE WM_POOL ADD CONSTRAINT WM_POOL_PK PRIMARY KEY (POOL_ID); @@ -931,8 +931,6 @@ CREATE UNIQUE INDEX UNIQUE_WM_MAPPING ON WM_MAPPING (RP_ID, ENTITY_TYPE, ENTITY_ ALTER TABLE WM_MAPPING ADD CONSTRAINT WM_MAPPING_FK1 FOREIGN KEY (RP_ID) REFERENCES WM_RESOURCEPLAN (RP_ID); -ALTER TABLE WM_MAPPING ADD CONSTRAINT WM_MAPPING_FK2 FOREIGN KEY (POOL_ID) REFERENCES WM_POOL (POOL_ID); - -- ----------------------------------------------------------------------------------------------------------------------------------------------- -- Transaction and Lock Tables diff --git metastore/scripts/upgrade/mysql/046-HIVE-17566.mysql.sql metastore/scripts/upgrade/mysql/046-HIVE-17566.mysql.sql index 1affa7a119..fa1b9f5f8f 100644 --- metastore/scripts/upgrade/mysql/046-HIVE-17566.mysql.sql +++ metastore/scripts/upgrade/mysql/046-HIVE-17566.mysql.sql @@ -12,13 +12,12 @@ CREATE TABLE IF NOT EXISTS WM_POOL `POOL_ID` bigint(20) NOT NULL, `RP_ID` bigint(20) NOT NULL, `PATH` varchar(767) NOT NULL, - `PARENT_POOL_ID` bigint(20), `ALLOC_FRACTION` DOUBLE, `QUERY_PARALLELISM` int(11), + `SCHEDULING_POLICY` varchar(128), PRIMARY KEY (`POOL_ID`), KEY `UNIQUE_WM_POOL` (`RP_ID`, `PATH`), CONSTRAINT `WM_POOL_FK1` FOREIGN KEY (`RP_ID`) REFERENCES `WM_RESOURCEPLAN` (`RP_ID`), - CONSTRAINT `WM_POOL_FK2` FOREIGN KEY (`PARENT_POOL_ID`) REFERENCES `WM_POOL` (`POOL_ID`) ) ENGINE=InnoDB DEFAULT CHARSET=latin1; CREATE TABLE IF NOT EXISTS WM_TRIGGER diff --git metastore/scripts/upgrade/mysql/hive-schema-3.0.0.mysql.sql metastore/scripts/upgrade/mysql/hive-schema-3.0.0.mysql.sql index 2453bb92c6..2226df3058 100644 --- metastore/scripts/upgrade/mysql/hive-schema-3.0.0.mysql.sql +++ metastore/scripts/upgrade/mysql/hive-schema-3.0.0.mysql.sql @@ -863,13 +863,12 @@ CREATE TABLE IF NOT EXISTS WM_POOL `POOL_ID` bigint(20) NOT NULL, `RP_ID` bigint(20) NOT NULL, `PATH` varchar(767) NOT NULL, - `PARENT_POOL_ID` bigint(20), `ALLOC_FRACTION` DOUBLE, `QUERY_PARALLELISM` int(11), + `SCHEDULING_POLICY` varchar(128), PRIMARY KEY (`POOL_ID`), KEY `UNIQUE_WM_POOL` (`RP_ID`, `PATH`), CONSTRAINT `WM_POOL_FK1` FOREIGN KEY (`RP_ID`) REFERENCES `WM_RESOURCEPLAN` (`RP_ID`), - CONSTRAINT `WM_POOL_FK2` FOREIGN KEY (`PARENT_POOL_ID`) REFERENCES `WM_POOL` (`POOL_ID`) ) ENGINE=InnoDB DEFAULT CHARSET=latin1; CREATE TABLE IF NOT EXISTS WM_TRIGGER diff --git metastore/scripts/upgrade/oracle/046-HIVE-17566.oracle.sql metastore/scripts/upgrade/oracle/046-HIVE-17566.oracle.sql index 0ee0f758f1..3b8f5fd771 100644 --- metastore/scripts/upgrade/oracle/046-HIVE-17566.oracle.sql +++ metastore/scripts/upgrade/oracle/046-HIVE-17566.oracle.sql @@ -16,16 +16,15 @@ CREATE TABLE WM_POOL POOL_ID bigint NOT NULL, RP_ID bigint NOT NULL, PATH nvarchar(1024) NOT NULL, - PARENT_POOL_ID bigint, ALLOC_FRACTION DOUBLE, - QUERY_PARALLELISM int + QUERY_PARALLELISM int, + SCHEDULING_POLICY nvarchar(128) ); ALTER TABLE WM_POOL ADD CONSTRAINT WM_POOL_PK PRIMARY KEY (POOL_ID); CREATE UNIQUE INDEX UNIQUE_WM_POOL ON WM_POOL (RP_ID, "NAME"); ALTER TABLE WM_POOL ADD CONSTRAINT WM_POOL_FK1 FOREIGN KEY (RP_ID) REFERENCES WM_RESOURCEPLAN (RP_ID); -ALTER TABLE WM_POOL ADD CONSTRAINT WM_POOL_FK2 FOREIGN KEY (PARENT_POOL_ID) REFERENCES WM_POOL (POOL_ID); CREATE TABLE WM_TRIGGER diff --git metastore/scripts/upgrade/oracle/hive-schema-3.0.0.oracle.sql metastore/scripts/upgrade/oracle/hive-schema-3.0.0.oracle.sql index 47bfc5ae08..159906ba41 100644 --- metastore/scripts/upgrade/oracle/hive-schema-3.0.0.oracle.sql +++ metastore/scripts/upgrade/oracle/hive-schema-3.0.0.oracle.sql @@ -593,9 +593,9 @@ CREATE TABLE WM_POOL POOL_ID bigint NOT NULL, RP_ID bigint NOT NULL, PATH nvarchar(1024) NOT NULL, - PARENT_POOL_ID bigint, ALLOC_FRACTION DOUBLE, - QUERY_PARALLELISM int + QUERY_PARALLELISM int, + SCHEDULING_POLICY nvarchar(128) ); ALTER TABLE WM_POOL ADD CONSTRAINT WM_POOL_PK PRIMARY KEY (POOL_ID); @@ -874,8 +874,6 @@ CREATE UNIQUE INDEX UNIQUE_WM_POOL ON WM_POOL (RP_ID, PATH); ALTER TABLE WM_POOL ADD CONSTRAINT WM_POOL_FK1 FOREIGN KEY (RP_ID) REFERENCES WM_RESOURCEPLAN (RP_ID); -ALTER TABLE WM_POOL ADD CONSTRAINT WM_POOL_FK2 FOREIGN KEY (PARENT_POOL_ID) REFERENCES WM_POOL (POOL_ID); - CREATE UNIQUE INDEX UNIQUE_WM_TRIGGER ON WM_TRIGGER (RP_ID, "NAME"); ALTER TABLE WM_TRIGGER ADD CONSTRAINT WM_TRIGGER_FK1 FOREIGN KEY (RP_ID) REFERENCES WM_RESOURCEPLAN (RP_ID); diff --git metastore/scripts/upgrade/postgres/045-HIVE-17566.postgres.sql metastore/scripts/upgrade/postgres/045-HIVE-17566.postgres.sql index aa27a6486b..53a21ce782 100644 --- metastore/scripts/upgrade/postgres/045-HIVE-17566.postgres.sql +++ metastore/scripts/upgrade/postgres/045-HIVE-17566.postgres.sql @@ -16,9 +16,9 @@ CREATE TABLE "WM_POOL" ( "POOL_ID" bigint NOT NULL, "RP_ID" bigint NOT NULL, "PATH" character varying(1024) NOT NULL, - "PARENT_POOL_ID" bigint, "ALLOC_FRACTION" DOUBLE, - "QUERY_PARALLELISM" integer + "QUERY_PARALLELISM" integer, + "SCHEDULING_POLICY" character varying(128) ); ALTER TABLE ONLY "WM_POOL" @@ -29,8 +29,6 @@ ALTER TABLE ONLY "WM_POOL" ALTER TABLE ONLY "WM_POOL" ADD CONSTRAINT "WM_POOL_FK1" FOREIGN KEY ("RP_ID") REFERENCES "WM_RESOURCEPLAN" ("RP_ID") DEFERRABLE; -ALTER TABLE ONLY "WM_POOL" - ADD CONSTRAINT "WM_POOL_FK2" FOREIGN KEY ("PARENT_POOL_ID") REFERENCES "WM_POOL" ("POOL_ID") DEFERRABLE; CREATE TABLE "WM_TRIGGER" ( diff --git metastore/scripts/upgrade/postgres/hive-schema-3.0.0.postgres.sql metastore/scripts/upgrade/postgres/hive-schema-3.0.0.postgres.sql index 5c770e2659..6e62bcc79e 100644 --- metastore/scripts/upgrade/postgres/hive-schema-3.0.0.postgres.sql +++ metastore/scripts/upgrade/postgres/hive-schema-3.0.0.postgres.sql @@ -630,9 +630,9 @@ CREATE TABLE "WM_POOL" ( "POOL_ID" bigint NOT NULL, "RP_ID" bigint NOT NULL, "PATH" character varying(1024) NOT NULL, - "PARENT_POOL_ID" bigint, "ALLOC_FRACTION" DOUBLE, - "QUERY_PARALLELISM" integer + "QUERY_PARALLELISM" integer, + "SCHEDULING_POLICY" character varying(128) ); CREATE TABLE "WM_TRIGGER" ( diff --git metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java index 8a55305647..871caadaba 100644 --- metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java +++ metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java @@ -7479,7 +7479,7 @@ public WMDropTriggerResponse drop_wm_trigger(WMDropTriggerRequest request) getMS().dropWMTrigger(request.getResourcePlanName(), request.getTriggerName()); return new WMDropTriggerResponse(); } catch (MetaException e) { - LOG.error("Exception while trying to retrieve resource plans", e); + LOG.error("Exception while trying to drop trigger.", e); throw e; } } @@ -7498,6 +7498,75 @@ public WMGetTriggersForResourePlanResponse get_triggers_for_resourceplan( throw e; } } + + @Override + public WMCreateOrUpdatePoolResponse create_or_update_wm_pool( + WMCreateOrUpdatePoolRequest request) throws AlreadyExistsException, NoSuchObjectException, + InvalidObjectException, MetaException, TException { + try { + getMS().createOrUpdatePool(request.getPool(), request.getNewPoolPath(), request.isUpdate()); + return new WMCreateOrUpdatePoolResponse(); + } catch (MetaException e) { + LOG.error("Exception while trying to create or update WMPool", e); + throw e; + } + } + + @Override + public WMDropPoolResponse drop_wm_pool(WMDropPoolRequest request) + throws NoSuchObjectException, InvalidOperationException, MetaException, TException { + try { + getMS().dropWMPool(request.getResourcePlanName(), request.getPoolPath()); + return new WMDropPoolResponse(); + } catch (MetaException e) { + LOG.error("Exception while trying to drop WMPool", e); + throw e; + } + } + + @Override + public WMCreateOrUpdateMappingResponse create_or_update_wm_mapping( + WMCreateOrUpdateMappingRequest request) throws AlreadyExistsException, + NoSuchObjectException, InvalidObjectException, MetaException, TException { + try { + getMS().createOrUpdateWMMapping(request.getMapping(), request.isUpdate()); + return new WMCreateOrUpdateMappingResponse(); + } catch (MetaException e) { + LOG.error("Exception while trying to drop WMPool", e); + throw e; + } + } + + @Override + public WMDropMappingResponse drop_wm_mapping(WMDropMappingRequest request) + throws NoSuchObjectException, InvalidOperationException, MetaException, TException { + try { + getMS().dropWMMapping(request.getMapping()); + return new WMDropMappingResponse(); + } catch (MetaException e) { + LOG.error("Exception while trying to drop WMPool", e); + throw e; + } + } + + @Override + public WMCreateOrDropTriggerToPoolMappingResponse create_or_drop_wm_trigger_to_pool_mapping( + WMCreateOrDropTriggerToPoolMappingRequest request) throws AlreadyExistsException, + NoSuchObjectException, InvalidObjectException, MetaException, TException { + try { + if (request.isDrop()) { + getMS().dropWMTriggerToPoolMapping( + request.getResourcePlanName(), request.getTriggerName(), request.getPoolPath()); + } else { + getMS().createWMTriggerToPoolMapping( + request.getResourcePlanName(), request.getTriggerName(), request.getPoolPath()); + } + return new WMCreateOrDropTriggerToPoolMappingResponse(); + } catch (MetaException e) { + LOG.error("Exception while trying to drop WMPool", 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 dfb0a6d6aa..310698f082 100644 --- metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java +++ metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java @@ -2716,4 +2716,52 @@ public void dropWMTrigger(String resourcePlanName, String triggerName) request.setResourcePlanName(resourcePlan); return client.get_triggers_for_resourceplan(request).getTriggers(); } + + @Override + public void createOrUpdateWMPool(WMPool pool, String newPoolPath, boolean isUpdate) + throws NoSuchObjectException, InvalidObjectException, MetaException, TException { + WMCreateOrUpdatePoolRequest request = new WMCreateOrUpdatePoolRequest(); + request.setPool(pool); + request.setNewPoolPath(newPoolPath); + request.setUpdate(isUpdate); + client.create_or_update_wm_pool(request); + } + + @Override + public void dropWMPool(String resourcePlanName, String poolPath) + throws NoSuchObjectException, MetaException, TException { + WMDropPoolRequest request = new WMDropPoolRequest(); + request.setResourcePlanName(resourcePlanName); + request.setPoolPath(poolPath); + client.drop_wm_pool(request); + } + + @Override + public void createOrUpdateWMMapping(WMMapping mapping, boolean isUpdate) + throws NoSuchObjectException, InvalidObjectException, MetaException, TException { + WMCreateOrUpdateMappingRequest request = new WMCreateOrUpdateMappingRequest(); + request.setMapping(mapping); + request.setUpdate(isUpdate); + client.create_or_update_wm_mapping(request); + } + + @Override + public void dropWMMapping(WMMapping mapping) + throws NoSuchObjectException, MetaException, TException { + WMDropMappingRequest request = new WMDropMappingRequest(); + request.setMapping(mapping); + client.drop_wm_mapping(request); + } + + @Override + public void createOrDropTriggerToPoolMapping(String resourcePlanName, String triggerName, + String poolPath, boolean shouldDrop) throws AlreadyExistsException, NoSuchObjectException, + InvalidObjectException, MetaException, TException { + WMCreateOrDropTriggerToPoolMappingRequest request = new WMCreateOrDropTriggerToPoolMappingRequest(); + request.setResourcePlanName(resourcePlanName); + request.setTriggerName(triggerName); + request.setPoolPath(poolPath); + request.setDrop(shouldDrop); + client.create_or_drop_wm_trigger_to_pool_mapping(request); + } } diff --git metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java index 5aa20c582b..9efd82e712 100644 --- metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java +++ metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java @@ -105,6 +105,8 @@ import org.apache.hadoop.hive.metastore.api.UnknownDBException; import org.apache.hadoop.hive.metastore.api.UnknownPartitionException; import org.apache.hadoop.hive.metastore.api.UnknownTableException; +import org.apache.hadoop.hive.metastore.api.WMMapping; +import org.apache.hadoop.hive.metastore.api.WMPool; import org.apache.hadoop.hive.metastore.partition.spec.PartitionSpecProxy; import org.apache.thrift.TException; @@ -1797,4 +1799,20 @@ void dropWMTrigger(String resourcePlanName, String triggerName) List getTriggersForResourcePlan(String resourcePlan) throws NoSuchObjectException, MetaException, TException; + + void createOrUpdateWMPool(WMPool pool, String newPoolPath, boolean isUpdate) + throws NoSuchObjectException, InvalidObjectException, MetaException, TException; + + void dropWMPool(String resourcePlanName, String poolPath) + throws NoSuchObjectException, MetaException, TException; + + void createOrUpdateWMMapping(WMMapping mapping, boolean isUpdate) + throws NoSuchObjectException, InvalidObjectException, MetaException, TException; + + void dropWMMapping(WMMapping mapping) + throws NoSuchObjectException, MetaException, TException; + + void createOrDropTriggerToPoolMapping(String resourcePlanName, String triggerName, + String poolPath, boolean shouldDrop) throws AlreadyExistsException, NoSuchObjectException, + InvalidObjectException, 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 610b9fafd5..6e52392ece 100644 --- metastore/src/test/org/apache/hadoop/hive/metastore/DummyRawStoreControlledCommit.java +++ metastore/src/test/org/apache/hadoop/hive/metastore/DummyRawStoreControlledCommit.java @@ -68,6 +68,8 @@ import org.apache.hadoop.hive.metastore.api.UnknownDBException; import org.apache.hadoop.hive.metastore.api.UnknownPartitionException; import org.apache.hadoop.hive.metastore.api.UnknownTableException; +import org.apache.hadoop.hive.metastore.api.WMMapping; +import org.apache.hadoop.hive.metastore.api.WMPool; import org.apache.hadoop.hive.metastore.partition.spec.PartitionSpecProxy; import org.apache.thrift.TException; @@ -996,4 +998,43 @@ public void dropWMTrigger(String resourcePlanName, String triggerName) throws NoSuchObjectException, MetaException { return objectStore.getTriggersForResourcePlan(resourcePlanName); } + + @Override + public void createOrUpdatePool(WMPool pool, String newPoolPath, boolean update) + throws AlreadyExistsException, NoSuchObjectException, InvalidOperationException, + MetaException { + objectStore.createOrUpdatePool(pool, newPoolPath, update); + } + + @Override + public void dropWMPool(String resourcePlanName, String poolPath) + throws NoSuchObjectException, InvalidOperationException, MetaException { + objectStore.dropWMPool(resourcePlanName, poolPath); + } + + @Override + public void createOrUpdateWMMapping(WMMapping mapping, boolean update) + throws AlreadyExistsException, NoSuchObjectException, InvalidOperationException, + MetaException { + objectStore.createOrUpdateWMMapping(mapping, update); + } + + @Override + public void dropWMMapping(WMMapping mapping) + throws NoSuchObjectException, InvalidOperationException, MetaException { + objectStore.dropWMMapping(mapping); + } + + @Override + public void createWMTriggerToPoolMapping(String resourcePlanName, String triggerName, + String poolPath) throws AlreadyExistsException, NoSuchObjectException, + InvalidOperationException, MetaException { + objectStore.createWMTriggerToPoolMapping(resourcePlanName, triggerName, poolPath); + } + + @Override + public void dropWMTriggerToPoolMapping(String resourcePlanName, String triggerName, + String poolPath) throws NoSuchObjectException, InvalidOperationException, MetaException { + objectStore.dropWMTriggerToPoolMapping(resourcePlanName, triggerName, poolPath); + } } diff --git metastore/src/test/org/apache/hadoop/hive/metastore/DummyRawStoreForJdoConnection.java metastore/src/test/org/apache/hadoop/hive/metastore/DummyRawStoreForJdoConnection.java index 84b70d88b0..9a1df36a6a 100644 --- metastore/src/test/org/apache/hadoop/hive/metastore/DummyRawStoreForJdoConnection.java +++ metastore/src/test/org/apache/hadoop/hive/metastore/DummyRawStoreForJdoConnection.java @@ -28,6 +28,7 @@ import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hive.conf.HiveConf; 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; @@ -68,6 +69,8 @@ import org.apache.hadoop.hive.metastore.api.UnknownDBException; import org.apache.hadoop.hive.metastore.api.UnknownPartitionException; import org.apache.hadoop.hive.metastore.api.UnknownTableException; +import org.apache.hadoop.hive.metastore.api.WMMapping; +import org.apache.hadoop.hive.metastore.api.WMPool; import org.apache.hadoop.hive.metastore.partition.spec.PartitionSpecProxy; import org.apache.thrift.TException; @@ -998,4 +1001,37 @@ public void dropWMTrigger(String resourcePlanName, String triggerName) throws NoSuchObjectException, MetaException { return null; } + + @Override + public void createOrUpdatePool(WMPool pool, String newPoolPath, boolean update) + throws AlreadyExistsException, NoSuchObjectException, InvalidOperationException, + MetaException { + } + + @Override + public void dropWMPool(String resourcePlanName, String poolPath) + throws NoSuchObjectException, InvalidOperationException, MetaException { + } + + @Override + public void createOrUpdateWMMapping(WMMapping mapping, boolean update) + throws AlreadyExistsException, NoSuchObjectException, InvalidOperationException, + MetaException { + } + + @Override + public void dropWMMapping(WMMapping mapping) + throws NoSuchObjectException, InvalidOperationException, MetaException { + } + + @Override + public void createWMTriggerToPoolMapping(String resourcePlanName, String triggerName, + String poolPath) throws AlreadyExistsException, NoSuchObjectException, + InvalidOperationException, MetaException { + } + + @Override + public void dropWMTriggerToPoolMapping(String resourcePlanName, String triggerName, + String poolPath) throws NoSuchObjectException, InvalidOperationException, MetaException { + } } 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 591be49af1..981d8f1ec4 100644 --- ql/src/java/org/apache/hadoop/hive/ql/exec/DDLTask.java +++ ql/src/java/org/apache/hadoop/hive/ql/exec/DDLTask.java @@ -102,6 +102,8 @@ import org.apache.hadoop.hive.metastore.api.SkewedInfo; import org.apache.hadoop.hive.metastore.api.StorageDescriptor; import org.apache.hadoop.hive.metastore.api.TxnInfo; +import org.apache.hadoop.hive.metastore.api.WMMapping; +import org.apache.hadoop.hive.metastore.api.WMPool; import org.apache.hadoop.hive.metastore.txn.TxnStore; import org.apache.hadoop.hive.ql.CompilationOpContext; import org.apache.hadoop.hive.ql.Context; @@ -172,6 +174,7 @@ import org.apache.hadoop.hive.ql.plan.ColStatistics; import org.apache.hadoop.hive.ql.plan.CreateDatabaseDesc; import org.apache.hadoop.hive.ql.plan.CreateIndexDesc; +import org.apache.hadoop.hive.ql.plan.CreateOrAlterWMMappingDesc; import org.apache.hadoop.hive.ql.plan.CreateResourcePlanDesc; import org.apache.hadoop.hive.ql.plan.CreateTableDesc; import org.apache.hadoop.hive.ql.plan.CreateTableLikeDesc; @@ -185,6 +188,8 @@ 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.DropWMMappingDesc; +import org.apache.hadoop.hive.ql.plan.DropWMPoolDesc; import org.apache.hadoop.hive.ql.plan.DropWMTriggerDesc; import org.apache.hadoop.hive.ql.plan.FileMergeDesc; import org.apache.hadoop.hive.ql.plan.GrantDesc; @@ -228,6 +233,8 @@ import org.apache.hadoop.hive.ql.plan.TruncateTableDesc; import org.apache.hadoop.hive.ql.plan.UnlockDatabaseDesc; import org.apache.hadoop.hive.ql.plan.UnlockTableDesc; +import org.apache.hadoop.hive.ql.plan.CreateOrAlterWMPoolDesc; +import org.apache.hadoop.hive.ql.plan.CreateOrDropTriggerToPoolMappingDesc; import org.apache.hadoop.hive.ql.plan.api.StageType; import org.apache.hadoop.hive.ql.security.authorization.AuthorizationUtils; import org.apache.hadoop.hive.ql.security.authorization.DefaultHiveAuthorizationTranslator; @@ -642,6 +649,26 @@ public int execute(DriverContext driverContext) { if (work.getDropWMTriggerDesc() != null) { return dropWMTrigger(db, work.getDropWMTriggerDesc()); } + + if (work.getWmPoolDesc() != null) { + return createOrAlterWMPool(db, work.getWmPoolDesc()); + } + + if (work.getDropWMPoolDesc() != null) { + return dropWMPool(db, work.getDropWMPoolDesc()); + } + + if (work.getWmMappingDesc() != null) { + return createOrAlterWMMapping(db, work.getWmMappingDesc()); + } + + if (work.getDropWMMappingDesc() != null) { + return dropWMMapping(db, work.getDropWMMappingDesc()); + } + + if (work.getTriggerToPoolMappingDesc() != null) { + return createOrDropTriggerToPoolMapping(db, work.getTriggerToPoolMappingDesc()); + } } catch (Throwable e) { failed(e); return 1; @@ -733,6 +760,52 @@ private int dropWMTrigger(Hive db, DropWMTriggerDesc desc) throws HiveException return 0; } + private int createOrAlterWMPool(Hive db, CreateOrAlterWMPoolDesc desc) throws HiveException { + WMPool pool = new WMPool(desc.getResourcePlanName(), desc.getPoolPath()); + if (desc.getAllocFraction() != null) { + pool.setAllocFraction(desc.getAllocFraction()); + } + + if (desc.getQueryParallelism() != null) { + pool.setQueryParallelism(desc.getQueryParallelism()); + } + + if (desc.getSchedulingPolicy() != null) { + pool.setSchedulingPolicy(desc.getSchedulingPolicy()); + } + db.createOrUpdateWMPool(pool, desc.getNewPoolPath(), desc.isUpdate()); + return 0; + } + + private int dropWMPool(Hive db, DropWMPoolDesc desc) throws HiveException { + db.dropWMPool(desc.getResourcePlanName(), desc.getPoolPath()); + return 0; + } + + private int createOrAlterWMMapping(Hive db, CreateOrAlterWMMappingDesc desc) throws HiveException { + WMMapping mapping = + new WMMapping(desc.getResourcePlanName(), desc.getEntityType(), desc.getEntityName()); + mapping.setPoolPath(desc.getPoolPath()); + if (desc.getOrdering() != null) { + mapping.setOrdering(desc.getOrdering()); + } + db.createOrUpdateWMMapping(mapping, desc.isUpdate()); + return 0; + } + + private int dropWMMapping(Hive db, DropWMMappingDesc desc) throws HiveException { + db.dropWMMapping(new WMMapping( + desc.getResourcePlanName(), desc.getEntityType(), desc.getEntityName())); + return 0; + } + + private int createOrDropTriggerToPoolMapping(Hive db, CreateOrDropTriggerToPoolMappingDesc desc) + throws HiveException { + db.createOrDropTriggerToPoolMapping(desc.getResourcePlanName(), desc.getTriggerName(), + desc.getPoolPath(), desc.shouldDrop()); + 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 70656feea7..69d6c0c315 100644 --- ql/src/java/org/apache/hadoop/hive/ql/metadata/Hive.java +++ ql/src/java/org/apache/hadoop/hive/ql/metadata/Hive.java @@ -132,6 +132,8 @@ import org.apache.hadoop.hive.metastore.api.SkewedInfo; import org.apache.hadoop.hive.metastore.api.StorageDescriptor; import org.apache.hadoop.hive.metastore.api.UniqueConstraintsRequest; +import org.apache.hadoop.hive.metastore.api.WMMapping; +import org.apache.hadoop.hive.metastore.api.WMPool; import org.apache.hadoop.hive.metastore.api.hive_metastoreConstants; import org.apache.hadoop.hive.ql.ErrorMsg; import org.apache.hadoop.hive.ql.exec.AbstractFileMergeOperator; @@ -4773,4 +4775,48 @@ public void dropWMTrigger(String rpName, String triggerName) throws HiveExceptio throw new HiveException(e); } } + + public void createOrUpdateWMPool(WMPool pool, String newPoolPath, boolean isUpdate) + throws HiveException { + try { + getMSC().createOrUpdateWMPool(pool, newPoolPath, isUpdate); + } catch (Exception e) { + throw new HiveException(e); + } + } + + public void dropWMPool(String resourcePlanName, String poolPath) throws HiveException { + try { + getMSC().dropWMPool(resourcePlanName, poolPath); + } catch (Exception e) { + throw new HiveException(e); + } + } + + public void createOrUpdateWMMapping(WMMapping mapping, boolean isUpdate) + throws HiveException { + try { + getMSC().createOrUpdateWMMapping(mapping, isUpdate); + } catch (Exception e) { + throw new HiveException(e); + } + } + + public void dropWMMapping(WMMapping mapping) throws HiveException { + try { + getMSC().dropWMMapping(mapping); + } catch (Exception e) { + throw new HiveException(e); + } + } + + + public void createOrDropTriggerToPoolMapping(String resourcePlanName, String triggerName, + String poolPath, boolean shouldDrop) throws HiveException { + try { + getMSC().createOrDropTriggerToPoolMapping(resourcePlanName, triggerName, poolPath, shouldDrop); + } 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 6a2ff75c84..3cf7a3d853 100644 --- ql/src/java/org/apache/hadoop/hive/ql/parse/DDLSemanticAnalyzer.java +++ ql/src/java/org/apache/hadoop/hive/ql/parse/DDLSemanticAnalyzer.java @@ -97,6 +97,7 @@ 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.CreateOrAlterWMMappingDesc; import org.apache.hadoop.hive.ql.plan.CreateResourcePlanDesc; import org.apache.hadoop.hive.ql.plan.CreateWMTriggerDesc; import org.apache.hadoop.hive.ql.plan.DDLWork; @@ -107,6 +108,8 @@ 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.DropWMMappingDesc; +import org.apache.hadoop.hive.ql.plan.DropWMPoolDesc; import org.apache.hadoop.hive.ql.plan.DropWMTriggerDesc; import org.apache.hadoop.hive.ql.plan.ExprNodeColumnDesc; import org.apache.hadoop.hive.ql.plan.ExprNodeConstantDesc; @@ -146,6 +149,8 @@ import org.apache.hadoop.hive.ql.plan.TruncateTableDesc; import org.apache.hadoop.hive.ql.plan.UnlockDatabaseDesc; import org.apache.hadoop.hive.ql.plan.UnlockTableDesc; +import org.apache.hadoop.hive.ql.plan.CreateOrAlterWMPoolDesc; +import org.apache.hadoop.hive.ql.plan.CreateOrDropTriggerToPoolMappingDesc; import org.apache.hadoop.hive.ql.session.SessionState; import org.apache.hadoop.hive.ql.udf.generic.GenericUDF; import org.apache.hadoop.hive.serde.serdeConstants; @@ -570,6 +575,24 @@ public void analyzeInternal(ASTNode input) throws SemanticException { case HiveParser.TOK_DROP_TRIGGER: analyzeDropTrigger(ast); break; + case HiveParser.TOK_CREATE_POOL: + analyzeCreatePool(ast); + break; + case HiveParser.TOK_ALTER_POOL: + analyzeAlterPool(ast); + break; + case HiveParser.TOK_DROP_POOL: + analyzeDropPool(ast); + break; + case HiveParser.TOK_CREATE_MAPPING: + analyzeCreateMapping(ast, false); + break; + case HiveParser.TOK_ALTER_MAPPING: + analyzeCreateMapping(ast, true); + break; + case HiveParser.TOK_DROP_MAPPING: + analyzeDropMapping(ast); + break; default: throw new SemanticException("Unsupported command: " + ast); } @@ -917,6 +940,19 @@ private void analyzeAlterResourcePlan(ASTNode ast) throws SemanticException { String name = ast.getChild(2).getText(); desc = AlterResourcePlanDesc.createRenamePlan(rpName, name); break; + case HiveParser.TOK_ADD_TRIGGER: + case HiveParser.TOK_DROP_TRIGGER: { + if (ast.getChildCount() != 4) { + throw new SemanticException( + "Invalid syntax for in alter resource plan statment add trigger statement"); + } + boolean drop = ast.getChild(1).getType() == HiveParser.TOK_DROP_TRIGGER; + String triggerName = ast.getChild(2).getText(); + String poolPath = ast.getChild(3).getText(); + rootTasks.add(TaskFactory.get(new DDLWork(getInputs(), getOutputs(), + new CreateOrDropTriggerToPoolMappingDesc(rpName, triggerName, poolPath, drop)), conf)); + return; + } default: throw new SemanticException("Unexpected token in alter resource plan statement: " + ast.getChild(1).getType()); @@ -1014,6 +1050,99 @@ private void analyzeDropTrigger(ASTNode ast) throws SemanticException { new DDLWork(getInputs(), getOutputs(), desc), conf)); } + private void analyzeCreatePool(ASTNode ast) throws SemanticException { + if (ast.getChildCount() != 5) { + throw new SemanticException("Invalid syntax for create pool."); + } + String rpName = ast.getChild(0).getText(); + String poolPath = poolPath((ASTNode)ast.getChild(1)); + Double allocFraction = Double.parseDouble(ast.getChild(2).getText()); + Integer parallelism = Integer.parseInt(ast.getChild(3).getText()); + String policy = ast.getChild(4).getText(); + CreateOrAlterWMPoolDesc desc = new CreateOrAlterWMPoolDesc(rpName, poolPath, allocFraction, parallelism, policy, + false, null); + rootTasks.add(TaskFactory.get( + new DDLWork(getInputs(), getOutputs(), desc), conf)); + } + + private void analyzeAlterPool(ASTNode ast) throws SemanticException { + if (ast.getChildCount() < 3) { + throw new SemanticException("Invalid syntax for alter pool."); + } + String rpName = ast.getChild(0).getText(); + String poolPath = poolPath((ASTNode)ast.getChild(1)); + String newPoolPath = null; + Double allocFraction = null; + Integer parallelism = null; + String policy = null; + + for (int i = 2; i < ast.getChildCount(); ++i) { + Tree child = ast.getChild(i); + switch (child.getType()) { + case HiveParser.TOK_ALLOC_FRACTION: + allocFraction = Double.parseDouble(child.getChild(0).getText()); + break; + case HiveParser.TOK_QUERY_PARALLELISM: + parallelism = Integer.parseInt(child.getChild(0).getText()); + break; + case HiveParser.TOK_SCHEDULING_POLICY: + policy = child.getChild(0).getText(); + break; + case HiveParser.TOK_PATH: + newPoolPath = child.getChild(0).getText(); + } + } + + CreateOrAlterWMPoolDesc desc = new CreateOrAlterWMPoolDesc(rpName, poolPath, allocFraction, parallelism, policy, + true, newPoolPath); + rootTasks.add(TaskFactory.get( + new DDLWork(getInputs(), getOutputs(), desc), conf)); + } + + private void analyzeDropPool(ASTNode ast) throws SemanticException { + if (ast.getChildCount() != 2) { + throw new SemanticException("Invalid syntax for drop pool."); + } + String rpName = ast.getChild(0).getText(); + String poolPath = poolPath((ASTNode)ast.getChild(1)); + + DropWMPoolDesc desc = new DropWMPoolDesc(rpName, poolPath); + rootTasks.add(TaskFactory.get( + new DDLWork(getInputs(), getOutputs(), desc), conf)); + } + + private void analyzeCreateMapping(ASTNode ast, boolean update) throws SemanticException { + if (ast.getChildCount() < 4) { + throw new SemanticException("Invalid syntax for drop pool."); + } + String rpName = ast.getChild(0).getText(); + String entityType = ast.getChild(1).getText(); + String entityName = ast.getChild(2).getText(); + String poolPath = poolPath((ASTNode)ast.getChild(3)); + Integer ordering = null; + if (ast.getChildCount() == 5) { + ordering = Integer.valueOf(((ASTNode)ast.getChild(4)).getText()); + } + + CreateOrAlterWMMappingDesc desc = + new CreateOrAlterWMMappingDesc(rpName, entityType, entityName, poolPath, ordering, update); + rootTasks.add(TaskFactory.get( + new DDLWork(getInputs(), getOutputs(), desc), conf)); + } + + private void analyzeDropMapping(ASTNode ast) throws SemanticException { + if (ast.getChildCount() != 3) { + throw new SemanticException("Invalid syntax for drop mapping."); + } + String rpName = ast.getChild(0).getText(); + String entityType = ast.getChild(1).getText(); + String entityName = ast.getChild(2).getText(); + + DropWMMappingDesc desc = new DropWMMappingDesc(rpName, entityType, entityName); + 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 0263df0d04..872befd767 100644 --- ql/src/java/org/apache/hadoop/hive/ql/parse/HiveLexer.g +++ ql/src/java/org/apache/hadoop/hive/ql/parse/HiveLexer.g @@ -360,6 +360,11 @@ KW_PLANS: 'PLANS'; KW_ACTIVATE: 'ACTIVATE'; KW_MOVE: 'MOVE'; KW_DO: 'DO'; +KW_POOL: 'POOL'; +KW_ALLOC_FRACTION: 'ALLOC_FRACTION'; +KW_SCHEDULING_POLICY: 'SCHEDULING_POLICY'; +KW_PATH: 'PATH'; +KW_MAPPING: 'MAPPING'; // 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 306559c722..6ae716a1c5 100644 --- ql/src/java/org/apache/hadoop/hive/ql/parse/HiveParser.g +++ ql/src/java/org/apache/hadoop/hive/ql/parse/HiveParser.g @@ -417,6 +417,16 @@ TOK_CREATE_TRIGGER; TOK_ALTER_TRIGGER; TOK_DROP_TRIGGER; TOK_TRIGGER_EXPRESSION; +TOK_CREATE_POOL; +TOK_ALTER_POOL; +TOK_DROP_POOL; +TOK_ALLOC_FRACTION; +TOK_SCHEDULING_POLICY; +TOK_PATH; +TOK_CREATE_MAPPING; +TOK_ALTER_MAPPING; +TOK_DROP_MAPPING; +TOK_ADD_TRIGGER; } @@ -596,6 +606,10 @@ import org.apache.hadoop.hive.conf.HiveConf; xlateMap.put("KW_ACTIVATE", "ACTIVATE"); xlateMap.put("KW_MOVE", "MOVE"); xlateMap.put("KW_DO", "DO"); + xlateMap.put("KW_POOL", "POOL"); + xlateMap.put("KW_ALLOC_FRACTION", "ALLOC_FRACTION"); + xlateMap.put("KW_SCHEDULING_POLICY", "SCHEDULING_POLICY"); + xlateMap.put("KW_PATH", "PATH"); // Operators xlateMap.put("DOT", "."); @@ -940,6 +954,12 @@ ddlStatement | createTriggerStatement | alterTriggerStatement | dropTriggerStatement + | createPoolStatement + | alterPoolStatement + | dropPoolStatement + | createMappingStatement + | alterMappingStatement + | dropMappingStatement ; ifExists @@ -1014,6 +1034,10 @@ alterResourcePlanStatement -> ^(TOK_ALTER_RP $name TOK_QUERY_PARALLELISM $parallelism)) | (KW_RENAME KW_TO newName=identifier -> ^(TOK_ALTER_RP $name TOK_RENAME $newName)) + | (KW_ADD KW_TRIGGER triggerName=identifier KW_TO poolPath + -> ^(TOK_ALTER_RP $name TOK_ADD_TRIGGER $triggerName poolPath)) + | (KW_DROP KW_TRIGGER triggerName=identifier KW_FROM poolPath + -> ^(TOK_ALTER_RP $name TOK_DROP_TRIGGER $triggerName poolPath)) ) ; @@ -1099,6 +1123,75 @@ dropTriggerStatement -> ^(TOK_DROP_TRIGGER $rpName $triggerName) ; +createPoolStatement +@init { pushMsg("create pool statement", state); } +@after { popMsg(state); } + : KW_CREATE KW_POOL rpName=identifier DOT poolPath + KW_WITH + KW_ALLOC_FRACTION allocFraction=Number + KW_QUERY_PARALLELISM parallelism=Number + KW_SCHEDULING_POLICY policy=StringLiteral + -> ^(TOK_CREATE_POOL $rpName poolPath $allocFraction $parallelism $policy) + ; + +alterPoolSetCmd +@init { pushMsg("alterPoolSetCmd", state); } +@after { popMsg(state); } + : ( + (KW_ALLOC_FRACTION EQUAL allocFraction=Number) -> ^(TOK_ALLOC_FRACTION $allocFraction) + | (KW_QUERY_PARALLELISM EQUAL parallelism=Number) -> ^(TOK_QUERY_PARALLELISM $parallelism) + | (KW_SCHEDULING_POLICY EQUAL policy=StringLiteral) -> ^(TOK_SCHEDULING_POLICY $policy) + | (KW_PATH EQUAL path=poolPath) -> ^(TOK_PATH $path) + ) + ; + +alterPoolSetCmdList +@init { pushMsg("alterPoolSetCmdList", state); } +@after { popMsg(state); } + : alterPoolSetCmd (COMMA alterPoolSetCmd)* -> alterPoolSetCmd+ + ; + +alterPoolStatement +@init { pushMsg("alter pool statement", state); } +@after { popMsg(state); } + : KW_ALTER KW_POOL rpName=identifier DOT poolPath + KW_SET alterPoolSetCmdList + -> ^(TOK_ALTER_POOL $rpName poolPath alterPoolSetCmdList) + ; + +dropPoolStatement +@init { pushMsg("drop pool statement", state); } +@after { popMsg(state); } + : KW_DROP KW_POOL rpName=identifier DOT poolPath + -> ^(TOK_DROP_POOL $rpName poolPath) + ; + +createMappingStatement +@init { pushMsg("create mapping statement", state); } +@after { popMsg(state); } + : KW_CREATE mappingType=(KW_USER | KW_GROUP) KW_MAPPING + rpName=identifier DOT name=identifier KW_TO poolPath + (KW_WITH KW_ORDER order=Number)? + -> ^(TOK_CREATE_MAPPING $mappingType $rpName $name poolPath $order?) + ; + +alterMappingStatement +@init { pushMsg("alter mapping statement", state); } +@after { popMsg(state); } + : KW_ALTER mappingType=(KW_USER | KW_GROUP) KW_MAPPING + rpName=identifier DOT name=identifier KW_TO poolPath + (KW_WITH KW_ORDER order=Number)? + -> ^(TOK_ALTER_MAPPING $mappingType $rpName $name poolPath $order?) + ; + +dropMappingStatement +@init { pushMsg("drop mapping statement", state); } +@after { popMsg(state); } + : KW_DROP mappingType=(KW_USER | KW_GROUP) KW_MAPPING + rpName=identifier DOT name=identifier + -> ^(TOK_DROP_MAPPING $mappingType $rpName $name) + ; + createDatabaseStatement @init { pushMsg("create database statement", state); } @after { popMsg(state); } diff --git ql/src/java/org/apache/hadoop/hive/ql/parse/IdentifiersParser.g ql/src/java/org/apache/hadoop/hive/ql/parse/IdentifiersParser.g index 69a1d63f93..852e922805 100644 --- ql/src/java/org/apache/hadoop/hive/ql/parse/IdentifiersParser.g +++ ql/src/java/org/apache/hadoop/hive/ql/parse/IdentifiersParser.g @@ -829,7 +829,8 @@ nonReserved | KW_WAIT | KW_ZONE | KW_TIMESTAMPTZ - + | KW_RESOURCE | KW_PLAN | KW_PLANS | KW_QUERY_PARALLELISM | KW_ACTIVATE | KW_MOVE | KW_DO + | KW_POOL | KW_ALLOC_FRACTION | KW_SCHEDULING_POLICY | KW_PATH | KW_MAPPING ; //The following SQL2011 reserved keywords are used as function name only, but not as identifiers. 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 e704c73112..dd2b647cfe 100644 --- ql/src/java/org/apache/hadoop/hive/ql/parse/SemanticAnalyzerFactory.java +++ ql/src/java/org/apache/hadoop/hive/ql/parse/SemanticAnalyzerFactory.java @@ -141,6 +141,12 @@ 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); + commandType.put(HiveParser.TOK_CREATE_POOL, HiveOperation.CREATE_POOL); + commandType.put(HiveParser.TOK_ALTER_POOL, HiveOperation.ALTER_POOL); + commandType.put(HiveParser.TOK_DROP_POOL, HiveOperation.DROP_POOL); + commandType.put(HiveParser.TOK_CREATE_MAPPING, HiveOperation.CREATE_MAPPING); + commandType.put(HiveParser.TOK_ALTER_MAPPING, HiveOperation.ALTER_MAPPING); + commandType.put(HiveParser.TOK_DROP_MAPPING, HiveOperation.DROP_MAPPING); } static { @@ -323,6 +329,12 @@ private static BaseSemanticAnalyzer getInternal(QueryState queryState, ASTNode t case HiveParser.TOK_CREATE_TRIGGER: case HiveParser.TOK_ALTER_TRIGGER: case HiveParser.TOK_DROP_TRIGGER: + case HiveParser.TOK_CREATE_POOL: + case HiveParser.TOK_ALTER_POOL: + case HiveParser.TOK_DROP_POOL: + case HiveParser.TOK_CREATE_MAPPING: + case HiveParser.TOK_ALTER_MAPPING: + case HiveParser.TOK_DROP_MAPPING: return new DDLSemanticAnalyzer(queryState); case HiveParser.TOK_CREATEFUNCTION: diff --git ql/src/java/org/apache/hadoop/hive/ql/plan/CreateOrAlterWMMappingDesc.java ql/src/java/org/apache/hadoop/hive/ql/plan/CreateOrAlterWMMappingDesc.java new file mode 100644 index 0000000000..8da2125b66 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/plan/CreateOrAlterWMMappingDesc.java @@ -0,0 +1,90 @@ +package org.apache.hadoop.hive.ql.plan; + +import java.io.Serializable; + +import org.apache.hadoop.hive.ql.plan.Explain.Level; + +@Explain(displayName = "Create/Alter Mapping", + explainLevels = { Level.USER, Level.DEFAULT, Level.EXTENDED }) +public class CreateOrAlterWMMappingDesc extends DDLDesc implements Serializable { + private static final long serialVersionUID = -442968568922083053L; + + private String resourcePlanName; + private String entityType; + private String entityName; + private String poolPath; + private Integer ordering; + private boolean update; + + public CreateOrAlterWMMappingDesc() {} + + public CreateOrAlterWMMappingDesc(String resourcePlanName, String entityType, String entityName, + String poolPath, Integer ordering, boolean update) { + this.resourcePlanName = resourcePlanName; + this.entityType = entityType; + this.entityName = entityName; + this.poolPath = poolPath; + this.ordering = ordering; + this.setUpdate(update); + } + + @Explain(displayName = "resourcePlanName", + explainLevels = { Level.USER, Level.DEFAULT, Level.EXTENDED }) + public String getResourcePlanName() { + return resourcePlanName; + } + + public void setResourcePlanName(String resourcePlanName) { + this.resourcePlanName = resourcePlanName; + } + + @Explain(displayName = "entityType", + explainLevels = { Level.USER, Level.DEFAULT, Level.EXTENDED }) + public String getEntityType() { + return entityType; + } + + public void setEntityType(String entityType) { + this.entityType = entityType; + } + + @Explain(displayName = "entityName", + explainLevels = { Level.USER, Level.DEFAULT, Level.EXTENDED }) + public String getEntityName() { + return entityName; + } + + public void setEntityName(String entityName) { + this.entityName = entityName; + } + + @Explain(displayName = "poolPath", + explainLevels = { Level.USER, Level.DEFAULT, Level.EXTENDED }) + public String getPoolPath() { + return poolPath; + } + + public void setPoolPath(String poolPath) { + this.poolPath = poolPath; + } + + @Explain(displayName = "ordering", + explainLevels = { Level.USER, Level.DEFAULT, Level.EXTENDED }) + public Integer getOrdering() { + return ordering; + } + + public void setOrdering(Integer ordering) { + this.ordering = ordering; + } + + @Explain(displayName = "update", + explainLevels = { Level.USER, Level.DEFAULT, Level.EXTENDED }) + public boolean isUpdate() { + return update; + } + + public void setUpdate(boolean update) { + this.update = update; + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/plan/CreateOrAlterWMPoolDesc.java ql/src/java/org/apache/hadoop/hive/ql/plan/CreateOrAlterWMPoolDesc.java new file mode 100644 index 0000000000..a430b708a1 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/plan/CreateOrAlterWMPoolDesc.java @@ -0,0 +1,94 @@ +package org.apache.hadoop.hive.ql.plan; + +import java.io.Serializable; + +import org.apache.hadoop.hive.ql.plan.Explain.Level; + +@Explain(displayName = "Create/Alter Pool", explainLevels = { Level.USER, Level.DEFAULT, Level.EXTENDED }) +public class CreateOrAlterWMPoolDesc extends DDLDesc implements Serializable { + private static final long serialVersionUID = 4872940135771213510L; + + private String resourcePlanName; + private String poolPath; + private Double allocFraction; + private Integer queryParallelism; + private String schedulingPolicy; + private boolean update; + private String newPoolPath; + + public CreateOrAlterWMPoolDesc() {} + + public CreateOrAlterWMPoolDesc(String resourcePlanName, String poolPath, Double allocFraction, + Integer queryParallelism, String schedulingPolicy, boolean update, String newPoolPath) { + this.resourcePlanName = resourcePlanName; + this.poolPath = poolPath; + this.allocFraction = allocFraction; + this.queryParallelism = queryParallelism; + this.schedulingPolicy = schedulingPolicy; + this.update = update; + this.newPoolPath = newPoolPath; + } + + @Explain(displayName="resourcePlanName", explainLevels = { Level.USER, Level.DEFAULT, Level.EXTENDED }) + public String getResourcePlanName() { + return resourcePlanName; + } + + public void setResourcePlanName(String resourcePlanName) { + this.resourcePlanName = resourcePlanName; + } + + @Explain(displayName="poolPath", explainLevels = { Level.USER, Level.DEFAULT, Level.EXTENDED }) + public String getPoolPath() { + return poolPath; + } + + public void setPoolPath(String poolPath) { + this.poolPath = poolPath; + } + + @Explain(displayName="allocFraction", explainLevels = { Level.USER, Level.DEFAULT, Level.EXTENDED }) + public Double getAllocFraction() { + return allocFraction; + } + + public void setAllocFraction(Double allocFraction) { + this.allocFraction = allocFraction; + } + + @Explain(displayName="queryParallelism", explainLevels = { Level.USER, Level.DEFAULT, Level.EXTENDED }) + public Integer getQueryParallelism() { + return queryParallelism; + } + + public void setQueryParallelism(Integer queryParallelism) { + this.queryParallelism = queryParallelism; + } + + @Explain(displayName="schedulingPolicy", explainLevels = { Level.USER, Level.DEFAULT, Level.EXTENDED }) + public String getSchedulingPolicy() { + return schedulingPolicy; + } + + public void setSchedulingPolicy(String schedulingPolicy) { + this.schedulingPolicy = schedulingPolicy; + } + + @Explain(displayName="isUpdate", explainLevels = { Level.USER, Level.DEFAULT, Level.EXTENDED }) + public boolean isUpdate() { + return update; + } + + public void setUpdate(boolean update) { + this.update = update; + } + + @Explain(displayName="newPoolPath", explainLevels = { Level.USER, Level.DEFAULT, Level.EXTENDED }) + public String getNewPoolPath() { + return newPoolPath; + } + + public void setNewPoolPath(String newPoolPath) { + this.newPoolPath = newPoolPath; + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/plan/CreateOrDropTriggerToPoolMappingDesc.java ql/src/java/org/apache/hadoop/hive/ql/plan/CreateOrDropTriggerToPoolMappingDesc.java new file mode 100644 index 0000000000..e1f912f951 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/plan/CreateOrDropTriggerToPoolMappingDesc.java @@ -0,0 +1,66 @@ +package org.apache.hadoop.hive.ql.plan; + +import java.io.Serializable; + +import org.apache.hadoop.hive.ql.plan.Explain.Level; + +@Explain(displayName = "Create/Drop Trigger to pool mappings", + explainLevels = { Level.USER, Level.DEFAULT, Level.EXTENDED }) +public class CreateOrDropTriggerToPoolMappingDesc extends DDLDesc implements Serializable { + private static final long serialVersionUID = 383046258694558029L; + + private String resourcePlanName; + private String triggerName; + private String poolPath; + private boolean drop; + + public CreateOrDropTriggerToPoolMappingDesc() {} + + public CreateOrDropTriggerToPoolMappingDesc(String resourcePlanName, String triggerName, + String poolPath, boolean drop) { + this.resourcePlanName = resourcePlanName; + this.triggerName = triggerName; + this.poolPath = poolPath; + this.drop = drop; + } + + @Explain(displayName = "resourcePlanName", + explainLevels = { Level.USER, Level.DEFAULT, Level.EXTENDED }) + public String getResourcePlanName() { + return resourcePlanName; + } + + public void setResourcePlanName(String resourcePlanName) { + this.resourcePlanName = resourcePlanName; + } + + @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 = "poolPath", + explainLevels = { Level.USER, Level.DEFAULT, Level.EXTENDED }) + public String getPoolPath() { + return poolPath; + } + + public void setPoolPath(String poolPath) { + this.poolPath = poolPath; + } + + @Explain(displayName = "drop or create", + explainLevels = { Level.USER, Level.DEFAULT, Level.EXTENDED }) + public boolean shouldDrop() { + return drop; + } + + public void setDrop(boolean drop) { + this.drop = drop; + } +} 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 8152cfeb59..1fb724138b 100644 --- ql/src/java/org/apache/hadoop/hive/ql/plan/DDLWork.java +++ ql/src/java/org/apache/hadoop/hive/ql/plan/DDLWork.java @@ -94,6 +94,14 @@ private AlterWMTriggerDesc alterWMTriggerDesc; private DropWMTriggerDesc dropWMTriggerDesc; + private CreateOrAlterWMPoolDesc wmPoolDesc; + private DropWMPoolDesc dropWMPoolDesc; + + private CreateOrAlterWMMappingDesc wmMappingDesc; + private DropWMMappingDesc dropWMMappingDesc; + + private CreateOrDropTriggerToPoolMappingDesc triggerToPoolMappingDesc; + boolean needLock = false; /** @@ -570,31 +578,61 @@ public DDLWork(HashSet inputs, HashSet outputs, public DDLWork(HashSet inputs, HashSet outputs, DropResourcePlanDesc dropResourcePlanDesc) { this(inputs, outputs); - this.setDropResourcePlanDesc(dropResourcePlanDesc); + this.dropResourcePlanDesc = dropResourcePlanDesc; } public DDLWork(HashSet inputs, HashSet outputs, AlterResourcePlanDesc alterResourcePlanDesc) { this(inputs, outputs); - this.setAlterResourcePlanDesc(alterResourcePlanDesc); + this.alterResourcePlanDesc = alterResourcePlanDesc; } public DDLWork(HashSet inputs, HashSet outputs, CreateWMTriggerDesc createWMTriggerDesc) { this(inputs, outputs); - this.setCreateWMTriggerDesc(createWMTriggerDesc); + this.createWMTriggerDesc = createWMTriggerDesc; } public DDLWork(HashSet inputs, HashSet outputs, AlterWMTriggerDesc alterWMTriggerDesc) { this(inputs, outputs); - this.setAlterWMTriggerDesc(alterWMTriggerDesc); + this.alterWMTriggerDesc = alterWMTriggerDesc; } public DDLWork(HashSet inputs, HashSet outputs, DropWMTriggerDesc dropWMTriggerDesc) { this(inputs, outputs); - this.setDropWMTriggerDesc(dropWMTriggerDesc); + this.dropWMTriggerDesc = dropWMTriggerDesc; + } + + public DDLWork(HashSet inputs, HashSet outputs, + CreateOrAlterWMPoolDesc wmPoolDesc) { + this(inputs, outputs); + this.wmPoolDesc = wmPoolDesc; + } + + public DDLWork(HashSet inputs, HashSet outputs, + DropWMPoolDesc dropWMPoolDesc) { + this(inputs, outputs); + this.dropWMPoolDesc = dropWMPoolDesc; + } + + public DDLWork(HashSet inputs, HashSet outputs, + CreateOrAlterWMMappingDesc wmMappingDesc) { + this(inputs, outputs); + this.wmMappingDesc = wmMappingDesc; + } + + public DDLWork(HashSet inputs, HashSet outputs, + DropWMMappingDesc dropWMMappingDesc) { + this(inputs, outputs); + this.dropWMMappingDesc = dropWMMappingDesc; + } + + public DDLWork(HashSet inputs, HashSet outputs, + CreateOrDropTriggerToPoolMappingDesc triggerToPoolMappingDesc) { + this(inputs, outputs); + this.triggerToPoolMappingDesc = triggerToPoolMappingDesc; } /** @@ -1343,4 +1381,44 @@ public DropWMTriggerDesc getDropWMTriggerDesc() { public void setDropWMTriggerDesc(DropWMTriggerDesc dropWMTriggerDesc) { this.dropWMTriggerDesc = dropWMTriggerDesc; } + + public CreateOrAlterWMPoolDesc getWmPoolDesc() { + return wmPoolDesc; + } + + public void setWmPoolDesc(CreateOrAlterWMPoolDesc wmPoolDesc) { + this.wmPoolDesc = wmPoolDesc; + } + + public DropWMPoolDesc getDropWMPoolDesc() { + return dropWMPoolDesc; + } + + public void setDropWMPoolDesc(DropWMPoolDesc dropWMPoolDesc) { + this.dropWMPoolDesc = dropWMPoolDesc; + } + + public CreateOrAlterWMMappingDesc getWmMappingDesc() { + return wmMappingDesc; + } + + public void setWmMappingDesc(CreateOrAlterWMMappingDesc wmMappingDesc) { + this.wmMappingDesc = wmMappingDesc; + } + + public DropWMMappingDesc getDropWMMappingDesc() { + return dropWMMappingDesc; + } + + public void setDropWMMappingDesc(DropWMMappingDesc dropWMMappingDesc) { + this.dropWMMappingDesc = dropWMMappingDesc; + } + + public CreateOrDropTriggerToPoolMappingDesc getTriggerToPoolMappingDesc() { + return triggerToPoolMappingDesc; + } + + public void setTriggerToPoolMappingDesc(CreateOrDropTriggerToPoolMappingDesc triggerToPoolMappingDesc) { + this.triggerToPoolMappingDesc = triggerToPoolMappingDesc; + } } diff --git ql/src/java/org/apache/hadoop/hive/ql/plan/DropWMMappingDesc.java ql/src/java/org/apache/hadoop/hive/ql/plan/DropWMMappingDesc.java new file mode 100644 index 0000000000..889713b0d4 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/plan/DropWMMappingDesc.java @@ -0,0 +1,54 @@ +package org.apache.hadoop.hive.ql.plan; + +import java.io.Serializable; + +import org.apache.hadoop.hive.ql.plan.Explain.Level; + +@Explain(displayName = "Drop resource plan", + explainLevels = { Level.USER, Level.DEFAULT, Level.EXTENDED }) +public class DropWMMappingDesc extends DDLDesc implements Serializable { + private static final long serialVersionUID = -1567558687529244218L; + + private String resourcePlanName; + private String entityType; + private String entityName; + + public DropWMMappingDesc() {} + + public DropWMMappingDesc(String resourcePlanName, String entityType, String entityName) { + super(); + this.resourcePlanName = resourcePlanName; + this.entityType = entityType; + this.entityName = entityName; + } + + @Explain(displayName = "resourcePlanName", + explainLevels = { Level.USER, Level.DEFAULT, Level.EXTENDED }) + public String getResourcePlanName() { + return resourcePlanName; + } + + public void setResourcePlanName(String resourcePlanName) { + this.resourcePlanName = resourcePlanName; + } + + @Explain(displayName = "entityType", + explainLevels = { Level.USER, Level.DEFAULT, Level.EXTENDED }) + public String getEntityType() { + return entityType; + } + + public void setEntityType(String entityType) { + this.entityType = entityType; + } + + @Explain(displayName = "entityName", + explainLevels = { Level.USER, Level.DEFAULT, Level.EXTENDED }) + public String getEntityName() { + return entityName; + } + + public void setEntityName(String entityName) { + this.entityName = entityName; + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/plan/DropWMPoolDesc.java ql/src/java/org/apache/hadoop/hive/ql/plan/DropWMPoolDesc.java new file mode 100644 index 0000000000..ff1bedd0c4 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/plan/DropWMPoolDesc.java @@ -0,0 +1,33 @@ +package org.apache.hadoop.hive.ql.plan; + +import java.io.Serializable; + +public class DropWMPoolDesc extends DDLDesc implements Serializable { + private static final long serialVersionUID = -2608462103392563252L; + + private String resourcePlanName; + private String poolPath; + + public DropWMPoolDesc() {} + + public DropWMPoolDesc(String resourcePlanName, String poolPath) { + this.resourcePlanName = resourcePlanName; + this.poolPath = poolPath; + } + + public String getResourcePlanName() { + return resourcePlanName; + } + + public void setResourcePlanName(String resourcePlanName) { + this.resourcePlanName = resourcePlanName; + } + + public String getPoolPath() { + return poolPath; + } + + public void setPoolPath(String poolPath) { + this.poolPath = poolPath; + } +} 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 1ce1c76f37..226214f34a 100644 --- ql/src/java/org/apache/hadoop/hive/ql/plan/HiveOperation.java +++ ql/src/java/org/apache/hadoop/hive/ql/plan/HiveOperation.java @@ -146,7 +146,14 @@ 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); + DROP_TRIGGER("DROP TRIGGER", null, null, false, false), + CREATE_POOL("CREATE POOL", null, null, false, false), + ALTER_POOL("ALTER POOL", null, null, false, false), + DROP_POOL("DROP POOL", null, null, false, false), + CREATE_MAPPING("CREATE MAPPING", null, null, false, false), + ALTER_MAPPING("ALTER MAPPING", null, null, false, false), + DROP_MAPPING("DROP MAPPING", 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 ba1d01f3c6..6ac6d6ea42 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 @@ -139,6 +139,12 @@ CREATE_TRIGGER, ALTER_TRIGGER, DROP_TRIGGER, + CREATE_POOL, + ALTER_POOL, + DROP_POOL, + CREATE_MAPPING, + ALTER_MAPPING, + DROP_MAPPING, // ==== Hive command operation types starts here ==== // SET, diff --git ql/src/java/org/apache/hadoop/hive/ql/security/authorization/plugin/sqlstd/Operation2Privilege.java ql/src/java/org/apache/hadoop/hive/ql/security/authorization/plugin/sqlstd/Operation2Privilege.java index dc20d16df5..5b09ae8514 100644 --- ql/src/java/org/apache/hadoop/hive/ql/security/authorization/plugin/sqlstd/Operation2Privilege.java +++ ql/src/java/org/apache/hadoop/hive/ql/security/authorization/plugin/sqlstd/Operation2Privilege.java @@ -317,6 +317,12 @@ public HivePrivilegeObjectType getObjectType() { adminPrivOps.add(HiveOperationType.CREATE_TRIGGER); adminPrivOps.add(HiveOperationType.ALTER_TRIGGER); adminPrivOps.add(HiveOperationType.DROP_TRIGGER); + adminPrivOps.add(HiveOperationType.CREATE_POOL); + adminPrivOps.add(HiveOperationType.ALTER_POOL); + adminPrivOps.add(HiveOperationType.DROP_POOL); + adminPrivOps.add(HiveOperationType.CREATE_MAPPING); + adminPrivOps.add(HiveOperationType.ALTER_MAPPING); + adminPrivOps.add(HiveOperationType.DROP_MAPPING); // operations require select priv op2Priv.put(HiveOperationType.SHOWCOLUMNS, PrivRequirement.newIOPrivRequirement @@ -482,6 +488,12 @@ public HivePrivilegeObjectType getObjectType() { op2Priv.put(HiveOperationType.CREATE_TRIGGER, PrivRequirement.newIOPrivRequirement(null, null)); op2Priv.put(HiveOperationType.ALTER_TRIGGER, PrivRequirement.newIOPrivRequirement(null, null)); op2Priv.put(HiveOperationType.DROP_TRIGGER, PrivRequirement.newIOPrivRequirement(null, null)); + op2Priv.put(HiveOperationType.CREATE_POOL, PrivRequirement.newIOPrivRequirement(null, null)); + op2Priv.put(HiveOperationType.ALTER_POOL, PrivRequirement.newIOPrivRequirement(null, null)); + op2Priv.put(HiveOperationType.DROP_POOL, PrivRequirement.newIOPrivRequirement(null, null)); + op2Priv.put(HiveOperationType.CREATE_MAPPING, PrivRequirement.newIOPrivRequirement(null, null)); + op2Priv.put(HiveOperationType.ALTER_MAPPING, PrivRequirement.newIOPrivRequirement(null, null)); + op2Priv.put(HiveOperationType.DROP_MAPPING, PrivRequirement.newIOPrivRequirement(null, null)); } /** diff --git ql/src/test/queries/clientpositive/resourceplan.q ql/src/test/queries/clientpositive/resourceplan.q index f1be695cb8..e8201c634a 100644 --- ql/src/test/queries/clientpositive/resourceplan.q +++ ql/src/test/queries/clientpositive/resourceplan.q @@ -146,3 +146,30 @@ ALTER TRIGGER plan_1.trigger_2 WHEN BYTES_READ = 1000K DO KILL; 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; + + +-- +-- Create pool command. +-- + +-- Cannot create pool in active plans. +CREATE POOL plan_1.default WITH + ALLOC_FRACTION 1.0 QUERY_PARALLELISM 5 SCHEDULING_POLICY 'default'; + +CREATE POOL plan_2.default WITH + ALLOC_FRACTION 1.0 QUERY_PARALLELISM 5 SCHEDULING_POLICY 'default'; +SELECT * FROM SYS.WM_POOLS; + +CREATE POOL plan_2.default.c1 WITH + ALLOC_FRACTION 0.3 QUERY_PARALLELISM 3 SCHEDULING_POLICY 'priority'; + +CREATE POOL plan_2.default.c2 WITH + ALLOC_FRACTION 0.7 QUERY_PARALLELISM 2 SCHEDULING_POLICY 'fair'; + +ALTER POOL plan_2.default.c2 SET ALLOC_FRACTION = 0.2; + +ALTER POOL plan_2.default SET path = def; +SELECT * FROM SYS.WM_POOLS; + +DROP POOL plan_2.default; +SELECT * FROM SYS.WM_POOLS; diff --git standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp index bf1af88436..49e658e1f7 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 _size956; - ::apache::thrift::protocol::TType _etype959; - xfer += iprot->readListBegin(_etype959, _size956); - this->success.resize(_size956); - uint32_t _i960; - for (_i960 = 0; _i960 < _size956; ++_i960) + uint32_t _size976; + ::apache::thrift::protocol::TType _etype979; + xfer += iprot->readListBegin(_etype979, _size976); + this->success.resize(_size976); + uint32_t _i980; + for (_i980 = 0; _i980 < _size976; ++_i980) { - xfer += iprot->readString(this->success[_i960]); + xfer += iprot->readString(this->success[_i980]); } 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 _iter961; - for (_iter961 = this->success.begin(); _iter961 != this->success.end(); ++_iter961) + std::vector ::const_iterator _iter981; + for (_iter981 = this->success.begin(); _iter981 != this->success.end(); ++_iter981) { - xfer += oprot->writeString((*_iter961)); + xfer += oprot->writeString((*_iter981)); } 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 _size962; - ::apache::thrift::protocol::TType _etype965; - xfer += iprot->readListBegin(_etype965, _size962); - (*(this->success)).resize(_size962); - uint32_t _i966; - for (_i966 = 0; _i966 < _size962; ++_i966) + 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) { - xfer += iprot->readString((*(this->success))[_i966]); + xfer += iprot->readString((*(this->success))[_i986]); } 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 _size967; - ::apache::thrift::protocol::TType _etype970; - xfer += iprot->readListBegin(_etype970, _size967); - this->success.resize(_size967); - uint32_t _i971; - for (_i971 = 0; _i971 < _size967; ++_i971) + uint32_t _size987; + ::apache::thrift::protocol::TType _etype990; + xfer += iprot->readListBegin(_etype990, _size987); + this->success.resize(_size987); + uint32_t _i991; + for (_i991 = 0; _i991 < _size987; ++_i991) { - xfer += iprot->readString(this->success[_i971]); + xfer += iprot->readString(this->success[_i991]); } 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 _iter972; - for (_iter972 = this->success.begin(); _iter972 != this->success.end(); ++_iter972) + std::vector ::const_iterator _iter992; + for (_iter992 = this->success.begin(); _iter992 != this->success.end(); ++_iter992) { - xfer += oprot->writeString((*_iter972)); + xfer += oprot->writeString((*_iter992)); } 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 _size973; - ::apache::thrift::protocol::TType _etype976; - xfer += iprot->readListBegin(_etype976, _size973); - (*(this->success)).resize(_size973); - uint32_t _i977; - for (_i977 = 0; _i977 < _size973; ++_i977) + 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 += iprot->readString((*(this->success))[_i977]); + xfer += iprot->readString((*(this->success))[_i997]); } 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 _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) + uint32_t _size998; + ::apache::thrift::protocol::TType _ktype999; + ::apache::thrift::protocol::TType _vtype1000; + xfer += iprot->readMapBegin(_ktype999, _vtype1000, _size998); + uint32_t _i1002; + for (_i1002 = 0; _i1002 < _size998; ++_i1002) { - std::string _key983; - xfer += iprot->readString(_key983); - Type& _val984 = this->success[_key983]; - xfer += _val984.read(iprot); + std::string _key1003; + xfer += iprot->readString(_key1003); + Type& _val1004 = this->success[_key1003]; + xfer += _val1004.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 _iter985; - for (_iter985 = this->success.begin(); _iter985 != this->success.end(); ++_iter985) + std::map ::const_iterator _iter1005; + for (_iter1005 = this->success.begin(); _iter1005 != this->success.end(); ++_iter1005) { - xfer += oprot->writeString(_iter985->first); - xfer += _iter985->second.write(oprot); + xfer += oprot->writeString(_iter1005->first); + xfer += _iter1005->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 _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) + uint32_t _size1006; + ::apache::thrift::protocol::TType _ktype1007; + ::apache::thrift::protocol::TType _vtype1008; + xfer += iprot->readMapBegin(_ktype1007, _vtype1008, _size1006); + uint32_t _i1010; + for (_i1010 = 0; _i1010 < _size1006; ++_i1010) { - std::string _key991; - xfer += iprot->readString(_key991); - Type& _val992 = (*(this->success))[_key991]; - xfer += _val992.read(iprot); + std::string _key1011; + xfer += iprot->readString(_key1011); + Type& _val1012 = (*(this->success))[_key1011]; + xfer += _val1012.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 _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 _size1013; + ::apache::thrift::protocol::TType _etype1016; + xfer += iprot->readListBegin(_etype1016, _size1013); + this->success.resize(_size1013); + uint32_t _i1017; + for (_i1017 = 0; _i1017 < _size1013; ++_i1017) { - xfer += this->success[_i997].read(iprot); + xfer += this->success[_i1017].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 _iter998; - for (_iter998 = this->success.begin(); _iter998 != this->success.end(); ++_iter998) + std::vector ::const_iterator _iter1018; + for (_iter1018 = this->success.begin(); _iter1018 != this->success.end(); ++_iter1018) { - xfer += (*_iter998).write(oprot); + xfer += (*_iter1018).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 _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 _size1019; + ::apache::thrift::protocol::TType _etype1022; + xfer += iprot->readListBegin(_etype1022, _size1019); + (*(this->success)).resize(_size1019); + uint32_t _i1023; + for (_i1023 = 0; _i1023 < _size1019; ++_i1023) { - xfer += (*(this->success))[_i1003].read(iprot); + xfer += (*(this->success))[_i1023].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 _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 _size1024; + ::apache::thrift::protocol::TType _etype1027; + xfer += iprot->readListBegin(_etype1027, _size1024); + this->success.resize(_size1024); + uint32_t _i1028; + for (_i1028 = 0; _i1028 < _size1024; ++_i1028) { - xfer += this->success[_i1008].read(iprot); + xfer += this->success[_i1028].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 _iter1009; - for (_iter1009 = this->success.begin(); _iter1009 != this->success.end(); ++_iter1009) + std::vector ::const_iterator _iter1029; + for (_iter1029 = this->success.begin(); _iter1029 != this->success.end(); ++_iter1029) { - xfer += (*_iter1009).write(oprot); + xfer += (*_iter1029).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 _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 _size1030; + ::apache::thrift::protocol::TType _etype1033; + xfer += iprot->readListBegin(_etype1033, _size1030); + (*(this->success)).resize(_size1030); + uint32_t _i1034; + for (_i1034 = 0; _i1034 < _size1030; ++_i1034) { - xfer += (*(this->success))[_i1014].read(iprot); + xfer += (*(this->success))[_i1034].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 _size1015; - ::apache::thrift::protocol::TType _etype1018; - xfer += iprot->readListBegin(_etype1018, _size1015); - this->success.resize(_size1015); - uint32_t _i1019; - for (_i1019 = 0; _i1019 < _size1015; ++_i1019) + uint32_t _size1035; + ::apache::thrift::protocol::TType _etype1038; + xfer += iprot->readListBegin(_etype1038, _size1035); + this->success.resize(_size1035); + uint32_t _i1039; + for (_i1039 = 0; _i1039 < _size1035; ++_i1039) { - xfer += this->success[_i1019].read(iprot); + xfer += this->success[_i1039].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 _iter1020; - for (_iter1020 = this->success.begin(); _iter1020 != this->success.end(); ++_iter1020) + std::vector ::const_iterator _iter1040; + for (_iter1040 = this->success.begin(); _iter1040 != this->success.end(); ++_iter1040) { - xfer += (*_iter1020).write(oprot); + xfer += (*_iter1040).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 _size1021; - ::apache::thrift::protocol::TType _etype1024; - xfer += iprot->readListBegin(_etype1024, _size1021); - (*(this->success)).resize(_size1021); - uint32_t _i1025; - for (_i1025 = 0; _i1025 < _size1021; ++_i1025) + uint32_t _size1041; + ::apache::thrift::protocol::TType _etype1044; + xfer += iprot->readListBegin(_etype1044, _size1041); + (*(this->success)).resize(_size1041); + uint32_t _i1045; + for (_i1045 = 0; _i1045 < _size1041; ++_i1045) { - xfer += (*(this->success))[_i1025].read(iprot); + xfer += (*(this->success))[_i1045].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 _size1026; - ::apache::thrift::protocol::TType _etype1029; - xfer += iprot->readListBegin(_etype1029, _size1026); - this->success.resize(_size1026); - uint32_t _i1030; - for (_i1030 = 0; _i1030 < _size1026; ++_i1030) + uint32_t _size1046; + ::apache::thrift::protocol::TType _etype1049; + xfer += iprot->readListBegin(_etype1049, _size1046); + this->success.resize(_size1046); + uint32_t _i1050; + for (_i1050 = 0; _i1050 < _size1046; ++_i1050) { - xfer += this->success[_i1030].read(iprot); + xfer += this->success[_i1050].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 _iter1031; - for (_iter1031 = this->success.begin(); _iter1031 != this->success.end(); ++_iter1031) + std::vector ::const_iterator _iter1051; + for (_iter1051 = this->success.begin(); _iter1051 != this->success.end(); ++_iter1051) { - xfer += (*_iter1031).write(oprot); + xfer += (*_iter1051).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 _size1032; - ::apache::thrift::protocol::TType _etype1035; - xfer += iprot->readListBegin(_etype1035, _size1032); - (*(this->success)).resize(_size1032); - uint32_t _i1036; - for (_i1036 = 0; _i1036 < _size1032; ++_i1036) + uint32_t _size1052; + ::apache::thrift::protocol::TType _etype1055; + xfer += iprot->readListBegin(_etype1055, _size1052); + (*(this->success)).resize(_size1052); + uint32_t _i1056; + for (_i1056 = 0; _i1056 < _size1052; ++_i1056) { - xfer += (*(this->success))[_i1036].read(iprot); + xfer += (*(this->success))[_i1056].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 _size1037; - ::apache::thrift::protocol::TType _etype1040; - xfer += iprot->readListBegin(_etype1040, _size1037); - this->primaryKeys.resize(_size1037); - uint32_t _i1041; - for (_i1041 = 0; _i1041 < _size1037; ++_i1041) + uint32_t _size1057; + ::apache::thrift::protocol::TType _etype1060; + xfer += iprot->readListBegin(_etype1060, _size1057); + this->primaryKeys.resize(_size1057); + uint32_t _i1061; + for (_i1061 = 0; _i1061 < _size1057; ++_i1061) { - xfer += this->primaryKeys[_i1041].read(iprot); + xfer += this->primaryKeys[_i1061].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 _size1042; - ::apache::thrift::protocol::TType _etype1045; - xfer += iprot->readListBegin(_etype1045, _size1042); - this->foreignKeys.resize(_size1042); - uint32_t _i1046; - for (_i1046 = 0; _i1046 < _size1042; ++_i1046) + uint32_t _size1062; + ::apache::thrift::protocol::TType _etype1065; + xfer += iprot->readListBegin(_etype1065, _size1062); + this->foreignKeys.resize(_size1062); + uint32_t _i1066; + for (_i1066 = 0; _i1066 < _size1062; ++_i1066) { - xfer += this->foreignKeys[_i1046].read(iprot); + xfer += this->foreignKeys[_i1066].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 _size1047; - ::apache::thrift::protocol::TType _etype1050; - xfer += iprot->readListBegin(_etype1050, _size1047); - this->uniqueConstraints.resize(_size1047); - uint32_t _i1051; - for (_i1051 = 0; _i1051 < _size1047; ++_i1051) + uint32_t _size1067; + ::apache::thrift::protocol::TType _etype1070; + xfer += iprot->readListBegin(_etype1070, _size1067); + this->uniqueConstraints.resize(_size1067); + uint32_t _i1071; + for (_i1071 = 0; _i1071 < _size1067; ++_i1071) { - xfer += this->uniqueConstraints[_i1051].read(iprot); + xfer += this->uniqueConstraints[_i1071].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 _size1052; - ::apache::thrift::protocol::TType _etype1055; - xfer += iprot->readListBegin(_etype1055, _size1052); - this->notNullConstraints.resize(_size1052); - uint32_t _i1056; - for (_i1056 = 0; _i1056 < _size1052; ++_i1056) + uint32_t _size1072; + ::apache::thrift::protocol::TType _etype1075; + xfer += iprot->readListBegin(_etype1075, _size1072); + this->notNullConstraints.resize(_size1072); + uint32_t _i1076; + for (_i1076 = 0; _i1076 < _size1072; ++_i1076) { - xfer += this->notNullConstraints[_i1056].read(iprot); + xfer += this->notNullConstraints[_i1076].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 _iter1057; - for (_iter1057 = this->primaryKeys.begin(); _iter1057 != this->primaryKeys.end(); ++_iter1057) + std::vector ::const_iterator _iter1077; + for (_iter1077 = this->primaryKeys.begin(); _iter1077 != this->primaryKeys.end(); ++_iter1077) { - xfer += (*_iter1057).write(oprot); + xfer += (*_iter1077).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 _iter1058; - for (_iter1058 = this->foreignKeys.begin(); _iter1058 != this->foreignKeys.end(); ++_iter1058) + std::vector ::const_iterator _iter1078; + for (_iter1078 = this->foreignKeys.begin(); _iter1078 != this->foreignKeys.end(); ++_iter1078) { - xfer += (*_iter1058).write(oprot); + xfer += (*_iter1078).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 _iter1059; - for (_iter1059 = this->uniqueConstraints.begin(); _iter1059 != this->uniqueConstraints.end(); ++_iter1059) + std::vector ::const_iterator _iter1079; + for (_iter1079 = this->uniqueConstraints.begin(); _iter1079 != this->uniqueConstraints.end(); ++_iter1079) { - xfer += (*_iter1059).write(oprot); + xfer += (*_iter1079).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 _iter1060; - for (_iter1060 = this->notNullConstraints.begin(); _iter1060 != this->notNullConstraints.end(); ++_iter1060) + std::vector ::const_iterator _iter1080; + for (_iter1080 = this->notNullConstraints.begin(); _iter1080 != this->notNullConstraints.end(); ++_iter1080) { - xfer += (*_iter1060).write(oprot); + xfer += (*_iter1080).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 _iter1061; - for (_iter1061 = (*(this->primaryKeys)).begin(); _iter1061 != (*(this->primaryKeys)).end(); ++_iter1061) + std::vector ::const_iterator _iter1081; + for (_iter1081 = (*(this->primaryKeys)).begin(); _iter1081 != (*(this->primaryKeys)).end(); ++_iter1081) { - xfer += (*_iter1061).write(oprot); + xfer += (*_iter1081).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 _iter1062; - for (_iter1062 = (*(this->foreignKeys)).begin(); _iter1062 != (*(this->foreignKeys)).end(); ++_iter1062) + std::vector ::const_iterator _iter1082; + for (_iter1082 = (*(this->foreignKeys)).begin(); _iter1082 != (*(this->foreignKeys)).end(); ++_iter1082) { - xfer += (*_iter1062).write(oprot); + xfer += (*_iter1082).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 _iter1063; - for (_iter1063 = (*(this->uniqueConstraints)).begin(); _iter1063 != (*(this->uniqueConstraints)).end(); ++_iter1063) + std::vector ::const_iterator _iter1083; + for (_iter1083 = (*(this->uniqueConstraints)).begin(); _iter1083 != (*(this->uniqueConstraints)).end(); ++_iter1083) { - xfer += (*_iter1063).write(oprot); + xfer += (*_iter1083).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 _iter1064; - for (_iter1064 = (*(this->notNullConstraints)).begin(); _iter1064 != (*(this->notNullConstraints)).end(); ++_iter1064) + std::vector ::const_iterator _iter1084; + for (_iter1084 = (*(this->notNullConstraints)).begin(); _iter1084 != (*(this->notNullConstraints)).end(); ++_iter1084) { - xfer += (*_iter1064).write(oprot); + xfer += (*_iter1084).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 _size1065; - ::apache::thrift::protocol::TType _etype1068; - xfer += iprot->readListBegin(_etype1068, _size1065); - this->partNames.resize(_size1065); - uint32_t _i1069; - for (_i1069 = 0; _i1069 < _size1065; ++_i1069) + uint32_t _size1085; + ::apache::thrift::protocol::TType _etype1088; + xfer += iprot->readListBegin(_etype1088, _size1085); + this->partNames.resize(_size1085); + uint32_t _i1089; + for (_i1089 = 0; _i1089 < _size1085; ++_i1089) { - xfer += iprot->readString(this->partNames[_i1069]); + xfer += iprot->readString(this->partNames[_i1089]); } 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 _iter1070; - for (_iter1070 = this->partNames.begin(); _iter1070 != this->partNames.end(); ++_iter1070) + std::vector ::const_iterator _iter1090; + for (_iter1090 = this->partNames.begin(); _iter1090 != this->partNames.end(); ++_iter1090) { - xfer += oprot->writeString((*_iter1070)); + xfer += oprot->writeString((*_iter1090)); } 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 _iter1071; - for (_iter1071 = (*(this->partNames)).begin(); _iter1071 != (*(this->partNames)).end(); ++_iter1071) + std::vector ::const_iterator _iter1091; + for (_iter1091 = (*(this->partNames)).begin(); _iter1091 != (*(this->partNames)).end(); ++_iter1091) { - xfer += oprot->writeString((*_iter1071)); + xfer += oprot->writeString((*_iter1091)); } xfer += oprot->writeListEnd(); } @@ -6804,285 +6804,285 @@ uint32_t ThriftHiveMetastore_get_tables_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - 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[_i1076]); - } - 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_get_tables_result::write(::apache::thrift::protocol::TProtocol* oprot) const { - - uint32_t xfer = 0; - - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_tables_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 _iter1077; - for (_iter1077 = this->success.begin(); _iter1077 != this->success.end(); ++_iter1077) - { - xfer += oprot->writeString((*_iter1077)); - } - 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_get_tables_presult::~ThriftHiveMetastore_get_tables_presult() throw() { -} - - -uint32_t ThriftHiveMetastore_get_tables_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 _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))[_i1082]); - } - 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_get_tables_by_type_args::~ThriftHiveMetastore_get_tables_by_type_args() throw() { -} - - -uint32_t ThriftHiveMetastore_get_tables_by_type_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->db_name); - this->__isset.db_name = true; - } else { - xfer += iprot->skip(ftype); - } - break; - case 2: - if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->pattern); - this->__isset.pattern = true; - } else { - xfer += iprot->skip(ftype); - } - break; - case 3: - if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->tableType); - this->__isset.tableType = true; - } else { - xfer += iprot->skip(ftype); - } - break; - default: - xfer += iprot->skip(ftype); - break; - } - xfer += iprot->readFieldEnd(); - } - - xfer += iprot->readStructEnd(); - - return xfer; -} - -uint32_t ThriftHiveMetastore_get_tables_by_type_args::write(::apache::thrift::protocol::TProtocol* oprot) const { - uint32_t xfer = 0; - apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_tables_by_type_args"); - - xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString(this->db_name); - xfer += oprot->writeFieldEnd(); - - xfer += oprot->writeFieldBegin("pattern", ::apache::thrift::protocol::T_STRING, 2); - xfer += oprot->writeString(this->pattern); - xfer += oprot->writeFieldEnd(); - - xfer += oprot->writeFieldBegin("tableType", ::apache::thrift::protocol::T_STRING, 3); - xfer += oprot->writeString(this->tableType); - xfer += oprot->writeFieldEnd(); - - xfer += oprot->writeFieldStop(); - xfer += oprot->writeStructEnd(); - return xfer; -} - - -ThriftHiveMetastore_get_tables_by_type_pargs::~ThriftHiveMetastore_get_tables_by_type_pargs() throw() { -} - - -uint32_t ThriftHiveMetastore_get_tables_by_type_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { - uint32_t xfer = 0; - apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_tables_by_type_pargs"); - - xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString((*(this->db_name))); - xfer += oprot->writeFieldEnd(); - - xfer += oprot->writeFieldBegin("pattern", ::apache::thrift::protocol::T_STRING, 2); - xfer += oprot->writeString((*(this->pattern))); - xfer += oprot->writeFieldEnd(); - - xfer += oprot->writeFieldBegin("tableType", ::apache::thrift::protocol::T_STRING, 3); - xfer += oprot->writeString((*(this->tableType))); - xfer += oprot->writeFieldEnd(); - - xfer += oprot->writeFieldStop(); - xfer += oprot->writeStructEnd(); - return xfer; -} - - -ThriftHiveMetastore_get_tables_by_type_result::~ThriftHiveMetastore_get_tables_by_type_result() throw() { -} - - -uint32_t ThriftHiveMetastore_get_tables_by_type_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 _size1083; - ::apache::thrift::protocol::TType _etype1086; - xfer += iprot->readListBegin(_etype1086, _size1083); - this->success.resize(_size1083); - uint32_t _i1087; - for (_i1087 = 0; _i1087 < _size1083; ++_i1087) + uint32_t _size1092; + ::apache::thrift::protocol::TType _etype1095; + xfer += iprot->readListBegin(_etype1095, _size1092); + this->success.resize(_size1092); + uint32_t _i1096; + for (_i1096 = 0; _i1096 < _size1092; ++_i1096) + { + xfer += iprot->readString(this->success[_i1096]); + } + 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_get_tables_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_tables_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 _iter1097; + for (_iter1097 = this->success.begin(); _iter1097 != this->success.end(); ++_iter1097) + { + xfer += oprot->writeString((*_iter1097)); + } + 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_get_tables_presult::~ThriftHiveMetastore_get_tables_presult() throw() { +} + + +uint32_t ThriftHiveMetastore_get_tables_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 _size1098; + ::apache::thrift::protocol::TType _etype1101; + xfer += iprot->readListBegin(_etype1101, _size1098); + (*(this->success)).resize(_size1098); + uint32_t _i1102; + for (_i1102 = 0; _i1102 < _size1098; ++_i1102) + { + xfer += iprot->readString((*(this->success))[_i1102]); + } + 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_get_tables_by_type_args::~ThriftHiveMetastore_get_tables_by_type_args() throw() { +} + + +uint32_t ThriftHiveMetastore_get_tables_by_type_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->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->pattern); + this->__isset.pattern = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tableType); + this->__isset.tableType = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_tables_by_type_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_tables_by_type_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("pattern", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->pattern); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tableType", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->tableType); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_tables_by_type_pargs::~ThriftHiveMetastore_get_tables_by_type_pargs() throw() { +} + + +uint32_t ThriftHiveMetastore_get_tables_by_type_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_tables_by_type_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("pattern", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->pattern))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tableType", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString((*(this->tableType))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_tables_by_type_result::~ThriftHiveMetastore_get_tables_by_type_result() throw() { +} + + +uint32_t ThriftHiveMetastore_get_tables_by_type_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 _size1103; + ::apache::thrift::protocol::TType _etype1106; + xfer += iprot->readListBegin(_etype1106, _size1103); + this->success.resize(_size1103); + uint32_t _i1107; + for (_i1107 = 0; _i1107 < _size1103; ++_i1107) { - xfer += iprot->readString(this->success[_i1087]); + xfer += iprot->readString(this->success[_i1107]); } 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 _iter1088; - for (_iter1088 = this->success.begin(); _iter1088 != this->success.end(); ++_iter1088) + std::vector ::const_iterator _iter1108; + for (_iter1108 = this->success.begin(); _iter1108 != this->success.end(); ++_iter1108) { - xfer += oprot->writeString((*_iter1088)); + xfer += oprot->writeString((*_iter1108)); } 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 _size1089; - ::apache::thrift::protocol::TType _etype1092; - xfer += iprot->readListBegin(_etype1092, _size1089); - (*(this->success)).resize(_size1089); - uint32_t _i1093; - for (_i1093 = 0; _i1093 < _size1089; ++_i1093) + uint32_t _size1109; + ::apache::thrift::protocol::TType _etype1112; + xfer += iprot->readListBegin(_etype1112, _size1109); + (*(this->success)).resize(_size1109); + uint32_t _i1113; + for (_i1113 = 0; _i1113 < _size1109; ++_i1113) { - xfer += iprot->readString((*(this->success))[_i1093]); + xfer += iprot->readString((*(this->success))[_i1113]); } 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 _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) + uint32_t _size1114; + ::apache::thrift::protocol::TType _etype1117; + xfer += iprot->readListBegin(_etype1117, _size1114); + this->tbl_types.resize(_size1114); + uint32_t _i1118; + for (_i1118 = 0; _i1118 < _size1114; ++_i1118) { - xfer += iprot->readString(this->tbl_types[_i1098]); + xfer += iprot->readString(this->tbl_types[_i1118]); } 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 _iter1099; - for (_iter1099 = this->tbl_types.begin(); _iter1099 != this->tbl_types.end(); ++_iter1099) + std::vector ::const_iterator _iter1119; + for (_iter1119 = this->tbl_types.begin(); _iter1119 != this->tbl_types.end(); ++_iter1119) { - xfer += oprot->writeString((*_iter1099)); + xfer += oprot->writeString((*_iter1119)); } 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 _iter1100; - for (_iter1100 = (*(this->tbl_types)).begin(); _iter1100 != (*(this->tbl_types)).end(); ++_iter1100) + std::vector ::const_iterator _iter1120; + for (_iter1120 = (*(this->tbl_types)).begin(); _iter1120 != (*(this->tbl_types)).end(); ++_iter1120) { - xfer += oprot->writeString((*_iter1100)); + xfer += oprot->writeString((*_iter1120)); } 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 _size1101; - ::apache::thrift::protocol::TType _etype1104; - xfer += iprot->readListBegin(_etype1104, _size1101); - this->success.resize(_size1101); - uint32_t _i1105; - for (_i1105 = 0; _i1105 < _size1101; ++_i1105) + uint32_t _size1121; + ::apache::thrift::protocol::TType _etype1124; + xfer += iprot->readListBegin(_etype1124, _size1121); + this->success.resize(_size1121); + uint32_t _i1125; + for (_i1125 = 0; _i1125 < _size1121; ++_i1125) { - xfer += this->success[_i1105].read(iprot); + xfer += this->success[_i1125].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 _iter1106; - for (_iter1106 = this->success.begin(); _iter1106 != this->success.end(); ++_iter1106) + std::vector ::const_iterator _iter1126; + for (_iter1126 = this->success.begin(); _iter1126 != this->success.end(); ++_iter1126) { - xfer += (*_iter1106).write(oprot); + xfer += (*_iter1126).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 _size1107; - ::apache::thrift::protocol::TType _etype1110; - xfer += iprot->readListBegin(_etype1110, _size1107); - (*(this->success)).resize(_size1107); - uint32_t _i1111; - for (_i1111 = 0; _i1111 < _size1107; ++_i1111) + uint32_t _size1127; + ::apache::thrift::protocol::TType _etype1130; + xfer += iprot->readListBegin(_etype1130, _size1127); + (*(this->success)).resize(_size1127); + uint32_t _i1131; + for (_i1131 = 0; _i1131 < _size1127; ++_i1131) { - xfer += (*(this->success))[_i1111].read(iprot); + xfer += (*(this->success))[_i1131].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 _size1112; - ::apache::thrift::protocol::TType _etype1115; - xfer += iprot->readListBegin(_etype1115, _size1112); - this->success.resize(_size1112); - uint32_t _i1116; - for (_i1116 = 0; _i1116 < _size1112; ++_i1116) + uint32_t _size1132; + ::apache::thrift::protocol::TType _etype1135; + xfer += iprot->readListBegin(_etype1135, _size1132); + this->success.resize(_size1132); + uint32_t _i1136; + for (_i1136 = 0; _i1136 < _size1132; ++_i1136) { - xfer += iprot->readString(this->success[_i1116]); + xfer += iprot->readString(this->success[_i1136]); } 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 _iter1117; - for (_iter1117 = this->success.begin(); _iter1117 != this->success.end(); ++_iter1117) + std::vector ::const_iterator _iter1137; + for (_iter1137 = this->success.begin(); _iter1137 != this->success.end(); ++_iter1137) { - xfer += oprot->writeString((*_iter1117)); + xfer += oprot->writeString((*_iter1137)); } 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 _size1118; - ::apache::thrift::protocol::TType _etype1121; - xfer += iprot->readListBegin(_etype1121, _size1118); - (*(this->success)).resize(_size1118); - uint32_t _i1122; - for (_i1122 = 0; _i1122 < _size1118; ++_i1122) + uint32_t _size1138; + ::apache::thrift::protocol::TType _etype1141; + xfer += iprot->readListBegin(_etype1141, _size1138); + (*(this->success)).resize(_size1138); + uint32_t _i1142; + for (_i1142 = 0; _i1142 < _size1138; ++_i1142) { - xfer += iprot->readString((*(this->success))[_i1122]); + xfer += iprot->readString((*(this->success))[_i1142]); } 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 _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) + uint32_t _size1143; + ::apache::thrift::protocol::TType _etype1146; + xfer += iprot->readListBegin(_etype1146, _size1143); + this->tbl_names.resize(_size1143); + uint32_t _i1147; + for (_i1147 = 0; _i1147 < _size1143; ++_i1147) { - xfer += iprot->readString(this->tbl_names[_i1127]); + xfer += iprot->readString(this->tbl_names[_i1147]); } 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 _iter1128; - for (_iter1128 = this->tbl_names.begin(); _iter1128 != this->tbl_names.end(); ++_iter1128) + std::vector ::const_iterator _iter1148; + for (_iter1148 = this->tbl_names.begin(); _iter1148 != this->tbl_names.end(); ++_iter1148) { - xfer += oprot->writeString((*_iter1128)); + xfer += oprot->writeString((*_iter1148)); } 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 _iter1129; - for (_iter1129 = (*(this->tbl_names)).begin(); _iter1129 != (*(this->tbl_names)).end(); ++_iter1129) + std::vector ::const_iterator _iter1149; + for (_iter1149 = (*(this->tbl_names)).begin(); _iter1149 != (*(this->tbl_names)).end(); ++_iter1149) { - xfer += oprot->writeString((*_iter1129)); + xfer += oprot->writeString((*_iter1149)); } 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 _size1130; - ::apache::thrift::protocol::TType _etype1133; - xfer += iprot->readListBegin(_etype1133, _size1130); - this->success.resize(_size1130); - uint32_t _i1134; - for (_i1134 = 0; _i1134 < _size1130; ++_i1134) + uint32_t _size1150; + ::apache::thrift::protocol::TType _etype1153; + xfer += iprot->readListBegin(_etype1153, _size1150); + this->success.resize(_size1150); + uint32_t _i1154; + for (_i1154 = 0; _i1154 < _size1150; ++_i1154) { - xfer += this->success[_i1134].read(iprot); + xfer += this->success[_i1154].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 _iter1135; - for (_iter1135 = this->success.begin(); _iter1135 != this->success.end(); ++_iter1135) + std::vector
::const_iterator _iter1155; + for (_iter1155 = this->success.begin(); _iter1155 != this->success.end(); ++_iter1155) { - xfer += (*_iter1135).write(oprot); + xfer += (*_iter1155).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 _size1136; - ::apache::thrift::protocol::TType _etype1139; - xfer += iprot->readListBegin(_etype1139, _size1136); - (*(this->success)).resize(_size1136); - uint32_t _i1140; - for (_i1140 = 0; _i1140 < _size1136; ++_i1140) + uint32_t _size1156; + ::apache::thrift::protocol::TType _etype1159; + xfer += iprot->readListBegin(_etype1159, _size1156); + (*(this->success)).resize(_size1156); + uint32_t _i1160; + for (_i1160 = 0; _i1160 < _size1156; ++_i1160) { - xfer += (*(this->success))[_i1140].read(iprot); + xfer += (*(this->success))[_i1160].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 _size1141; - ::apache::thrift::protocol::TType _etype1144; - xfer += iprot->readListBegin(_etype1144, _size1141); - this->success.resize(_size1141); - uint32_t _i1145; - for (_i1145 = 0; _i1145 < _size1141; ++_i1145) + uint32_t _size1161; + ::apache::thrift::protocol::TType _etype1164; + xfer += iprot->readListBegin(_etype1164, _size1161); + this->success.resize(_size1161); + uint32_t _i1165; + for (_i1165 = 0; _i1165 < _size1161; ++_i1165) { - xfer += iprot->readString(this->success[_i1145]); + xfer += iprot->readString(this->success[_i1165]); } 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 _iter1146; - for (_iter1146 = this->success.begin(); _iter1146 != this->success.end(); ++_iter1146) + std::vector ::const_iterator _iter1166; + for (_iter1166 = this->success.begin(); _iter1166 != this->success.end(); ++_iter1166) { - xfer += oprot->writeString((*_iter1146)); + xfer += oprot->writeString((*_iter1166)); } 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 _size1147; - ::apache::thrift::protocol::TType _etype1150; - xfer += iprot->readListBegin(_etype1150, _size1147); - (*(this->success)).resize(_size1147); - uint32_t _i1151; - for (_i1151 = 0; _i1151 < _size1147; ++_i1151) + uint32_t _size1167; + ::apache::thrift::protocol::TType _etype1170; + xfer += iprot->readListBegin(_etype1170, _size1167); + (*(this->success)).resize(_size1167); + uint32_t _i1171; + for (_i1171 = 0; _i1171 < _size1167; ++_i1171) { - xfer += iprot->readString((*(this->success))[_i1151]); + xfer += iprot->readString((*(this->success))[_i1171]); } 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 _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) + uint32_t _size1172; + ::apache::thrift::protocol::TType _etype1175; + xfer += iprot->readListBegin(_etype1175, _size1172); + this->new_parts.resize(_size1172); + uint32_t _i1176; + for (_i1176 = 0; _i1176 < _size1172; ++_i1176) { - xfer += this->new_parts[_i1156].read(iprot); + xfer += this->new_parts[_i1176].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 _iter1157; - for (_iter1157 = this->new_parts.begin(); _iter1157 != this->new_parts.end(); ++_iter1157) + std::vector ::const_iterator _iter1177; + for (_iter1177 = this->new_parts.begin(); _iter1177 != this->new_parts.end(); ++_iter1177) { - xfer += (*_iter1157).write(oprot); + xfer += (*_iter1177).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 _iter1158; - for (_iter1158 = (*(this->new_parts)).begin(); _iter1158 != (*(this->new_parts)).end(); ++_iter1158) + std::vector ::const_iterator _iter1178; + for (_iter1178 = (*(this->new_parts)).begin(); _iter1178 != (*(this->new_parts)).end(); ++_iter1178) { - xfer += (*_iter1158).write(oprot); + xfer += (*_iter1178).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 _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) + uint32_t _size1179; + ::apache::thrift::protocol::TType _etype1182; + xfer += iprot->readListBegin(_etype1182, _size1179); + this->new_parts.resize(_size1179); + uint32_t _i1183; + for (_i1183 = 0; _i1183 < _size1179; ++_i1183) { - xfer += this->new_parts[_i1163].read(iprot); + xfer += this->new_parts[_i1183].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 _iter1164; - for (_iter1164 = this->new_parts.begin(); _iter1164 != this->new_parts.end(); ++_iter1164) + std::vector ::const_iterator _iter1184; + for (_iter1184 = this->new_parts.begin(); _iter1184 != this->new_parts.end(); ++_iter1184) { - xfer += (*_iter1164).write(oprot); + xfer += (*_iter1184).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 _iter1165; - for (_iter1165 = (*(this->new_parts)).begin(); _iter1165 != (*(this->new_parts)).end(); ++_iter1165) + std::vector ::const_iterator _iter1185; + for (_iter1185 = (*(this->new_parts)).begin(); _iter1185 != (*(this->new_parts)).end(); ++_iter1185) { - xfer += (*_iter1165).write(oprot); + xfer += (*_iter1185).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 _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) + uint32_t _size1186; + ::apache::thrift::protocol::TType _etype1189; + xfer += iprot->readListBegin(_etype1189, _size1186); + this->part_vals.resize(_size1186); + uint32_t _i1190; + for (_i1190 = 0; _i1190 < _size1186; ++_i1190) { - xfer += iprot->readString(this->part_vals[_i1170]); + xfer += iprot->readString(this->part_vals[_i1190]); } 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 _iter1171; - for (_iter1171 = this->part_vals.begin(); _iter1171 != this->part_vals.end(); ++_iter1171) + std::vector ::const_iterator _iter1191; + for (_iter1191 = this->part_vals.begin(); _iter1191 != this->part_vals.end(); ++_iter1191) { - xfer += oprot->writeString((*_iter1171)); + xfer += oprot->writeString((*_iter1191)); } 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 _iter1172; - for (_iter1172 = (*(this->part_vals)).begin(); _iter1172 != (*(this->part_vals)).end(); ++_iter1172) + std::vector ::const_iterator _iter1192; + for (_iter1192 = (*(this->part_vals)).begin(); _iter1192 != (*(this->part_vals)).end(); ++_iter1192) { - xfer += oprot->writeString((*_iter1172)); + xfer += oprot->writeString((*_iter1192)); } 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 _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) + uint32_t _size1193; + ::apache::thrift::protocol::TType _etype1196; + xfer += iprot->readListBegin(_etype1196, _size1193); + this->part_vals.resize(_size1193); + uint32_t _i1197; + for (_i1197 = 0; _i1197 < _size1193; ++_i1197) { - xfer += iprot->readString(this->part_vals[_i1177]); + xfer += iprot->readString(this->part_vals[_i1197]); } 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 _iter1178; - for (_iter1178 = this->part_vals.begin(); _iter1178 != this->part_vals.end(); ++_iter1178) + std::vector ::const_iterator _iter1198; + for (_iter1198 = this->part_vals.begin(); _iter1198 != this->part_vals.end(); ++_iter1198) { - xfer += oprot->writeString((*_iter1178)); + xfer += oprot->writeString((*_iter1198)); } 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 _iter1179; - for (_iter1179 = (*(this->part_vals)).begin(); _iter1179 != (*(this->part_vals)).end(); ++_iter1179) + std::vector ::const_iterator _iter1199; + for (_iter1199 = (*(this->part_vals)).begin(); _iter1199 != (*(this->part_vals)).end(); ++_iter1199) { - xfer += oprot->writeString((*_iter1179)); + xfer += oprot->writeString((*_iter1199)); } 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 _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) + uint32_t _size1200; + ::apache::thrift::protocol::TType _etype1203; + xfer += iprot->readListBegin(_etype1203, _size1200); + this->part_vals.resize(_size1200); + uint32_t _i1204; + for (_i1204 = 0; _i1204 < _size1200; ++_i1204) { - xfer += iprot->readString(this->part_vals[_i1184]); + xfer += iprot->readString(this->part_vals[_i1204]); } 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 _iter1185; - for (_iter1185 = this->part_vals.begin(); _iter1185 != this->part_vals.end(); ++_iter1185) + std::vector ::const_iterator _iter1205; + for (_iter1205 = this->part_vals.begin(); _iter1205 != this->part_vals.end(); ++_iter1205) { - xfer += oprot->writeString((*_iter1185)); + xfer += oprot->writeString((*_iter1205)); } 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 _iter1186; - for (_iter1186 = (*(this->part_vals)).begin(); _iter1186 != (*(this->part_vals)).end(); ++_iter1186) + std::vector ::const_iterator _iter1206; + for (_iter1206 = (*(this->part_vals)).begin(); _iter1206 != (*(this->part_vals)).end(); ++_iter1206) { - xfer += oprot->writeString((*_iter1186)); + xfer += oprot->writeString((*_iter1206)); } 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 _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) + uint32_t _size1207; + ::apache::thrift::protocol::TType _etype1210; + xfer += iprot->readListBegin(_etype1210, _size1207); + this->part_vals.resize(_size1207); + uint32_t _i1211; + for (_i1211 = 0; _i1211 < _size1207; ++_i1211) { - xfer += iprot->readString(this->part_vals[_i1191]); + xfer += iprot->readString(this->part_vals[_i1211]); } 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 _iter1192; - for (_iter1192 = this->part_vals.begin(); _iter1192 != this->part_vals.end(); ++_iter1192) + std::vector ::const_iterator _iter1212; + for (_iter1212 = this->part_vals.begin(); _iter1212 != this->part_vals.end(); ++_iter1212) { - xfer += oprot->writeString((*_iter1192)); + xfer += oprot->writeString((*_iter1212)); } 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 _iter1193; - for (_iter1193 = (*(this->part_vals)).begin(); _iter1193 != (*(this->part_vals)).end(); ++_iter1193) + std::vector ::const_iterator _iter1213; + for (_iter1213 = (*(this->part_vals)).begin(); _iter1213 != (*(this->part_vals)).end(); ++_iter1213) { - xfer += oprot->writeString((*_iter1193)); + xfer += oprot->writeString((*_iter1213)); } 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 _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) + uint32_t _size1214; + ::apache::thrift::protocol::TType _etype1217; + xfer += iprot->readListBegin(_etype1217, _size1214); + this->part_vals.resize(_size1214); + uint32_t _i1218; + for (_i1218 = 0; _i1218 < _size1214; ++_i1218) { - xfer += iprot->readString(this->part_vals[_i1198]); + xfer += iprot->readString(this->part_vals[_i1218]); } 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 _iter1199; - for (_iter1199 = this->part_vals.begin(); _iter1199 != this->part_vals.end(); ++_iter1199) + std::vector ::const_iterator _iter1219; + for (_iter1219 = this->part_vals.begin(); _iter1219 != this->part_vals.end(); ++_iter1219) { - xfer += oprot->writeString((*_iter1199)); + xfer += oprot->writeString((*_iter1219)); } 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 _iter1200; - for (_iter1200 = (*(this->part_vals)).begin(); _iter1200 != (*(this->part_vals)).end(); ++_iter1200) + std::vector ::const_iterator _iter1220; + for (_iter1220 = (*(this->part_vals)).begin(); _iter1220 != (*(this->part_vals)).end(); ++_iter1220) { - xfer += oprot->writeString((*_iter1200)); + xfer += oprot->writeString((*_iter1220)); } 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 _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) + uint32_t _size1221; + ::apache::thrift::protocol::TType _ktype1222; + ::apache::thrift::protocol::TType _vtype1223; + xfer += iprot->readMapBegin(_ktype1222, _vtype1223, _size1221); + uint32_t _i1225; + for (_i1225 = 0; _i1225 < _size1221; ++_i1225) { - std::string _key1206; - xfer += iprot->readString(_key1206); - std::string& _val1207 = this->partitionSpecs[_key1206]; - xfer += iprot->readString(_val1207); + std::string _key1226; + xfer += iprot->readString(_key1226); + std::string& _val1227 = this->partitionSpecs[_key1226]; + xfer += iprot->readString(_val1227); } 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 _iter1208; - for (_iter1208 = this->partitionSpecs.begin(); _iter1208 != this->partitionSpecs.end(); ++_iter1208) + std::map ::const_iterator _iter1228; + for (_iter1228 = this->partitionSpecs.begin(); _iter1228 != this->partitionSpecs.end(); ++_iter1228) { - xfer += oprot->writeString(_iter1208->first); - xfer += oprot->writeString(_iter1208->second); + xfer += oprot->writeString(_iter1228->first); + xfer += oprot->writeString(_iter1228->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 _iter1209; - for (_iter1209 = (*(this->partitionSpecs)).begin(); _iter1209 != (*(this->partitionSpecs)).end(); ++_iter1209) + std::map ::const_iterator _iter1229; + for (_iter1229 = (*(this->partitionSpecs)).begin(); _iter1229 != (*(this->partitionSpecs)).end(); ++_iter1229) { - xfer += oprot->writeString(_iter1209->first); - xfer += oprot->writeString(_iter1209->second); + xfer += oprot->writeString(_iter1229->first); + xfer += oprot->writeString(_iter1229->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 _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) + uint32_t _size1230; + ::apache::thrift::protocol::TType _ktype1231; + ::apache::thrift::protocol::TType _vtype1232; + xfer += iprot->readMapBegin(_ktype1231, _vtype1232, _size1230); + uint32_t _i1234; + for (_i1234 = 0; _i1234 < _size1230; ++_i1234) { - std::string _key1215; - xfer += iprot->readString(_key1215); - std::string& _val1216 = this->partitionSpecs[_key1215]; - xfer += iprot->readString(_val1216); + std::string _key1235; + xfer += iprot->readString(_key1235); + std::string& _val1236 = this->partitionSpecs[_key1235]; + xfer += iprot->readString(_val1236); } 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 _iter1217; - for (_iter1217 = this->partitionSpecs.begin(); _iter1217 != this->partitionSpecs.end(); ++_iter1217) + std::map ::const_iterator _iter1237; + for (_iter1237 = this->partitionSpecs.begin(); _iter1237 != this->partitionSpecs.end(); ++_iter1237) { - xfer += oprot->writeString(_iter1217->first); - xfer += oprot->writeString(_iter1217->second); + xfer += oprot->writeString(_iter1237->first); + xfer += oprot->writeString(_iter1237->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 _iter1218; - for (_iter1218 = (*(this->partitionSpecs)).begin(); _iter1218 != (*(this->partitionSpecs)).end(); ++_iter1218) + std::map ::const_iterator _iter1238; + for (_iter1238 = (*(this->partitionSpecs)).begin(); _iter1238 != (*(this->partitionSpecs)).end(); ++_iter1238) { - xfer += oprot->writeString(_iter1218->first); - xfer += oprot->writeString(_iter1218->second); + xfer += oprot->writeString(_iter1238->first); + xfer += oprot->writeString(_iter1238->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 _size1219; - ::apache::thrift::protocol::TType _etype1222; - xfer += iprot->readListBegin(_etype1222, _size1219); - this->success.resize(_size1219); - uint32_t _i1223; - for (_i1223 = 0; _i1223 < _size1219; ++_i1223) + uint32_t _size1239; + ::apache::thrift::protocol::TType _etype1242; + xfer += iprot->readListBegin(_etype1242, _size1239); + this->success.resize(_size1239); + uint32_t _i1243; + for (_i1243 = 0; _i1243 < _size1239; ++_i1243) { - xfer += this->success[_i1223].read(iprot); + xfer += this->success[_i1243].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 _iter1224; - for (_iter1224 = this->success.begin(); _iter1224 != this->success.end(); ++_iter1224) + std::vector ::const_iterator _iter1244; + for (_iter1244 = this->success.begin(); _iter1244 != this->success.end(); ++_iter1244) { - xfer += (*_iter1224).write(oprot); + xfer += (*_iter1244).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 _size1225; - ::apache::thrift::protocol::TType _etype1228; - xfer += iprot->readListBegin(_etype1228, _size1225); - (*(this->success)).resize(_size1225); - uint32_t _i1229; - for (_i1229 = 0; _i1229 < _size1225; ++_i1229) + uint32_t _size1245; + ::apache::thrift::protocol::TType _etype1248; + xfer += iprot->readListBegin(_etype1248, _size1245); + (*(this->success)).resize(_size1245); + uint32_t _i1249; + for (_i1249 = 0; _i1249 < _size1245; ++_i1249) { - xfer += (*(this->success))[_i1229].read(iprot); + xfer += (*(this->success))[_i1249].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 _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) + uint32_t _size1250; + ::apache::thrift::protocol::TType _etype1253; + xfer += iprot->readListBegin(_etype1253, _size1250); + this->part_vals.resize(_size1250); + uint32_t _i1254; + for (_i1254 = 0; _i1254 < _size1250; ++_i1254) { - xfer += iprot->readString(this->part_vals[_i1234]); + xfer += iprot->readString(this->part_vals[_i1254]); } 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 _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) + 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[_i1239]); + xfer += iprot->readString(this->group_names[_i1259]); } 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 _iter1240; - for (_iter1240 = this->part_vals.begin(); _iter1240 != this->part_vals.end(); ++_iter1240) + std::vector ::const_iterator _iter1260; + for (_iter1260 = this->part_vals.begin(); _iter1260 != this->part_vals.end(); ++_iter1260) { - xfer += oprot->writeString((*_iter1240)); + xfer += oprot->writeString((*_iter1260)); } 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 _iter1241; - for (_iter1241 = this->group_names.begin(); _iter1241 != this->group_names.end(); ++_iter1241) + std::vector ::const_iterator _iter1261; + for (_iter1261 = this->group_names.begin(); _iter1261 != this->group_names.end(); ++_iter1261) { - xfer += oprot->writeString((*_iter1241)); + xfer += oprot->writeString((*_iter1261)); } 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 _iter1242; - for (_iter1242 = (*(this->part_vals)).begin(); _iter1242 != (*(this->part_vals)).end(); ++_iter1242) + std::vector ::const_iterator _iter1262; + for (_iter1262 = (*(this->part_vals)).begin(); _iter1262 != (*(this->part_vals)).end(); ++_iter1262) { - xfer += oprot->writeString((*_iter1242)); + xfer += oprot->writeString((*_iter1262)); } 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 _iter1243; - for (_iter1243 = (*(this->group_names)).begin(); _iter1243 != (*(this->group_names)).end(); ++_iter1243) + std::vector ::const_iterator _iter1263; + for (_iter1263 = (*(this->group_names)).begin(); _iter1263 != (*(this->group_names)).end(); ++_iter1263) { - xfer += oprot->writeString((*_iter1243)); + xfer += oprot->writeString((*_iter1263)); } 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 _size1244; - ::apache::thrift::protocol::TType _etype1247; - xfer += iprot->readListBegin(_etype1247, _size1244); - this->success.resize(_size1244); - uint32_t _i1248; - for (_i1248 = 0; _i1248 < _size1244; ++_i1248) + uint32_t _size1264; + ::apache::thrift::protocol::TType _etype1267; + xfer += iprot->readListBegin(_etype1267, _size1264); + this->success.resize(_size1264); + uint32_t _i1268; + for (_i1268 = 0; _i1268 < _size1264; ++_i1268) { - xfer += this->success[_i1248].read(iprot); + xfer += this->success[_i1268].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 _iter1249; - for (_iter1249 = this->success.begin(); _iter1249 != this->success.end(); ++_iter1249) + std::vector ::const_iterator _iter1269; + for (_iter1269 = this->success.begin(); _iter1269 != this->success.end(); ++_iter1269) { - xfer += (*_iter1249).write(oprot); + xfer += (*_iter1269).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 _size1250; - ::apache::thrift::protocol::TType _etype1253; - xfer += iprot->readListBegin(_etype1253, _size1250); - (*(this->success)).resize(_size1250); - uint32_t _i1254; - for (_i1254 = 0; _i1254 < _size1250; ++_i1254) + uint32_t _size1270; + ::apache::thrift::protocol::TType _etype1273; + xfer += iprot->readListBegin(_etype1273, _size1270); + (*(this->success)).resize(_size1270); + uint32_t _i1274; + for (_i1274 = 0; _i1274 < _size1270; ++_i1274) { - xfer += (*(this->success))[_i1254].read(iprot); + xfer += (*(this->success))[_i1274].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 _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) + uint32_t _size1275; + ::apache::thrift::protocol::TType _etype1278; + xfer += iprot->readListBegin(_etype1278, _size1275); + this->group_names.resize(_size1275); + uint32_t _i1279; + for (_i1279 = 0; _i1279 < _size1275; ++_i1279) { - xfer += iprot->readString(this->group_names[_i1259]); + xfer += iprot->readString(this->group_names[_i1279]); } 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 _iter1260; - for (_iter1260 = this->group_names.begin(); _iter1260 != this->group_names.end(); ++_iter1260) + std::vector ::const_iterator _iter1280; + for (_iter1280 = this->group_names.begin(); _iter1280 != this->group_names.end(); ++_iter1280) { - xfer += oprot->writeString((*_iter1260)); + xfer += oprot->writeString((*_iter1280)); } 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 _iter1261; - for (_iter1261 = (*(this->group_names)).begin(); _iter1261 != (*(this->group_names)).end(); ++_iter1261) + std::vector ::const_iterator _iter1281; + for (_iter1281 = (*(this->group_names)).begin(); _iter1281 != (*(this->group_names)).end(); ++_iter1281) { - xfer += oprot->writeString((*_iter1261)); + xfer += oprot->writeString((*_iter1281)); } 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 _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 _size1282; + ::apache::thrift::protocol::TType _etype1285; + xfer += iprot->readListBegin(_etype1285, _size1282); + this->success.resize(_size1282); + uint32_t _i1286; + for (_i1286 = 0; _i1286 < _size1282; ++_i1286) { - xfer += this->success[_i1266].read(iprot); + xfer += this->success[_i1286].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 _iter1267; - for (_iter1267 = this->success.begin(); _iter1267 != this->success.end(); ++_iter1267) + std::vector ::const_iterator _iter1287; + for (_iter1287 = this->success.begin(); _iter1287 != this->success.end(); ++_iter1287) { - xfer += (*_iter1267).write(oprot); + xfer += (*_iter1287).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 _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 _size1288; + ::apache::thrift::protocol::TType _etype1291; + xfer += iprot->readListBegin(_etype1291, _size1288); + (*(this->success)).resize(_size1288); + uint32_t _i1292; + for (_i1292 = 0; _i1292 < _size1288; ++_i1292) { - xfer += (*(this->success))[_i1272].read(iprot); + xfer += (*(this->success))[_i1292].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 _size1273; - ::apache::thrift::protocol::TType _etype1276; - xfer += iprot->readListBegin(_etype1276, _size1273); - this->success.resize(_size1273); - uint32_t _i1277; - for (_i1277 = 0; _i1277 < _size1273; ++_i1277) + uint32_t _size1293; + ::apache::thrift::protocol::TType _etype1296; + xfer += iprot->readListBegin(_etype1296, _size1293); + this->success.resize(_size1293); + uint32_t _i1297; + for (_i1297 = 0; _i1297 < _size1293; ++_i1297) { - xfer += this->success[_i1277].read(iprot); + xfer += this->success[_i1297].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 _iter1278; - for (_iter1278 = this->success.begin(); _iter1278 != this->success.end(); ++_iter1278) + std::vector ::const_iterator _iter1298; + for (_iter1298 = this->success.begin(); _iter1298 != this->success.end(); ++_iter1298) { - xfer += (*_iter1278).write(oprot); + xfer += (*_iter1298).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 _size1279; - ::apache::thrift::protocol::TType _etype1282; - xfer += iprot->readListBegin(_etype1282, _size1279); - (*(this->success)).resize(_size1279); - uint32_t _i1283; - for (_i1283 = 0; _i1283 < _size1279; ++_i1283) + uint32_t _size1299; + ::apache::thrift::protocol::TType _etype1302; + xfer += iprot->readListBegin(_etype1302, _size1299); + (*(this->success)).resize(_size1299); + uint32_t _i1303; + for (_i1303 = 0; _i1303 < _size1299; ++_i1303) { - xfer += (*(this->success))[_i1283].read(iprot); + xfer += (*(this->success))[_i1303].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 _size1284; - ::apache::thrift::protocol::TType _etype1287; - xfer += iprot->readListBegin(_etype1287, _size1284); - this->success.resize(_size1284); - uint32_t _i1288; - for (_i1288 = 0; _i1288 < _size1284; ++_i1288) + uint32_t _size1304; + ::apache::thrift::protocol::TType _etype1307; + xfer += iprot->readListBegin(_etype1307, _size1304); + this->success.resize(_size1304); + uint32_t _i1308; + for (_i1308 = 0; _i1308 < _size1304; ++_i1308) { - xfer += iprot->readString(this->success[_i1288]); + xfer += iprot->readString(this->success[_i1308]); } 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 _iter1289; - for (_iter1289 = this->success.begin(); _iter1289 != this->success.end(); ++_iter1289) + std::vector ::const_iterator _iter1309; + for (_iter1309 = this->success.begin(); _iter1309 != this->success.end(); ++_iter1309) { - xfer += oprot->writeString((*_iter1289)); + xfer += oprot->writeString((*_iter1309)); } 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 _size1290; - ::apache::thrift::protocol::TType _etype1293; - xfer += iprot->readListBegin(_etype1293, _size1290); - (*(this->success)).resize(_size1290); - uint32_t _i1294; - for (_i1294 = 0; _i1294 < _size1290; ++_i1294) + uint32_t _size1310; + ::apache::thrift::protocol::TType _etype1313; + xfer += iprot->readListBegin(_etype1313, _size1310); + (*(this->success)).resize(_size1310); + uint32_t _i1314; + for (_i1314 = 0; _i1314 < _size1310; ++_i1314) { - xfer += iprot->readString((*(this->success))[_i1294]); + xfer += iprot->readString((*(this->success))[_i1314]); } 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 _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) + uint32_t _size1315; + ::apache::thrift::protocol::TType _etype1318; + xfer += iprot->readListBegin(_etype1318, _size1315); + this->part_vals.resize(_size1315); + uint32_t _i1319; + for (_i1319 = 0; _i1319 < _size1315; ++_i1319) { - xfer += iprot->readString(this->part_vals[_i1299]); + xfer += iprot->readString(this->part_vals[_i1319]); } 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 _iter1300; - for (_iter1300 = this->part_vals.begin(); _iter1300 != this->part_vals.end(); ++_iter1300) + std::vector ::const_iterator _iter1320; + for (_iter1320 = this->part_vals.begin(); _iter1320 != this->part_vals.end(); ++_iter1320) { - xfer += oprot->writeString((*_iter1300)); + xfer += oprot->writeString((*_iter1320)); } 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 _iter1301; - for (_iter1301 = (*(this->part_vals)).begin(); _iter1301 != (*(this->part_vals)).end(); ++_iter1301) + std::vector ::const_iterator _iter1321; + for (_iter1321 = (*(this->part_vals)).begin(); _iter1321 != (*(this->part_vals)).end(); ++_iter1321) { - xfer += oprot->writeString((*_iter1301)); + xfer += oprot->writeString((*_iter1321)); } 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 _size1302; - ::apache::thrift::protocol::TType _etype1305; - xfer += iprot->readListBegin(_etype1305, _size1302); - this->success.resize(_size1302); - uint32_t _i1306; - for (_i1306 = 0; _i1306 < _size1302; ++_i1306) + uint32_t _size1322; + ::apache::thrift::protocol::TType _etype1325; + xfer += iprot->readListBegin(_etype1325, _size1322); + this->success.resize(_size1322); + uint32_t _i1326; + for (_i1326 = 0; _i1326 < _size1322; ++_i1326) { - xfer += this->success[_i1306].read(iprot); + xfer += this->success[_i1326].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 _iter1307; - for (_iter1307 = this->success.begin(); _iter1307 != this->success.end(); ++_iter1307) + std::vector ::const_iterator _iter1327; + for (_iter1327 = this->success.begin(); _iter1327 != this->success.end(); ++_iter1327) { - xfer += (*_iter1307).write(oprot); + xfer += (*_iter1327).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 _size1308; - ::apache::thrift::protocol::TType _etype1311; - xfer += iprot->readListBegin(_etype1311, _size1308); - (*(this->success)).resize(_size1308); - uint32_t _i1312; - for (_i1312 = 0; _i1312 < _size1308; ++_i1312) + uint32_t _size1328; + ::apache::thrift::protocol::TType _etype1331; + xfer += iprot->readListBegin(_etype1331, _size1328); + (*(this->success)).resize(_size1328); + uint32_t _i1332; + for (_i1332 = 0; _i1332 < _size1328; ++_i1332) { - xfer += (*(this->success))[_i1312].read(iprot); + xfer += (*(this->success))[_i1332].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 _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) + uint32_t _size1333; + ::apache::thrift::protocol::TType _etype1336; + xfer += iprot->readListBegin(_etype1336, _size1333); + this->part_vals.resize(_size1333); + uint32_t _i1337; + for (_i1337 = 0; _i1337 < _size1333; ++_i1337) { - xfer += iprot->readString(this->part_vals[_i1317]); + xfer += iprot->readString(this->part_vals[_i1337]); } xfer += iprot->readListEnd(); } @@ -17230,385 +17230,18 @@ 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 _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[_i1322]); - } - xfer += iprot->readListEnd(); - } - this->__isset.group_names = 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_partitions_ps_with_auth_args::write(::apache::thrift::protocol::TProtocol* oprot) const { - uint32_t xfer = 0; - apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_ps_with_auth_args"); - - xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString(this->db_name); - xfer += oprot->writeFieldEnd(); - - xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); - xfer += oprot->writeString(this->tbl_name); - xfer += oprot->writeFieldEnd(); - - 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 _iter1323; - for (_iter1323 = this->part_vals.begin(); _iter1323 != this->part_vals.end(); ++_iter1323) - { - xfer += oprot->writeString((*_iter1323)); - } - xfer += oprot->writeListEnd(); - } - xfer += oprot->writeFieldEnd(); - - xfer += oprot->writeFieldBegin("max_parts", ::apache::thrift::protocol::T_I16, 4); - xfer += oprot->writeI16(this->max_parts); - xfer += oprot->writeFieldEnd(); - - xfer += oprot->writeFieldBegin("user_name", ::apache::thrift::protocol::T_STRING, 5); - xfer += oprot->writeString(this->user_name); - xfer += oprot->writeFieldEnd(); - - 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 _iter1324; - for (_iter1324 = this->group_names.begin(); _iter1324 != this->group_names.end(); ++_iter1324) - { - xfer += oprot->writeString((*_iter1324)); - } - xfer += oprot->writeListEnd(); - } - xfer += oprot->writeFieldEnd(); - - xfer += oprot->writeFieldStop(); - xfer += oprot->writeStructEnd(); - return xfer; -} - - -ThriftHiveMetastore_get_partitions_ps_with_auth_pargs::~ThriftHiveMetastore_get_partitions_ps_with_auth_pargs() throw() { -} - - -uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { - uint32_t xfer = 0; - apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_ps_with_auth_pargs"); - - xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString((*(this->db_name))); - xfer += oprot->writeFieldEnd(); - - xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); - xfer += oprot->writeString((*(this->tbl_name))); - xfer += oprot->writeFieldEnd(); - - 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 _iter1325; - for (_iter1325 = (*(this->part_vals)).begin(); _iter1325 != (*(this->part_vals)).end(); ++_iter1325) - { - xfer += oprot->writeString((*_iter1325)); - } - xfer += oprot->writeListEnd(); - } - xfer += oprot->writeFieldEnd(); - - xfer += oprot->writeFieldBegin("max_parts", ::apache::thrift::protocol::T_I16, 4); - xfer += oprot->writeI16((*(this->max_parts))); - xfer += oprot->writeFieldEnd(); - - xfer += oprot->writeFieldBegin("user_name", ::apache::thrift::protocol::T_STRING, 5); - xfer += oprot->writeString((*(this->user_name))); - xfer += oprot->writeFieldEnd(); - - 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 _iter1326; - for (_iter1326 = (*(this->group_names)).begin(); _iter1326 != (*(this->group_names)).end(); ++_iter1326) - { - xfer += oprot->writeString((*_iter1326)); - } - xfer += oprot->writeListEnd(); - } - xfer += oprot->writeFieldEnd(); - - xfer += oprot->writeFieldStop(); - xfer += oprot->writeStructEnd(); - return xfer; -} - - -ThriftHiveMetastore_get_partitions_ps_with_auth_result::~ThriftHiveMetastore_get_partitions_ps_with_auth_result() throw() { -} - - -uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_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 _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[_i1331].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; - 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_partitions_ps_with_auth_result::write(::apache::thrift::protocol::TProtocol* oprot) const { - - uint32_t xfer = 0; - - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_ps_with_auth_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 _iter1332; - for (_iter1332 = this->success.begin(); _iter1332 != this->success.end(); ++_iter1332) - { - xfer += (*_iter1332).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(); - } 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_partitions_ps_with_auth_presult::~ThriftHiveMetastore_get_partitions_ps_with_auth_presult() throw() { -} - - -uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_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 _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))[_i1337].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; - 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; -} - - -ThriftHiveMetastore_get_partition_names_ps_args::~ThriftHiveMetastore_get_partition_names_ps_args() throw() { -} - - -uint32_t ThriftHiveMetastore_get_partition_names_ps_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->db_name); - this->__isset.db_name = true; - } else { - xfer += iprot->skip(ftype); - } - break; - case 2: - if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->tbl_name); - this->__isset.tbl_name = true; - } else { - xfer += iprot->skip(ftype); - } - break; - case 3: - if (ftype == ::apache::thrift::protocol::T_LIST) { - { - this->part_vals.clear(); uint32_t _size1338; ::apache::thrift::protocol::TType _etype1341; xfer += iprot->readListBegin(_etype1341, _size1338); - this->part_vals.resize(_size1338); + this->group_names.resize(_size1338); uint32_t _i1342; for (_i1342 = 0; _i1342 < _size1338; ++_i1342) { - xfer += iprot->readString(this->part_vals[_i1342]); + xfer += iprot->readString(this->group_names[_i1342]); } xfer += iprot->readListEnd(); } - this->__isset.part_vals = true; - } else { - xfer += iprot->skip(ftype); - } - break; - case 4: - if (ftype == ::apache::thrift::protocol::T_I16) { - xfer += iprot->readI16(this->max_parts); - this->__isset.max_parts = true; + this->__isset.group_names = true; } else { xfer += iprot->skip(ftype); } @@ -17625,10 +17258,10 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_args::read(::apache::thrift: return xfer; } -uint32_t ThriftHiveMetastore_get_partition_names_ps_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partition_names_ps_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_ps_with_auth_args"); xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); xfer += oprot->writeString(this->db_name); @@ -17654,20 +17287,36 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_args::write(::apache::thrift xfer += oprot->writeI16(this->max_parts); xfer += oprot->writeFieldEnd(); + xfer += oprot->writeFieldBegin("user_name", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->user_name); + xfer += oprot->writeFieldEnd(); + + 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 _iter1344; + for (_iter1344 = this->group_names.begin(); _iter1344 != this->group_names.end(); ++_iter1344) + { + xfer += oprot->writeString((*_iter1344)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; } -ThriftHiveMetastore_get_partition_names_ps_pargs::~ThriftHiveMetastore_get_partition_names_ps_pargs() throw() { +ThriftHiveMetastore_get_partitions_ps_with_auth_pargs::~ThriftHiveMetastore_get_partitions_ps_with_auth_pargs() throw() { } -uint32_t ThriftHiveMetastore_get_partition_names_ps_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partition_names_ps_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_ps_with_auth_pargs"); xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); xfer += oprot->writeString((*(this->db_name))); @@ -17680,10 +17329,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 _iter1344; - for (_iter1344 = (*(this->part_vals)).begin(); _iter1344 != (*(this->part_vals)).end(); ++_iter1344) + std::vector ::const_iterator _iter1345; + for (_iter1345 = (*(this->part_vals)).begin(); _iter1345 != (*(this->part_vals)).end(); ++_iter1345) { - xfer += oprot->writeString((*_iter1344)); + xfer += oprot->writeString((*_iter1345)); } xfer += oprot->writeListEnd(); } @@ -17693,17 +17342,33 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_pargs::write(::apache::thrif xfer += oprot->writeI16((*(this->max_parts))); xfer += oprot->writeFieldEnd(); + xfer += oprot->writeFieldBegin("user_name", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString((*(this->user_name))); + xfer += oprot->writeFieldEnd(); + + 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 _iter1346; + for (_iter1346 = (*(this->group_names)).begin(); _iter1346 != (*(this->group_names)).end(); ++_iter1346) + { + xfer += oprot->writeString((*_iter1346)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; } -ThriftHiveMetastore_get_partition_names_ps_result::~ThriftHiveMetastore_get_partition_names_ps_result() throw() { +ThriftHiveMetastore_get_partitions_ps_with_auth_result::~ThriftHiveMetastore_get_partitions_ps_with_auth_result() throw() { } -uint32_t ThriftHiveMetastore_get_partition_names_ps_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -17728,14 +17393,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_result::read(::apache::thrif 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 _size1347; + ::apache::thrift::protocol::TType _etype1350; + xfer += iprot->readListBegin(_etype1350, _size1347); + this->success.resize(_size1347); + uint32_t _i1351; + for (_i1351 = 0; _i1351 < _size1347; ++_i1351) { - xfer += iprot->readString(this->success[_i1349]); + xfer += this->success[_i1351].read(iprot); } xfer += iprot->readListEnd(); } @@ -17772,20 +17437,20 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_result::read(::apache::thrif return xfer; } -uint32_t ThriftHiveMetastore_get_partition_names_ps_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partition_names_ps_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_ps_with_auth_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 _iter1350; - for (_iter1350 = this->success.begin(); _iter1350 != this->success.end(); ++_iter1350) + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); + std::vector ::const_iterator _iter1352; + for (_iter1352 = this->success.begin(); _iter1352 != this->success.end(); ++_iter1352) { - xfer += oprot->writeString((*_iter1350)); + xfer += (*_iter1352).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17805,11 +17470,11 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_result::write(::apache::thri } -ThriftHiveMetastore_get_partition_names_ps_presult::~ThriftHiveMetastore_get_partition_names_ps_presult() throw() { +ThriftHiveMetastore_get_partitions_ps_with_auth_presult::~ThriftHiveMetastore_get_partitions_ps_with_auth_presult() throw() { } -uint32_t ThriftHiveMetastore_get_partition_names_ps_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -17834,14 +17499,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_presult::read(::apache::thri 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 _size1353; + ::apache::thrift::protocol::TType _etype1356; + xfer += iprot->readListBegin(_etype1356, _size1353); + (*(this->success)).resize(_size1353); + uint32_t _i1357; + for (_i1357 = 0; _i1357 < _size1353; ++_i1357) { - xfer += iprot->readString((*(this->success))[_i1355]); + xfer += (*(this->success))[_i1357].read(iprot); } xfer += iprot->readListEnd(); } @@ -17879,11 +17544,11 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_presult::read(::apache::thri } -ThriftHiveMetastore_get_partitions_by_filter_args::~ThriftHiveMetastore_get_partitions_by_filter_args() throw() { +ThriftHiveMetastore_get_partition_names_ps_args::~ThriftHiveMetastore_get_partition_names_ps_args() throw() { } -uint32_t ThriftHiveMetastore_get_partitions_by_filter_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_partition_names_ps_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -17921,9 +17586,21 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_args::read(::apache::thrif } break; case 3: - if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->filter); - this->__isset.filter = true; + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->part_vals.clear(); + uint32_t _size1358; + ::apache::thrift::protocol::TType _etype1361; + xfer += iprot->readListBegin(_etype1361, _size1358); + this->part_vals.resize(_size1358); + uint32_t _i1362; + for (_i1362 = 0; _i1362 < _size1358; ++_i1362) + { + xfer += iprot->readString(this->part_vals[_i1362]); + } + xfer += iprot->readListEnd(); + } + this->__isset.part_vals = true; } else { xfer += iprot->skip(ftype); } @@ -17948,10 +17625,10 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_args::read(::apache::thrif return xfer; } -uint32_t ThriftHiveMetastore_get_partitions_by_filter_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_partition_names_ps_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_by_filter_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partition_names_ps_args"); xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); xfer += oprot->writeString(this->db_name); @@ -17961,8 +17638,16 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_args::write(::apache::thri xfer += oprot->writeString(this->tbl_name); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("filter", ::apache::thrift::protocol::T_STRING, 3); - xfer += oprot->writeString(this->filter); + 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 _iter1363; + for (_iter1363 = this->part_vals.begin(); _iter1363 != this->part_vals.end(); ++_iter1363) + { + xfer += oprot->writeString((*_iter1363)); + } + xfer += oprot->writeListEnd(); + } xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldBegin("max_parts", ::apache::thrift::protocol::T_I16, 4); @@ -17975,14 +17660,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_args::write(::apache::thri } -ThriftHiveMetastore_get_partitions_by_filter_pargs::~ThriftHiveMetastore_get_partitions_by_filter_pargs() throw() { +ThriftHiveMetastore_get_partition_names_ps_pargs::~ThriftHiveMetastore_get_partition_names_ps_pargs() throw() { } -uint32_t ThriftHiveMetastore_get_partitions_by_filter_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_partition_names_ps_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_by_filter_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partition_names_ps_pargs"); xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); xfer += oprot->writeString((*(this->db_name))); @@ -17992,8 +17677,16 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_pargs::write(::apache::thr xfer += oprot->writeString((*(this->tbl_name))); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("filter", ::apache::thrift::protocol::T_STRING, 3); - xfer += oprot->writeString((*(this->filter))); + 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 _iter1364; + for (_iter1364 = (*(this->part_vals)).begin(); _iter1364 != (*(this->part_vals)).end(); ++_iter1364) + { + xfer += oprot->writeString((*_iter1364)); + } + xfer += oprot->writeListEnd(); + } xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldBegin("max_parts", ::apache::thrift::protocol::T_I16, 4); @@ -18006,11 +17699,11 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_pargs::write(::apache::thr } -ThriftHiveMetastore_get_partitions_by_filter_result::~ThriftHiveMetastore_get_partitions_by_filter_result() throw() { +ThriftHiveMetastore_get_partition_names_ps_result::~ThriftHiveMetastore_get_partition_names_ps_result() throw() { } -uint32_t ThriftHiveMetastore_get_partitions_by_filter_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_partition_names_ps_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -18035,14 +17728,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - 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) + uint32_t _size1365; + ::apache::thrift::protocol::TType _etype1368; + xfer += iprot->readListBegin(_etype1368, _size1365); + this->success.resize(_size1365); + uint32_t _i1369; + for (_i1369 = 0; _i1369 < _size1365; ++_i1369) { - xfer += this->success[_i1360].read(iprot); + xfer += iprot->readString(this->success[_i1369]); } xfer += iprot->readListEnd(); } @@ -18079,20 +17772,20 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_result::read(::apache::thr return xfer; } -uint32_t ThriftHiveMetastore_get_partitions_by_filter_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_partition_names_ps_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_by_filter_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partition_names_ps_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 _iter1361; - for (_iter1361 = this->success.begin(); _iter1361 != this->success.end(); ++_iter1361) + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); + std::vector ::const_iterator _iter1370; + for (_iter1370 = this->success.begin(); _iter1370 != this->success.end(); ++_iter1370) { - xfer += (*_iter1361).write(oprot); + xfer += oprot->writeString((*_iter1370)); } xfer += oprot->writeListEnd(); } @@ -18112,11 +17805,11 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_result::write(::apache::th } -ThriftHiveMetastore_get_partitions_by_filter_presult::~ThriftHiveMetastore_get_partitions_by_filter_presult() throw() { +ThriftHiveMetastore_get_partition_names_ps_presult::~ThriftHiveMetastore_get_partition_names_ps_presult() throw() { } -uint32_t ThriftHiveMetastore_get_partitions_by_filter_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_partition_names_ps_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -18141,14 +17834,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - 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) + uint32_t _size1371; + ::apache::thrift::protocol::TType _etype1374; + xfer += iprot->readListBegin(_etype1374, _size1371); + (*(this->success)).resize(_size1371); + uint32_t _i1375; + for (_i1375 = 0; _i1375 < _size1371; ++_i1375) { - xfer += (*(this->success))[_i1366].read(iprot); + xfer += iprot->readString((*(this->success))[_i1375]); } xfer += iprot->readListEnd(); } @@ -18186,11 +17879,11 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_presult::read(::apache::th } -ThriftHiveMetastore_get_part_specs_by_filter_args::~ThriftHiveMetastore_get_part_specs_by_filter_args() throw() { +ThriftHiveMetastore_get_partitions_by_filter_args::~ThriftHiveMetastore_get_partitions_by_filter_args() throw() { } -uint32_t ThriftHiveMetastore_get_part_specs_by_filter_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_partitions_by_filter_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -18236,8 +17929,8 @@ uint32_t ThriftHiveMetastore_get_part_specs_by_filter_args::read(::apache::thrif } break; case 4: - if (ftype == ::apache::thrift::protocol::T_I32) { - xfer += iprot->readI32(this->max_parts); + if (ftype == ::apache::thrift::protocol::T_I16) { + xfer += iprot->readI16(this->max_parts); this->__isset.max_parts = true; } else { xfer += iprot->skip(ftype); @@ -18255,10 +17948,10 @@ uint32_t ThriftHiveMetastore_get_part_specs_by_filter_args::read(::apache::thrif return xfer; } -uint32_t ThriftHiveMetastore_get_part_specs_by_filter_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_partitions_by_filter_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_part_specs_by_filter_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_by_filter_args"); xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); xfer += oprot->writeString(this->db_name); @@ -18272,8 +17965,8 @@ uint32_t ThriftHiveMetastore_get_part_specs_by_filter_args::write(::apache::thri xfer += oprot->writeString(this->filter); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("max_parts", ::apache::thrift::protocol::T_I32, 4); - xfer += oprot->writeI32(this->max_parts); + xfer += oprot->writeFieldBegin("max_parts", ::apache::thrift::protocol::T_I16, 4); + xfer += oprot->writeI16(this->max_parts); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -18282,14 +17975,14 @@ uint32_t ThriftHiveMetastore_get_part_specs_by_filter_args::write(::apache::thri } -ThriftHiveMetastore_get_part_specs_by_filter_pargs::~ThriftHiveMetastore_get_part_specs_by_filter_pargs() throw() { +ThriftHiveMetastore_get_partitions_by_filter_pargs::~ThriftHiveMetastore_get_partitions_by_filter_pargs() throw() { } -uint32_t ThriftHiveMetastore_get_part_specs_by_filter_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_partitions_by_filter_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_part_specs_by_filter_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_by_filter_pargs"); xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); xfer += oprot->writeString((*(this->db_name))); @@ -18303,8 +17996,8 @@ uint32_t ThriftHiveMetastore_get_part_specs_by_filter_pargs::write(::apache::thr xfer += oprot->writeString((*(this->filter))); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("max_parts", ::apache::thrift::protocol::T_I32, 4); - xfer += oprot->writeI32((*(this->max_parts))); + xfer += oprot->writeFieldBegin("max_parts", ::apache::thrift::protocol::T_I16, 4); + xfer += oprot->writeI16((*(this->max_parts))); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -18313,11 +18006,11 @@ uint32_t ThriftHiveMetastore_get_part_specs_by_filter_pargs::write(::apache::thr } -ThriftHiveMetastore_get_part_specs_by_filter_result::~ThriftHiveMetastore_get_part_specs_by_filter_result() throw() { +ThriftHiveMetastore_get_partitions_by_filter_result::~ThriftHiveMetastore_get_partitions_by_filter_result() throw() { } -uint32_t ThriftHiveMetastore_get_part_specs_by_filter_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_partitions_by_filter_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -18342,14 +18035,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 _size1367; - ::apache::thrift::protocol::TType _etype1370; - xfer += iprot->readListBegin(_etype1370, _size1367); - this->success.resize(_size1367); - uint32_t _i1371; - for (_i1371 = 0; _i1371 < _size1367; ++_i1371) + uint32_t _size1376; + ::apache::thrift::protocol::TType _etype1379; + xfer += iprot->readListBegin(_etype1379, _size1376); + this->success.resize(_size1376); + uint32_t _i1380; + for (_i1380 = 0; _i1380 < _size1376; ++_i1380) { - xfer += this->success[_i1371].read(iprot); + xfer += this->success[_i1380].read(iprot); } xfer += iprot->readListEnd(); } @@ -18386,20 +18079,20 @@ uint32_t ThriftHiveMetastore_get_part_specs_by_filter_result::read(::apache::thr return xfer; } -uint32_t ThriftHiveMetastore_get_part_specs_by_filter_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_partitions_by_filter_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_part_specs_by_filter_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_by_filter_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 _iter1372; - for (_iter1372 = this->success.begin(); _iter1372 != this->success.end(); ++_iter1372) + std::vector ::const_iterator _iter1381; + for (_iter1381 = this->success.begin(); _iter1381 != this->success.end(); ++_iter1381) { - xfer += (*_iter1372).write(oprot); + xfer += (*_iter1381).write(oprot); } xfer += oprot->writeListEnd(); } @@ -18419,11 +18112,11 @@ uint32_t ThriftHiveMetastore_get_part_specs_by_filter_result::write(::apache::th } -ThriftHiveMetastore_get_part_specs_by_filter_presult::~ThriftHiveMetastore_get_part_specs_by_filter_presult() throw() { +ThriftHiveMetastore_get_partitions_by_filter_presult::~ThriftHiveMetastore_get_partitions_by_filter_presult() throw() { } -uint32_t ThriftHiveMetastore_get_part_specs_by_filter_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_partitions_by_filter_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -18448,14 +18141,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 _size1373; - ::apache::thrift::protocol::TType _etype1376; - xfer += iprot->readListBegin(_etype1376, _size1373); - (*(this->success)).resize(_size1373); - uint32_t _i1377; - for (_i1377 = 0; _i1377 < _size1373; ++_i1377) + uint32_t _size1382; + ::apache::thrift::protocol::TType _etype1385; + xfer += iprot->readListBegin(_etype1385, _size1382); + (*(this->success)).resize(_size1382); + uint32_t _i1386; + for (_i1386 = 0; _i1386 < _size1382; ++_i1386) { - xfer += (*(this->success))[_i1377].read(iprot); + xfer += (*(this->success))[_i1386].read(iprot); } xfer += iprot->readListEnd(); } @@ -18493,11 +18186,11 @@ uint32_t ThriftHiveMetastore_get_part_specs_by_filter_presult::read(::apache::th } -ThriftHiveMetastore_get_partitions_by_expr_args::~ThriftHiveMetastore_get_partitions_by_expr_args() throw() { +ThriftHiveMetastore_get_part_specs_by_filter_args::~ThriftHiveMetastore_get_part_specs_by_filter_args() throw() { } -uint32_t ThriftHiveMetastore_get_partitions_by_expr_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_part_specs_by_filter_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -18519,9 +18212,33 @@ uint32_t ThriftHiveMetastore_get_partitions_by_expr_args::read(::apache::thrift: switch (fid) { case 1: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->req.read(iprot); - this->__isset.req = true; + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + this->__isset.tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->filter); + this->__isset.filter = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->max_parts); + this->__isset.max_parts = true; } else { xfer += iprot->skip(ftype); } @@ -18538,13 +18255,25 @@ uint32_t ThriftHiveMetastore_get_partitions_by_expr_args::read(::apache::thrift: return xfer; } -uint32_t ThriftHiveMetastore_get_partitions_by_expr_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_part_specs_by_filter_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_by_expr_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_part_specs_by_filter_args"); - xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += this->req.write(oprot); + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("filter", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->filter); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("max_parts", ::apache::thrift::protocol::T_I32, 4); + xfer += oprot->writeI32(this->max_parts); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -18553,17 +18282,29 @@ uint32_t ThriftHiveMetastore_get_partitions_by_expr_args::write(::apache::thrift } -ThriftHiveMetastore_get_partitions_by_expr_pargs::~ThriftHiveMetastore_get_partitions_by_expr_pargs() throw() { +ThriftHiveMetastore_get_part_specs_by_filter_pargs::~ThriftHiveMetastore_get_part_specs_by_filter_pargs() throw() { } -uint32_t ThriftHiveMetastore_get_partitions_by_expr_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_part_specs_by_filter_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_by_expr_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_part_specs_by_filter_pargs"); - xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += (*(this->req)).write(oprot); + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tbl_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("filter", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString((*(this->filter))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("max_parts", ::apache::thrift::protocol::T_I32, 4); + xfer += oprot->writeI32((*(this->max_parts))); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -18572,11 +18313,11 @@ uint32_t ThriftHiveMetastore_get_partitions_by_expr_pargs::write(::apache::thrif } -ThriftHiveMetastore_get_partitions_by_expr_result::~ThriftHiveMetastore_get_partitions_by_expr_result() throw() { +ThriftHiveMetastore_get_part_specs_by_filter_result::~ThriftHiveMetastore_get_part_specs_by_filter_result() throw() { } -uint32_t ThriftHiveMetastore_get_partitions_by_expr_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_part_specs_by_filter_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -18598,8 +18339,20 @@ uint32_t ThriftHiveMetastore_get_partitions_by_expr_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_LIST) { + { + this->success.clear(); + uint32_t _size1387; + ::apache::thrift::protocol::TType _etype1390; + xfer += iprot->readListBegin(_etype1390, _size1387); + this->success.resize(_size1387); + uint32_t _i1391; + for (_i1391 = 0; _i1391 < _size1387; ++_i1391) + { + xfer += this->success[_i1391].read(iprot); + } + xfer += iprot->readListEnd(); + } this->__isset.success = true; } else { xfer += iprot->skip(ftype); @@ -18633,15 +18386,23 @@ uint32_t ThriftHiveMetastore_get_partitions_by_expr_result::read(::apache::thrif return xfer; } -uint32_t ThriftHiveMetastore_get_partitions_by_expr_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_part_specs_by_filter_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_by_expr_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_part_specs_by_filter_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_STRUCT, static_cast(this->success.size())); + std::vector ::const_iterator _iter1392; + for (_iter1392 = this->success.begin(); _iter1392 != this->success.end(); ++_iter1392) + { + xfer += (*_iter1392).write(oprot); + } + xfer += oprot->writeListEnd(); + } xfer += oprot->writeFieldEnd(); } else if (this->__isset.o1) { xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); @@ -18658,11 +18419,11 @@ uint32_t ThriftHiveMetastore_get_partitions_by_expr_result::write(::apache::thri } -ThriftHiveMetastore_get_partitions_by_expr_presult::~ThriftHiveMetastore_get_partitions_by_expr_presult() throw() { +ThriftHiveMetastore_get_part_specs_by_filter_presult::~ThriftHiveMetastore_get_part_specs_by_filter_presult() throw() { } -uint32_t ThriftHiveMetastore_get_partitions_by_expr_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_part_specs_by_filter_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -18684,8 +18445,20 @@ uint32_t ThriftHiveMetastore_get_partitions_by_expr_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_LIST) { + { + (*(this->success)).clear(); + uint32_t _size1393; + ::apache::thrift::protocol::TType _etype1396; + xfer += iprot->readListBegin(_etype1396, _size1393); + (*(this->success)).resize(_size1393); + uint32_t _i1397; + for (_i1397 = 0; _i1397 < _size1393; ++_i1397) + { + xfer += (*(this->success))[_i1397].read(iprot); + } + xfer += iprot->readListEnd(); + } this->__isset.success = true; } else { xfer += iprot->skip(ftype); @@ -18720,11 +18493,11 @@ uint32_t ThriftHiveMetastore_get_partitions_by_expr_presult::read(::apache::thri } -ThriftHiveMetastore_get_num_partitions_by_filter_args::~ThriftHiveMetastore_get_num_partitions_by_filter_args() throw() { +ThriftHiveMetastore_get_partitions_by_expr_args::~ThriftHiveMetastore_get_partitions_by_expr_args() throw() { } -uint32_t ThriftHiveMetastore_get_num_partitions_by_filter_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_partitions_by_expr_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -18746,25 +18519,9 @@ uint32_t ThriftHiveMetastore_get_num_partitions_by_filter_args::read(::apache::t switch (fid) { case 1: - if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->db_name); - this->__isset.db_name = true; - } else { - xfer += iprot->skip(ftype); - } - break; - case 2: - if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->tbl_name); - this->__isset.tbl_name = true; - } else { - xfer += iprot->skip(ftype); - } - break; - case 3: - if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->filter); - this->__isset.filter = true; + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->req.read(iprot); + this->__isset.req = true; } else { xfer += iprot->skip(ftype); } @@ -18781,21 +18538,13 @@ uint32_t ThriftHiveMetastore_get_num_partitions_by_filter_args::read(::apache::t return xfer; } -uint32_t ThriftHiveMetastore_get_num_partitions_by_filter_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_partitions_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_num_partitions_by_filter_args"); - - xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString(this->db_name); - xfer += oprot->writeFieldEnd(); - - xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); - xfer += oprot->writeString(this->tbl_name); - xfer += oprot->writeFieldEnd(); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_by_expr_args"); - xfer += oprot->writeFieldBegin("filter", ::apache::thrift::protocol::T_STRING, 3); - xfer += oprot->writeString(this->filter); + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->req.write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -18804,25 +18553,17 @@ uint32_t ThriftHiveMetastore_get_num_partitions_by_filter_args::write(::apache:: } -ThriftHiveMetastore_get_num_partitions_by_filter_pargs::~ThriftHiveMetastore_get_num_partitions_by_filter_pargs() throw() { +ThriftHiveMetastore_get_partitions_by_expr_pargs::~ThriftHiveMetastore_get_partitions_by_expr_pargs() throw() { } -uint32_t ThriftHiveMetastore_get_num_partitions_by_filter_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_partitions_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_num_partitions_by_filter_pargs"); - - xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString((*(this->db_name))); - xfer += oprot->writeFieldEnd(); - - xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); - xfer += oprot->writeString((*(this->tbl_name))); - xfer += oprot->writeFieldEnd(); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_by_expr_pargs"); - xfer += oprot->writeFieldBegin("filter", ::apache::thrift::protocol::T_STRING, 3); - xfer += oprot->writeString((*(this->filter))); + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->req)).write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -18831,11 +18572,11 @@ uint32_t ThriftHiveMetastore_get_num_partitions_by_filter_pargs::write(::apache: } -ThriftHiveMetastore_get_num_partitions_by_filter_result::~ThriftHiveMetastore_get_num_partitions_by_filter_result() throw() { +ThriftHiveMetastore_get_partitions_by_expr_result::~ThriftHiveMetastore_get_partitions_by_expr_result() throw() { } -uint32_t ThriftHiveMetastore_get_num_partitions_by_filter_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_partitions_by_expr_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -18857,8 +18598,8 @@ uint32_t ThriftHiveMetastore_get_num_partitions_by_filter_result::read(::apache: switch (fid) { case 0: - if (ftype == ::apache::thrift::protocol::T_I32) { - xfer += iprot->readI32(this->success); + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); this->__isset.success = true; } else { xfer += iprot->skip(ftype); @@ -18892,15 +18633,15 @@ uint32_t ThriftHiveMetastore_get_num_partitions_by_filter_result::read(::apache: return xfer; } -uint32_t ThriftHiveMetastore_get_num_partitions_by_filter_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_partitions_by_expr_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_num_partitions_by_filter_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_by_expr_result"); if (this->__isset.success) { - xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I32, 0); - xfer += oprot->writeI32(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); @@ -18917,11 +18658,11 @@ uint32_t ThriftHiveMetastore_get_num_partitions_by_filter_result::write(::apache } -ThriftHiveMetastore_get_num_partitions_by_filter_presult::~ThriftHiveMetastore_get_num_partitions_by_filter_presult() throw() { +ThriftHiveMetastore_get_partitions_by_expr_presult::~ThriftHiveMetastore_get_partitions_by_expr_presult() throw() { } -uint32_t ThriftHiveMetastore_get_num_partitions_by_filter_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_partitions_by_expr_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -18943,8 +18684,8 @@ uint32_t ThriftHiveMetastore_get_num_partitions_by_filter_presult::read(::apache switch (fid) { case 0: - if (ftype == ::apache::thrift::protocol::T_I32) { - xfer += iprot->readI32((*(this->success))); + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); this->__isset.success = true; } else { xfer += iprot->skip(ftype); @@ -18979,11 +18720,11 @@ uint32_t ThriftHiveMetastore_get_num_partitions_by_filter_presult::read(::apache } -ThriftHiveMetastore_get_partitions_by_names_args::~ThriftHiveMetastore_get_partitions_by_names_args() throw() { +ThriftHiveMetastore_get_num_partitions_by_filter_args::~ThriftHiveMetastore_get_num_partitions_by_filter_args() throw() { } -uint32_t ThriftHiveMetastore_get_partitions_by_names_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_num_partitions_by_filter_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -19021,21 +18762,9 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_args::read(::apache::thrift } break; case 3: - if (ftype == ::apache::thrift::protocol::T_LIST) { - { - this->names.clear(); - 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[_i1382]); - } - xfer += iprot->readListEnd(); - } - this->__isset.names = true; + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->filter); + this->__isset.filter = true; } else { xfer += iprot->skip(ftype); } @@ -19052,10 +18781,10 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_args::read(::apache::thrift return xfer; } -uint32_t ThriftHiveMetastore_get_partitions_by_names_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_num_partitions_by_filter_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_by_names_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_num_partitions_by_filter_args"); xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); xfer += oprot->writeString(this->db_name); @@ -19065,16 +18794,8 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_args::write(::apache::thrif xfer += oprot->writeString(this->tbl_name); xfer += oprot->writeFieldEnd(); - 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 _iter1383; - for (_iter1383 = this->names.begin(); _iter1383 != this->names.end(); ++_iter1383) - { - xfer += oprot->writeString((*_iter1383)); - } - xfer += oprot->writeListEnd(); - } + xfer += oprot->writeFieldBegin("filter", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->filter); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -19083,14 +18804,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_args::write(::apache::thrif } -ThriftHiveMetastore_get_partitions_by_names_pargs::~ThriftHiveMetastore_get_partitions_by_names_pargs() throw() { +ThriftHiveMetastore_get_num_partitions_by_filter_pargs::~ThriftHiveMetastore_get_num_partitions_by_filter_pargs() throw() { } -uint32_t ThriftHiveMetastore_get_partitions_by_names_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_num_partitions_by_filter_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_by_names_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_num_partitions_by_filter_pargs"); xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); xfer += oprot->writeString((*(this->db_name))); @@ -19100,16 +18821,8 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_pargs::write(::apache::thri xfer += oprot->writeString((*(this->tbl_name))); xfer += oprot->writeFieldEnd(); - 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 _iter1384; - for (_iter1384 = (*(this->names)).begin(); _iter1384 != (*(this->names)).end(); ++_iter1384) - { - xfer += oprot->writeString((*_iter1384)); - } - xfer += oprot->writeListEnd(); - } + xfer += oprot->writeFieldBegin("filter", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString((*(this->filter))); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -19118,11 +18831,11 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_pargs::write(::apache::thri } -ThriftHiveMetastore_get_partitions_by_names_result::~ThriftHiveMetastore_get_partitions_by_names_result() throw() { +ThriftHiveMetastore_get_num_partitions_by_filter_result::~ThriftHiveMetastore_get_num_partitions_by_filter_result() throw() { } -uint32_t ThriftHiveMetastore_get_partitions_by_names_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_num_partitions_by_filter_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -19144,20 +18857,8 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_result::read(::apache::thri switch (fid) { case 0: - if (ftype == ::apache::thrift::protocol::T_LIST) { - { - this->success.clear(); - uint32_t _size1385; - ::apache::thrift::protocol::TType _etype1388; - xfer += iprot->readListBegin(_etype1388, _size1385); - this->success.resize(_size1385); - uint32_t _i1389; - for (_i1389 = 0; _i1389 < _size1385; ++_i1389) - { - xfer += this->success[_i1389].read(iprot); - } - xfer += iprot->readListEnd(); - } + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->success); this->__isset.success = true; } else { xfer += iprot->skip(ftype); @@ -19191,23 +18892,15 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_result::read(::apache::thri return xfer; } -uint32_t ThriftHiveMetastore_get_partitions_by_names_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_num_partitions_by_filter_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_by_names_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_num_partitions_by_filter_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 _iter1390; - for (_iter1390 = this->success.begin(); _iter1390 != this->success.end(); ++_iter1390) - { - xfer += (*_iter1390).write(oprot); - } - xfer += oprot->writeListEnd(); - } + 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); @@ -19224,11 +18917,11 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_result::write(::apache::thr } -ThriftHiveMetastore_get_partitions_by_names_presult::~ThriftHiveMetastore_get_partitions_by_names_presult() throw() { +ThriftHiveMetastore_get_num_partitions_by_filter_presult::~ThriftHiveMetastore_get_num_partitions_by_filter_presult() throw() { } -uint32_t ThriftHiveMetastore_get_partitions_by_names_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_num_partitions_by_filter_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -19250,20 +18943,8 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_presult::read(::apache::thr switch (fid) { case 0: - if (ftype == ::apache::thrift::protocol::T_LIST) { - { - (*(this->success)).clear(); - uint32_t _size1391; - ::apache::thrift::protocol::TType _etype1394; - xfer += iprot->readListBegin(_etype1394, _size1391); - (*(this->success)).resize(_size1391); - uint32_t _i1395; - for (_i1395 = 0; _i1395 < _size1391; ++_i1395) - { - xfer += (*(this->success))[_i1395].read(iprot); - } - xfer += iprot->readListEnd(); - } + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32((*(this->success))); this->__isset.success = true; } else { xfer += iprot->skip(ftype); @@ -19298,11 +18979,11 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_presult::read(::apache::thr } -ThriftHiveMetastore_alter_partition_args::~ThriftHiveMetastore_alter_partition_args() throw() { +ThriftHiveMetastore_get_partitions_by_names_args::~ThriftHiveMetastore_get_partitions_by_names_args() throw() { } -uint32_t ThriftHiveMetastore_alter_partition_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_partitions_by_names_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -19340,9 +19021,21 @@ uint32_t ThriftHiveMetastore_alter_partition_args::read(::apache::thrift::protoc } break; case 3: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->new_part.read(iprot); - this->__isset.new_part = true; + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->names.clear(); + uint32_t _size1398; + ::apache::thrift::protocol::TType _etype1401; + xfer += iprot->readListBegin(_etype1401, _size1398); + this->names.resize(_size1398); + uint32_t _i1402; + for (_i1402 = 0; _i1402 < _size1398; ++_i1402) + { + xfer += iprot->readString(this->names[_i1402]); + } + xfer += iprot->readListEnd(); + } + this->__isset.names = true; } else { xfer += iprot->skip(ftype); } @@ -19359,10 +19052,10 @@ uint32_t ThriftHiveMetastore_alter_partition_args::read(::apache::thrift::protoc return xfer; } -uint32_t ThriftHiveMetastore_alter_partition_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_partitions_by_names_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_partition_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_by_names_args"); xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); xfer += oprot->writeString(this->db_name); @@ -19372,8 +19065,16 @@ uint32_t ThriftHiveMetastore_alter_partition_args::write(::apache::thrift::proto xfer += oprot->writeString(this->tbl_name); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("new_part", ::apache::thrift::protocol::T_STRUCT, 3); - xfer += this->new_part.write(oprot); + 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 _iter1403; + for (_iter1403 = this->names.begin(); _iter1403 != this->names.end(); ++_iter1403) + { + xfer += oprot->writeString((*_iter1403)); + } + xfer += oprot->writeListEnd(); + } xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -19382,14 +19083,14 @@ uint32_t ThriftHiveMetastore_alter_partition_args::write(::apache::thrift::proto } -ThriftHiveMetastore_alter_partition_pargs::~ThriftHiveMetastore_alter_partition_pargs() throw() { +ThriftHiveMetastore_get_partitions_by_names_pargs::~ThriftHiveMetastore_get_partitions_by_names_pargs() throw() { } -uint32_t ThriftHiveMetastore_alter_partition_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_partitions_by_names_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_partition_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_by_names_pargs"); xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); xfer += oprot->writeString((*(this->db_name))); @@ -19399,8 +19100,16 @@ uint32_t ThriftHiveMetastore_alter_partition_pargs::write(::apache::thrift::prot xfer += oprot->writeString((*(this->tbl_name))); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("new_part", ::apache::thrift::protocol::T_STRUCT, 3); - xfer += (*(this->new_part)).write(oprot); + 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 _iter1404; + for (_iter1404 = (*(this->names)).begin(); _iter1404 != (*(this->names)).end(); ++_iter1404) + { + xfer += oprot->writeString((*_iter1404)); + } + xfer += oprot->writeListEnd(); + } xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -19409,11 +19118,11 @@ uint32_t ThriftHiveMetastore_alter_partition_pargs::write(::apache::thrift::prot } -ThriftHiveMetastore_alter_partition_result::~ThriftHiveMetastore_alter_partition_result() throw() { +ThriftHiveMetastore_get_partitions_by_names_result::~ThriftHiveMetastore_get_partitions_by_names_result() throw() { } -uint32_t ThriftHiveMetastore_alter_partition_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_partitions_by_names_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -19434,6 +19143,26 @@ uint32_t ThriftHiveMetastore_alter_partition_result::read(::apache::thrift::prot } switch (fid) { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size1405; + ::apache::thrift::protocol::TType _etype1408; + xfer += iprot->readListBegin(_etype1408, _size1405); + this->success.resize(_size1405); + uint32_t _i1409; + for (_i1409 = 0; _i1409 < _size1405; ++_i1409) + { + xfer += this->success[_i1409].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); @@ -19462,13 +19191,25 @@ uint32_t ThriftHiveMetastore_alter_partition_result::read(::apache::thrift::prot return xfer; } -uint32_t ThriftHiveMetastore_alter_partition_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_partitions_by_names_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_partition_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_by_names_result"); - if (this->__isset.o1) { + 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 _iter1410; + for (_iter1410 = this->success.begin(); _iter1410 != this->success.end(); ++_iter1410) + { + xfer += (*_iter1410).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(); @@ -19483,11 +19224,270 @@ uint32_t ThriftHiveMetastore_alter_partition_result::write(::apache::thrift::pro } -ThriftHiveMetastore_alter_partition_presult::~ThriftHiveMetastore_alter_partition_presult() throw() { +ThriftHiveMetastore_get_partitions_by_names_presult::~ThriftHiveMetastore_get_partitions_by_names_presult() throw() { } -uint32_t ThriftHiveMetastore_alter_partition_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_partitions_by_names_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 _size1411; + ::apache::thrift::protocol::TType _etype1414; + xfer += iprot->readListBegin(_etype1414, _size1411); + (*(this->success)).resize(_size1411); + uint32_t _i1415; + for (_i1415 = 0; _i1415 < _size1411; ++_i1415) + { + xfer += (*(this->success))[_i1415].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; + 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; +} + + +ThriftHiveMetastore_alter_partition_args::~ThriftHiveMetastore_alter_partition_args() throw() { +} + + +uint32_t ThriftHiveMetastore_alter_partition_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->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + this->__isset.tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->new_part.read(iprot); + this->__isset.new_part = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_alter_partition_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_partition_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("new_part", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->new_part.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_partition_pargs::~ThriftHiveMetastore_alter_partition_pargs() throw() { +} + + +uint32_t ThriftHiveMetastore_alter_partition_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_partition_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tbl_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("new_part", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += (*(this->new_part)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_partition_result::~ThriftHiveMetastore_alter_partition_result() throw() { +} + + +uint32_t ThriftHiveMetastore_alter_partition_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); + 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_alter_partition_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_partition_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_alter_partition_presult::~ThriftHiveMetastore_alter_partition_presult() throw() { +} + + +uint32_t ThriftHiveMetastore_alter_partition_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -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 _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) + uint32_t _size1416; + ::apache::thrift::protocol::TType _etype1419; + xfer += iprot->readListBegin(_etype1419, _size1416); + this->new_parts.resize(_size1416); + uint32_t _i1420; + for (_i1420 = 0; _i1420 < _size1416; ++_i1420) { - xfer += this->new_parts[_i1400].read(iprot); + xfer += this->new_parts[_i1420].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 _iter1401; - for (_iter1401 = this->new_parts.begin(); _iter1401 != this->new_parts.end(); ++_iter1401) + std::vector ::const_iterator _iter1421; + for (_iter1421 = this->new_parts.begin(); _iter1421 != this->new_parts.end(); ++_iter1421) { - xfer += (*_iter1401).write(oprot); + xfer += (*_iter1421).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 _iter1402; - for (_iter1402 = (*(this->new_parts)).begin(); _iter1402 != (*(this->new_parts)).end(); ++_iter1402) + std::vector ::const_iterator _iter1422; + for (_iter1422 = (*(this->new_parts)).begin(); _iter1422 != (*(this->new_parts)).end(); ++_iter1422) { - xfer += (*_iter1402).write(oprot); + xfer += (*_iter1422).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 _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) + uint32_t _size1423; + ::apache::thrift::protocol::TType _etype1426; + xfer += iprot->readListBegin(_etype1426, _size1423); + this->new_parts.resize(_size1423); + uint32_t _i1427; + for (_i1427 = 0; _i1427 < _size1423; ++_i1427) { - xfer += this->new_parts[_i1407].read(iprot); + xfer += this->new_parts[_i1427].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 _iter1408; - for (_iter1408 = this->new_parts.begin(); _iter1408 != this->new_parts.end(); ++_iter1408) + std::vector ::const_iterator _iter1428; + for (_iter1428 = this->new_parts.begin(); _iter1428 != this->new_parts.end(); ++_iter1428) { - xfer += (*_iter1408).write(oprot); + xfer += (*_iter1428).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 _iter1409; - for (_iter1409 = (*(this->new_parts)).begin(); _iter1409 != (*(this->new_parts)).end(); ++_iter1409) + std::vector ::const_iterator _iter1429; + for (_iter1429 = (*(this->new_parts)).begin(); _iter1429 != (*(this->new_parts)).end(); ++_iter1429) { - xfer += (*_iter1409).write(oprot); + xfer += (*_iter1429).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 _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) + uint32_t _size1430; + ::apache::thrift::protocol::TType _etype1433; + xfer += iprot->readListBegin(_etype1433, _size1430); + this->part_vals.resize(_size1430); + uint32_t _i1434; + for (_i1434 = 0; _i1434 < _size1430; ++_i1434) { - xfer += iprot->readString(this->part_vals[_i1414]); + xfer += iprot->readString(this->part_vals[_i1434]); } 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 _iter1415; - for (_iter1415 = this->part_vals.begin(); _iter1415 != this->part_vals.end(); ++_iter1415) + std::vector ::const_iterator _iter1435; + for (_iter1435 = this->part_vals.begin(); _iter1435 != this->part_vals.end(); ++_iter1435) { - xfer += oprot->writeString((*_iter1415)); + xfer += oprot->writeString((*_iter1435)); } 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 _iter1416; - for (_iter1416 = (*(this->part_vals)).begin(); _iter1416 != (*(this->part_vals)).end(); ++_iter1416) + std::vector ::const_iterator _iter1436; + for (_iter1436 = (*(this->part_vals)).begin(); _iter1436 != (*(this->part_vals)).end(); ++_iter1436) { - xfer += oprot->writeString((*_iter1416)); + xfer += oprot->writeString((*_iter1436)); } 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 _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) + uint32_t _size1437; + ::apache::thrift::protocol::TType _etype1440; + xfer += iprot->readListBegin(_etype1440, _size1437); + this->part_vals.resize(_size1437); + uint32_t _i1441; + for (_i1441 = 0; _i1441 < _size1437; ++_i1441) { - xfer += iprot->readString(this->part_vals[_i1421]); + xfer += iprot->readString(this->part_vals[_i1441]); } 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 _iter1422; - for (_iter1422 = this->part_vals.begin(); _iter1422 != this->part_vals.end(); ++_iter1422) + std::vector ::const_iterator _iter1442; + for (_iter1442 = this->part_vals.begin(); _iter1442 != this->part_vals.end(); ++_iter1442) { - xfer += oprot->writeString((*_iter1422)); + xfer += oprot->writeString((*_iter1442)); } 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 _iter1423; - for (_iter1423 = (*(this->part_vals)).begin(); _iter1423 != (*(this->part_vals)).end(); ++_iter1423) + std::vector ::const_iterator _iter1443; + for (_iter1443 = (*(this->part_vals)).begin(); _iter1443 != (*(this->part_vals)).end(); ++_iter1443) { - xfer += oprot->writeString((*_iter1423)); + xfer += oprot->writeString((*_iter1443)); } 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 _size1424; - ::apache::thrift::protocol::TType _etype1427; - xfer += iprot->readListBegin(_etype1427, _size1424); - this->success.resize(_size1424); - uint32_t _i1428; - for (_i1428 = 0; _i1428 < _size1424; ++_i1428) + uint32_t _size1444; + ::apache::thrift::protocol::TType _etype1447; + xfer += iprot->readListBegin(_etype1447, _size1444); + this->success.resize(_size1444); + uint32_t _i1448; + for (_i1448 = 0; _i1448 < _size1444; ++_i1448) { - xfer += iprot->readString(this->success[_i1428]); + xfer += iprot->readString(this->success[_i1448]); } 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 _iter1429; - for (_iter1429 = this->success.begin(); _iter1429 != this->success.end(); ++_iter1429) + std::vector ::const_iterator _iter1449; + for (_iter1449 = this->success.begin(); _iter1449 != this->success.end(); ++_iter1449) { - xfer += oprot->writeString((*_iter1429)); + xfer += oprot->writeString((*_iter1449)); } 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 _size1430; - ::apache::thrift::protocol::TType _etype1433; - xfer += iprot->readListBegin(_etype1433, _size1430); - (*(this->success)).resize(_size1430); - uint32_t _i1434; - for (_i1434 = 0; _i1434 < _size1430; ++_i1434) + uint32_t _size1450; + ::apache::thrift::protocol::TType _etype1453; + xfer += iprot->readListBegin(_etype1453, _size1450); + (*(this->success)).resize(_size1450); + uint32_t _i1454; + for (_i1454 = 0; _i1454 < _size1450; ++_i1454) { - xfer += iprot->readString((*(this->success))[_i1434]); + xfer += iprot->readString((*(this->success))[_i1454]); } 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 _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) + uint32_t _size1455; + ::apache::thrift::protocol::TType _ktype1456; + ::apache::thrift::protocol::TType _vtype1457; + xfer += iprot->readMapBegin(_ktype1456, _vtype1457, _size1455); + uint32_t _i1459; + for (_i1459 = 0; _i1459 < _size1455; ++_i1459) { - std::string _key1440; - xfer += iprot->readString(_key1440); - std::string& _val1441 = this->success[_key1440]; - xfer += iprot->readString(_val1441); + std::string _key1460; + xfer += iprot->readString(_key1460); + std::string& _val1461 = this->success[_key1460]; + xfer += iprot->readString(_val1461); } 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 _iter1442; - for (_iter1442 = this->success.begin(); _iter1442 != this->success.end(); ++_iter1442) + std::map ::const_iterator _iter1462; + for (_iter1462 = this->success.begin(); _iter1462 != this->success.end(); ++_iter1462) { - xfer += oprot->writeString(_iter1442->first); - xfer += oprot->writeString(_iter1442->second); + xfer += oprot->writeString(_iter1462->first); + xfer += oprot->writeString(_iter1462->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 _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) + uint32_t _size1463; + ::apache::thrift::protocol::TType _ktype1464; + ::apache::thrift::protocol::TType _vtype1465; + xfer += iprot->readMapBegin(_ktype1464, _vtype1465, _size1463); + uint32_t _i1467; + for (_i1467 = 0; _i1467 < _size1463; ++_i1467) { - std::string _key1448; - xfer += iprot->readString(_key1448); - std::string& _val1449 = (*(this->success))[_key1448]; - xfer += iprot->readString(_val1449); + std::string _key1468; + xfer += iprot->readString(_key1468); + std::string& _val1469 = (*(this->success))[_key1468]; + xfer += iprot->readString(_val1469); } 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 _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) + uint32_t _size1470; + ::apache::thrift::protocol::TType _ktype1471; + ::apache::thrift::protocol::TType _vtype1472; + xfer += iprot->readMapBegin(_ktype1471, _vtype1472, _size1470); + uint32_t _i1474; + for (_i1474 = 0; _i1474 < _size1470; ++_i1474) { - std::string _key1455; - xfer += iprot->readString(_key1455); - std::string& _val1456 = this->part_vals[_key1455]; - xfer += iprot->readString(_val1456); + std::string _key1475; + xfer += iprot->readString(_key1475); + std::string& _val1476 = this->part_vals[_key1475]; + xfer += iprot->readString(_val1476); } 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 ecast1457; - xfer += iprot->readI32(ecast1457); - this->eventType = (PartitionEventType::type)ecast1457; + int32_t ecast1477; + xfer += iprot->readI32(ecast1477); + this->eventType = (PartitionEventType::type)ecast1477; 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 _iter1458; - for (_iter1458 = this->part_vals.begin(); _iter1458 != this->part_vals.end(); ++_iter1458) + std::map ::const_iterator _iter1478; + for (_iter1478 = this->part_vals.begin(); _iter1478 != this->part_vals.end(); ++_iter1478) { - xfer += oprot->writeString(_iter1458->first); - xfer += oprot->writeString(_iter1458->second); + xfer += oprot->writeString(_iter1478->first); + xfer += oprot->writeString(_iter1478->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 _iter1459; - for (_iter1459 = (*(this->part_vals)).begin(); _iter1459 != (*(this->part_vals)).end(); ++_iter1459) + std::map ::const_iterator _iter1479; + for (_iter1479 = (*(this->part_vals)).begin(); _iter1479 != (*(this->part_vals)).end(); ++_iter1479) { - xfer += oprot->writeString(_iter1459->first); - xfer += oprot->writeString(_iter1459->second); + xfer += oprot->writeString(_iter1479->first); + xfer += oprot->writeString(_iter1479->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 _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) + uint32_t _size1480; + ::apache::thrift::protocol::TType _ktype1481; + ::apache::thrift::protocol::TType _vtype1482; + xfer += iprot->readMapBegin(_ktype1481, _vtype1482, _size1480); + uint32_t _i1484; + for (_i1484 = 0; _i1484 < _size1480; ++_i1484) { - std::string _key1465; - xfer += iprot->readString(_key1465); - std::string& _val1466 = this->part_vals[_key1465]; - xfer += iprot->readString(_val1466); + std::string _key1485; + xfer += iprot->readString(_key1485); + std::string& _val1486 = this->part_vals[_key1485]; + xfer += iprot->readString(_val1486); } 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 ecast1467; - xfer += iprot->readI32(ecast1467); - this->eventType = (PartitionEventType::type)ecast1467; + int32_t ecast1487; + xfer += iprot->readI32(ecast1487); + this->eventType = (PartitionEventType::type)ecast1487; 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 _iter1468; - for (_iter1468 = this->part_vals.begin(); _iter1468 != this->part_vals.end(); ++_iter1468) + std::map ::const_iterator _iter1488; + for (_iter1488 = this->part_vals.begin(); _iter1488 != this->part_vals.end(); ++_iter1488) { - xfer += oprot->writeString(_iter1468->first); - xfer += oprot->writeString(_iter1468->second); + xfer += oprot->writeString(_iter1488->first); + xfer += oprot->writeString(_iter1488->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 _iter1469; - for (_iter1469 = (*(this->part_vals)).begin(); _iter1469 != (*(this->part_vals)).end(); ++_iter1469) + std::map ::const_iterator _iter1489; + for (_iter1489 = (*(this->part_vals)).begin(); _iter1489 != (*(this->part_vals)).end(); ++_iter1489) { - xfer += oprot->writeString(_iter1469->first); - xfer += oprot->writeString(_iter1469->second); + xfer += oprot->writeString(_iter1489->first); + xfer += oprot->writeString(_iter1489->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 _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 _size1490; + ::apache::thrift::protocol::TType _etype1493; + xfer += iprot->readListBegin(_etype1493, _size1490); + this->success.resize(_size1490); + uint32_t _i1494; + for (_i1494 = 0; _i1494 < _size1490; ++_i1494) { - xfer += this->success[_i1474].read(iprot); + xfer += this->success[_i1494].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 _iter1475; - for (_iter1475 = this->success.begin(); _iter1475 != this->success.end(); ++_iter1475) + std::vector ::const_iterator _iter1495; + for (_iter1495 = this->success.begin(); _iter1495 != this->success.end(); ++_iter1495) { - xfer += (*_iter1475).write(oprot); + xfer += (*_iter1495).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 _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 _size1496; + ::apache::thrift::protocol::TType _etype1499; + xfer += iprot->readListBegin(_etype1499, _size1496); + (*(this->success)).resize(_size1496); + uint32_t _i1500; + for (_i1500 = 0; _i1500 < _size1496; ++_i1500) { - xfer += (*(this->success))[_i1480].read(iprot); + xfer += (*(this->success))[_i1500].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 _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 _size1501; + ::apache::thrift::protocol::TType _etype1504; + xfer += iprot->readListBegin(_etype1504, _size1501); + this->success.resize(_size1501); + uint32_t _i1505; + for (_i1505 = 0; _i1505 < _size1501; ++_i1505) { - xfer += iprot->readString(this->success[_i1485]); + xfer += iprot->readString(this->success[_i1505]); } 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 _iter1486; - for (_iter1486 = this->success.begin(); _iter1486 != this->success.end(); ++_iter1486) + std::vector ::const_iterator _iter1506; + for (_iter1506 = this->success.begin(); _iter1506 != this->success.end(); ++_iter1506) { - xfer += oprot->writeString((*_iter1486)); + xfer += oprot->writeString((*_iter1506)); } 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 _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 _size1507; + ::apache::thrift::protocol::TType _etype1510; + xfer += iprot->readListBegin(_etype1510, _size1507); + (*(this->success)).resize(_size1507); + uint32_t _i1511; + for (_i1511 = 0; _i1511 < _size1507; ++_i1511) { - xfer += iprot->readString((*(this->success))[_i1491]); + xfer += iprot->readString((*(this->success))[_i1511]); } 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 _size1492; - ::apache::thrift::protocol::TType _etype1495; - xfer += iprot->readListBegin(_etype1495, _size1492); - this->success.resize(_size1492); - uint32_t _i1496; - for (_i1496 = 0; _i1496 < _size1492; ++_i1496) + uint32_t _size1512; + ::apache::thrift::protocol::TType _etype1515; + xfer += iprot->readListBegin(_etype1515, _size1512); + this->success.resize(_size1512); + uint32_t _i1516; + for (_i1516 = 0; _i1516 < _size1512; ++_i1516) { - xfer += iprot->readString(this->success[_i1496]); + xfer += iprot->readString(this->success[_i1516]); } 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 _iter1497; - for (_iter1497 = this->success.begin(); _iter1497 != this->success.end(); ++_iter1497) + std::vector ::const_iterator _iter1517; + for (_iter1517 = this->success.begin(); _iter1517 != this->success.end(); ++_iter1517) { - xfer += oprot->writeString((*_iter1497)); + xfer += oprot->writeString((*_iter1517)); } 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 _size1498; - ::apache::thrift::protocol::TType _etype1501; - xfer += iprot->readListBegin(_etype1501, _size1498); - (*(this->success)).resize(_size1498); - uint32_t _i1502; - for (_i1502 = 0; _i1502 < _size1498; ++_i1502) + 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 += iprot->readString((*(this->success))[_i1502]); + xfer += iprot->readString((*(this->success))[_i1522]); } xfer += iprot->readListEnd(); } @@ -28746,26 +28746,934 @@ uint32_t ThriftHiveMetastore_get_function_presult::read(::apache::thrift::protoc } switch (fid) { - case 0: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += (*(this->success)).read(iprot); - this->__isset.success = true; + 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; +} + + +ThriftHiveMetastore_get_all_functions_args::~ThriftHiveMetastore_get_all_functions_args() throw() { +} + + +uint32_t ThriftHiveMetastore_get_all_functions_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_get_all_functions_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_functions_args"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_all_functions_pargs::~ThriftHiveMetastore_get_all_functions_pargs() throw() { +} + + +uint32_t ThriftHiveMetastore_get_all_functions_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_functions_pargs"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_all_functions_result::~ThriftHiveMetastore_get_all_functions_result() throw() { +} + + +uint32_t ThriftHiveMetastore_get_all_functions_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_all_functions_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_functions_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_all_functions_presult::~ThriftHiveMetastore_get_all_functions_presult() throw() { +} + + +uint32_t ThriftHiveMetastore_get_all_functions_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_create_role_args::~ThriftHiveMetastore_create_role_args() throw() { +} + + +uint32_t ThriftHiveMetastore_create_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->role.read(iprot); + this->__isset.role = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_create_role_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_role_args"); + + xfer += oprot->writeFieldBegin("role", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->role.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_role_pargs::~ThriftHiveMetastore_create_role_pargs() throw() { +} + + +uint32_t ThriftHiveMetastore_create_role_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_role_pargs"); + + xfer += oprot->writeFieldBegin("role", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->role)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_create_role_result::~ThriftHiveMetastore_create_role_result() throw() { +} + + +uint32_t ThriftHiveMetastore_create_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_create_role_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_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_create_role_presult::~ThriftHiveMetastore_create_role_presult() throw() { +} + + +uint32_t ThriftHiveMetastore_create_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_drop_role_args::~ThriftHiveMetastore_drop_role_args() throw() { +} + + +uint32_t ThriftHiveMetastore_drop_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; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_role_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_role_args"); + + xfer += oprot->writeFieldBegin("role_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->role_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_role_pargs::~ThriftHiveMetastore_drop_role_pargs() throw() { +} + + +uint32_t ThriftHiveMetastore_drop_role_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_role_pargs"); + + xfer += oprot->writeFieldBegin("role_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->role_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_role_result::~ThriftHiveMetastore_drop_role_result() throw() { +} + + +uint32_t ThriftHiveMetastore_drop_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_drop_role_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_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_drop_role_presult::~ThriftHiveMetastore_drop_role_presult() throw() { +} + + +uint32_t ThriftHiveMetastore_drop_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_get_role_names_args::~ThriftHiveMetastore_get_role_names_args() throw() { +} + + +uint32_t ThriftHiveMetastore_get_role_names_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_get_role_names_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_role_names_args"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_role_names_pargs::~ThriftHiveMetastore_get_role_names_pargs() throw() { +} + + +uint32_t ThriftHiveMetastore_get_role_names_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_role_names_pargs"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_role_names_result::~ThriftHiveMetastore_get_role_names_result() throw() { +} + + +uint32_t ThriftHiveMetastore_get_role_names_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 _size1523; + ::apache::thrift::protocol::TType _etype1526; + xfer += iprot->readListBegin(_etype1526, _size1523); + this->success.resize(_size1523); + uint32_t _i1527; + for (_i1527 = 0; _i1527 < _size1523; ++_i1527) + { + xfer += iprot->readString(this->success[_i1527]); + } + 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_get_role_names_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_role_names_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 _iter1528; + for (_iter1528 = this->success.begin(); _iter1528 != this->success.end(); ++_iter1528) + { + xfer += oprot->writeString((*_iter1528)); + } + 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_get_role_names_presult::~ThriftHiveMetastore_get_role_names_presult() throw() { +} + + +uint32_t ThriftHiveMetastore_get_role_names_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 _size1529; + ::apache::thrift::protocol::TType _etype1532; + xfer += iprot->readListBegin(_etype1532, _size1529); + (*(this->success)).resize(_size1529); + uint32_t _i1533; + for (_i1533 = 0; _i1533 < _size1529; ++_i1533) + { + xfer += iprot->readString((*(this->success))[_i1533]); + } + 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_role_args::~ThriftHiveMetastore_grant_role_args() throw() { +} + + +uint32_t ThriftHiveMetastore_grant_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 1: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->o1.read(iprot); - this->__isset.o1 = true; + 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 2: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->o2.read(iprot); - this->__isset.o2 = true; + case 3: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast1534; + xfer += iprot->readI32(ecast1534); + this->principal_type = (PrincipalType::type)ecast1534; + this->__isset.principal_type = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->grantor); + this->__isset.grantor = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast1535; + xfer += iprot->readI32(ecast1535); + this->grantorType = (PrincipalType::type)ecast1535; + this->__isset.grantorType = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->grant_option); + this->__isset.grant_option = true; } else { xfer += iprot->skip(ftype); } @@ -28782,43 +29690,34 @@ uint32_t ThriftHiveMetastore_get_function_presult::read(::apache::thrift::protoc return xfer; } - -ThriftHiveMetastore_get_all_functions_args::~ThriftHiveMetastore_get_all_functions_args() throw() { -} - - -uint32_t ThriftHiveMetastore_get_all_functions_args::read(::apache::thrift::protocol::TProtocol* iprot) { - - apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); +uint32_t ThriftHiveMetastore_grant_role_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - std::string fname; - ::apache::thrift::protocol::TType ftype; - int16_t fid; - - xfer += iprot->readStructBegin(fname); + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_grant_role_args"); - using ::apache::thrift::protocol::TProtocolException; + 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(); - while (true) - { - xfer += iprot->readFieldBegin(fname, ftype, fid); - if (ftype == ::apache::thrift::protocol::T_STOP) { - break; - } - xfer += iprot->skip(ftype); - xfer += iprot->readFieldEnd(); - } + xfer += oprot->writeFieldBegin("principal_type", ::apache::thrift::protocol::T_I32, 3); + xfer += oprot->writeI32((int32_t)this->principal_type); + xfer += oprot->writeFieldEnd(); - xfer += iprot->readStructEnd(); + xfer += oprot->writeFieldBegin("grantor", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->grantor); + xfer += oprot->writeFieldEnd(); - return xfer; -} + xfer += oprot->writeFieldBegin("grantorType", ::apache::thrift::protocol::T_I32, 5); + xfer += oprot->writeI32((int32_t)this->grantorType); + xfer += oprot->writeFieldEnd(); -uint32_t ThriftHiveMetastore_get_all_functions_args::write(::apache::thrift::protocol::TProtocol* oprot) const { - uint32_t xfer = 0; - apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_functions_args"); + xfer += oprot->writeFieldBegin("grant_option", ::apache::thrift::protocol::T_BOOL, 6); + xfer += oprot->writeBool(this->grant_option); + xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); @@ -28826,14 +29725,38 @@ uint32_t ThriftHiveMetastore_get_all_functions_args::write(::apache::thrift::pro } -ThriftHiveMetastore_get_all_functions_pargs::~ThriftHiveMetastore_get_all_functions_pargs() throw() { +ThriftHiveMetastore_grant_role_pargs::~ThriftHiveMetastore_grant_role_pargs() throw() { } -uint32_t ThriftHiveMetastore_get_all_functions_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_grant_role_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_functions_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_grant_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->writeFieldBegin("grantor", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString((*(this->grantor))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("grantorType", ::apache::thrift::protocol::T_I32, 5); + xfer += oprot->writeI32((int32_t)(*(this->grantorType))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("grant_option", ::apache::thrift::protocol::T_BOOL, 6); + xfer += oprot->writeBool((*(this->grant_option))); + xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); @@ -28841,11 +29764,11 @@ uint32_t ThriftHiveMetastore_get_all_functions_pargs::write(::apache::thrift::pr } -ThriftHiveMetastore_get_all_functions_result::~ThriftHiveMetastore_get_all_functions_result() throw() { +ThriftHiveMetastore_grant_role_result::~ThriftHiveMetastore_grant_role_result() throw() { } -uint32_t ThriftHiveMetastore_get_all_functions_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_grant_role_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -28867,8 +29790,8 @@ uint32_t ThriftHiveMetastore_get_all_functions_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); @@ -28894,15 +29817,15 @@ uint32_t ThriftHiveMetastore_get_all_functions_result::read(::apache::thrift::pr return xfer; } -uint32_t ThriftHiveMetastore_get_all_functions_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_get_all_functions_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_grant_role_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); @@ -28915,11 +29838,11 @@ uint32_t ThriftHiveMetastore_get_all_functions_result::write(::apache::thrift::p } -ThriftHiveMetastore_get_all_functions_presult::~ThriftHiveMetastore_get_all_functions_presult() throw() { +ThriftHiveMetastore_grant_role_presult::~ThriftHiveMetastore_grant_role_presult() throw() { } -uint32_t ThriftHiveMetastore_get_all_functions_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_grant_role_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -28941,8 +29864,8 @@ uint32_t ThriftHiveMetastore_get_all_functions_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); @@ -28969,11 +29892,11 @@ uint32_t ThriftHiveMetastore_get_all_functions_presult::read(::apache::thrift::p } -ThriftHiveMetastore_create_role_args::~ThriftHiveMetastore_create_role_args() throw() { +ThriftHiveMetastore_revoke_role_args::~ThriftHiveMetastore_revoke_role_args() throw() { } -uint32_t ThriftHiveMetastore_create_role_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_revoke_role_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -28995,9 +29918,27 @@ uint32_t ThriftHiveMetastore_create_role_args::read(::apache::thrift::protocol:: switch (fid) { case 1: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->role.read(iprot); - this->__isset.role = true; + 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 ecast1536; + xfer += iprot->readI32(ecast1536); + this->principal_type = (PrincipalType::type)ecast1536; + this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); } @@ -29014,13 +29955,21 @@ uint32_t ThriftHiveMetastore_create_role_args::read(::apache::thrift::protocol:: return xfer; } -uint32_t ThriftHiveMetastore_create_role_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +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_create_role_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_revoke_role_args"); - xfer += oprot->writeFieldBegin("role", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += this->role.write(oprot); + 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(); @@ -29029,17 +29978,25 @@ uint32_t ThriftHiveMetastore_create_role_args::write(::apache::thrift::protocol: } -ThriftHiveMetastore_create_role_pargs::~ThriftHiveMetastore_create_role_pargs() throw() { +ThriftHiveMetastore_revoke_role_pargs::~ThriftHiveMetastore_revoke_role_pargs() throw() { } -uint32_t ThriftHiveMetastore_create_role_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +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_create_role_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_revoke_role_pargs"); - xfer += oprot->writeFieldBegin("role", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += (*(this->role)).write(oprot); + 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(); @@ -29048,11 +30005,11 @@ uint32_t ThriftHiveMetastore_create_role_pargs::write(::apache::thrift::protocol } -ThriftHiveMetastore_create_role_result::~ThriftHiveMetastore_create_role_result() throw() { +ThriftHiveMetastore_revoke_role_result::~ThriftHiveMetastore_revoke_role_result() throw() { } -uint32_t ThriftHiveMetastore_create_role_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_revoke_role_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -29101,11 +30058,11 @@ uint32_t ThriftHiveMetastore_create_role_result::read(::apache::thrift::protocol return xfer; } -uint32_t ThriftHiveMetastore_create_role_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_revoke_role_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_role_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_revoke_role_result"); if (this->__isset.success) { xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0); @@ -29122,11 +30079,11 @@ uint32_t ThriftHiveMetastore_create_role_result::write(::apache::thrift::protoco } -ThriftHiveMetastore_create_role_presult::~ThriftHiveMetastore_create_role_presult() throw() { +ThriftHiveMetastore_revoke_role_presult::~ThriftHiveMetastore_revoke_role_presult() throw() { } -uint32_t ThriftHiveMetastore_create_role_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_revoke_role_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -29176,11 +30133,11 @@ uint32_t ThriftHiveMetastore_create_role_presult::read(::apache::thrift::protoco } -ThriftHiveMetastore_drop_role_args::~ThriftHiveMetastore_drop_role_args() throw() { +ThriftHiveMetastore_list_roles_args::~ThriftHiveMetastore_list_roles_args() throw() { } -uint32_t ThriftHiveMetastore_drop_role_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_list_roles_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -29203,8 +30160,18 @@ uint32_t ThriftHiveMetastore_drop_role_args::read(::apache::thrift::protocol::TP { case 1: if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->role_name); - this->__isset.role_name = true; + 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 ecast1537; + xfer += iprot->readI32(ecast1537); + this->principal_type = (PrincipalType::type)ecast1537; + this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); } @@ -29221,13 +30188,17 @@ uint32_t ThriftHiveMetastore_drop_role_args::read(::apache::thrift::protocol::TP return xfer; } -uint32_t ThriftHiveMetastore_drop_role_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +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_drop_role_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_list_roles_args"); - xfer += oprot->writeFieldBegin("role_name", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString(this->role_name); + 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(); @@ -29236,17 +30207,21 @@ uint32_t ThriftHiveMetastore_drop_role_args::write(::apache::thrift::protocol::T } -ThriftHiveMetastore_drop_role_pargs::~ThriftHiveMetastore_drop_role_pargs() throw() { +ThriftHiveMetastore_list_roles_pargs::~ThriftHiveMetastore_list_roles_pargs() throw() { } -uint32_t ThriftHiveMetastore_drop_role_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +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_drop_role_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_list_roles_pargs"); - xfer += oprot->writeFieldBegin("role_name", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString((*(this->role_name))); + 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(); @@ -29255,11 +30230,11 @@ uint32_t ThriftHiveMetastore_drop_role_pargs::write(::apache::thrift::protocol:: } -ThriftHiveMetastore_drop_role_result::~ThriftHiveMetastore_drop_role_result() throw() { +ThriftHiveMetastore_list_roles_result::~ThriftHiveMetastore_list_roles_result() throw() { } -uint32_t ThriftHiveMetastore_drop_role_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_list_roles_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -29281,8 +30256,20 @@ uint32_t ThriftHiveMetastore_drop_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_LIST) { + { + this->success.clear(); + uint32_t _size1538; + ::apache::thrift::protocol::TType _etype1541; + xfer += iprot->readListBegin(_etype1541, _size1538); + this->success.resize(_size1538); + uint32_t _i1542; + for (_i1542 = 0; _i1542 < _size1538; ++_i1542) + { + xfer += this->success[_i1542].read(iprot); + } + xfer += iprot->readListEnd(); + } this->__isset.success = true; } else { xfer += iprot->skip(ftype); @@ -29308,15 +30295,23 @@ uint32_t ThriftHiveMetastore_drop_role_result::read(::apache::thrift::protocol:: return xfer; } -uint32_t ThriftHiveMetastore_drop_role_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_list_roles_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_role_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_list_roles_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_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); + std::vector ::const_iterator _iter1543; + for (_iter1543 = this->success.begin(); _iter1543 != this->success.end(); ++_iter1543) + { + xfer += (*_iter1543).write(oprot); + } + xfer += oprot->writeListEnd(); + } xfer += oprot->writeFieldEnd(); } else if (this->__isset.o1) { xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); @@ -29329,11 +30324,11 @@ uint32_t ThriftHiveMetastore_drop_role_result::write(::apache::thrift::protocol: } -ThriftHiveMetastore_drop_role_presult::~ThriftHiveMetastore_drop_role_presult() throw() { +ThriftHiveMetastore_list_roles_presult::~ThriftHiveMetastore_list_roles_presult() throw() { } -uint32_t ThriftHiveMetastore_drop_role_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_list_roles_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -29355,8 +30350,20 @@ uint32_t ThriftHiveMetastore_drop_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_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 += (*(this->success))[_i1548].read(iprot); + } + xfer += iprot->readListEnd(); + } this->__isset.success = true; } else { xfer += iprot->skip(ftype); @@ -29383,11 +30390,11 @@ uint32_t ThriftHiveMetastore_drop_role_presult::read(::apache::thrift::protocol: } -ThriftHiveMetastore_get_role_names_args::~ThriftHiveMetastore_get_role_names_args() throw() { +ThriftHiveMetastore_grant_revoke_role_args::~ThriftHiveMetastore_grant_revoke_role_args() throw() { } -uint32_t ThriftHiveMetastore_get_role_names_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_grant_revoke_role_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -29406,7 +30413,20 @@ uint32_t ThriftHiveMetastore_get_role_names_args::read(::apache::thrift::protoco 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(); } @@ -29415,10 +30435,14 @@ uint32_t ThriftHiveMetastore_get_role_names_args::read(::apache::thrift::protoco return xfer; } -uint32_t ThriftHiveMetastore_get_role_names_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +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_get_role_names_args"); + 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(); @@ -29426,14 +30450,18 @@ uint32_t ThriftHiveMetastore_get_role_names_args::write(::apache::thrift::protoc } -ThriftHiveMetastore_get_role_names_pargs::~ThriftHiveMetastore_get_role_names_pargs() throw() { +ThriftHiveMetastore_grant_revoke_role_pargs::~ThriftHiveMetastore_grant_revoke_role_pargs() throw() { } -uint32_t ThriftHiveMetastore_get_role_names_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +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_get_role_names_pargs"); + 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(); @@ -29441,11 +30469,11 @@ uint32_t ThriftHiveMetastore_get_role_names_pargs::write(::apache::thrift::proto } -ThriftHiveMetastore_get_role_names_result::~ThriftHiveMetastore_get_role_names_result() throw() { +ThriftHiveMetastore_grant_revoke_role_result::~ThriftHiveMetastore_grant_revoke_role_result() throw() { } -uint32_t ThriftHiveMetastore_get_role_names_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_grant_revoke_role_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -29467,20 +30495,8 @@ uint32_t ThriftHiveMetastore_get_role_names_result::read(::apache::thrift::proto switch (fid) { case 0: - if (ftype == ::apache::thrift::protocol::T_LIST) { - { - this->success.clear(); - 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[_i1507]); - } - xfer += iprot->readListEnd(); - } + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); this->__isset.success = true; } else { xfer += iprot->skip(ftype); @@ -29506,23 +30522,15 @@ uint32_t ThriftHiveMetastore_get_role_names_result::read(::apache::thrift::proto return xfer; } -uint32_t ThriftHiveMetastore_get_role_names_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_grant_revoke_role_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_role_names_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_grant_revoke_role_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 _iter1508; - for (_iter1508 = this->success.begin(); _iter1508 != this->success.end(); ++_iter1508) - { - xfer += oprot->writeString((*_iter1508)); - } - xfer += oprot->writeListEnd(); - } + 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); @@ -29535,11 +30543,11 @@ uint32_t ThriftHiveMetastore_get_role_names_result::write(::apache::thrift::prot } -ThriftHiveMetastore_get_role_names_presult::~ThriftHiveMetastore_get_role_names_presult() throw() { +ThriftHiveMetastore_grant_revoke_role_presult::~ThriftHiveMetastore_grant_revoke_role_presult() throw() { } -uint32_t ThriftHiveMetastore_get_role_names_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_grant_revoke_role_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -29561,20 +30569,8 @@ uint32_t ThriftHiveMetastore_get_role_names_presult::read(::apache::thrift::prot switch (fid) { case 0: - if (ftype == ::apache::thrift::protocol::T_LIST) { - { - (*(this->success)).clear(); - 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))[_i1513]); - } - xfer += iprot->readListEnd(); - } + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); this->__isset.success = true; } else { xfer += iprot->skip(ftype); @@ -29601,11 +30597,11 @@ uint32_t ThriftHiveMetastore_get_role_names_presult::read(::apache::thrift::prot } -ThriftHiveMetastore_grant_role_args::~ThriftHiveMetastore_grant_role_args() throw() { +ThriftHiveMetastore_get_principals_in_role_args::~ThriftHiveMetastore_get_principals_in_role_args() throw() { } -uint32_t ThriftHiveMetastore_grant_role_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_principals_in_role_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -29627,53 +30623,9 @@ uint32_t ThriftHiveMetastore_grant_role_args::read(::apache::thrift::protocol::T 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 ecast1514; - xfer += iprot->readI32(ecast1514); - this->principal_type = (PrincipalType::type)ecast1514; - this->__isset.principal_type = true; - } else { - xfer += iprot->skip(ftype); - } - break; - case 4: - if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->grantor); - this->__isset.grantor = true; - } else { - xfer += iprot->skip(ftype); - } - break; - case 5: - if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1515; - xfer += iprot->readI32(ecast1515); - this->grantorType = (PrincipalType::type)ecast1515; - this->__isset.grantorType = true; - } else { - xfer += iprot->skip(ftype); - } - break; - case 6: - if (ftype == ::apache::thrift::protocol::T_BOOL) { - xfer += iprot->readBool(this->grant_option); - this->__isset.grant_option = true; + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; } else { xfer += iprot->skip(ftype); } @@ -29690,33 +30642,13 @@ uint32_t ThriftHiveMetastore_grant_role_args::read(::apache::thrift::protocol::T return xfer; } -uint32_t ThriftHiveMetastore_grant_role_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +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_grant_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->writeFieldBegin("grantor", ::apache::thrift::protocol::T_STRING, 4); - xfer += oprot->writeString(this->grantor); - xfer += oprot->writeFieldEnd(); - - xfer += oprot->writeFieldBegin("grantorType", ::apache::thrift::protocol::T_I32, 5); - xfer += oprot->writeI32((int32_t)this->grantorType); - xfer += oprot->writeFieldEnd(); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_principals_in_role_args"); - xfer += oprot->writeFieldBegin("grant_option", ::apache::thrift::protocol::T_BOOL, 6); - xfer += oprot->writeBool(this->grant_option); + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -29725,37 +30657,17 @@ uint32_t ThriftHiveMetastore_grant_role_args::write(::apache::thrift::protocol:: } -ThriftHiveMetastore_grant_role_pargs::~ThriftHiveMetastore_grant_role_pargs() throw() { +ThriftHiveMetastore_get_principals_in_role_pargs::~ThriftHiveMetastore_get_principals_in_role_pargs() throw() { } -uint32_t ThriftHiveMetastore_grant_role_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +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_grant_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->writeFieldBegin("grantor", ::apache::thrift::protocol::T_STRING, 4); - xfer += oprot->writeString((*(this->grantor))); - xfer += oprot->writeFieldEnd(); - - xfer += oprot->writeFieldBegin("grantorType", ::apache::thrift::protocol::T_I32, 5); - xfer += oprot->writeI32((int32_t)(*(this->grantorType))); - xfer += oprot->writeFieldEnd(); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_principals_in_role_pargs"); - xfer += oprot->writeFieldBegin("grant_option", ::apache::thrift::protocol::T_BOOL, 6); - xfer += oprot->writeBool((*(this->grant_option))); + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -29764,11 +30676,11 @@ uint32_t ThriftHiveMetastore_grant_role_pargs::write(::apache::thrift::protocol: } -ThriftHiveMetastore_grant_role_result::~ThriftHiveMetastore_grant_role_result() throw() { +ThriftHiveMetastore_get_principals_in_role_result::~ThriftHiveMetastore_get_principals_in_role_result() throw() { } -uint32_t ThriftHiveMetastore_grant_role_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_principals_in_role_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -29790,8 +30702,8 @@ uint32_t ThriftHiveMetastore_grant_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); @@ -29817,15 +30729,15 @@ 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_get_principals_in_role_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_grant_role_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_principals_in_role_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 +30750,11 @@ uint32_t ThriftHiveMetastore_grant_role_result::write(::apache::thrift::protocol } -ThriftHiveMetastore_grant_role_presult::~ThriftHiveMetastore_grant_role_presult() throw() { +ThriftHiveMetastore_get_principals_in_role_presult::~ThriftHiveMetastore_get_principals_in_role_presult() throw() { } -uint32_t ThriftHiveMetastore_grant_role_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_principals_in_role_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -29864,8 +30776,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 +30804,11 @@ uint32_t ThriftHiveMetastore_grant_role_presult::read(::apache::thrift::protocol } -ThriftHiveMetastore_revoke_role_args::~ThriftHiveMetastore_revoke_role_args() throw() { +ThriftHiveMetastore_get_role_grants_for_principal_args::~ThriftHiveMetastore_get_role_grants_for_principal_args() throw() { } -uint32_t ThriftHiveMetastore_revoke_role_args::read(::apache::thrift::protocol::TProtocol* iprot) { +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; @@ -29918,27 +30830,9 @@ 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; - } 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; + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; } else { xfer += iprot->skip(ftype); } @@ -29955,21 +30849,13 @@ 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_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_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->writeStructBegin("ThriftHiveMetastore_get_role_grants_for_principal_args"); - xfer += oprot->writeFieldBegin("principal_type", ::apache::thrift::protocol::T_I32, 3); - xfer += oprot->writeI32((int32_t)this->principal_type); + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -29978,25 +30864,17 @@ uint32_t ThriftHiveMetastore_revoke_role_args::write(::apache::thrift::protocol: } -ThriftHiveMetastore_revoke_role_pargs::~ThriftHiveMetastore_revoke_role_pargs() throw() { +ThriftHiveMetastore_get_role_grants_for_principal_pargs::~ThriftHiveMetastore_get_role_grants_for_principal_pargs() throw() { } -uint32_t ThriftHiveMetastore_revoke_role_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +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_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->writeStructBegin("ThriftHiveMetastore_get_role_grants_for_principal_pargs"); - xfer += oprot->writeFieldBegin("principal_type", ::apache::thrift::protocol::T_I32, 3); - xfer += oprot->writeI32((int32_t)(*(this->principal_type))); + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -30005,11 +30883,11 @@ uint32_t ThriftHiveMetastore_revoke_role_pargs::write(::apache::thrift::protocol } -ThriftHiveMetastore_revoke_role_result::~ThriftHiveMetastore_revoke_role_result() throw() { +ThriftHiveMetastore_get_role_grants_for_principal_result::~ThriftHiveMetastore_get_role_grants_for_principal_result() throw() { } -uint32_t ThriftHiveMetastore_revoke_role_result::read(::apache::thrift::protocol::TProtocol* iprot) { +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; @@ -30031,8 +30909,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 +30936,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_role_grants_for_principal_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_revoke_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); @@ -30079,11 +30957,11 @@ uint32_t ThriftHiveMetastore_revoke_role_result::write(::apache::thrift::protoco } -ThriftHiveMetastore_revoke_role_presult::~ThriftHiveMetastore_revoke_role_presult() throw() { +ThriftHiveMetastore_get_role_grants_for_principal_presult::~ThriftHiveMetastore_get_role_grants_for_principal_presult() throw() { } -uint32_t ThriftHiveMetastore_revoke_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; @@ -30105,8 +30983,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 +31011,11 @@ uint32_t ThriftHiveMetastore_revoke_role_presult::read(::apache::thrift::protoco } -ThriftHiveMetastore_list_roles_args::~ThriftHiveMetastore_list_roles_args() throw() { +ThriftHiveMetastore_get_privilege_set_args::~ThriftHiveMetastore_get_privilege_set_args() throw() { } -uint32_t ThriftHiveMetastore_list_roles_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; @@ -30159,19 +31037,37 @@ uint32_t ThriftHiveMetastore_list_roles_args::read(::apache::thrift::protocol::T switch (fid) { case 1: - if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->principal_name); - this->__isset.principal_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_I32) { - int32_t ecast1517; - xfer += iprot->readI32(ecast1517); - this->principal_type = (PrincipalType::type)ecast1517; - this->__isset.principal_type = true; + 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 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->group_names.clear(); + uint32_t _size1549; + ::apache::thrift::protocol::TType _etype1552; + xfer += iprot->readListBegin(_etype1552, _size1549); + this->group_names.resize(_size1549); + uint32_t _i1553; + for (_i1553 = 0; _i1553 < _size1549; ++_i1553) + { + xfer += iprot->readString(this->group_names[_i1553]); + } + xfer += iprot->readListEnd(); + } + this->__isset.group_names = true; } else { xfer += iprot->skip(ftype); } @@ -30188,17 +31084,29 @@ 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_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_list_roles_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_privilege_set_args"); - xfer += oprot->writeFieldBegin("principal_name", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString(this->principal_name); + xfer += oprot->writeFieldBegin("hiveObject", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->hiveObject.write(oprot); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("principal_type", ::apache::thrift::protocol::T_I32, 2); - xfer += oprot->writeI32((int32_t)this->principal_type); + xfer += oprot->writeFieldBegin("user_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->user_name); + xfer += oprot->writeFieldEnd(); + + 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 _iter1554; + for (_iter1554 = this->group_names.begin(); _iter1554 != this->group_names.end(); ++_iter1554) + { + xfer += oprot->writeString((*_iter1554)); + } + xfer += oprot->writeListEnd(); + } xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -30207,21 +31115,33 @@ uint32_t ThriftHiveMetastore_list_roles_args::write(::apache::thrift::protocol:: } -ThriftHiveMetastore_list_roles_pargs::~ThriftHiveMetastore_list_roles_pargs() throw() { +ThriftHiveMetastore_get_privilege_set_pargs::~ThriftHiveMetastore_get_privilege_set_pargs() throw() { } -uint32_t ThriftHiveMetastore_list_roles_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_list_roles_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_privilege_set_pargs"); - xfer += oprot->writeFieldBegin("principal_name", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString((*(this->principal_name))); + xfer += oprot->writeFieldBegin("hiveObject", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->hiveObject)).write(oprot); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("principal_type", ::apache::thrift::protocol::T_I32, 2); - xfer += oprot->writeI32((int32_t)(*(this->principal_type))); + xfer += oprot->writeFieldBegin("user_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->user_name))); + xfer += oprot->writeFieldEnd(); + + 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 _iter1555; + for (_iter1555 = (*(this->group_names)).begin(); _iter1555 != (*(this->group_names)).end(); ++_iter1555) + { + xfer += oprot->writeString((*_iter1555)); + } + xfer += oprot->writeListEnd(); + } xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -30230,11 +31150,11 @@ uint32_t ThriftHiveMetastore_list_roles_pargs::write(::apache::thrift::protocol: } -ThriftHiveMetastore_list_roles_result::~ThriftHiveMetastore_list_roles_result() throw() { +ThriftHiveMetastore_get_privilege_set_result::~ThriftHiveMetastore_get_privilege_set_result() throw() { } -uint32_t ThriftHiveMetastore_list_roles_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; @@ -30256,20 +31176,8 @@ uint32_t ThriftHiveMetastore_list_roles_result::read(::apache::thrift::protocol: 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(); - } + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); this->__isset.success = true; } else { xfer += iprot->skip(ftype); @@ -30295,23 +31203,15 @@ 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_get_privilege_set_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_list_roles_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_privilege_set_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->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); @@ -30324,11 +31224,11 @@ uint32_t ThriftHiveMetastore_list_roles_result::write(::apache::thrift::protocol } -ThriftHiveMetastore_list_roles_presult::~ThriftHiveMetastore_list_roles_presult() throw() { +ThriftHiveMetastore_get_privilege_set_presult::~ThriftHiveMetastore_get_privilege_set_presult() throw() { } -uint32_t ThriftHiveMetastore_list_roles_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; @@ -30350,20 +31250,8 @@ uint32_t ThriftHiveMetastore_list_roles_presult::read(::apache::thrift::protocol 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(); - } + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); this->__isset.success = true; } else { xfer += iprot->skip(ftype); @@ -30390,11 +31278,11 @@ uint32_t ThriftHiveMetastore_list_roles_presult::read(::apache::thrift::protocol } -ThriftHiveMetastore_grant_revoke_role_args::~ThriftHiveMetastore_grant_revoke_role_args() throw() { +ThriftHiveMetastore_list_privileges_args::~ThriftHiveMetastore_list_privileges_args() throw() { } -uint32_t ThriftHiveMetastore_grant_revoke_role_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; @@ -30416,9 +31304,27 @@ uint32_t ThriftHiveMetastore_grant_revoke_role_args::read(::apache::thrift::prot 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 ecast1556; + xfer += iprot->readI32(ecast1556); + this->principal_type = (PrincipalType::type)ecast1556; + this->__isset.principal_type = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->request.read(iprot); - this->__isset.request = true; + xfer += this->hiveObject.read(iprot); + this->__isset.hiveObject = true; } else { xfer += iprot->skip(ftype); } @@ -30435,13 +31341,21 @@ 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_list_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_list_privileges_args"); - xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += this->request.write(oprot); + 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->writeFieldBegin("hiveObject", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->hiveObject.write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -30450,17 +31364,25 @@ uint32_t ThriftHiveMetastore_grant_revoke_role_args::write(::apache::thrift::pro } -ThriftHiveMetastore_grant_revoke_role_pargs::~ThriftHiveMetastore_grant_revoke_role_pargs() throw() { +ThriftHiveMetastore_list_privileges_pargs::~ThriftHiveMetastore_list_privileges_pargs() throw() { } -uint32_t ThriftHiveMetastore_grant_revoke_role_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_grant_revoke_role_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_list_privileges_pargs"); - xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += (*(this->request)).write(oprot); + 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->writeFieldBegin("hiveObject", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += (*(this->hiveObject)).write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -30469,11 +31391,11 @@ uint32_t ThriftHiveMetastore_grant_revoke_role_pargs::write(::apache::thrift::pr } -ThriftHiveMetastore_grant_revoke_role_result::~ThriftHiveMetastore_grant_revoke_role_result() throw() { +ThriftHiveMetastore_list_privileges_result::~ThriftHiveMetastore_list_privileges_result() throw() { } -uint32_t ThriftHiveMetastore_grant_revoke_role_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; @@ -30495,8 +31417,20 @@ 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_LIST) { + { + this->success.clear(); + uint32_t _size1557; + ::apache::thrift::protocol::TType _etype1560; + xfer += iprot->readListBegin(_etype1560, _size1557); + this->success.resize(_size1557); + uint32_t _i1561; + for (_i1561 = 0; _i1561 < _size1557; ++_i1561) + { + xfer += this->success[_i1561].read(iprot); + } + xfer += iprot->readListEnd(); + } this->__isset.success = true; } else { xfer += iprot->skip(ftype); @@ -30522,15 +31456,23 @@ 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_list_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_list_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_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); + std::vector ::const_iterator _iter1562; + for (_iter1562 = this->success.begin(); _iter1562 != this->success.end(); ++_iter1562) + { + xfer += (*_iter1562).write(oprot); + } + xfer += oprot->writeListEnd(); + } xfer += oprot->writeFieldEnd(); } else if (this->__isset.o1) { xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); @@ -30543,11 +31485,11 @@ uint32_t ThriftHiveMetastore_grant_revoke_role_result::write(::apache::thrift::p } -ThriftHiveMetastore_grant_revoke_role_presult::~ThriftHiveMetastore_grant_revoke_role_presult() throw() { +ThriftHiveMetastore_list_privileges_presult::~ThriftHiveMetastore_list_privileges_presult() throw() { } -uint32_t ThriftHiveMetastore_grant_revoke_role_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; @@ -30569,8 +31511,20 @@ 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_LIST) { + { + (*(this->success)).clear(); + uint32_t _size1563; + ::apache::thrift::protocol::TType _etype1566; + xfer += iprot->readListBegin(_etype1566, _size1563); + (*(this->success)).resize(_size1563); + uint32_t _i1567; + for (_i1567 = 0; _i1567 < _size1563; ++_i1567) + { + xfer += (*(this->success))[_i1567].read(iprot); + } + xfer += iprot->readListEnd(); + } this->__isset.success = true; } else { xfer += iprot->skip(ftype); @@ -30597,11 +31551,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_grant_privileges_args::~ThriftHiveMetastore_grant_privileges_args() throw() { } -uint32_t ThriftHiveMetastore_get_principals_in_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; @@ -30624,8 +31578,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 +31596,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_grant_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_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(); @@ -30657,17 +31611,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_grant_privileges_pargs::~ThriftHiveMetastore_grant_privileges_pargs() throw() { } -uint32_t ThriftHiveMetastore_get_principals_in_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_get_principals_in_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(); @@ -30676,11 +31630,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_grant_privileges_result::~ThriftHiveMetastore_grant_privileges_result() throw() { } -uint32_t ThriftHiveMetastore_get_principals_in_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; @@ -30702,8 +31656,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 +31683,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_grant_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_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); @@ -30750,11 +31704,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_grant_privileges_presult::~ThriftHiveMetastore_grant_privileges_presult() throw() { } -uint32_t ThriftHiveMetastore_get_principals_in_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; @@ -30776,8 +31730,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 +31758,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_revoke_privileges_args::~ThriftHiveMetastore_revoke_privileges_args() throw() { } -uint32_t ThriftHiveMetastore_get_role_grants_for_principal_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; @@ -30831,8 +31785,8 @@ uint32_t ThriftHiveMetastore_get_role_grants_for_principal_args::read(::apache:: { 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); } @@ -30849,13 +31803,13 @@ 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_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_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(); @@ -30864,17 +31818,17 @@ 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_revoke_privileges_pargs::~ThriftHiveMetastore_revoke_privileges_pargs() throw() { } -uint32_t ThriftHiveMetastore_get_role_grants_for_principal_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_role_grants_for_principal_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(); @@ -30883,11 +31837,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_revoke_privileges_result::~ThriftHiveMetastore_revoke_privileges_result() throw() { } -uint32_t ThriftHiveMetastore_get_role_grants_for_principal_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; @@ -30909,8 +31863,8 @@ uint32_t ThriftHiveMetastore_get_role_grants_for_principal_result::read(::apache 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); @@ -30936,15 +31890,15 @@ 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_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_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); @@ -30957,11 +31911,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_revoke_privileges_presult::~ThriftHiveMetastore_revoke_privileges_presult() throw() { } -uint32_t ThriftHiveMetastore_get_role_grants_for_principal_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; @@ -30983,8 +31937,8 @@ uint32_t ThriftHiveMetastore_get_role_grants_for_principal_presult::read(::apach 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); @@ -31011,11 +31965,11 @@ uint32_t ThriftHiveMetastore_get_role_grants_for_principal_presult::read(::apach } -ThriftHiveMetastore_get_privilege_set_args::~ThriftHiveMetastore_get_privilege_set_args() throw() { +ThriftHiveMetastore_grant_revoke_privileges_args::~ThriftHiveMetastore_grant_revoke_privileges_args() throw() { } -uint32_t ThriftHiveMetastore_get_privilege_set_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; @@ -31038,36 +31992,8 @@ uint32_t ThriftHiveMetastore_get_privilege_set_args::read(::apache::thrift::prot { 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; - } else { - xfer += iprot->skip(ftype); - } - break; - case 3: - 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; + xfer += this->request.read(iprot); + this->__isset.request = true; } else { xfer += iprot->skip(ftype); } @@ -31084,29 +32010,13 @@ 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_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_privilege_set_args"); - - xfer += oprot->writeFieldBegin("hiveObject", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += this->hiveObject.write(oprot); - xfer += oprot->writeFieldEnd(); - - xfer += oprot->writeFieldBegin("user_name", ::apache::thrift::protocol::T_STRING, 2); - xfer += oprot->writeString(this->user_name); - xfer += oprot->writeFieldEnd(); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_grant_revoke_privileges_args"); - 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->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -31115,33 +32025,17 @@ uint32_t ThriftHiveMetastore_get_privilege_set_args::write(::apache::thrift::pro } -ThriftHiveMetastore_get_privilege_set_pargs::~ThriftHiveMetastore_get_privilege_set_pargs() throw() { +ThriftHiveMetastore_grant_revoke_privileges_pargs::~ThriftHiveMetastore_grant_revoke_privileges_pargs() throw() { } -uint32_t ThriftHiveMetastore_get_privilege_set_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_privilege_set_pargs"); - - xfer += oprot->writeFieldBegin("hiveObject", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += (*(this->hiveObject)).write(oprot); - xfer += oprot->writeFieldEnd(); - - xfer += oprot->writeFieldBegin("user_name", ::apache::thrift::protocol::T_STRING, 2); - xfer += oprot->writeString((*(this->user_name))); - xfer += oprot->writeFieldEnd(); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_grant_revoke_privileges_pargs"); - 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->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -31150,11 +32044,11 @@ uint32_t ThriftHiveMetastore_get_privilege_set_pargs::write(::apache::thrift::pr } -ThriftHiveMetastore_get_privilege_set_result::~ThriftHiveMetastore_get_privilege_set_result() throw() { +ThriftHiveMetastore_grant_revoke_privileges_result::~ThriftHiveMetastore_grant_revoke_privileges_result() throw() { } -uint32_t ThriftHiveMetastore_get_privilege_set_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; @@ -31203,11 +32097,11 @@ 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_grant_revoke_privileges_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_privilege_set_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_grant_revoke_privileges_result"); if (this->__isset.success) { xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); @@ -31224,11 +32118,11 @@ uint32_t ThriftHiveMetastore_get_privilege_set_result::write(::apache::thrift::p } -ThriftHiveMetastore_get_privilege_set_presult::~ThriftHiveMetastore_get_privilege_set_presult() throw() { +ThriftHiveMetastore_grant_revoke_privileges_presult::~ThriftHiveMetastore_grant_revoke_privileges_presult() throw() { } -uint32_t ThriftHiveMetastore_get_privilege_set_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; @@ -31278,11 +32172,11 @@ uint32_t ThriftHiveMetastore_get_privilege_set_presult::read(::apache::thrift::p } -ThriftHiveMetastore_list_privileges_args::~ThriftHiveMetastore_list_privileges_args() throw() { +ThriftHiveMetastore_set_ugi_args::~ThriftHiveMetastore_set_ugi_args() throw() { } -uint32_t ThriftHiveMetastore_list_privileges_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; @@ -31305,26 +32199,28 @@ 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->user_name); + this->__isset.user_name = true; } else { xfer += iprot->skip(ftype); } break; case 2: - if (ftype == ::apache::thrift::protocol::T_I32) { - 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; + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->group_names.clear(); + uint32_t _size1568; + ::apache::thrift::protocol::TType _etype1571; + xfer += iprot->readListBegin(_etype1571, _size1568); + this->group_names.resize(_size1568); + uint32_t _i1572; + for (_i1572 = 0; _i1572 < _size1568; ++_i1572) + { + xfer += iprot->readString(this->group_names[_i1572]); + } + xfer += iprot->readListEnd(); + } + this->__isset.group_names = true; } else { xfer += iprot->skip(ftype); } @@ -31341,21 +32237,25 @@ 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_set_ugi_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_set_ugi_args"); - xfer += oprot->writeFieldBegin("principal_type", ::apache::thrift::protocol::T_I32, 2); - xfer += oprot->writeI32((int32_t)this->principal_type); + xfer += oprot->writeFieldBegin("user_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->user_name); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("hiveObject", ::apache::thrift::protocol::T_STRUCT, 3); - xfer += this->hiveObject.write(oprot); + 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 _iter1573; + for (_iter1573 = this->group_names.begin(); _iter1573 != this->group_names.end(); ++_iter1573) + { + xfer += oprot->writeString((*_iter1573)); + } + xfer += oprot->writeListEnd(); + } xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -31364,25 +32264,29 @@ uint32_t ThriftHiveMetastore_list_privileges_args::write(::apache::thrift::proto } -ThriftHiveMetastore_list_privileges_pargs::~ThriftHiveMetastore_list_privileges_pargs() throw() { +ThriftHiveMetastore_set_ugi_pargs::~ThriftHiveMetastore_set_ugi_pargs() throw() { } -uint32_t ThriftHiveMetastore_list_privileges_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_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_set_ugi_pargs"); - xfer += oprot->writeFieldBegin("principal_type", ::apache::thrift::protocol::T_I32, 2); - xfer += oprot->writeI32((int32_t)(*(this->principal_type))); + xfer += oprot->writeFieldBegin("user_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->user_name))); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("hiveObject", ::apache::thrift::protocol::T_STRUCT, 3); - xfer += (*(this->hiveObject)).write(oprot); + 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 _iter1574; + for (_iter1574 = (*(this->group_names)).begin(); _iter1574 != (*(this->group_names)).end(); ++_iter1574) + { + xfer += oprot->writeString((*_iter1574)); + } + xfer += oprot->writeListEnd(); + } xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -31391,11 +32295,11 @@ uint32_t ThriftHiveMetastore_list_privileges_pargs::write(::apache::thrift::prot } -ThriftHiveMetastore_list_privileges_result::~ThriftHiveMetastore_list_privileges_result() throw() { +ThriftHiveMetastore_set_ugi_result::~ThriftHiveMetastore_set_ugi_result() throw() { } -uint32_t ThriftHiveMetastore_list_privileges_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; @@ -31420,14 +32324,108 @@ uint32_t ThriftHiveMetastore_list_privileges_result::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - 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) + uint32_t _size1575; + ::apache::thrift::protocol::TType _etype1578; + xfer += iprot->readListBegin(_etype1578, _size1575); + this->success.resize(_size1575); + uint32_t _i1579; + for (_i1579 = 0; _i1579 < _size1575; ++_i1579) + { + xfer += iprot->readString(this->success[_i1579]); + } + 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_set_ugi_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_set_ugi_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 _iter1580; + for (_iter1580 = this->success.begin(); _iter1580 != this->success.end(); ++_iter1580) + { + xfer += oprot->writeString((*_iter1580)); + } + 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_set_ugi_presult::~ThriftHiveMetastore_set_ugi_presult() throw() { +} + + +uint32_t ThriftHiveMetastore_set_ugi_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 _size1581; + ::apache::thrift::protocol::TType _etype1584; + xfer += iprot->readListBegin(_etype1584, _size1581); + (*(this->success)).resize(_size1581); + uint32_t _i1585; + for (_i1585 = 0; _i1585 < _size1581; ++_i1585) { - xfer += this->success[_i1541].read(iprot); + xfer += iprot->readString((*(this->success))[_i1585]); } xfer += iprot->readListEnd(); } @@ -31456,40 +32454,12 @@ 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 xfer = 0; - - 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 _iter1542; - for (_iter1542 = this->success.begin(); _iter1542 != this->success.end(); ++_iter1542) - { - xfer += (*_iter1542).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_privileges_presult::~ThriftHiveMetastore_list_privileges_presult() throw() { +ThriftHiveMetastore_get_delegation_token_args::~ThriftHiveMetastore_get_delegation_token_args() throw() { } -uint32_t ThriftHiveMetastore_list_privileges_presult::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; @@ -31510,76 +32480,18 @@ 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 _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))[_i1547].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; + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->token_owner); + this->__isset.token_owner = true; } else { xfer += iprot->skip(ftype); } break; - default: - xfer += iprot->skip(ftype); - break; - } - xfer += iprot->readFieldEnd(); - } - - xfer += iprot->readStructEnd(); - - return xfer; -} - - -ThriftHiveMetastore_grant_privileges_args::~ThriftHiveMetastore_grant_privileges_args() throw() { -} - - -uint32_t ThriftHiveMetastore_grant_privileges_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->privileges.read(iprot); - this->__isset.privileges = true; + case 2: + 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); } @@ -31596,13 +32508,17 @@ 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_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_grant_privileges_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_delegation_token_args"); - xfer += oprot->writeFieldBegin("privileges", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += this->privileges.write(oprot); + xfer += oprot->writeFieldBegin("token_owner", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->token_owner); + xfer += oprot->writeFieldEnd(); + + 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(); @@ -31611,17 +32527,21 @@ uint32_t ThriftHiveMetastore_grant_privileges_args::write(::apache::thrift::prot } -ThriftHiveMetastore_grant_privileges_pargs::~ThriftHiveMetastore_grant_privileges_pargs() throw() { +ThriftHiveMetastore_get_delegation_token_pargs::~ThriftHiveMetastore_get_delegation_token_pargs() throw() { } -uint32_t ThriftHiveMetastore_grant_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_grant_privileges_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_delegation_token_pargs"); - xfer += oprot->writeFieldBegin("privileges", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += (*(this->privileges)).write(oprot); + xfer += oprot->writeFieldBegin("token_owner", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->token_owner))); + xfer += oprot->writeFieldEnd(); + + 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(); @@ -31630,11 +32550,11 @@ uint32_t ThriftHiveMetastore_grant_privileges_pargs::write(::apache::thrift::pro } -ThriftHiveMetastore_grant_privileges_result::~ThriftHiveMetastore_grant_privileges_result() throw() { +ThriftHiveMetastore_get_delegation_token_result::~ThriftHiveMetastore_get_delegation_token_result() throw() { } -uint32_t ThriftHiveMetastore_grant_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; @@ -31656,8 +32576,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_STRING) { + xfer += iprot->readString(this->success); this->__isset.success = true; } else { xfer += iprot->skip(ftype); @@ -31683,15 +32603,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_get_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_get_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_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); @@ -31704,11 +32624,11 @@ uint32_t ThriftHiveMetastore_grant_privileges_result::write(::apache::thrift::pr } -ThriftHiveMetastore_grant_privileges_presult::~ThriftHiveMetastore_grant_privileges_presult() throw() { +ThriftHiveMetastore_get_delegation_token_presult::~ThriftHiveMetastore_get_delegation_token_presult() throw() { } -uint32_t ThriftHiveMetastore_grant_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; @@ -31730,8 +32650,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_STRING) { + xfer += iprot->readString((*(this->success))); this->__isset.success = true; } else { xfer += iprot->skip(ftype); @@ -31758,11 +32678,11 @@ uint32_t ThriftHiveMetastore_grant_privileges_presult::read(::apache::thrift::pr } -ThriftHiveMetastore_revoke_privileges_args::~ThriftHiveMetastore_revoke_privileges_args() throw() { +ThriftHiveMetastore_renew_delegation_token_args::~ThriftHiveMetastore_renew_delegation_token_args() throw() { } -uint32_t ThriftHiveMetastore_revoke_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; @@ -31784,9 +32704,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 +32723,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_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_revoke_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(); @@ -31818,17 +32738,17 @@ uint32_t ThriftHiveMetastore_revoke_privileges_args::write(::apache::thrift::pro } -ThriftHiveMetastore_revoke_privileges_pargs::~ThriftHiveMetastore_revoke_privileges_pargs() throw() { +ThriftHiveMetastore_renew_delegation_token_pargs::~ThriftHiveMetastore_renew_delegation_token_pargs() throw() { } -uint32_t ThriftHiveMetastore_revoke_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_revoke_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(); @@ -31837,11 +32757,11 @@ uint32_t ThriftHiveMetastore_revoke_privileges_pargs::write(::apache::thrift::pr } -ThriftHiveMetastore_revoke_privileges_result::~ThriftHiveMetastore_revoke_privileges_result() throw() { +ThriftHiveMetastore_renew_delegation_token_result::~ThriftHiveMetastore_renew_delegation_token_result() throw() { } -uint32_t ThriftHiveMetastore_revoke_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; @@ -31863,8 +32783,8 @@ 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); + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->success); this->__isset.success = true; } else { xfer += iprot->skip(ftype); @@ -31890,15 +32810,15 @@ 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_renew_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_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); @@ -31911,11 +32831,11 @@ uint32_t ThriftHiveMetastore_revoke_privileges_result::write(::apache::thrift::p } -ThriftHiveMetastore_revoke_privileges_presult::~ThriftHiveMetastore_revoke_privileges_presult() throw() { +ThriftHiveMetastore_renew_delegation_token_presult::~ThriftHiveMetastore_renew_delegation_token_presult() throw() { } -uint32_t ThriftHiveMetastore_revoke_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; @@ -31937,8 +32857,8 @@ 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))); + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64((*(this->success))); this->__isset.success = true; } else { xfer += iprot->skip(ftype); @@ -31965,11 +32885,11 @@ uint32_t ThriftHiveMetastore_revoke_privileges_presult::read(::apache::thrift::p } -ThriftHiveMetastore_grant_revoke_privileges_args::~ThriftHiveMetastore_grant_revoke_privileges_args() throw() { +ThriftHiveMetastore_cancel_delegation_token_args::~ThriftHiveMetastore_cancel_delegation_token_args() throw() { } -uint32_t ThriftHiveMetastore_grant_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; @@ -31991,9 +32911,9 @@ 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_str_form); + this->__isset.token_str_form = true; } else { xfer += iprot->skip(ftype); } @@ -32010,13 +32930,13 @@ 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_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_grant_revoke_privileges_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_cancel_delegation_token_args"); - xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += this->request.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(); @@ -32025,17 +32945,17 @@ uint32_t ThriftHiveMetastore_grant_revoke_privileges_args::write(::apache::thrif } -ThriftHiveMetastore_grant_revoke_privileges_pargs::~ThriftHiveMetastore_grant_revoke_privileges_pargs() throw() { +ThriftHiveMetastore_cancel_delegation_token_pargs::~ThriftHiveMetastore_cancel_delegation_token_pargs() throw() { } -uint32_t ThriftHiveMetastore_grant_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_grant_revoke_privileges_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_cancel_delegation_token_pargs"); - xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += (*(this->request)).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(); @@ -32044,11 +32964,11 @@ uint32_t ThriftHiveMetastore_grant_revoke_privileges_pargs::write(::apache::thri } -ThriftHiveMetastore_grant_revoke_privileges_result::~ThriftHiveMetastore_grant_revoke_privileges_result() throw() { +ThriftHiveMetastore_cancel_delegation_token_result::~ThriftHiveMetastore_cancel_delegation_token_result() throw() { } -uint32_t ThriftHiveMetastore_grant_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; @@ -32069,14 +32989,6 @@ 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); - this->__isset.success = true; - } else { - xfer += iprot->skip(ftype); - } - break; case 1: if (ftype == ::apache::thrift::protocol::T_STRUCT) { xfer += this->o1.read(iprot); @@ -32097,17 +33009,13 @@ 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_cancel_delegation_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_cancel_delegation_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) { + if (this->__isset.o1) { xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); xfer += this->o1.write(oprot); xfer += oprot->writeFieldEnd(); @@ -32118,11 +33026,11 @@ uint32_t ThriftHiveMetastore_grant_revoke_privileges_result::write(::apache::thr } -ThriftHiveMetastore_grant_revoke_privileges_presult::~ThriftHiveMetastore_grant_revoke_privileges_presult() throw() { +ThriftHiveMetastore_cancel_delegation_token_presult::~ThriftHiveMetastore_cancel_delegation_token_presult() throw() { } -uint32_t ThriftHiveMetastore_grant_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; @@ -32143,14 +33051,6 @@ 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); - this->__isset.success = true; - } else { - xfer += iprot->skip(ftype); - } - break; case 1: if (ftype == ::apache::thrift::protocol::T_STRUCT) { xfer += this->o1.read(iprot); @@ -32172,11 +33072,11 @@ uint32_t ThriftHiveMetastore_grant_revoke_privileges_presult::read(::apache::thr } -ThriftHiveMetastore_set_ugi_args::~ThriftHiveMetastore_set_ugi_args() throw() { +ThriftHiveMetastore_add_token_args::~ThriftHiveMetastore_add_token_args() throw() { } -uint32_t ThriftHiveMetastore_set_ugi_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; @@ -32199,28 +33099,16 @@ 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; + 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_LIST) { - { - this->group_names.clear(); - 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[_i1552]); - } - xfer += iprot->readListEnd(); - } - this->__isset.group_names = true; + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->delegation_token); + this->__isset.delegation_token = true; } else { xfer += iprot->skip(ftype); } @@ -32237,25 +33125,17 @@ 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_add_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->writeStructBegin("ThriftHiveMetastore_add_token_args"); - xfer += oprot->writeFieldBegin("user_name", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString(this->user_name); + xfer += oprot->writeFieldBegin("token_identifier", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->token_identifier); xfer += oprot->writeFieldEnd(); - 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 _iter1553; - for (_iter1553 = this->group_names.begin(); _iter1553 != this->group_names.end(); ++_iter1553) - { - xfer += oprot->writeString((*_iter1553)); - } - xfer += oprot->writeListEnd(); - } + xfer += oprot->writeFieldBegin("delegation_token", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->delegation_token); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -32264,29 +33144,21 @@ uint32_t ThriftHiveMetastore_set_ugi_args::write(::apache::thrift::protocol::TPr } -ThriftHiveMetastore_set_ugi_pargs::~ThriftHiveMetastore_set_ugi_pargs() throw() { +ThriftHiveMetastore_add_token_pargs::~ThriftHiveMetastore_add_token_pargs() throw() { } -uint32_t ThriftHiveMetastore_set_ugi_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_set_ugi_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_token_pargs"); - xfer += oprot->writeFieldBegin("user_name", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString((*(this->user_name))); + xfer += oprot->writeFieldBegin("token_identifier", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->token_identifier))); xfer += oprot->writeFieldEnd(); - 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 _iter1554; - for (_iter1554 = (*(this->group_names)).begin(); _iter1554 != (*(this->group_names)).end(); ++_iter1554) - { - xfer += oprot->writeString((*_iter1554)); - } - xfer += oprot->writeListEnd(); - } + xfer += oprot->writeFieldBegin("delegation_token", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->delegation_token))); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -32295,11 +33167,11 @@ uint32_t ThriftHiveMetastore_set_ugi_pargs::write(::apache::thrift::protocol::TP } -ThriftHiveMetastore_set_ugi_result::~ThriftHiveMetastore_set_ugi_result() throw() { +ThriftHiveMetastore_add_token_result::~ThriftHiveMetastore_add_token_result() throw() { } -uint32_t ThriftHiveMetastore_set_ugi_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; @@ -32321,33 +33193,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 _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(); - } + 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 +33212,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_add_token_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_set_ugi_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_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 _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); - 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 +33229,11 @@ uint32_t ThriftHiveMetastore_set_ugi_result::write(::apache::thrift::protocol::T } -ThriftHiveMetastore_set_ugi_presult::~ThriftHiveMetastore_set_ugi_presult() throw() { +ThriftHiveMetastore_add_token_presult::~ThriftHiveMetastore_add_token_presult() throw() { } -uint32_t ThriftHiveMetastore_set_ugi_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; @@ -32415,33 +33255,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 _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(); - } + 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 +33275,11 @@ uint32_t ThriftHiveMetastore_set_ugi_presult::read(::apache::thrift::protocol::T } -ThriftHiveMetastore_get_delegation_token_args::~ThriftHiveMetastore_get_delegation_token_args() throw() { +ThriftHiveMetastore_remove_token_args::~ThriftHiveMetastore_remove_token_args() throw() { } -uint32_t ThriftHiveMetastore_get_delegation_token_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; @@ -32482,16 +33302,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 +33320,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_remove_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_remove_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 +33335,17 @@ uint32_t ThriftHiveMetastore_get_delegation_token_args::write(::apache::thrift:: } -ThriftHiveMetastore_get_delegation_token_pargs::~ThriftHiveMetastore_get_delegation_token_pargs() throw() { +ThriftHiveMetastore_remove_token_pargs::~ThriftHiveMetastore_remove_token_pargs() throw() { } -uint32_t ThriftHiveMetastore_get_delegation_token_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_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_remove_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 +33354,11 @@ uint32_t ThriftHiveMetastore_get_delegation_token_pargs::write(::apache::thrift: } -ThriftHiveMetastore_get_delegation_token_result::~ThriftHiveMetastore_get_delegation_token_result() throw() { +ThriftHiveMetastore_remove_token_result::~ThriftHiveMetastore_remove_token_result() throw() { } -uint32_t ThriftHiveMetastore_get_delegation_token_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; @@ -32576,21 +33380,13 @@ uint32_t ThriftHiveMetastore_get_delegation_token_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_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; @@ -32603,19 +33399,15 @@ 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_remove_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_remove_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->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0); + xfer += oprot->writeBool(this->success); xfer += oprot->writeFieldEnd(); } xfer += oprot->writeFieldStop(); @@ -32624,11 +33416,11 @@ uint32_t ThriftHiveMetastore_get_delegation_token_result::write(::apache::thrift } -ThriftHiveMetastore_get_delegation_token_presult::~ThriftHiveMetastore_get_delegation_token_presult() throw() { +ThriftHiveMetastore_remove_token_presult::~ThriftHiveMetastore_remove_token_presult() throw() { } -uint32_t ThriftHiveMetastore_get_delegation_token_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; @@ -32650,21 +33442,13 @@ uint32_t ThriftHiveMetastore_get_delegation_token_presult::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_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; @@ -32678,11 +33462,11 @@ uint32_t ThriftHiveMetastore_get_delegation_token_presult::read(::apache::thrift } -ThriftHiveMetastore_renew_delegation_token_args::~ThriftHiveMetastore_renew_delegation_token_args() throw() { +ThriftHiveMetastore_get_token_args::~ThriftHiveMetastore_get_token_args() throw() { } -uint32_t ThriftHiveMetastore_renew_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; @@ -32705,8 +33489,8 @@ uint32_t ThriftHiveMetastore_renew_delegation_token_args::read(::apache::thrift: { case 1: if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->token_str_form); - this->__isset.token_str_form = true; + xfer += iprot->readString(this->token_identifier); + this->__isset.token_identifier = true; } else { xfer += iprot->skip(ftype); } @@ -32723,13 +33507,13 @@ 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_token_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->writeStructBegin("ThriftHiveMetastore_get_token_args"); - xfer += oprot->writeFieldBegin("token_str_form", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString(this->token_str_form); + xfer += oprot->writeFieldBegin("token_identifier", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->token_identifier); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -32738,17 +33522,17 @@ uint32_t ThriftHiveMetastore_renew_delegation_token_args::write(::apache::thrift } -ThriftHiveMetastore_renew_delegation_token_pargs::~ThriftHiveMetastore_renew_delegation_token_pargs() throw() { +ThriftHiveMetastore_get_token_pargs::~ThriftHiveMetastore_get_token_pargs() throw() { } -uint32_t ThriftHiveMetastore_renew_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_renew_delegation_token_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_token_pargs"); - xfer += oprot->writeFieldBegin("token_str_form", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString((*(this->token_str_form))); + xfer += oprot->writeFieldBegin("token_identifier", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->token_identifier))); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -32757,11 +33541,11 @@ uint32_t ThriftHiveMetastore_renew_delegation_token_pargs::write(::apache::thrif } -ThriftHiveMetastore_renew_delegation_token_result::~ThriftHiveMetastore_renew_delegation_token_result() throw() { +ThriftHiveMetastore_get_token_result::~ThriftHiveMetastore_get_token_result() throw() { } -uint32_t ThriftHiveMetastore_renew_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; @@ -32783,21 +33567,13 @@ 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_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; @@ -32810,19 +33586,15 @@ 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_token_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_token_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_STRING, 0); + xfer += oprot->writeString(this->success); xfer += oprot->writeFieldEnd(); } xfer += oprot->writeFieldStop(); @@ -32831,11 +33603,11 @@ uint32_t ThriftHiveMetastore_renew_delegation_token_result::write(::apache::thri } -ThriftHiveMetastore_renew_delegation_token_presult::~ThriftHiveMetastore_renew_delegation_token_presult() throw() { +ThriftHiveMetastore_get_token_presult::~ThriftHiveMetastore_get_token_presult() throw() { } -uint32_t ThriftHiveMetastore_renew_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; @@ -32857,21 +33629,13 @@ 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_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; @@ -32885,11 +33649,11 @@ uint32_t ThriftHiveMetastore_renew_delegation_token_presult::read(::apache::thri } -ThriftHiveMetastore_cancel_delegation_token_args::~ThriftHiveMetastore_cancel_delegation_token_args() throw() { +ThriftHiveMetastore_get_all_token_identifiers_args::~ThriftHiveMetastore_get_all_token_identifiers_args() throw() { } -uint32_t ThriftHiveMetastore_cancel_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; @@ -32908,20 +33672,7 @@ uint32_t ThriftHiveMetastore_cancel_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(); } @@ -32930,14 +33681,10 @@ uint32_t ThriftHiveMetastore_cancel_delegation_token_args::read(::apache::thrift return xfer; } -uint32_t ThriftHiveMetastore_cancel_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_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->writeStructBegin("ThriftHiveMetastore_get_all_token_identifiers_args"); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); @@ -32945,18 +33692,14 @@ uint32_t ThriftHiveMetastore_cancel_delegation_token_args::write(::apache::thrif } -ThriftHiveMetastore_cancel_delegation_token_pargs::~ThriftHiveMetastore_cancel_delegation_token_pargs() throw() { +ThriftHiveMetastore_get_all_token_identifiers_pargs::~ThriftHiveMetastore_get_all_token_identifiers_pargs() throw() { } -uint32_t ThriftHiveMetastore_cancel_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_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->writeStructBegin("ThriftHiveMetastore_get_all_token_identifiers_pargs"); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); @@ -32964,11 +33707,11 @@ uint32_t ThriftHiveMetastore_cancel_delegation_token_pargs::write(::apache::thri } -ThriftHiveMetastore_cancel_delegation_token_result::~ThriftHiveMetastore_cancel_delegation_token_result() throw() { +ThriftHiveMetastore_get_all_token_identifiers_result::~ThriftHiveMetastore_get_all_token_identifiers_result() throw() { } -uint32_t ThriftHiveMetastore_cancel_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; @@ -32989,10 +33732,22 @@ uint32_t ThriftHiveMetastore_cancel_delegation_token_result::read(::apache::thri } switch (fid) { - case 1: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->o1.read(iprot); - this->__isset.o1 = true; + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size1586; + ::apache::thrift::protocol::TType _etype1589; + xfer += iprot->readListBegin(_etype1589, _size1586); + this->success.resize(_size1586); + uint32_t _i1590; + for (_i1590 = 0; _i1590 < _size1586; ++_i1590) + { + xfer += iprot->readString(this->success[_i1590]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; } else { xfer += iprot->skip(ftype); } @@ -33009,15 +33764,23 @@ 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_get_all_token_identifiers_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_cancel_delegation_token_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_all_token_identifiers_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_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); + std::vector ::const_iterator _iter1591; + for (_iter1591 = this->success.begin(); _iter1591 != this->success.end(); ++_iter1591) + { + xfer += oprot->writeString((*_iter1591)); + } + xfer += oprot->writeListEnd(); + } xfer += oprot->writeFieldEnd(); } xfer += oprot->writeFieldStop(); @@ -33026,11 +33789,11 @@ uint32_t ThriftHiveMetastore_cancel_delegation_token_result::write(::apache::thr } -ThriftHiveMetastore_cancel_delegation_token_presult::~ThriftHiveMetastore_cancel_delegation_token_presult() throw() { +ThriftHiveMetastore_get_all_token_identifiers_presult::~ThriftHiveMetastore_get_all_token_identifiers_presult() throw() { } -uint32_t ThriftHiveMetastore_cancel_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; @@ -33051,10 +33814,22 @@ uint32_t ThriftHiveMetastore_cancel_delegation_token_presult::read(::apache::thr } switch (fid) { - case 1: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->o1.read(iprot); - this->__isset.o1 = true; + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size1592; + ::apache::thrift::protocol::TType _etype1595; + xfer += iprot->readListBegin(_etype1595, _size1592); + (*(this->success)).resize(_size1592); + uint32_t _i1596; + for (_i1596 = 0; _i1596 < _size1592; ++_i1596) + { + xfer += iprot->readString((*(this->success))[_i1596]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; } else { xfer += iprot->skip(ftype); } @@ -33072,11 +33847,11 @@ uint32_t ThriftHiveMetastore_cancel_delegation_token_presult::read(::apache::thr } -ThriftHiveMetastore_add_token_args::~ThriftHiveMetastore_add_token_args() throw() { +ThriftHiveMetastore_add_master_key_args::~ThriftHiveMetastore_add_master_key_args() throw() { } -uint32_t ThriftHiveMetastore_add_token_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_add_master_key_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -33099,16 +33874,8 @@ uint32_t ThriftHiveMetastore_add_token_args::read(::apache::thrift::protocol::TP { 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; - 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 +33892,13 @@ 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_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_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_add_master_key_args"); - 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, 1); + xfer += oprot->writeString(this->key); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -33144,21 +33907,17 @@ uint32_t ThriftHiveMetastore_add_token_args::write(::apache::thrift::protocol::T } -ThriftHiveMetastore_add_token_pargs::~ThriftHiveMetastore_add_token_pargs() throw() { +ThriftHiveMetastore_add_master_key_pargs::~ThriftHiveMetastore_add_master_key_pargs() throw() { } -uint32_t ThriftHiveMetastore_add_token_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +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_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_add_master_key_pargs"); - 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, 1); + xfer += oprot->writeString((*(this->key))); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -33167,11 +33926,11 @@ uint32_t ThriftHiveMetastore_add_token_pargs::write(::apache::thrift::protocol:: } -ThriftHiveMetastore_add_token_result::~ThriftHiveMetastore_add_token_result() throw() { +ThriftHiveMetastore_add_master_key_result::~ThriftHiveMetastore_add_master_key_result() throw() { } -uint32_t ThriftHiveMetastore_add_token_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_add_master_key_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -33193,13 +33952,21 @@ 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); + 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; + } else { + xfer += iprot->skip(ftype); + } + break; default: xfer += iprot->skip(ftype); break; @@ -33212,15 +33979,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_add_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_add_master_key_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_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(); } xfer += oprot->writeFieldStop(); @@ -33229,11 +34000,11 @@ uint32_t ThriftHiveMetastore_add_token_result::write(::apache::thrift::protocol: } -ThriftHiveMetastore_add_token_presult::~ThriftHiveMetastore_add_token_presult() throw() { +ThriftHiveMetastore_add_master_key_presult::~ThriftHiveMetastore_add_master_key_presult() throw() { } -uint32_t ThriftHiveMetastore_add_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; @@ -33255,13 +34026,21 @@ 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))); + 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; + } else { + xfer += iprot->skip(ftype); + } + break; default: xfer += iprot->skip(ftype); break; @@ -33275,11 +34054,11 @@ uint32_t ThriftHiveMetastore_add_token_presult::read(::apache::thrift::protocol: } -ThriftHiveMetastore_remove_token_args::~ThriftHiveMetastore_remove_token_args() throw() { +ThriftHiveMetastore_update_master_key_args::~ThriftHiveMetastore_update_master_key_args() throw() { } -uint32_t ThriftHiveMetastore_remove_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; @@ -33301,9 +34080,17 @@ uint32_t ThriftHiveMetastore_remove_token_args::read(::apache::thrift::protocol: 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->token_identifier); - this->__isset.token_identifier = true; + xfer += iprot->readString(this->key); + this->__isset.key = true; } else { xfer += iprot->skip(ftype); } @@ -33320,13 +34107,17 @@ 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_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_remove_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("key", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->key); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -33335,17 +34126,21 @@ uint32_t ThriftHiveMetastore_remove_token_args::write(::apache::thrift::protocol } -ThriftHiveMetastore_remove_token_pargs::~ThriftHiveMetastore_remove_token_pargs() throw() { +ThriftHiveMetastore_update_master_key_pargs::~ThriftHiveMetastore_update_master_key_pargs() throw() { } -uint32_t ThriftHiveMetastore_remove_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_remove_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("key", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->key))); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -33354,11 +34149,11 @@ uint32_t ThriftHiveMetastore_remove_token_pargs::write(::apache::thrift::protoco } -ThriftHiveMetastore_remove_token_result::~ThriftHiveMetastore_remove_token_result() throw() { +ThriftHiveMetastore_update_master_key_result::~ThriftHiveMetastore_update_master_key_result() throw() { } -uint32_t ThriftHiveMetastore_remove_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; @@ -33379,10 +34174,18 @@ uint32_t ThriftHiveMetastore_remove_token_result::read(::apache::thrift::protoco } 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); } @@ -33399,15 +34202,19 @@ 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_update_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_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(); @@ -33416,11 +34223,11 @@ uint32_t ThriftHiveMetastore_remove_token_result::write(::apache::thrift::protoc } -ThriftHiveMetastore_remove_token_presult::~ThriftHiveMetastore_remove_token_presult() throw() { +ThriftHiveMetastore_update_master_key_presult::~ThriftHiveMetastore_update_master_key_presult() throw() { } -uint32_t ThriftHiveMetastore_remove_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; @@ -33441,10 +34248,18 @@ uint32_t ThriftHiveMetastore_remove_token_presult::read(::apache::thrift::protoc } 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); } @@ -33462,11 +34277,11 @@ uint32_t ThriftHiveMetastore_remove_token_presult::read(::apache::thrift::protoc } -ThriftHiveMetastore_get_token_args::~ThriftHiveMetastore_get_token_args() throw() { +ThriftHiveMetastore_remove_master_key_args::~ThriftHiveMetastore_remove_master_key_args() throw() { } -uint32_t ThriftHiveMetastore_get_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; @@ -33488,9 +34303,9 @@ uint32_t ThriftHiveMetastore_get_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->key_seq); + this->__isset.key_seq = true; } else { xfer += iprot->skip(ftype); } @@ -33507,13 +34322,13 @@ 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_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_get_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(); @@ -33522,17 +34337,17 @@ uint32_t ThriftHiveMetastore_get_token_args::write(::apache::thrift::protocol::T } -ThriftHiveMetastore_get_token_pargs::~ThriftHiveMetastore_get_token_pargs() throw() { +ThriftHiveMetastore_remove_master_key_pargs::~ThriftHiveMetastore_remove_master_key_pargs() throw() { } -uint32_t ThriftHiveMetastore_get_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_get_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(); @@ -33541,11 +34356,11 @@ uint32_t ThriftHiveMetastore_get_token_pargs::write(::apache::thrift::protocol:: } -ThriftHiveMetastore_get_token_result::~ThriftHiveMetastore_get_token_result() throw() { +ThriftHiveMetastore_remove_master_key_result::~ThriftHiveMetastore_remove_master_key_result() throw() { } -uint32_t ThriftHiveMetastore_get_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; @@ -33567,8 +34382,8 @@ 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_BOOL) { + xfer += iprot->readBool(this->success); this->__isset.success = true; } else { xfer += iprot->skip(ftype); @@ -33586,15 +34401,15 @@ 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_remove_master_key_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_token_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_remove_master_key_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_BOOL, 0); + xfer += oprot->writeBool(this->success); xfer += oprot->writeFieldEnd(); } xfer += oprot->writeFieldStop(); @@ -33603,11 +34418,11 @@ uint32_t ThriftHiveMetastore_get_token_result::write(::apache::thrift::protocol: } -ThriftHiveMetastore_get_token_presult::~ThriftHiveMetastore_get_token_presult() throw() { +ThriftHiveMetastore_remove_master_key_presult::~ThriftHiveMetastore_remove_master_key_presult() throw() { } -uint32_t ThriftHiveMetastore_get_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; @@ -33629,8 +34444,8 @@ 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_BOOL) { + xfer += iprot->readBool((*(this->success))); this->__isset.success = true; } else { xfer += iprot->skip(ftype); @@ -33649,11 +34464,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_master_keys_args::~ThriftHiveMetastore_get_master_keys_args() throw() { } -uint32_t ThriftHiveMetastore_get_all_token_identifiers_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; @@ -33681,10 +34496,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_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_all_token_identifiers_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_master_keys_args"); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); @@ -33692,14 +34507,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_master_keys_pargs::~ThriftHiveMetastore_get_master_keys_pargs() throw() { } -uint32_t ThriftHiveMetastore_get_all_token_identifiers_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_all_token_identifiers_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_master_keys_pargs"); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); @@ -33707,11 +34522,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_master_keys_result::~ThriftHiveMetastore_get_master_keys_result() throw() { } -uint32_t ThriftHiveMetastore_get_all_token_identifiers_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; @@ -33736,14 +34551,14 @@ uint32_t ThriftHiveMetastore_get_all_token_identifiers_result::read(::apache::th 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) + uint32_t _size1597; + ::apache::thrift::protocol::TType _etype1600; + xfer += iprot->readListBegin(_etype1600, _size1597); + this->success.resize(_size1597); + uint32_t _i1601; + for (_i1601 = 0; _i1601 < _size1597; ++_i1601) { - xfer += iprot->readString(this->success[_i1570]); + xfer += iprot->readString(this->success[_i1601]); } xfer += iprot->readListEnd(); } @@ -33764,20 +34579,20 @@ 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_master_keys_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_master_keys_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 _iter1571; - for (_iter1571 = this->success.begin(); _iter1571 != this->success.end(); ++_iter1571) + std::vector ::const_iterator _iter1602; + for (_iter1602 = this->success.begin(); _iter1602 != this->success.end(); ++_iter1602) { - xfer += oprot->writeString((*_iter1571)); + xfer += oprot->writeString((*_iter1602)); } xfer += oprot->writeListEnd(); } @@ -33789,11 +34604,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_master_keys_presult::~ThriftHiveMetastore_get_master_keys_presult() throw() { } -uint32_t ThriftHiveMetastore_get_all_token_identifiers_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; @@ -33818,14 +34633,14 @@ uint32_t ThriftHiveMetastore_get_all_token_identifiers_presult::read(::apache::t 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) + uint32_t _size1603; + ::apache::thrift::protocol::TType _etype1606; + xfer += iprot->readListBegin(_etype1606, _size1603); + (*(this->success)).resize(_size1603); + uint32_t _i1607; + for (_i1607 = 0; _i1607 < _size1603; ++_i1607) { - xfer += iprot->readString((*(this->success))[_i1576]); + xfer += iprot->readString((*(this->success))[_i1607]); } xfer += iprot->readListEnd(); } @@ -33847,11 +34662,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_args::~ThriftHiveMetastore_get_open_txns_args() throw() { } -uint32_t ThriftHiveMetastore_add_master_key_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; @@ -33870,20 +34685,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 +34694,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_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_args"); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); @@ -33907,18 +34705,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_pargs::~ThriftHiveMetastore_get_open_txns_pargs() throw() { } -uint32_t ThriftHiveMetastore_add_master_key_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_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_pargs"); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); @@ -33926,11 +34720,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_result::~ThriftHiveMetastore_get_open_txns_result() throw() { } -uint32_t ThriftHiveMetastore_add_master_key_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; @@ -33952,17 +34746,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 +34765,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_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_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 +34782,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_presult::~ThriftHiveMetastore_get_open_txns_presult() throw() { } -uint32_t ThriftHiveMetastore_add_master_key_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; @@ -34026,17 +34808,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 +34828,11 @@ uint32_t ThriftHiveMetastore_add_master_key_presult::read(::apache::thrift::prot } -ThriftHiveMetastore_update_master_key_args::~ThriftHiveMetastore_update_master_key_args() throw() { +ThriftHiveMetastore_get_open_txns_info_args::~ThriftHiveMetastore_get_open_txns_info_args() throw() { } -uint32_t ThriftHiveMetastore_update_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; @@ -34077,28 +34851,7 @@ uint32_t ThriftHiveMetastore_update_master_key_args::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_STOP) { break; } - 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; - } else { - xfer += iprot->skip(ftype); - } - break; - default: - xfer += iprot->skip(ftype); - break; - } + xfer += iprot->skip(ftype); xfer += iprot->readFieldEnd(); } @@ -34107,18 +34860,10 @@ 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_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_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->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 2); - xfer += oprot->writeString(this->key); - xfer += oprot->writeFieldEnd(); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_open_txns_info_args"); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); @@ -34126,22 +34871,14 @@ uint32_t ThriftHiveMetastore_update_master_key_args::write(::apache::thrift::pro } -ThriftHiveMetastore_update_master_key_pargs::~ThriftHiveMetastore_update_master_key_pargs() throw() { +ThriftHiveMetastore_get_open_txns_info_pargs::~ThriftHiveMetastore_get_open_txns_info_pargs() throw() { } -uint32_t ThriftHiveMetastore_update_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_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->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 2); - xfer += oprot->writeString((*(this->key))); - xfer += oprot->writeFieldEnd(); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_open_txns_info_pargs"); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); @@ -34149,11 +34886,11 @@ uint32_t ThriftHiveMetastore_update_master_key_pargs::write(::apache::thrift::pr } -ThriftHiveMetastore_update_master_key_result::~ThriftHiveMetastore_update_master_key_result() throw() { +ThriftHiveMetastore_get_open_txns_info_result::~ThriftHiveMetastore_get_open_txns_info_result() throw() { } -uint32_t ThriftHiveMetastore_update_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; @@ -34174,18 +34911,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 +34931,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_get_open_txns_info_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_update_master_key_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_open_txns_info_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 +34948,11 @@ uint32_t ThriftHiveMetastore_update_master_key_result::write(::apache::thrift::p } -ThriftHiveMetastore_update_master_key_presult::~ThriftHiveMetastore_update_master_key_presult() throw() { +ThriftHiveMetastore_get_open_txns_info_presult::~ThriftHiveMetastore_get_open_txns_info_presult() throw() { } -uint32_t ThriftHiveMetastore_update_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; @@ -34248,18 +34973,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 +34994,11 @@ uint32_t ThriftHiveMetastore_update_master_key_presult::read(::apache::thrift::p } -ThriftHiveMetastore_remove_master_key_args::~ThriftHiveMetastore_remove_master_key_args() throw() { +ThriftHiveMetastore_open_txns_args::~ThriftHiveMetastore_open_txns_args() throw() { } -uint32_t ThriftHiveMetastore_remove_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; @@ -34303,9 +35020,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 +35039,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_open_txns_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_open_txns_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 +35054,17 @@ uint32_t ThriftHiveMetastore_remove_master_key_args::write(::apache::thrift::pro } -ThriftHiveMetastore_remove_master_key_pargs::~ThriftHiveMetastore_remove_master_key_pargs() throw() { +ThriftHiveMetastore_open_txns_pargs::~ThriftHiveMetastore_open_txns_pargs() throw() { } -uint32_t ThriftHiveMetastore_remove_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_remove_master_key_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_open_txns_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 +35073,11 @@ uint32_t ThriftHiveMetastore_remove_master_key_pargs::write(::apache::thrift::pr } -ThriftHiveMetastore_remove_master_key_result::~ThriftHiveMetastore_remove_master_key_result() throw() { +ThriftHiveMetastore_open_txns_result::~ThriftHiveMetastore_open_txns_result() throw() { } -uint32_t ThriftHiveMetastore_remove_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; @@ -34382,8 +35099,8 @@ 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); + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); this->__isset.success = true; } else { xfer += iprot->skip(ftype); @@ -34401,15 +35118,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_open_txns_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_remove_master_key_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_open_txns_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(); } xfer += oprot->writeFieldStop(); @@ -34418,11 +35135,11 @@ uint32_t ThriftHiveMetastore_remove_master_key_result::write(::apache::thrift::p } -ThriftHiveMetastore_remove_master_key_presult::~ThriftHiveMetastore_remove_master_key_presult() throw() { +ThriftHiveMetastore_open_txns_presult::~ThriftHiveMetastore_open_txns_presult() throw() { } -uint32_t ThriftHiveMetastore_remove_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; @@ -34444,8 +35161,8 @@ 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))); + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); this->__isset.success = true; } else { xfer += iprot->skip(ftype); @@ -34464,11 +35181,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_txn_args::~ThriftHiveMetastore_abort_txn_args() throw() { } -uint32_t ThriftHiveMetastore_get_master_keys_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; @@ -34487,7 +35204,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 +35226,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_txn_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_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(); @@ -34507,14 +35241,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_txn_pargs::~ThriftHiveMetastore_abort_txn_pargs() throw() { } -uint32_t ThriftHiveMetastore_get_master_keys_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_get_master_keys_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_abort_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(); @@ -34522,11 +35260,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_txn_result::~ThriftHiveMetastore_abort_txn_result() throw() { } -uint32_t ThriftHiveMetastore_get_master_keys_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; @@ -34547,22 +35285,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 _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; + 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 +35305,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_txn_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_txn_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 _iter1582; - for (_iter1582 = this->success.begin(); _iter1582 != this->success.end(); ++_iter1582) - { - xfer += oprot->writeString((*_iter1582)); - } - 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 +35322,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_txn_presult::~ThriftHiveMetastore_abort_txn_presult() throw() { } -uint32_t ThriftHiveMetastore_get_master_keys_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; @@ -34629,22 +35347,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 _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; + 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 +35368,11 @@ uint32_t ThriftHiveMetastore_get_master_keys_presult::read(::apache::thrift::pro } -ThriftHiveMetastore_get_open_txns_args::~ThriftHiveMetastore_get_open_txns_args() throw() { +ThriftHiveMetastore_abort_txns_args::~ThriftHiveMetastore_abort_txns_args() throw() { } -uint32_t ThriftHiveMetastore_get_open_txns_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; @@ -34685,7 +35391,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 +35413,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_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_open_txns_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(); @@ -34705,14 +35428,18 @@ uint32_t ThriftHiveMetastore_get_open_txns_args::write(::apache::thrift::protoco } -ThriftHiveMetastore_get_open_txns_pargs::~ThriftHiveMetastore_get_open_txns_pargs() throw() { +ThriftHiveMetastore_abort_txns_pargs::~ThriftHiveMetastore_abort_txns_pargs() throw() { } -uint32_t ThriftHiveMetastore_get_open_txns_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_open_txns_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(); @@ -34720,11 +35447,11 @@ uint32_t ThriftHiveMetastore_get_open_txns_pargs::write(::apache::thrift::protoc } -ThriftHiveMetastore_get_open_txns_result::~ThriftHiveMetastore_get_open_txns_result() throw() { +ThriftHiveMetastore_abort_txns_result::~ThriftHiveMetastore_abort_txns_result() throw() { } -uint32_t ThriftHiveMetastore_get_open_txns_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; @@ -34745,10 +35472,10 @@ 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); } @@ -34765,15 +35492,15 @@ 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_abort_txns_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_open_txns_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_abort_txns_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(); } xfer += oprot->writeFieldStop(); @@ -34782,11 +35509,11 @@ uint32_t ThriftHiveMetastore_get_open_txns_result::write(::apache::thrift::proto } -ThriftHiveMetastore_get_open_txns_presult::~ThriftHiveMetastore_get_open_txns_presult() throw() { +ThriftHiveMetastore_abort_txns_presult::~ThriftHiveMetastore_abort_txns_presult() throw() { } -uint32_t ThriftHiveMetastore_get_open_txns_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; @@ -34807,10 +35534,10 @@ 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); } @@ -34828,11 +35555,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_commit_txn_args::~ThriftHiveMetastore_commit_txn_args() throw() { } -uint32_t ThriftHiveMetastore_get_open_txns_info_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; @@ -34851,7 +35578,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 +35600,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_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_info_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(); @@ -34871,14 +35615,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_commit_txn_pargs::~ThriftHiveMetastore_commit_txn_pargs() throw() { } -uint32_t ThriftHiveMetastore_get_open_txns_info_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_info_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(); @@ -34886,11 +35634,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_commit_txn_result::~ThriftHiveMetastore_commit_txn_result() throw() { } -uint32_t ThriftHiveMetastore_get_open_txns_info_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; @@ -34911,10 +35659,18 @@ uint32_t ThriftHiveMetastore_get_open_txns_info_result::read(::apache::thrift::p } 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); } @@ -34931,15 +35687,19 @@ 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_commit_txn_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_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(); @@ -34948,11 +35708,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_commit_txn_presult::~ThriftHiveMetastore_commit_txn_presult() throw() { } -uint32_t ThriftHiveMetastore_get_open_txns_info_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; @@ -34973,10 +35733,18 @@ uint32_t ThriftHiveMetastore_get_open_txns_info_presult::read(::apache::thrift:: } 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); } @@ -34994,11 +35762,11 @@ uint32_t ThriftHiveMetastore_get_open_txns_info_presult::read(::apache::thrift:: } -ThriftHiveMetastore_open_txns_args::~ThriftHiveMetastore_open_txns_args() throw() { +ThriftHiveMetastore_lock_args::~ThriftHiveMetastore_lock_args() throw() { } -uint32_t ThriftHiveMetastore_open_txns_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; @@ -35039,10 +35807,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_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_lock_args"); xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); xfer += this->rqst.write(oprot); @@ -35054,14 +35822,14 @@ uint32_t ThriftHiveMetastore_open_txns_args::write(::apache::thrift::protocol::T } -ThriftHiveMetastore_open_txns_pargs::~ThriftHiveMetastore_open_txns_pargs() throw() { +ThriftHiveMetastore_lock_pargs::~ThriftHiveMetastore_lock_pargs() throw() { } -uint32_t ThriftHiveMetastore_open_txns_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_open_txns_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_lock_pargs"); xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); xfer += (*(this->rqst)).write(oprot); @@ -35073,11 +35841,11 @@ uint32_t ThriftHiveMetastore_open_txns_pargs::write(::apache::thrift::protocol:: } -ThriftHiveMetastore_open_txns_result::~ThriftHiveMetastore_open_txns_result() throw() { +ThriftHiveMetastore_lock_result::~ThriftHiveMetastore_lock_result() throw() { } -uint32_t ThriftHiveMetastore_open_txns_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; @@ -35106,6 +35874,22 @@ 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; default: xfer += iprot->skip(ftype); break; @@ -35118,16 +35902,24 @@ 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_lock_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_open_txns_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(); @@ -35135,11 +35927,11 @@ uint32_t ThriftHiveMetastore_open_txns_result::write(::apache::thrift::protocol: } -ThriftHiveMetastore_open_txns_presult::~ThriftHiveMetastore_open_txns_presult() throw() { +ThriftHiveMetastore_lock_presult::~ThriftHiveMetastore_lock_presult() throw() { } -uint32_t ThriftHiveMetastore_open_txns_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; @@ -35168,6 +35960,22 @@ 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; default: xfer += iprot->skip(ftype); break; @@ -35181,11 +35989,11 @@ uint32_t ThriftHiveMetastore_open_txns_presult::read(::apache::thrift::protocol: } -ThriftHiveMetastore_abort_txn_args::~ThriftHiveMetastore_abort_txn_args() throw() { +ThriftHiveMetastore_check_lock_args::~ThriftHiveMetastore_check_lock_args() throw() { } -uint32_t ThriftHiveMetastore_abort_txn_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; @@ -35226,10 +36034,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_check_lock_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_check_lock_args"); xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); xfer += this->rqst.write(oprot); @@ -35241,14 +36049,14 @@ uint32_t ThriftHiveMetastore_abort_txn_args::write(::apache::thrift::protocol::T } -ThriftHiveMetastore_abort_txn_pargs::~ThriftHiveMetastore_abort_txn_pargs() throw() { +ThriftHiveMetastore_check_lock_pargs::~ThriftHiveMetastore_check_lock_pargs() throw() { } -uint32_t ThriftHiveMetastore_abort_txn_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_abort_txn_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_check_lock_pargs"); xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); xfer += (*(this->rqst)).write(oprot); @@ -35260,11 +36068,11 @@ uint32_t ThriftHiveMetastore_abort_txn_pargs::write(::apache::thrift::protocol:: } -ThriftHiveMetastore_abort_txn_result::~ThriftHiveMetastore_abort_txn_result() throw() { +ThriftHiveMetastore_check_lock_result::~ThriftHiveMetastore_check_lock_result() throw() { } -uint32_t ThriftHiveMetastore_abort_txn_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; @@ -35285,6 +36093,14 @@ uint32_t ThriftHiveMetastore_abort_txn_result::read(::apache::thrift::protocol:: } 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); @@ -35293,6 +36109,22 @@ 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; + 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; @@ -35305,16 +36137,28 @@ 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_check_lock_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_abort_txn_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_check_lock_result"); - if (this->__isset.o1) { + 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(); @@ -35322,11 +36166,11 @@ uint32_t ThriftHiveMetastore_abort_txn_result::write(::apache::thrift::protocol: } -ThriftHiveMetastore_abort_txn_presult::~ThriftHiveMetastore_abort_txn_presult() throw() { +ThriftHiveMetastore_check_lock_presult::~ThriftHiveMetastore_check_lock_presult() throw() { } -uint32_t ThriftHiveMetastore_abort_txn_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; @@ -35347,6 +36191,14 @@ uint32_t ThriftHiveMetastore_abort_txn_presult::read(::apache::thrift::protocol: } 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); @@ -35355,6 +36207,22 @@ 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; + 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; @@ -35368,11 +36236,11 @@ uint32_t ThriftHiveMetastore_abort_txn_presult::read(::apache::thrift::protocol: } -ThriftHiveMetastore_abort_txns_args::~ThriftHiveMetastore_abort_txns_args() throw() { +ThriftHiveMetastore_unlock_args::~ThriftHiveMetastore_unlock_args() throw() { } -uint32_t ThriftHiveMetastore_abort_txns_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; @@ -35413,10 +36281,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_unlock_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_unlock_args"); xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); xfer += this->rqst.write(oprot); @@ -35428,14 +36296,14 @@ uint32_t ThriftHiveMetastore_abort_txns_args::write(::apache::thrift::protocol:: } -ThriftHiveMetastore_abort_txns_pargs::~ThriftHiveMetastore_abort_txns_pargs() throw() { +ThriftHiveMetastore_unlock_pargs::~ThriftHiveMetastore_unlock_pargs() throw() { } -uint32_t ThriftHiveMetastore_abort_txns_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_txns_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_unlock_pargs"); xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); xfer += (*(this->rqst)).write(oprot); @@ -35447,11 +36315,11 @@ uint32_t ThriftHiveMetastore_abort_txns_pargs::write(::apache::thrift::protocol: } -ThriftHiveMetastore_abort_txns_result::~ThriftHiveMetastore_abort_txns_result() throw() { +ThriftHiveMetastore_unlock_result::~ThriftHiveMetastore_unlock_result() throw() { } -uint32_t ThriftHiveMetastore_abort_txns_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; @@ -35480,6 +36348,14 @@ uint32_t ThriftHiveMetastore_abort_txns_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; @@ -35492,16 +36368,20 @@ 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_unlock_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_abort_txns_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(); @@ -35509,11 +36389,11 @@ uint32_t ThriftHiveMetastore_abort_txns_result::write(::apache::thrift::protocol } -ThriftHiveMetastore_abort_txns_presult::~ThriftHiveMetastore_abort_txns_presult() throw() { +ThriftHiveMetastore_unlock_presult::~ThriftHiveMetastore_unlock_presult() throw() { } -uint32_t ThriftHiveMetastore_abort_txns_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; @@ -35542,6 +36422,14 @@ uint32_t ThriftHiveMetastore_abort_txns_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; @@ -35555,11 +36443,11 @@ uint32_t ThriftHiveMetastore_abort_txns_presult::read(::apache::thrift::protocol } -ThriftHiveMetastore_commit_txn_args::~ThriftHiveMetastore_commit_txn_args() throw() { +ThriftHiveMetastore_show_locks_args::~ThriftHiveMetastore_show_locks_args() throw() { } -uint32_t ThriftHiveMetastore_commit_txn_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; @@ -35600,10 +36488,10 @@ 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_show_locks_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_show_locks_args"); xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); xfer += this->rqst.write(oprot); @@ -35615,14 +36503,14 @@ uint32_t ThriftHiveMetastore_commit_txn_args::write(::apache::thrift::protocol:: } -ThriftHiveMetastore_commit_txn_pargs::~ThriftHiveMetastore_commit_txn_pargs() throw() { +ThriftHiveMetastore_show_locks_pargs::~ThriftHiveMetastore_show_locks_pargs() throw() { } -uint32_t ThriftHiveMetastore_commit_txn_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_commit_txn_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_show_locks_pargs"); xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); xfer += (*(this->rqst)).write(oprot); @@ -35634,11 +36522,11 @@ uint32_t ThriftHiveMetastore_commit_txn_pargs::write(::apache::thrift::protocol: } -ThriftHiveMetastore_commit_txn_result::~ThriftHiveMetastore_commit_txn_result() throw() { +ThriftHiveMetastore_show_locks_result::~ThriftHiveMetastore_show_locks_result() throw() { } -uint32_t ThriftHiveMetastore_commit_txn_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; @@ -35659,18 +36547,10 @@ uint32_t ThriftHiveMetastore_commit_txn_result::read(::apache::thrift::protocol: } 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); } @@ -35687,19 +36567,15 @@ 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_show_locks_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_commit_txn_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); - 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(); @@ -35708,11 +36584,11 @@ uint32_t ThriftHiveMetastore_commit_txn_result::write(::apache::thrift::protocol } -ThriftHiveMetastore_commit_txn_presult::~ThriftHiveMetastore_commit_txn_presult() throw() { +ThriftHiveMetastore_show_locks_presult::~ThriftHiveMetastore_show_locks_presult() throw() { } -uint32_t ThriftHiveMetastore_commit_txn_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; @@ -35733,18 +36609,10 @@ uint32_t ThriftHiveMetastore_commit_txn_presult::read(::apache::thrift::protocol } 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); } @@ -35762,11 +36630,11 @@ uint32_t ThriftHiveMetastore_commit_txn_presult::read(::apache::thrift::protocol } -ThriftHiveMetastore_lock_args::~ThriftHiveMetastore_lock_args() throw() { +ThriftHiveMetastore_heartbeat_args::~ThriftHiveMetastore_heartbeat_args() throw() { } -uint32_t ThriftHiveMetastore_lock_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; @@ -35789,8 +36657,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->ids.read(iprot); + this->__isset.ids = true; } else { xfer += iprot->skip(ftype); } @@ -35807,13 +36675,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_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_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(); @@ -35822,17 +36690,17 @@ uint32_t ThriftHiveMetastore_lock_args::write(::apache::thrift::protocol::TProto } -ThriftHiveMetastore_lock_pargs::~ThriftHiveMetastore_lock_pargs() throw() { +ThriftHiveMetastore_heartbeat_pargs::~ThriftHiveMetastore_heartbeat_pargs() throw() { } -uint32_t ThriftHiveMetastore_lock_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_lock_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(); @@ -35841,11 +36709,11 @@ uint32_t ThriftHiveMetastore_lock_pargs::write(::apache::thrift::protocol::TProt } -ThriftHiveMetastore_lock_result::~ThriftHiveMetastore_lock_result() throw() { +ThriftHiveMetastore_heartbeat_result::~ThriftHiveMetastore_heartbeat_result() throw() { } -uint32_t ThriftHiveMetastore_lock_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; @@ -35866,14 +36734,6 @@ uint32_t ThriftHiveMetastore_lock_result::read(::apache::thrift::protocol::TProt } 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); @@ -35890,6 +36750,14 @@ uint32_t ThriftHiveMetastore_lock_result::read(::apache::thrift::protocol::TProt 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; @@ -35902,17 +36770,13 @@ 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_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_lock_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_heartbeat_result"); - if (this->__isset.success) { - xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); - xfer += this->success.write(oprot); - xfer += oprot->writeFieldEnd(); - } else if (this->__isset.o1) { + if (this->__isset.o1) { xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); xfer += this->o1.write(oprot); xfer += oprot->writeFieldEnd(); @@ -35920,6 +36784,10 @@ uint32_t ThriftHiveMetastore_lock_result::write(::apache::thrift::protocol::TPro 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(); @@ -35927,11 +36795,11 @@ uint32_t ThriftHiveMetastore_lock_result::write(::apache::thrift::protocol::TPro } -ThriftHiveMetastore_lock_presult::~ThriftHiveMetastore_lock_presult() throw() { +ThriftHiveMetastore_heartbeat_presult::~ThriftHiveMetastore_heartbeat_presult() throw() { } -uint32_t ThriftHiveMetastore_lock_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; @@ -35952,14 +36820,6 @@ uint32_t ThriftHiveMetastore_lock_presult::read(::apache::thrift::protocol::TPro } 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); @@ -35976,6 +36836,14 @@ uint32_t ThriftHiveMetastore_lock_presult::read(::apache::thrift::protocol::TPro 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; @@ -35989,11 +36857,11 @@ uint32_t ThriftHiveMetastore_lock_presult::read(::apache::thrift::protocol::TPro } -ThriftHiveMetastore_check_lock_args::~ThriftHiveMetastore_check_lock_args() throw() { +ThriftHiveMetastore_heartbeat_txn_range_args::~ThriftHiveMetastore_heartbeat_txn_range_args() throw() { } -uint32_t ThriftHiveMetastore_check_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; @@ -36016,8 +36884,8 @@ uint32_t ThriftHiveMetastore_check_lock_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->txns.read(iprot); + this->__isset.txns = true; } else { xfer += iprot->skip(ftype); } @@ -36034,13 +36902,13 @@ 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_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_check_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(); @@ -36049,17 +36917,17 @@ uint32_t ThriftHiveMetastore_check_lock_args::write(::apache::thrift::protocol:: } -ThriftHiveMetastore_check_lock_pargs::~ThriftHiveMetastore_check_lock_pargs() throw() { +ThriftHiveMetastore_heartbeat_txn_range_pargs::~ThriftHiveMetastore_heartbeat_txn_range_pargs() throw() { } -uint32_t ThriftHiveMetastore_check_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_check_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(); @@ -36068,11 +36936,11 @@ uint32_t ThriftHiveMetastore_check_lock_pargs::write(::apache::thrift::protocol: } -ThriftHiveMetastore_check_lock_result::~ThriftHiveMetastore_check_lock_result() throw() { +ThriftHiveMetastore_heartbeat_txn_range_result::~ThriftHiveMetastore_heartbeat_txn_range_result() throw() { } -uint32_t ThriftHiveMetastore_check_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; @@ -36101,30 +36969,6 @@ uint32_t ThriftHiveMetastore_check_lock_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; @@ -36137,28 +36981,16 @@ 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_heartbeat_txn_range_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_check_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(); - } 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(); @@ -36166,11 +36998,11 @@ uint32_t ThriftHiveMetastore_check_lock_result::write(::apache::thrift::protocol } -ThriftHiveMetastore_check_lock_presult::~ThriftHiveMetastore_check_lock_presult() throw() { +ThriftHiveMetastore_heartbeat_txn_range_presult::~ThriftHiveMetastore_heartbeat_txn_range_presult() throw() { } -uint32_t ThriftHiveMetastore_check_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; @@ -36199,30 +37031,6 @@ uint32_t ThriftHiveMetastore_check_lock_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; @@ -36236,11 +37044,11 @@ uint32_t ThriftHiveMetastore_check_lock_presult::read(::apache::thrift::protocol } -ThriftHiveMetastore_unlock_args::~ThriftHiveMetastore_unlock_args() throw() { +ThriftHiveMetastore_compact_args::~ThriftHiveMetastore_compact_args() throw() { } -uint32_t ThriftHiveMetastore_unlock_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; @@ -36281,10 +37089,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_compact_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_compact_args"); xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); xfer += this->rqst.write(oprot); @@ -36296,14 +37104,14 @@ uint32_t ThriftHiveMetastore_unlock_args::write(::apache::thrift::protocol::TPro } -ThriftHiveMetastore_unlock_pargs::~ThriftHiveMetastore_unlock_pargs() throw() { +ThriftHiveMetastore_compact_pargs::~ThriftHiveMetastore_compact_pargs() throw() { } -uint32_t ThriftHiveMetastore_unlock_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_unlock_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_compact_pargs"); xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); xfer += (*(this->rqst)).write(oprot); @@ -36315,11 +37123,11 @@ uint32_t ThriftHiveMetastore_unlock_pargs::write(::apache::thrift::protocol::TPr } -ThriftHiveMetastore_unlock_result::~ThriftHiveMetastore_unlock_result() throw() { +ThriftHiveMetastore_compact_result::~ThriftHiveMetastore_compact_result() throw() { } -uint32_t ThriftHiveMetastore_unlock_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; @@ -36338,28 +37146,7 @@ uint32_t ThriftHiveMetastore_unlock_result::read(::apache::thrift::protocol::TPr 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(); } @@ -36368,32 +37155,56 @@ 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_compact_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_unlock_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_compact_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_unlock_presult::~ThriftHiveMetastore_unlock_presult() throw() { +ThriftHiveMetastore_compact_presult::~ThriftHiveMetastore_compact_presult() throw() { } -uint32_t ThriftHiveMetastore_unlock_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; + 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_compact2_args::~ThriftHiveMetastore_compact2_args() throw() { +} + + +uint32_t ThriftHiveMetastore_compact2_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -36416,16 +37227,87 @@ uint32_t ThriftHiveMetastore_unlock_presult::read(::apache::thrift::protocol::TP { case 1: if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->o1.read(iprot); - this->__isset.o1 = true; + xfer += this->rqst.read(iprot); + this->__isset.rqst = true; } else { xfer += iprot->skip(ftype); } break; - case 2: + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +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_compact2_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(); + return xfer; +} + + +ThriftHiveMetastore_compact2_pargs::~ThriftHiveMetastore_compact2_pargs() throw() { +} + + +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_compact2_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(); + return xfer; +} + + +ThriftHiveMetastore_compact2_result::~ThriftHiveMetastore_compact2_result() throw() { +} + + +uint32_t ThriftHiveMetastore_compact2_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->o2.read(iprot); - this->__isset.o2 = true; + xfer += this->success.read(iprot); + this->__isset.success = true; } else { xfer += iprot->skip(ftype); } @@ -36442,12 +37324,74 @@ uint32_t ThriftHiveMetastore_unlock_presult::read(::apache::thrift::protocol::TP return xfer; } +uint32_t ThriftHiveMetastore_compact2_result::write(::apache::thrift::protocol::TProtocol* oprot) const { -ThriftHiveMetastore_show_locks_args::~ThriftHiveMetastore_show_locks_args() throw() { + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_compact2_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; } -uint32_t ThriftHiveMetastore_show_locks_args::read(::apache::thrift::protocol::TProtocol* iprot) { +ThriftHiveMetastore_compact2_presult::~ThriftHiveMetastore_compact2_presult() throw() { +} + + +uint32_t ThriftHiveMetastore_compact2_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; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_show_compact_args::~ThriftHiveMetastore_show_compact_args() throw() { +} + + +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,85 @@ 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; + 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_cm_recycle_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + 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(); + return xfer; +} + + +ThriftHiveMetastore_cm_recycle_presult::~ThriftHiveMetastore_cm_recycle_presult() throw() { +} + + +uint32_t ThriftHiveMetastore_cm_recycle_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -37887,12 +38823,20 @@ uint32_t ThriftHiveMetastore_get_next_notification_result::read(::apache::thrift { case 0: if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->success.read(iprot); + 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; @@ -37905,28 +38849,12 @@ 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 xfer = 0; - - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_next_notification_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_get_next_notification_presult::~ThriftHiveMetastore_get_next_notification_presult() throw() { +ThriftHiveMetastore_get_file_metadata_by_expr_args::~ThriftHiveMetastore_get_file_metadata_by_expr_args() throw() { } -uint32_t ThriftHiveMetastore_get_next_notification_presult::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; @@ -37947,10 +38875,10 @@ uint32_t ThriftHiveMetastore_get_next_notification_presult::read(::apache::thrif } switch (fid) { - case 0: + case 1: if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += (*(this->success)).read(iprot); - this->__isset.success = true; + xfer += this->req.read(iprot); + this->__isset.req = true; } else { xfer += iprot->skip(ftype); } @@ -37967,43 +38895,14 @@ uint32_t ThriftHiveMetastore_get_next_notification_presult::read(::apache::thrif return xfer; } - -ThriftHiveMetastore_get_current_notificationEventId_args::~ThriftHiveMetastore_get_current_notificationEventId_args() throw() { -} - - -uint32_t ThriftHiveMetastore_get_current_notificationEventId_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_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,11 +39411,11 @@ uint32_t ThriftHiveMetastore_fire_listener_event_presult::read(::apache::thrift: } -ThriftHiveMetastore_flushCache_args::~ThriftHiveMetastore_flushCache_args() throw() { +ThriftHiveMetastore_clear_file_metadata_args::~ThriftHiveMetastore_clear_file_metadata_args() throw() { } -uint32_t ThriftHiveMetastore_flushCache_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; @@ -38531,7 +39434,20 @@ uint32_t ThriftHiveMetastore_flushCache_args::read(::apache::thrift::protocol::T 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(); } @@ -38540,10 +39456,14 @@ uint32_t ThriftHiveMetastore_flushCache_args::read(::apache::thrift::protocol::T return xfer; } -uint32_t ThriftHiveMetastore_flushCache_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_flushCache_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_clear_file_metadata_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(); @@ -38551,14 +39471,18 @@ uint32_t ThriftHiveMetastore_flushCache_args::write(::apache::thrift::protocol:: } -ThriftHiveMetastore_flushCache_pargs::~ThriftHiveMetastore_flushCache_pargs() throw() { +ThriftHiveMetastore_clear_file_metadata_pargs::~ThriftHiveMetastore_clear_file_metadata_pargs() throw() { } -uint32_t ThriftHiveMetastore_flushCache_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_flushCache_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_clear_file_metadata_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(); @@ -38566,11 +39490,11 @@ uint32_t ThriftHiveMetastore_flushCache_pargs::write(::apache::thrift::protocol: } -ThriftHiveMetastore_flushCache_result::~ThriftHiveMetastore_flushCache_result() throw() { +ThriftHiveMetastore_clear_file_metadata_result::~ThriftHiveMetastore_clear_file_metadata_result() throw() { } -uint32_t ThriftHiveMetastore_flushCache_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; @@ -38589,7 +39513,20 @@ uint32_t ThriftHiveMetastore_flushCache_result::read(::apache::thrift::protocol: 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(); } @@ -38598,23 +39535,28 @@ uint32_t ThriftHiveMetastore_flushCache_result::read(::apache::thrift::protocol: return xfer; } -uint32_t ThriftHiveMetastore_flushCache_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_flushCache_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(); + } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; } -ThriftHiveMetastore_flushCache_presult::~ThriftHiveMetastore_flushCache_presult() throw() { +ThriftHiveMetastore_clear_file_metadata_presult::~ThriftHiveMetastore_clear_file_metadata_presult() throw() { } -uint32_t ThriftHiveMetastore_flushCache_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; @@ -38633,7 +39575,20 @@ uint32_t ThriftHiveMetastore_flushCache_presult::read(::apache::thrift::protocol 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(); } @@ -38643,11 +39598,11 @@ uint32_t ThriftHiveMetastore_flushCache_presult::read(::apache::thrift::protocol } -ThriftHiveMetastore_cm_recycle_args::~ThriftHiveMetastore_cm_recycle_args() throw() { +ThriftHiveMetastore_cache_file_metadata_args::~ThriftHiveMetastore_cache_file_metadata_args() throw() { } -uint32_t ThriftHiveMetastore_cm_recycle_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; @@ -38670,8 +39625,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 +39643,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_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_cm_recycle_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_cache_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 +39658,17 @@ uint32_t ThriftHiveMetastore_cm_recycle_args::write(::apache::thrift::protocol:: } -ThriftHiveMetastore_cm_recycle_pargs::~ThriftHiveMetastore_cm_recycle_pargs() throw() { +ThriftHiveMetastore_cache_file_metadata_pargs::~ThriftHiveMetastore_cache_file_metadata_pargs() throw() { } -uint32_t ThriftHiveMetastore_cm_recycle_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_cm_recycle_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_cache_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 +39677,11 @@ uint32_t ThriftHiveMetastore_cm_recycle_pargs::write(::apache::thrift::protocol: } -ThriftHiveMetastore_cm_recycle_result::~ThriftHiveMetastore_cm_recycle_result() throw() { +ThriftHiveMetastore_cache_file_metadata_result::~ThriftHiveMetastore_cache_file_metadata_result() throw() { } -uint32_t ThriftHiveMetastore_cm_recycle_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; @@ -38755,14 +39710,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 +39722,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_cache_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_cache_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 +39739,11 @@ uint32_t ThriftHiveMetastore_cm_recycle_result::write(::apache::thrift::protocol } -ThriftHiveMetastore_cm_recycle_presult::~ThriftHiveMetastore_cm_recycle_presult() throw() { +ThriftHiveMetastore_cache_file_metadata_presult::~ThriftHiveMetastore_cache_file_metadata_presult() throw() { } -uint32_t ThriftHiveMetastore_cm_recycle_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; @@ -38829,14 +39772,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 +39785,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_get_metastore_db_uuid_args::~ThriftHiveMetastore_get_metastore_db_uuid_args() throw() { } -uint32_t ThriftHiveMetastore_get_file_metadata_by_expr_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; @@ -38873,20 +39808,7 @@ uint32_t ThriftHiveMetastore_get_file_metadata_by_expr_args::read(::apache::thri 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(); } @@ -38895,14 +39817,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_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_by_expr_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(); @@ -38910,18 +39828,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_get_metastore_db_uuid_pargs::~ThriftHiveMetastore_get_metastore_db_uuid_pargs() throw() { } -uint32_t ThriftHiveMetastore_get_file_metadata_by_expr_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_by_expr_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(); @@ -38929,11 +39843,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_get_metastore_db_uuid_result::~ThriftHiveMetastore_get_metastore_db_uuid_result() throw() { } -uint32_t ThriftHiveMetastore_get_file_metadata_by_expr_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; @@ -38955,13 +39869,21 @@ uint32_t ThriftHiveMetastore_get_file_metadata_by_expr_result::read(::apache::th 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; @@ -38974,15 +39896,19 @@ 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_get_metastore_db_uuid_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_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(); @@ -38991,11 +39917,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_get_metastore_db_uuid_presult::~ThriftHiveMetastore_get_metastore_db_uuid_presult() throw() { } -uint32_t ThriftHiveMetastore_get_file_metadata_by_expr_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; @@ -39017,13 +39943,21 @@ uint32_t ThriftHiveMetastore_get_file_metadata_by_expr_presult::read(::apache::t 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; @@ -39037,11 +39971,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_create_resource_plan_args::~ThriftHiveMetastore_create_resource_plan_args() throw() { } -uint32_t ThriftHiveMetastore_get_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; @@ -39064,8 +39998,8 @@ uint32_t ThriftHiveMetastore_get_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); } @@ -39082,13 +40016,13 @@ 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_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_get_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(); @@ -39097,17 +40031,17 @@ uint32_t ThriftHiveMetastore_get_file_metadata_args::write(::apache::thrift::pro } -ThriftHiveMetastore_get_file_metadata_pargs::~ThriftHiveMetastore_get_file_metadata_pargs() throw() { +ThriftHiveMetastore_create_resource_plan_pargs::~ThriftHiveMetastore_create_resource_plan_pargs() throw() { } -uint32_t ThriftHiveMetastore_get_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_get_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(); @@ -39116,11 +40050,11 @@ uint32_t ThriftHiveMetastore_get_file_metadata_pargs::write(::apache::thrift::pr } -ThriftHiveMetastore_get_file_metadata_result::~ThriftHiveMetastore_get_file_metadata_result() throw() { +ThriftHiveMetastore_create_resource_plan_result::~ThriftHiveMetastore_create_resource_plan_result() throw() { } -uint32_t ThriftHiveMetastore_get_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; @@ -39149,6 +40083,30 @@ uint32_t ThriftHiveMetastore_get_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; @@ -39161,16 +40119,28 @@ 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_create_resource_plan_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_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(); @@ -39178,11 +40148,11 @@ uint32_t ThriftHiveMetastore_get_file_metadata_result::write(::apache::thrift::p } -ThriftHiveMetastore_get_file_metadata_presult::~ThriftHiveMetastore_get_file_metadata_presult() throw() { +ThriftHiveMetastore_create_resource_plan_presult::~ThriftHiveMetastore_create_resource_plan_presult() throw() { } -uint32_t ThriftHiveMetastore_get_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; @@ -39211,6 +40181,30 @@ uint32_t ThriftHiveMetastore_get_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; @@ -39224,11 +40218,11 @@ uint32_t ThriftHiveMetastore_get_file_metadata_presult::read(::apache::thrift::p } -ThriftHiveMetastore_put_file_metadata_args::~ThriftHiveMetastore_put_file_metadata_args() throw() { +ThriftHiveMetastore_get_resource_plan_args::~ThriftHiveMetastore_get_resource_plan_args() throw() { } -uint32_t ThriftHiveMetastore_put_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; @@ -39251,8 +40245,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 +40263,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_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_put_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(); @@ -39284,17 +40278,17 @@ uint32_t ThriftHiveMetastore_put_file_metadata_args::write(::apache::thrift::pro } -ThriftHiveMetastore_put_file_metadata_pargs::~ThriftHiveMetastore_put_file_metadata_pargs() throw() { +ThriftHiveMetastore_get_resource_plan_pargs::~ThriftHiveMetastore_get_resource_plan_pargs() throw() { } -uint32_t ThriftHiveMetastore_put_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_put_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(); @@ -39303,11 +40297,11 @@ uint32_t ThriftHiveMetastore_put_file_metadata_pargs::write(::apache::thrift::pr } -ThriftHiveMetastore_put_file_metadata_result::~ThriftHiveMetastore_put_file_metadata_result() throw() { +ThriftHiveMetastore_get_resource_plan_result::~ThriftHiveMetastore_get_resource_plan_result() throw() { } -uint32_t ThriftHiveMetastore_put_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; @@ -39336,6 +40330,22 @@ 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; default: xfer += iprot->skip(ftype); break; @@ -39348,16 +40358,24 @@ 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_get_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_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(); @@ -39365,11 +40383,11 @@ uint32_t ThriftHiveMetastore_put_file_metadata_result::write(::apache::thrift::p } -ThriftHiveMetastore_put_file_metadata_presult::~ThriftHiveMetastore_put_file_metadata_presult() throw() { +ThriftHiveMetastore_get_resource_plan_presult::~ThriftHiveMetastore_get_resource_plan_presult() throw() { } -uint32_t ThriftHiveMetastore_put_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; @@ -39398,6 +40416,22 @@ 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; default: xfer += iprot->skip(ftype); break; @@ -39411,11 +40445,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_all_resource_plans_args::~ThriftHiveMetastore_get_all_resource_plans_args() throw() { } -uint32_t ThriftHiveMetastore_clear_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; @@ -39438,8 +40472,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 +40490,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_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_clear_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(); @@ -39471,17 +40505,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_all_resource_plans_pargs::~ThriftHiveMetastore_get_all_resource_plans_pargs() throw() { } -uint32_t ThriftHiveMetastore_clear_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_clear_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(); @@ -39490,11 +40524,11 @@ uint32_t ThriftHiveMetastore_clear_file_metadata_pargs::write(::apache::thrift:: } -ThriftHiveMetastore_clear_file_metadata_result::~ThriftHiveMetastore_clear_file_metadata_result() throw() { +ThriftHiveMetastore_get_all_resource_plans_result::~ThriftHiveMetastore_get_all_resource_plans_result() throw() { } -uint32_t ThriftHiveMetastore_clear_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; @@ -39523,6 +40557,14 @@ 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; default: xfer += iprot->skip(ftype); break; @@ -39535,16 +40577,20 @@ 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_all_resource_plans_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_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(); @@ -39552,11 +40598,11 @@ uint32_t ThriftHiveMetastore_clear_file_metadata_result::write(::apache::thrift: } -ThriftHiveMetastore_clear_file_metadata_presult::~ThriftHiveMetastore_clear_file_metadata_presult() throw() { +ThriftHiveMetastore_get_all_resource_plans_presult::~ThriftHiveMetastore_get_all_resource_plans_presult() throw() { } -uint32_t ThriftHiveMetastore_clear_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; @@ -39585,6 +40631,14 @@ 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; default: xfer += iprot->skip(ftype); break; @@ -39598,11 +40652,11 @@ uint32_t ThriftHiveMetastore_clear_file_metadata_presult::read(::apache::thrift: } -ThriftHiveMetastore_cache_file_metadata_args::~ThriftHiveMetastore_cache_file_metadata_args() throw() { +ThriftHiveMetastore_alter_resource_plan_args::~ThriftHiveMetastore_alter_resource_plan_args() throw() { } -uint32_t ThriftHiveMetastore_cache_file_metadata_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; @@ -39625,8 +40679,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 +40697,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_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_cache_file_metadata_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_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(); @@ -39658,17 +40712,17 @@ uint32_t ThriftHiveMetastore_cache_file_metadata_args::write(::apache::thrift::p } -ThriftHiveMetastore_cache_file_metadata_pargs::~ThriftHiveMetastore_cache_file_metadata_pargs() throw() { +ThriftHiveMetastore_alter_resource_plan_pargs::~ThriftHiveMetastore_alter_resource_plan_pargs() throw() { } -uint32_t ThriftHiveMetastore_cache_file_metadata_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_cache_file_metadata_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_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(); @@ -39677,11 +40731,11 @@ uint32_t ThriftHiveMetastore_cache_file_metadata_pargs::write(::apache::thrift:: } -ThriftHiveMetastore_cache_file_metadata_result::~ThriftHiveMetastore_cache_file_metadata_result() throw() { +ThriftHiveMetastore_alter_resource_plan_result::~ThriftHiveMetastore_alter_resource_plan_result() throw() { } -uint32_t ThriftHiveMetastore_cache_file_metadata_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; @@ -39710,6 +40764,30 @@ 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; + 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; @@ -39722,16 +40800,28 @@ 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_alter_resource_plan_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_cache_file_metadata_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_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(); @@ -39739,11 +40829,11 @@ uint32_t ThriftHiveMetastore_cache_file_metadata_result::write(::apache::thrift: } -ThriftHiveMetastore_cache_file_metadata_presult::~ThriftHiveMetastore_cache_file_metadata_presult() throw() { +ThriftHiveMetastore_alter_resource_plan_presult::~ThriftHiveMetastore_alter_resource_plan_presult() throw() { } -uint32_t ThriftHiveMetastore_cache_file_metadata_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; @@ -39772,6 +40862,30 @@ 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; + 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; @@ -39785,11 +40899,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_validate_resource_plan_args::~ThriftHiveMetastore_validate_resource_plan_args() throw() { } -uint32_t ThriftHiveMetastore_get_metastore_db_uuid_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; @@ -39808,7 +40922,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 +40944,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_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_get_metastore_db_uuid_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_validate_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 +40959,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_validate_resource_plan_pargs::~ThriftHiveMetastore_validate_resource_plan_pargs() throw() { } -uint32_t ThriftHiveMetastore_get_metastore_db_uuid_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_get_metastore_db_uuid_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_validate_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 +40978,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_validate_resource_plan_result::~ThriftHiveMetastore_validate_resource_plan_result() throw() { } -uint32_t ThriftHiveMetastore_get_metastore_db_uuid_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; @@ -39869,8 +41004,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 +41019,14 @@ 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; default: xfer += iprot->skip(ftype); break; @@ -39896,20 +41039,24 @@ 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_validate_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_validate_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(); } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); @@ -39917,11 +41064,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_validate_resource_plan_presult::~ThriftHiveMetastore_validate_resource_plan_presult() throw() { } -uint32_t ThriftHiveMetastore_get_metastore_db_uuid_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; @@ -39943,8 +41090,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 +41105,14 @@ 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; default: xfer += iprot->skip(ftype); break; @@ -39971,11 +41126,11 @@ uint32_t ThriftHiveMetastore_get_metastore_db_uuid_presult::read(::apache::thrif } -ThriftHiveMetastore_create_resource_plan_args::~ThriftHiveMetastore_create_resource_plan_args() throw() { +ThriftHiveMetastore_drop_resource_plan_args::~ThriftHiveMetastore_drop_resource_plan_args() throw() { } -uint32_t ThriftHiveMetastore_create_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; @@ -40016,10 +41171,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_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_create_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); @@ -40031,14 +41186,14 @@ uint32_t ThriftHiveMetastore_create_resource_plan_args::write(::apache::thrift:: } -ThriftHiveMetastore_create_resource_plan_pargs::~ThriftHiveMetastore_create_resource_plan_pargs() throw() { +ThriftHiveMetastore_drop_resource_plan_pargs::~ThriftHiveMetastore_drop_resource_plan_pargs() throw() { } -uint32_t ThriftHiveMetastore_create_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_create_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); @@ -40050,11 +41205,11 @@ uint32_t ThriftHiveMetastore_create_resource_plan_pargs::write(::apache::thrift: } -ThriftHiveMetastore_create_resource_plan_result::~ThriftHiveMetastore_create_resource_plan_result() throw() { +ThriftHiveMetastore_drop_resource_plan_result::~ThriftHiveMetastore_drop_resource_plan_result() throw() { } -uint32_t ThriftHiveMetastore_create_resource_plan_result::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; @@ -40119,11 +41274,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_drop_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_drop_resource_plan_result"); if (this->__isset.success) { xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); @@ -40148,11 +41303,11 @@ uint32_t ThriftHiveMetastore_create_resource_plan_result::write(::apache::thrift } -ThriftHiveMetastore_create_resource_plan_presult::~ThriftHiveMetastore_create_resource_plan_presult() throw() { +ThriftHiveMetastore_drop_resource_plan_presult::~ThriftHiveMetastore_drop_resource_plan_presult() throw() { } -uint32_t ThriftHiveMetastore_create_resource_plan_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_drop_resource_plan_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -40218,11 +41373,11 @@ uint32_t ThriftHiveMetastore_create_resource_plan_presult::read(::apache::thrift } -ThriftHiveMetastore_get_resource_plan_args::~ThriftHiveMetastore_get_resource_plan_args() throw() { +ThriftHiveMetastore_create_wm_trigger_args::~ThriftHiveMetastore_create_wm_trigger_args() throw() { } -uint32_t ThriftHiveMetastore_get_resource_plan_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; @@ -40263,10 +41418,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_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_resource_plan_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_wm_trigger_args"); xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); xfer += this->request.write(oprot); @@ -40278,14 +41433,14 @@ uint32_t ThriftHiveMetastore_get_resource_plan_args::write(::apache::thrift::pro } -ThriftHiveMetastore_get_resource_plan_pargs::~ThriftHiveMetastore_get_resource_plan_pargs() throw() { +ThriftHiveMetastore_create_wm_trigger_pargs::~ThriftHiveMetastore_create_wm_trigger_pargs() throw() { } -uint32_t ThriftHiveMetastore_get_resource_plan_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_resource_plan_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_wm_trigger_pargs"); xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); xfer += (*(this->request)).write(oprot); @@ -40297,11 +41452,11 @@ uint32_t ThriftHiveMetastore_get_resource_plan_pargs::write(::apache::thrift::pr } -ThriftHiveMetastore_get_resource_plan_result::~ThriftHiveMetastore_get_resource_plan_result() throw() { +ThriftHiveMetastore_create_wm_trigger_result::~ThriftHiveMetastore_create_wm_trigger_result() throw() { } -uint32_t ThriftHiveMetastore_get_resource_plan_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; @@ -40346,6 +41501,22 @@ uint32_t ThriftHiveMetastore_get_resource_plan_result::read(::apache::thrift::pr 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; @@ -40358,11 +41529,11 @@ uint32_t ThriftHiveMetastore_get_resource_plan_result::read(::apache::thrift::pr return xfer; } -uint32_t ThriftHiveMetastore_get_resource_plan_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_resource_plan_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_wm_trigger_result"); if (this->__isset.success) { xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); @@ -40376,6 +41547,14 @@ uint32_t ThriftHiveMetastore_get_resource_plan_result::write(::apache::thrift::p 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(); @@ -40383,11 +41562,11 @@ uint32_t ThriftHiveMetastore_get_resource_plan_result::write(::apache::thrift::p } -ThriftHiveMetastore_get_resource_plan_presult::~ThriftHiveMetastore_get_resource_plan_presult() throw() { +ThriftHiveMetastore_create_wm_trigger_presult::~ThriftHiveMetastore_create_wm_trigger_presult() throw() { } -uint32_t ThriftHiveMetastore_get_resource_plan_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; @@ -40432,6 +41611,22 @@ 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; + 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; @@ -40445,11 +41640,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_alter_wm_trigger_args::~ThriftHiveMetastore_alter_wm_trigger_args() throw() { } -uint32_t ThriftHiveMetastore_get_all_resource_plans_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; @@ -40490,10 +41685,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_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_get_all_resource_plans_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_wm_trigger_args"); xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); xfer += this->request.write(oprot); @@ -40505,14 +41700,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_alter_wm_trigger_pargs::~ThriftHiveMetastore_alter_wm_trigger_pargs() throw() { } -uint32_t ThriftHiveMetastore_get_all_resource_plans_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_get_all_resource_plans_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_wm_trigger_pargs"); xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); xfer += (*(this->request)).write(oprot); @@ -40524,11 +41719,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_alter_wm_trigger_result::~ThriftHiveMetastore_alter_wm_trigger_result() throw() { } -uint32_t ThriftHiveMetastore_get_all_resource_plans_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; @@ -40565,6 +41760,22 @@ 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; default: xfer += iprot->skip(ftype); break; @@ -40577,11 +41788,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_alter_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_alter_wm_trigger_result"); if (this->__isset.success) { xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); @@ -40591,6 +41802,14 @@ 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(); } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); @@ -40598,11 +41817,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_alter_wm_trigger_presult::~ThriftHiveMetastore_alter_wm_trigger_presult() throw() { } -uint32_t ThriftHiveMetastore_get_all_resource_plans_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; @@ -40639,6 +41858,22 @@ 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; default: xfer += iprot->skip(ftype); break; @@ -40652,11 +41887,11 @@ uint32_t ThriftHiveMetastore_get_all_resource_plans_presult::read(::apache::thri } -ThriftHiveMetastore_alter_resource_plan_args::~ThriftHiveMetastore_alter_resource_plan_args() throw() { +ThriftHiveMetastore_drop_wm_trigger_args::~ThriftHiveMetastore_drop_wm_trigger_args() throw() { } -uint32_t ThriftHiveMetastore_alter_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; @@ -40697,10 +41932,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_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_alter_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); @@ -40712,14 +41947,14 @@ uint32_t ThriftHiveMetastore_alter_resource_plan_args::write(::apache::thrift::p } -ThriftHiveMetastore_alter_resource_plan_pargs::~ThriftHiveMetastore_alter_resource_plan_pargs() throw() { +ThriftHiveMetastore_drop_wm_trigger_pargs::~ThriftHiveMetastore_drop_wm_trigger_pargs() throw() { } -uint32_t ThriftHiveMetastore_alter_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_alter_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); @@ -40731,11 +41966,11 @@ uint32_t ThriftHiveMetastore_alter_resource_plan_pargs::write(::apache::thrift:: } -ThriftHiveMetastore_alter_resource_plan_result::~ThriftHiveMetastore_alter_resource_plan_result() throw() { +ThriftHiveMetastore_drop_wm_trigger_result::~ThriftHiveMetastore_drop_wm_trigger_result() throw() { } -uint32_t ThriftHiveMetastore_alter_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; @@ -40800,11 +42035,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_drop_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_drop_wm_trigger_result"); if (this->__isset.success) { xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); @@ -40829,81 +42064,81 @@ uint32_t ThriftHiveMetastore_alter_resource_plan_result::write(::apache::thrift: } -ThriftHiveMetastore_alter_resource_plan_presult::~ThriftHiveMetastore_alter_resource_plan_presult() throw() { -} - - -uint32_t ThriftHiveMetastore_alter_resource_plan_presult::read(::apache::thrift::protocol::TProtocol* iprot) { - - apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); - uint32_t xfer = 0; - std::string fname; - ::apache::thrift::protocol::TType ftype; - int16_t fid; - - xfer += iprot->readStructBegin(fname); - - using ::apache::thrift::protocol::TProtocolException; - - - while (true) - { - xfer += iprot->readFieldBegin(fname, ftype, fid); - if (ftype == ::apache::thrift::protocol::T_STOP) { - break; - } - switch (fid) - { - case 0: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += (*(this->success)).read(iprot); - this->__isset.success = true; - } else { - xfer += iprot->skip(ftype); - } - break; - case 1: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->o1.read(iprot); - this->__isset.o1 = true; - } else { - xfer += iprot->skip(ftype); - } - break; - case 2: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->o2.read(iprot); - this->__isset.o2 = true; - } else { - xfer += iprot->skip(ftype); - } - break; - case 3: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->o3.read(iprot); - this->__isset.o3 = true; - } else { - xfer += iprot->skip(ftype); - } - break; - default: - xfer += iprot->skip(ftype); - break; - } - xfer += iprot->readFieldEnd(); - } - - xfer += iprot->readStructEnd(); - - return xfer; -} - - -ThriftHiveMetastore_validate_resource_plan_args::~ThriftHiveMetastore_validate_resource_plan_args() throw() { +ThriftHiveMetastore_drop_wm_trigger_presult::~ThriftHiveMetastore_drop_wm_trigger_presult() throw() { } -uint32_t ThriftHiveMetastore_validate_resource_plan_args::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; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_triggers_for_resourceplan_args::~ThriftHiveMetastore_get_triggers_for_resourceplan_args() throw() { +} + + +uint32_t ThriftHiveMetastore_get_triggers_for_resourceplan_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -40944,10 +42179,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_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_validate_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); @@ -40959,14 +42194,14 @@ uint32_t ThriftHiveMetastore_validate_resource_plan_args::write(::apache::thrift } -ThriftHiveMetastore_validate_resource_plan_pargs::~ThriftHiveMetastore_validate_resource_plan_pargs() throw() { +ThriftHiveMetastore_get_triggers_for_resourceplan_pargs::~ThriftHiveMetastore_get_triggers_for_resourceplan_pargs() throw() { } -uint32_t ThriftHiveMetastore_validate_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_validate_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); @@ -40978,11 +42213,11 @@ uint32_t ThriftHiveMetastore_validate_resource_plan_pargs::write(::apache::thrif } -ThriftHiveMetastore_validate_resource_plan_result::~ThriftHiveMetastore_validate_resource_plan_result() throw() { +ThriftHiveMetastore_get_triggers_for_resourceplan_result::~ThriftHiveMetastore_get_triggers_for_resourceplan_result() throw() { } -uint32_t ThriftHiveMetastore_validate_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; @@ -41039,11 +42274,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_get_triggers_for_resourceplan_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_validate_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); @@ -41064,11 +42299,11 @@ uint32_t ThriftHiveMetastore_validate_resource_plan_result::write(::apache::thri } -ThriftHiveMetastore_validate_resource_plan_presult::~ThriftHiveMetastore_validate_resource_plan_presult() throw() { +ThriftHiveMetastore_get_triggers_for_resourceplan_presult::~ThriftHiveMetastore_get_triggers_for_resourceplan_presult() throw() { } -uint32_t ThriftHiveMetastore_validate_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; @@ -41126,11 +42361,11 @@ uint32_t ThriftHiveMetastore_validate_resource_plan_presult::read(::apache::thri } -ThriftHiveMetastore_drop_resource_plan_args::~ThriftHiveMetastore_drop_resource_plan_args() throw() { +ThriftHiveMetastore_create_or_update_wm_pool_args::~ThriftHiveMetastore_create_or_update_wm_pool_args() throw() { } -uint32_t ThriftHiveMetastore_drop_resource_plan_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_create_or_update_wm_pool_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -41171,10 +42406,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_create_or_update_wm_pool_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_create_or_update_wm_pool_args"); xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); xfer += this->request.write(oprot); @@ -41186,14 +42421,14 @@ uint32_t ThriftHiveMetastore_drop_resource_plan_args::write(::apache::thrift::pr } -ThriftHiveMetastore_drop_resource_plan_pargs::~ThriftHiveMetastore_drop_resource_plan_pargs() throw() { +ThriftHiveMetastore_create_or_update_wm_pool_pargs::~ThriftHiveMetastore_create_or_update_wm_pool_pargs() throw() { } -uint32_t ThriftHiveMetastore_drop_resource_plan_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_create_or_update_wm_pool_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_create_or_update_wm_pool_pargs"); xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); xfer += (*(this->request)).write(oprot); @@ -41205,11 +42440,11 @@ uint32_t ThriftHiveMetastore_drop_resource_plan_pargs::write(::apache::thrift::p } -ThriftHiveMetastore_drop_resource_plan_result::~ThriftHiveMetastore_drop_resource_plan_result() throw() { +ThriftHiveMetastore_create_or_update_wm_pool_result::~ThriftHiveMetastore_create_or_update_wm_pool_result() throw() { } -uint32_t ThriftHiveMetastore_drop_resource_plan_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_create_or_update_wm_pool_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -41262,6 +42497,14 @@ uint32_t ThriftHiveMetastore_drop_resource_plan_result::read(::apache::thrift::p 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; @@ -41274,11 +42517,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_create_or_update_wm_pool_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_resource_plan_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_or_update_wm_pool_result"); if (this->__isset.success) { xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); @@ -41296,6 +42539,10 @@ uint32_t ThriftHiveMetastore_drop_resource_plan_result::write(::apache::thrift:: 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(); @@ -41303,11 +42550,11 @@ uint32_t ThriftHiveMetastore_drop_resource_plan_result::write(::apache::thrift:: } -ThriftHiveMetastore_drop_resource_plan_presult::~ThriftHiveMetastore_drop_resource_plan_presult() throw() { +ThriftHiveMetastore_create_or_update_wm_pool_presult::~ThriftHiveMetastore_create_or_update_wm_pool_presult() throw() { } -uint32_t ThriftHiveMetastore_drop_resource_plan_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_create_or_update_wm_pool_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -41360,6 +42607,14 @@ uint32_t ThriftHiveMetastore_drop_resource_plan_presult::read(::apache::thrift:: 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; @@ -41373,11 +42628,11 @@ uint32_t ThriftHiveMetastore_drop_resource_plan_presult::read(::apache::thrift:: } -ThriftHiveMetastore_create_wm_trigger_args::~ThriftHiveMetastore_create_wm_trigger_args() throw() { +ThriftHiveMetastore_drop_wm_pool_args::~ThriftHiveMetastore_drop_wm_pool_args() throw() { } -uint32_t ThriftHiveMetastore_create_wm_trigger_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_drop_wm_pool_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -41418,10 +42673,10 @@ uint32_t ThriftHiveMetastore_create_wm_trigger_args::read(::apache::thrift::prot return xfer; } -uint32_t ThriftHiveMetastore_create_wm_trigger_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_drop_wm_pool_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_wm_trigger_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_wm_pool_args"); xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); xfer += this->request.write(oprot); @@ -41433,14 +42688,14 @@ uint32_t ThriftHiveMetastore_create_wm_trigger_args::write(::apache::thrift::pro } -ThriftHiveMetastore_create_wm_trigger_pargs::~ThriftHiveMetastore_create_wm_trigger_pargs() throw() { +ThriftHiveMetastore_drop_wm_pool_pargs::~ThriftHiveMetastore_drop_wm_pool_pargs() throw() { } -uint32_t ThriftHiveMetastore_create_wm_trigger_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_drop_wm_pool_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_wm_trigger_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_wm_pool_pargs"); xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); xfer += (*(this->request)).write(oprot); @@ -41452,11 +42707,11 @@ uint32_t ThriftHiveMetastore_create_wm_trigger_pargs::write(::apache::thrift::pr } -ThriftHiveMetastore_create_wm_trigger_result::~ThriftHiveMetastore_create_wm_trigger_result() throw() { +ThriftHiveMetastore_drop_wm_pool_result::~ThriftHiveMetastore_drop_wm_pool_result() throw() { } -uint32_t ThriftHiveMetastore_create_wm_trigger_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_drop_wm_pool_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -41509,14 +42764,6 @@ uint32_t ThriftHiveMetastore_create_wm_trigger_result::read(::apache::thrift::pr 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; @@ -41529,11 +42776,11 @@ uint32_t ThriftHiveMetastore_create_wm_trigger_result::read(::apache::thrift::pr return xfer; } -uint32_t ThriftHiveMetastore_create_wm_trigger_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_drop_wm_pool_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_wm_trigger_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_wm_pool_result"); if (this->__isset.success) { xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); @@ -41551,10 +42798,6 @@ uint32_t ThriftHiveMetastore_create_wm_trigger_result::write(::apache::thrift::p 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(); @@ -41562,11 +42805,11 @@ uint32_t ThriftHiveMetastore_create_wm_trigger_result::write(::apache::thrift::p } -ThriftHiveMetastore_create_wm_trigger_presult::~ThriftHiveMetastore_create_wm_trigger_presult() throw() { +ThriftHiveMetastore_drop_wm_pool_presult::~ThriftHiveMetastore_drop_wm_pool_presult() throw() { } -uint32_t ThriftHiveMetastore_create_wm_trigger_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_drop_wm_pool_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -41619,14 +42862,6 @@ uint32_t ThriftHiveMetastore_create_wm_trigger_presult::read(::apache::thrift::p 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; @@ -41640,11 +42875,11 @@ uint32_t ThriftHiveMetastore_create_wm_trigger_presult::read(::apache::thrift::p } -ThriftHiveMetastore_alter_wm_trigger_args::~ThriftHiveMetastore_alter_wm_trigger_args() throw() { +ThriftHiveMetastore_create_or_update_wm_mapping_args::~ThriftHiveMetastore_create_or_update_wm_mapping_args() throw() { } -uint32_t ThriftHiveMetastore_alter_wm_trigger_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_create_or_update_wm_mapping_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -41685,10 +42920,10 @@ uint32_t ThriftHiveMetastore_alter_wm_trigger_args::read(::apache::thrift::proto return xfer; } -uint32_t ThriftHiveMetastore_alter_wm_trigger_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_create_or_update_wm_mapping_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_wm_trigger_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_or_update_wm_mapping_args"); xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); xfer += this->request.write(oprot); @@ -41700,14 +42935,14 @@ uint32_t ThriftHiveMetastore_alter_wm_trigger_args::write(::apache::thrift::prot } -ThriftHiveMetastore_alter_wm_trigger_pargs::~ThriftHiveMetastore_alter_wm_trigger_pargs() throw() { +ThriftHiveMetastore_create_or_update_wm_mapping_pargs::~ThriftHiveMetastore_create_or_update_wm_mapping_pargs() throw() { } -uint32_t ThriftHiveMetastore_alter_wm_trigger_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_create_or_update_wm_mapping_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_wm_trigger_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_or_update_wm_mapping_pargs"); xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); xfer += (*(this->request)).write(oprot); @@ -41719,11 +42954,11 @@ uint32_t ThriftHiveMetastore_alter_wm_trigger_pargs::write(::apache::thrift::pro } -ThriftHiveMetastore_alter_wm_trigger_result::~ThriftHiveMetastore_alter_wm_trigger_result() throw() { +ThriftHiveMetastore_create_or_update_wm_mapping_result::~ThriftHiveMetastore_create_or_update_wm_mapping_result() throw() { } -uint32_t ThriftHiveMetastore_alter_wm_trigger_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_create_or_update_wm_mapping_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -41776,6 +43011,14 @@ uint32_t ThriftHiveMetastore_alter_wm_trigger_result::read(::apache::thrift::pro 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; @@ -41788,11 +43031,11 @@ uint32_t ThriftHiveMetastore_alter_wm_trigger_result::read(::apache::thrift::pro return xfer; } -uint32_t ThriftHiveMetastore_alter_wm_trigger_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_create_or_update_wm_mapping_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_wm_trigger_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_or_update_wm_mapping_result"); if (this->__isset.success) { xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); @@ -41810,6 +43053,10 @@ uint32_t ThriftHiveMetastore_alter_wm_trigger_result::write(::apache::thrift::pr 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(); @@ -41817,11 +43064,11 @@ uint32_t ThriftHiveMetastore_alter_wm_trigger_result::write(::apache::thrift::pr } -ThriftHiveMetastore_alter_wm_trigger_presult::~ThriftHiveMetastore_alter_wm_trigger_presult() throw() { +ThriftHiveMetastore_create_or_update_wm_mapping_presult::~ThriftHiveMetastore_create_or_update_wm_mapping_presult() throw() { } -uint32_t ThriftHiveMetastore_alter_wm_trigger_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_create_or_update_wm_mapping_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -41874,6 +43121,14 @@ uint32_t ThriftHiveMetastore_alter_wm_trigger_presult::read(::apache::thrift::pr 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; @@ -41887,11 +43142,11 @@ uint32_t ThriftHiveMetastore_alter_wm_trigger_presult::read(::apache::thrift::pr } -ThriftHiveMetastore_drop_wm_trigger_args::~ThriftHiveMetastore_drop_wm_trigger_args() throw() { +ThriftHiveMetastore_drop_wm_mapping_args::~ThriftHiveMetastore_drop_wm_mapping_args() throw() { } -uint32_t ThriftHiveMetastore_drop_wm_trigger_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_drop_wm_mapping_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -41932,10 +43187,10 @@ uint32_t ThriftHiveMetastore_drop_wm_trigger_args::read(::apache::thrift::protoc return xfer; } -uint32_t ThriftHiveMetastore_drop_wm_trigger_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_drop_wm_mapping_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_wm_trigger_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_wm_mapping_args"); xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); xfer += this->request.write(oprot); @@ -41947,14 +43202,14 @@ uint32_t ThriftHiveMetastore_drop_wm_trigger_args::write(::apache::thrift::proto } -ThriftHiveMetastore_drop_wm_trigger_pargs::~ThriftHiveMetastore_drop_wm_trigger_pargs() throw() { +ThriftHiveMetastore_drop_wm_mapping_pargs::~ThriftHiveMetastore_drop_wm_mapping_pargs() throw() { } -uint32_t ThriftHiveMetastore_drop_wm_trigger_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_drop_wm_mapping_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_wm_trigger_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_wm_mapping_pargs"); xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); xfer += (*(this->request)).write(oprot); @@ -41966,11 +43221,11 @@ uint32_t ThriftHiveMetastore_drop_wm_trigger_pargs::write(::apache::thrift::prot } -ThriftHiveMetastore_drop_wm_trigger_result::~ThriftHiveMetastore_drop_wm_trigger_result() throw() { +ThriftHiveMetastore_drop_wm_mapping_result::~ThriftHiveMetastore_drop_wm_mapping_result() throw() { } -uint32_t ThriftHiveMetastore_drop_wm_trigger_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_drop_wm_mapping_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -42035,11 +43290,11 @@ uint32_t ThriftHiveMetastore_drop_wm_trigger_result::read(::apache::thrift::prot return xfer; } -uint32_t ThriftHiveMetastore_drop_wm_trigger_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_drop_wm_mapping_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_wm_trigger_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_wm_mapping_result"); if (this->__isset.success) { xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); @@ -42064,11 +43319,11 @@ uint32_t ThriftHiveMetastore_drop_wm_trigger_result::write(::apache::thrift::pro } -ThriftHiveMetastore_drop_wm_trigger_presult::~ThriftHiveMetastore_drop_wm_trigger_presult() throw() { +ThriftHiveMetastore_drop_wm_mapping_presult::~ThriftHiveMetastore_drop_wm_mapping_presult() throw() { } -uint32_t ThriftHiveMetastore_drop_wm_trigger_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_drop_wm_mapping_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -42134,11 +43389,11 @@ uint32_t ThriftHiveMetastore_drop_wm_trigger_presult::read(::apache::thrift::pro } -ThriftHiveMetastore_get_triggers_for_resourceplan_args::~ThriftHiveMetastore_get_triggers_for_resourceplan_args() throw() { +ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args::~ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args() throw() { } -uint32_t ThriftHiveMetastore_get_triggers_for_resourceplan_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -42179,10 +43434,10 @@ uint32_t ThriftHiveMetastore_get_triggers_for_resourceplan_args::read(::apache:: return xfer; } -uint32_t ThriftHiveMetastore_get_triggers_for_resourceplan_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_triggers_for_resourceplan_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args"); xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); xfer += this->request.write(oprot); @@ -42194,14 +43449,14 @@ uint32_t ThriftHiveMetastore_get_triggers_for_resourceplan_args::write(::apache: } -ThriftHiveMetastore_get_triggers_for_resourceplan_pargs::~ThriftHiveMetastore_get_triggers_for_resourceplan_pargs() throw() { +ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_pargs::~ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_pargs() throw() { } -uint32_t ThriftHiveMetastore_get_triggers_for_resourceplan_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_triggers_for_resourceplan_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_pargs"); xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); xfer += (*(this->request)).write(oprot); @@ -42213,11 +43468,11 @@ uint32_t ThriftHiveMetastore_get_triggers_for_resourceplan_pargs::write(::apache } -ThriftHiveMetastore_get_triggers_for_resourceplan_result::~ThriftHiveMetastore_get_triggers_for_resourceplan_result() throw() { +ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result::~ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result() throw() { } -uint32_t ThriftHiveMetastore_get_triggers_for_resourceplan_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -42262,6 +43517,22 @@ uint32_t ThriftHiveMetastore_get_triggers_for_resourceplan_result::read(::apache 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; @@ -42274,11 +43545,11 @@ uint32_t ThriftHiveMetastore_get_triggers_for_resourceplan_result::read(::apache return xfer; } -uint32_t ThriftHiveMetastore_get_triggers_for_resourceplan_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_triggers_for_resourceplan_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result"); if (this->__isset.success) { xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); @@ -42292,6 +43563,14 @@ uint32_t ThriftHiveMetastore_get_triggers_for_resourceplan_result::write(::apach 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(); @@ -42299,11 +43578,11 @@ uint32_t ThriftHiveMetastore_get_triggers_for_resourceplan_result::write(::apach } -ThriftHiveMetastore_get_triggers_for_resourceplan_presult::~ThriftHiveMetastore_get_triggers_for_resourceplan_presult() throw() { +ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_presult::~ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_presult() throw() { } -uint32_t ThriftHiveMetastore_get_triggers_for_resourceplan_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -42348,6 +43627,22 @@ uint32_t ThriftHiveMetastore_get_triggers_for_resourceplan_presult::read(::apach 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; @@ -53257,6 +54552,350 @@ void ThriftHiveMetastoreClient::recv_get_triggers_for_resourceplan(WMGetTriggers throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_triggers_for_resourceplan failed: unknown result"); } +void ThriftHiveMetastoreClient::create_or_update_wm_pool(WMCreateOrUpdatePoolResponse& _return, const WMCreateOrUpdatePoolRequest& request) +{ + send_create_or_update_wm_pool(request); + recv_create_or_update_wm_pool(_return); +} + +void ThriftHiveMetastoreClient::send_create_or_update_wm_pool(const WMCreateOrUpdatePoolRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("create_or_update_wm_pool", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_create_or_update_wm_pool_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_create_or_update_wm_pool(WMCreateOrUpdatePoolResponse& _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_or_update_wm_pool") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_create_or_update_wm_pool_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_or_update_wm_pool failed: unknown result"); +} + +void ThriftHiveMetastoreClient::drop_wm_pool(WMDropPoolResponse& _return, const WMDropPoolRequest& request) +{ + send_drop_wm_pool(request); + recv_drop_wm_pool(_return); +} + +void ThriftHiveMetastoreClient::send_drop_wm_pool(const WMDropPoolRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("drop_wm_pool", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_wm_pool_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_drop_wm_pool(WMDropPoolResponse& _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_pool") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_drop_wm_pool_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_pool failed: unknown result"); +} + +void ThriftHiveMetastoreClient::create_or_update_wm_mapping(WMCreateOrUpdateMappingResponse& _return, const WMCreateOrUpdateMappingRequest& request) +{ + send_create_or_update_wm_mapping(request); + recv_create_or_update_wm_mapping(_return); +} + +void ThriftHiveMetastoreClient::send_create_or_update_wm_mapping(const WMCreateOrUpdateMappingRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("create_or_update_wm_mapping", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_create_or_update_wm_mapping_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_create_or_update_wm_mapping(WMCreateOrUpdateMappingResponse& _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_or_update_wm_mapping") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_create_or_update_wm_mapping_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_or_update_wm_mapping failed: unknown result"); +} + +void ThriftHiveMetastoreClient::drop_wm_mapping(WMDropMappingResponse& _return, const WMDropMappingRequest& request) +{ + send_drop_wm_mapping(request); + recv_drop_wm_mapping(_return); +} + +void ThriftHiveMetastoreClient::send_drop_wm_mapping(const WMDropMappingRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("drop_wm_mapping", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_wm_mapping_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_drop_wm_mapping(WMDropMappingResponse& _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_mapping") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_drop_wm_mapping_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_mapping failed: unknown result"); +} + +void ThriftHiveMetastoreClient::create_or_drop_wm_trigger_to_pool_mapping(WMCreateOrDropTriggerToPoolMappingResponse& _return, const WMCreateOrDropTriggerToPoolMappingRequest& request) +{ + send_create_or_drop_wm_trigger_to_pool_mapping(request); + recv_create_or_drop_wm_trigger_to_pool_mapping(_return); +} + +void ThriftHiveMetastoreClient::send_create_or_drop_wm_trigger_to_pool_mapping(const WMCreateOrDropTriggerToPoolMappingRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("create_or_drop_wm_trigger_to_pool_mapping", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_create_or_drop_wm_trigger_to_pool_mapping(WMCreateOrDropTriggerToPoolMappingResponse& _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_or_drop_wm_trigger_to_pool_mapping") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_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_or_drop_wm_trigger_to_pool_mapping 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); @@ -63462,6 +65101,330 @@ void ThriftHiveMetastoreProcessor::process_get_triggers_for_resourceplan(int32_t } } +void ThriftHiveMetastoreProcessor::process_create_or_update_wm_pool(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_or_update_wm_pool", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.create_or_update_wm_pool"); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.create_or_update_wm_pool"); + } + + ThriftHiveMetastore_create_or_update_wm_pool_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.create_or_update_wm_pool", bytes); + } + + ThriftHiveMetastore_create_or_update_wm_pool_result result; + try { + iface_->create_or_update_wm_pool(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_or_update_wm_pool"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("create_or_update_wm_pool", ::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_or_update_wm_pool"); + } + + oprot->writeMessageBegin("create_or_update_wm_pool", ::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_or_update_wm_pool", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_drop_wm_pool(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_pool", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.drop_wm_pool"); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.drop_wm_pool"); + } + + ThriftHiveMetastore_drop_wm_pool_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_pool", bytes); + } + + ThriftHiveMetastore_drop_wm_pool_result result; + try { + iface_->drop_wm_pool(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_pool"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("drop_wm_pool", ::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_pool"); + } + + oprot->writeMessageBegin("drop_wm_pool", ::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_pool", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_create_or_update_wm_mapping(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_or_update_wm_mapping", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.create_or_update_wm_mapping"); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.create_or_update_wm_mapping"); + } + + ThriftHiveMetastore_create_or_update_wm_mapping_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.create_or_update_wm_mapping", bytes); + } + + ThriftHiveMetastore_create_or_update_wm_mapping_result result; + try { + iface_->create_or_update_wm_mapping(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_or_update_wm_mapping"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("create_or_update_wm_mapping", ::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_or_update_wm_mapping"); + } + + oprot->writeMessageBegin("create_or_update_wm_mapping", ::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_or_update_wm_mapping", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_drop_wm_mapping(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_mapping", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.drop_wm_mapping"); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.drop_wm_mapping"); + } + + ThriftHiveMetastore_drop_wm_mapping_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_mapping", bytes); + } + + ThriftHiveMetastore_drop_wm_mapping_result result; + try { + iface_->drop_wm_mapping(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_mapping"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("drop_wm_mapping", ::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_mapping"); + } + + oprot->writeMessageBegin("drop_wm_mapping", ::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_mapping", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_create_or_drop_wm_trigger_to_pool_mapping(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_or_drop_wm_trigger_to_pool_mapping", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.create_or_drop_wm_trigger_to_pool_mapping"); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.create_or_drop_wm_trigger_to_pool_mapping"); + } + + ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.create_or_drop_wm_trigger_to_pool_mapping", bytes); + } + + ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result result; + try { + iface_->create_or_drop_wm_trigger_to_pool_mapping(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_or_drop_wm_trigger_to_pool_mapping"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("create_or_drop_wm_trigger_to_pool_mapping", ::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_or_drop_wm_trigger_to_pool_mapping"); + } + + oprot->writeMessageBegin("create_or_drop_wm_trigger_to_pool_mapping", ::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_or_drop_wm_trigger_to_pool_mapping", 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); @@ -73405,7 +75368,274 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_function(Function& _return, c iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("get_function") != 0) { + if (fname.compare("get_function") != 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_function_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_function failed: unknown result"); + } + // seqid != rseqid + this->sync_.updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_.waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::get_all_functions(GetAllFunctionsResponse& _return) +{ + int32_t seqid = send_get_all_functions(); + recv_get_all_functions(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_all_functions() +{ + int32_t cseqid = this->sync_.generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); + oprot_->writeMessageBegin("get_all_functions", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_all_functions_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_all_functions(GetAllFunctionsResponse& _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_all_functions") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_all_functions_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_all_functions 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) +} + +bool ThriftHiveMetastoreConcurrentClient::create_role(const Role& role) +{ + int32_t seqid = send_create_role(role); + return recv_create_role(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_create_role(const Role& role) +{ + int32_t cseqid = this->sync_.generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); + oprot_->writeMessageBegin("create_role", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_create_role_pargs args; + args.role = &role; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +bool ThriftHiveMetastoreConcurrentClient::recv_create_role(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("create_role") != 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); + } + bool _return; + ThriftHiveMetastore_create_role_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + sentry.commit(); + return _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, "create_role 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) +} + +bool ThriftHiveMetastoreConcurrentClient::drop_role(const std::string& role_name) +{ + int32_t seqid = send_drop_role(role_name); + return recv_drop_role(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_drop_role(const std::string& role_name) +{ + int32_t cseqid = this->sync_.generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); + oprot_->writeMessageBegin("drop_role", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_role_pargs args; + args.role_name = &role_name; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +bool ThriftHiveMetastoreConcurrentClient::recv_drop_role(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("drop_role") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -73414,27 +75644,23 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_function(Function& _return, c using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_get_function_presult result; + bool _return; + ThriftHiveMetastore_drop_role_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; + return _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_function failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "drop_role failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -73444,19 +75670,19 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_function(Function& _return, c } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::get_all_functions(GetAllFunctionsResponse& _return) +void ThriftHiveMetastoreConcurrentClient::get_role_names(std::vector & _return) { - int32_t seqid = send_get_all_functions(); - recv_get_all_functions(_return, seqid); + int32_t seqid = send_get_role_names(); + recv_get_role_names(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_get_all_functions() +int32_t ThriftHiveMetastoreConcurrentClient::send_get_role_names() { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("get_all_functions", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("get_role_names", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_get_all_functions_pargs args; + ThriftHiveMetastore_get_role_names_pargs args; args.write(oprot_); oprot_->writeMessageEnd(); @@ -73467,7 +75693,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_get_all_functions() return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_get_all_functions(GetAllFunctionsResponse& _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_get_role_names(std::vector & _return, const int32_t seqid) { int32_t rseqid = 0; @@ -73496,7 +75722,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_all_functions(GetAllFunctions iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("get_all_functions") != 0) { + if (fname.compare("get_role_names") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -73505,7 +75731,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_all_functions(GetAllFunctions using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_get_all_functions_presult result; + ThriftHiveMetastore_get_role_names_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -73521,7 +75747,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_all_functions(GetAllFunctions throw result.o1; } // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_all_functions failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_role_names failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -73531,20 +75757,25 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_all_functions(GetAllFunctions } // end while(true) } -bool ThriftHiveMetastoreConcurrentClient::create_role(const Role& role) +bool ThriftHiveMetastoreConcurrentClient::grant_role(const std::string& role_name, const std::string& principal_name, const PrincipalType::type principal_type, const std::string& grantor, const PrincipalType::type grantorType, const bool grant_option) { - int32_t seqid = send_create_role(role); - return recv_create_role(seqid); + int32_t seqid = send_grant_role(role_name, principal_name, principal_type, grantor, grantorType, grant_option); + return recv_grant_role(seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_create_role(const Role& role) +int32_t ThriftHiveMetastoreConcurrentClient::send_grant_role(const std::string& role_name, const std::string& principal_name, const PrincipalType::type principal_type, const std::string& grantor, const PrincipalType::type grantorType, const bool grant_option) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("create_role", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("grant_role", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_create_role_pargs args; - args.role = &role; + ThriftHiveMetastore_grant_role_pargs args; + args.role_name = &role_name; + args.principal_name = &principal_name; + args.principal_type = &principal_type; + args.grantor = &grantor; + args.grantorType = &grantorType; + args.grant_option = &grant_option; args.write(oprot_); oprot_->writeMessageEnd(); @@ -73555,7 +75786,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_create_role(const Role& role) return cseqid; } -bool ThriftHiveMetastoreConcurrentClient::recv_create_role(const int32_t seqid) +bool ThriftHiveMetastoreConcurrentClient::recv_grant_role(const int32_t seqid) { int32_t rseqid = 0; @@ -73584,7 +75815,7 @@ bool ThriftHiveMetastoreConcurrentClient::recv_create_role(const int32_t seqid) iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("create_role") != 0) { + if (fname.compare("grant_role") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -73594,7 +75825,7 @@ bool ThriftHiveMetastoreConcurrentClient::recv_create_role(const int32_t seqid) throw TProtocolException(TProtocolException::INVALID_DATA); } bool _return; - ThriftHiveMetastore_create_role_presult result; + ThriftHiveMetastore_grant_role_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -73609,7 +75840,7 @@ bool ThriftHiveMetastoreConcurrentClient::recv_create_role(const int32_t seqid) throw result.o1; } // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "create_role failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "grant_role failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -73619,20 +75850,22 @@ bool ThriftHiveMetastoreConcurrentClient::recv_create_role(const int32_t seqid) } // end while(true) } -bool ThriftHiveMetastoreConcurrentClient::drop_role(const std::string& role_name) +bool ThriftHiveMetastoreConcurrentClient::revoke_role(const std::string& role_name, const std::string& principal_name, const PrincipalType::type principal_type) { - int32_t seqid = send_drop_role(role_name); - return recv_drop_role(seqid); + int32_t seqid = send_revoke_role(role_name, principal_name, principal_type); + return recv_revoke_role(seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_drop_role(const std::string& role_name) +int32_t ThriftHiveMetastoreConcurrentClient::send_revoke_role(const std::string& role_name, const std::string& principal_name, const PrincipalType::type principal_type) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("drop_role", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("revoke_role", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_drop_role_pargs args; + ThriftHiveMetastore_revoke_role_pargs args; args.role_name = &role_name; + args.principal_name = &principal_name; + args.principal_type = &principal_type; args.write(oprot_); oprot_->writeMessageEnd(); @@ -73643,7 +75876,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_drop_role(const std::string& r return cseqid; } -bool ThriftHiveMetastoreConcurrentClient::recv_drop_role(const int32_t seqid) +bool ThriftHiveMetastoreConcurrentClient::recv_revoke_role(const int32_t seqid) { int32_t rseqid = 0; @@ -73672,7 +75905,7 @@ bool ThriftHiveMetastoreConcurrentClient::recv_drop_role(const int32_t seqid) iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("drop_role") != 0) { + if (fname.compare("revoke_role") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -73682,7 +75915,7 @@ bool ThriftHiveMetastoreConcurrentClient::recv_drop_role(const int32_t seqid) throw TProtocolException(TProtocolException::INVALID_DATA); } bool _return; - ThriftHiveMetastore_drop_role_presult result; + ThriftHiveMetastore_revoke_role_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -73697,7 +75930,7 @@ bool ThriftHiveMetastoreConcurrentClient::recv_drop_role(const int32_t seqid) throw result.o1; } // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "drop_role failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "revoke_role failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -73707,19 +75940,21 @@ bool ThriftHiveMetastoreConcurrentClient::recv_drop_role(const int32_t seqid) } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::get_role_names(std::vector & _return) +void ThriftHiveMetastoreConcurrentClient::list_roles(std::vector & _return, const std::string& principal_name, const PrincipalType::type principal_type) { - int32_t seqid = send_get_role_names(); - recv_get_role_names(_return, seqid); + int32_t seqid = send_list_roles(principal_name, principal_type); + recv_list_roles(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_get_role_names() +int32_t ThriftHiveMetastoreConcurrentClient::send_list_roles(const std::string& principal_name, const PrincipalType::type principal_type) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("get_role_names", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("list_roles", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_get_role_names_pargs args; + ThriftHiveMetastore_list_roles_pargs args; + args.principal_name = &principal_name; + args.principal_type = &principal_type; args.write(oprot_); oprot_->writeMessageEnd(); @@ -73730,7 +75965,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_get_role_names() return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_get_role_names(std::vector & _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_list_roles(std::vector & _return, const int32_t seqid) { int32_t rseqid = 0; @@ -73759,7 +75994,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_role_names(std::vectorreadMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("get_role_names") != 0) { + if (fname.compare("list_roles") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -73768,7 +76003,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_role_names(std::vectorreadMessageEnd(); @@ -73784,7 +76019,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_role_names(std::vectorsync_.updatePending(fname, mtype, rseqid); @@ -73794,25 +76029,20 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_role_names(std::vectorsync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("grant_role", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("grant_revoke_role", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_grant_role_pargs args; - args.role_name = &role_name; - args.principal_name = &principal_name; - args.principal_type = &principal_type; - args.grantor = &grantor; - args.grantorType = &grantorType; - args.grant_option = &grant_option; + ThriftHiveMetastore_grant_revoke_role_pargs args; + args.request = &request; args.write(oprot_); oprot_->writeMessageEnd(); @@ -73823,7 +76053,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_grant_role(const std::string& return cseqid; } -bool ThriftHiveMetastoreConcurrentClient::recv_grant_role(const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_grant_revoke_role(GrantRevokeRoleResponse& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -73852,7 +76082,7 @@ bool ThriftHiveMetastoreConcurrentClient::recv_grant_role(const int32_t seqid) iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("grant_role") != 0) { + if (fname.compare("grant_revoke_role") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -73861,23 +76091,23 @@ bool ThriftHiveMetastoreConcurrentClient::recv_grant_role(const int32_t seqid) using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - bool _return; - ThriftHiveMetastore_grant_role_presult result; + ThriftHiveMetastore_grant_revoke_role_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 _return; + 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, "grant_role failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "grant_revoke_role failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -73887,22 +76117,20 @@ bool ThriftHiveMetastoreConcurrentClient::recv_grant_role(const int32_t seqid) } // end while(true) } -bool ThriftHiveMetastoreConcurrentClient::revoke_role(const std::string& role_name, const std::string& principal_name, const PrincipalType::type principal_type) +void ThriftHiveMetastoreConcurrentClient::get_principals_in_role(GetPrincipalsInRoleResponse& _return, const GetPrincipalsInRoleRequest& request) { - int32_t seqid = send_revoke_role(role_name, principal_name, principal_type); - return recv_revoke_role(seqid); + int32_t seqid = send_get_principals_in_role(request); + recv_get_principals_in_role(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_revoke_role(const std::string& role_name, const std::string& principal_name, const PrincipalType::type principal_type) +int32_t ThriftHiveMetastoreConcurrentClient::send_get_principals_in_role(const GetPrincipalsInRoleRequest& request) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("revoke_role", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("get_principals_in_role", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_revoke_role_pargs args; - args.role_name = &role_name; - args.principal_name = &principal_name; - args.principal_type = &principal_type; + ThriftHiveMetastore_get_principals_in_role_pargs args; + args.request = &request; args.write(oprot_); oprot_->writeMessageEnd(); @@ -73913,7 +76141,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_revoke_role(const std::string& return cseqid; } -bool ThriftHiveMetastoreConcurrentClient::recv_revoke_role(const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_get_principals_in_role(GetPrincipalsInRoleResponse& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -73942,7 +76170,7 @@ bool ThriftHiveMetastoreConcurrentClient::recv_revoke_role(const int32_t seqid) iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("revoke_role") != 0) { + if (fname.compare("get_principals_in_role") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -73951,23 +76179,23 @@ bool ThriftHiveMetastoreConcurrentClient::recv_revoke_role(const int32_t seqid) using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - bool _return; - ThriftHiveMetastore_revoke_role_presult result; + ThriftHiveMetastore_get_principals_in_role_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 _return; + 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, "revoke_role failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_principals_in_role failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -73977,21 +76205,20 @@ bool ThriftHiveMetastoreConcurrentClient::recv_revoke_role(const int32_t seqid) } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::list_roles(std::vector & _return, const std::string& principal_name, const PrincipalType::type principal_type) +void ThriftHiveMetastoreConcurrentClient::get_role_grants_for_principal(GetRoleGrantsForPrincipalResponse& _return, const GetRoleGrantsForPrincipalRequest& request) { - int32_t seqid = send_list_roles(principal_name, principal_type); - recv_list_roles(_return, seqid); + int32_t seqid = send_get_role_grants_for_principal(request); + recv_get_role_grants_for_principal(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_list_roles(const std::string& principal_name, const PrincipalType::type principal_type) +int32_t ThriftHiveMetastoreConcurrentClient::send_get_role_grants_for_principal(const GetRoleGrantsForPrincipalRequest& request) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("list_roles", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("get_role_grants_for_principal", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_list_roles_pargs args; - args.principal_name = &principal_name; - args.principal_type = &principal_type; + ThriftHiveMetastore_get_role_grants_for_principal_pargs args; + args.request = &request; args.write(oprot_); oprot_->writeMessageEnd(); @@ -74002,7 +76229,97 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_list_roles(const std::string& return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_list_roles(std::vector & _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_get_role_grants_for_principal(GetRoleGrantsForPrincipalResponse& _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_role_grants_for_principal") != 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_role_grants_for_principal_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_role_grants_for_principal 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_privilege_set(PrincipalPrivilegeSet& _return, const HiveObjectRef& hiveObject, const std::string& user_name, const std::vector & group_names) +{ + int32_t seqid = send_get_privilege_set(hiveObject, user_name, group_names); + recv_get_privilege_set(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_privilege_set(const HiveObjectRef& hiveObject, const std::string& user_name, const std::vector & group_names) +{ + int32_t cseqid = this->sync_.generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); + oprot_->writeMessageBegin("get_privilege_set", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_privilege_set_pargs args; + args.hiveObject = &hiveObject; + args.user_name = &user_name; + args.group_names = &group_names; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_privilege_set(PrincipalPrivilegeSet& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -74031,7 +76348,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_list_roles(std::vector & _r iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("list_roles") != 0) { + if (fname.compare("get_privilege_set") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -74040,7 +76357,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_list_roles(std::vector & _r using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_list_roles_presult result; + ThriftHiveMetastore_get_privilege_set_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -74056,7 +76373,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_list_roles(std::vector & _r throw result.o1; } // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "list_roles failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_privilege_set failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -74066,20 +76383,22 @@ void ThriftHiveMetastoreConcurrentClient::recv_list_roles(std::vector & _r } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::grant_revoke_role(GrantRevokeRoleResponse& _return, const GrantRevokeRoleRequest& request) +void ThriftHiveMetastoreConcurrentClient::list_privileges(std::vector & _return, const std::string& principal_name, const PrincipalType::type principal_type, const HiveObjectRef& hiveObject) { - int32_t seqid = send_grant_revoke_role(request); - recv_grant_revoke_role(_return, seqid); + int32_t seqid = send_list_privileges(principal_name, principal_type, hiveObject); + recv_list_privileges(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_grant_revoke_role(const GrantRevokeRoleRequest& request) +int32_t ThriftHiveMetastoreConcurrentClient::send_list_privileges(const std::string& principal_name, const PrincipalType::type principal_type, const HiveObjectRef& hiveObject) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("grant_revoke_role", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("list_privileges", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_grant_revoke_role_pargs args; - args.request = &request; + ThriftHiveMetastore_list_privileges_pargs args; + args.principal_name = &principal_name; + args.principal_type = &principal_type; + args.hiveObject = &hiveObject; args.write(oprot_); oprot_->writeMessageEnd(); @@ -74090,7 +76409,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_grant_revoke_role(const GrantR return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_grant_revoke_role(GrantRevokeRoleResponse& _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_list_privileges(std::vector & _return, const int32_t seqid) { int32_t rseqid = 0; @@ -74119,7 +76438,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_grant_revoke_role(GrantRevokeRole iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("grant_revoke_role") != 0) { + if (fname.compare("list_privileges") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -74128,7 +76447,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_grant_revoke_role(GrantRevokeRole using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_grant_revoke_role_presult result; + ThriftHiveMetastore_list_privileges_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -74144,7 +76463,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_grant_revoke_role(GrantRevokeRole throw result.o1; } // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "grant_revoke_role failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "list_privileges failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -74154,20 +76473,20 @@ void ThriftHiveMetastoreConcurrentClient::recv_grant_revoke_role(GrantRevokeRole } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::get_principals_in_role(GetPrincipalsInRoleResponse& _return, const GetPrincipalsInRoleRequest& request) +bool ThriftHiveMetastoreConcurrentClient::grant_privileges(const PrivilegeBag& privileges) { - int32_t seqid = send_get_principals_in_role(request); - recv_get_principals_in_role(_return, seqid); + int32_t seqid = send_grant_privileges(privileges); + return recv_grant_privileges(seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_get_principals_in_role(const GetPrincipalsInRoleRequest& request) +int32_t ThriftHiveMetastoreConcurrentClient::send_grant_privileges(const PrivilegeBag& privileges) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("get_principals_in_role", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("grant_privileges", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_get_principals_in_role_pargs args; - args.request = &request; + ThriftHiveMetastore_grant_privileges_pargs args; + args.privileges = &privileges; args.write(oprot_); oprot_->writeMessageEnd(); @@ -74178,7 +76497,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_get_principals_in_role(const G return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_get_principals_in_role(GetPrincipalsInRoleResponse& _return, const int32_t seqid) +bool ThriftHiveMetastoreConcurrentClient::recv_grant_privileges(const int32_t seqid) { int32_t rseqid = 0; @@ -74207,7 +76526,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_principals_in_role(GetPrincip iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("get_principals_in_role") != 0) { + if (fname.compare("grant_privileges") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -74216,23 +76535,23 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_principals_in_role(GetPrincip using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_get_principals_in_role_presult result; + bool _return; + ThriftHiveMetastore_grant_privileges_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; + return _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_principals_in_role failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "grant_privileges failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -74242,20 +76561,20 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_principals_in_role(GetPrincip } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::get_role_grants_for_principal(GetRoleGrantsForPrincipalResponse& _return, const GetRoleGrantsForPrincipalRequest& request) +bool ThriftHiveMetastoreConcurrentClient::revoke_privileges(const PrivilegeBag& privileges) { - int32_t seqid = send_get_role_grants_for_principal(request); - recv_get_role_grants_for_principal(_return, seqid); + int32_t seqid = send_revoke_privileges(privileges); + return recv_revoke_privileges(seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_get_role_grants_for_principal(const GetRoleGrantsForPrincipalRequest& request) +int32_t ThriftHiveMetastoreConcurrentClient::send_revoke_privileges(const PrivilegeBag& privileges) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("get_role_grants_for_principal", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("revoke_privileges", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_get_role_grants_for_principal_pargs args; - args.request = &request; + ThriftHiveMetastore_revoke_privileges_pargs args; + args.privileges = &privileges; args.write(oprot_); oprot_->writeMessageEnd(); @@ -74266,7 +76585,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_get_role_grants_for_principal( return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_get_role_grants_for_principal(GetRoleGrantsForPrincipalResponse& _return, const int32_t seqid) +bool ThriftHiveMetastoreConcurrentClient::recv_revoke_privileges(const int32_t seqid) { int32_t rseqid = 0; @@ -74295,7 +76614,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_role_grants_for_principal(Get iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("get_role_grants_for_principal") != 0) { + if (fname.compare("revoke_privileges") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -74304,23 +76623,23 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_role_grants_for_principal(Get using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_get_role_grants_for_principal_presult result; + bool _return; + ThriftHiveMetastore_revoke_privileges_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; + return _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_role_grants_for_principal failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "revoke_privileges failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -74330,22 +76649,20 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_role_grants_for_principal(Get } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::get_privilege_set(PrincipalPrivilegeSet& _return, const HiveObjectRef& hiveObject, const std::string& user_name, const std::vector & group_names) +void ThriftHiveMetastoreConcurrentClient::grant_revoke_privileges(GrantRevokePrivilegeResponse& _return, const GrantRevokePrivilegeRequest& request) { - int32_t seqid = send_get_privilege_set(hiveObject, user_name, group_names); - recv_get_privilege_set(_return, seqid); + int32_t seqid = send_grant_revoke_privileges(request); + recv_grant_revoke_privileges(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_get_privilege_set(const HiveObjectRef& hiveObject, const std::string& user_name, const std::vector & group_names) +int32_t ThriftHiveMetastoreConcurrentClient::send_grant_revoke_privileges(const GrantRevokePrivilegeRequest& request) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("get_privilege_set", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("grant_revoke_privileges", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_get_privilege_set_pargs args; - args.hiveObject = &hiveObject; - args.user_name = &user_name; - args.group_names = &group_names; + ThriftHiveMetastore_grant_revoke_privileges_pargs args; + args.request = &request; args.write(oprot_); oprot_->writeMessageEnd(); @@ -74356,7 +76673,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_get_privilege_set(const HiveOb return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_get_privilege_set(PrincipalPrivilegeSet& _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_grant_revoke_privileges(GrantRevokePrivilegeResponse& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -74385,7 +76702,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_privilege_set(PrincipalPrivil iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("get_privilege_set") != 0) { + if (fname.compare("grant_revoke_privileges") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -74394,7 +76711,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_privilege_set(PrincipalPrivil using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_get_privilege_set_presult result; + ThriftHiveMetastore_grant_revoke_privileges_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -74410,7 +76727,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_privilege_set(PrincipalPrivil throw result.o1; } // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_privilege_set failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "grant_revoke_privileges failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -74420,22 +76737,21 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_privilege_set(PrincipalPrivil } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::list_privileges(std::vector & _return, const std::string& principal_name, const PrincipalType::type principal_type, const HiveObjectRef& hiveObject) +void ThriftHiveMetastoreConcurrentClient::set_ugi(std::vector & _return, const std::string& user_name, const std::vector & group_names) { - int32_t seqid = send_list_privileges(principal_name, principal_type, hiveObject); - recv_list_privileges(_return, seqid); + int32_t seqid = send_set_ugi(user_name, group_names); + recv_set_ugi(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_list_privileges(const std::string& principal_name, const PrincipalType::type principal_type, const HiveObjectRef& hiveObject) +int32_t ThriftHiveMetastoreConcurrentClient::send_set_ugi(const std::string& user_name, const std::vector & group_names) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("list_privileges", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("set_ugi", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_list_privileges_pargs args; - args.principal_name = &principal_name; - args.principal_type = &principal_type; - args.hiveObject = &hiveObject; + ThriftHiveMetastore_set_ugi_pargs args; + args.user_name = &user_name; + args.group_names = &group_names; args.write(oprot_); oprot_->writeMessageEnd(); @@ -74446,7 +76762,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_list_privileges(const std::str return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_list_privileges(std::vector & _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_set_ugi(std::vector & _return, const int32_t seqid) { int32_t rseqid = 0; @@ -74475,7 +76791,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_list_privileges(std::vectorreadMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("list_privileges") != 0) { + if (fname.compare("set_ugi") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -74484,7 +76800,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_list_privileges(std::vectorreadMessageEnd(); @@ -74500,7 +76816,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_list_privileges(std::vectorsync_.updatePending(fname, mtype, rseqid); @@ -74510,20 +76826,21 @@ void ThriftHiveMetastoreConcurrentClient::recv_list_privileges(std::vectorsync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("grant_privileges", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("get_delegation_token", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_grant_privileges_pargs args; - args.privileges = &privileges; + ThriftHiveMetastore_get_delegation_token_pargs args; + args.token_owner = &token_owner; + args.renewer_kerberos_principal_name = &renewer_kerberos_principal_name; args.write(oprot_); oprot_->writeMessageEnd(); @@ -74534,7 +76851,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_grant_privileges(const Privile return cseqid; } -bool ThriftHiveMetastoreConcurrentClient::recv_grant_privileges(const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_get_delegation_token(std::string& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -74563,7 +76880,7 @@ bool ThriftHiveMetastoreConcurrentClient::recv_grant_privileges(const int32_t se iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("grant_privileges") != 0) { + if (fname.compare("get_delegation_token") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -74572,23 +76889,23 @@ bool ThriftHiveMetastoreConcurrentClient::recv_grant_privileges(const int32_t se using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - bool _return; - ThriftHiveMetastore_grant_privileges_presult result; + ThriftHiveMetastore_get_delegation_token_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 _return; + 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, "grant_privileges failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_delegation_token failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -74598,20 +76915,20 @@ bool ThriftHiveMetastoreConcurrentClient::recv_grant_privileges(const int32_t se } // end while(true) } -bool ThriftHiveMetastoreConcurrentClient::revoke_privileges(const PrivilegeBag& privileges) +int64_t ThriftHiveMetastoreConcurrentClient::renew_delegation_token(const std::string& token_str_form) { - int32_t seqid = send_revoke_privileges(privileges); - return recv_revoke_privileges(seqid); + int32_t seqid = send_renew_delegation_token(token_str_form); + return recv_renew_delegation_token(seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_revoke_privileges(const PrivilegeBag& privileges) +int32_t ThriftHiveMetastoreConcurrentClient::send_renew_delegation_token(const std::string& token_str_form) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("revoke_privileges", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("renew_delegation_token", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_revoke_privileges_pargs args; - args.privileges = &privileges; + ThriftHiveMetastore_renew_delegation_token_pargs args; + args.token_str_form = &token_str_form; args.write(oprot_); oprot_->writeMessageEnd(); @@ -74622,7 +76939,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_revoke_privileges(const Privil return cseqid; } -bool ThriftHiveMetastoreConcurrentClient::recv_revoke_privileges(const int32_t seqid) +int64_t ThriftHiveMetastoreConcurrentClient::recv_renew_delegation_token(const int32_t seqid) { int32_t rseqid = 0; @@ -74651,7 +76968,7 @@ bool ThriftHiveMetastoreConcurrentClient::recv_revoke_privileges(const int32_t s iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("revoke_privileges") != 0) { + if (fname.compare("renew_delegation_token") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -74660,8 +76977,8 @@ bool ThriftHiveMetastoreConcurrentClient::recv_revoke_privileges(const int32_t s using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - bool _return; - ThriftHiveMetastore_revoke_privileges_presult result; + int64_t _return; + ThriftHiveMetastore_renew_delegation_token_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -74676,7 +76993,7 @@ bool ThriftHiveMetastoreConcurrentClient::recv_revoke_privileges(const int32_t s throw result.o1; } // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "revoke_privileges failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "renew_delegation_token failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -74686,20 +77003,20 @@ bool ThriftHiveMetastoreConcurrentClient::recv_revoke_privileges(const int32_t s } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::grant_revoke_privileges(GrantRevokePrivilegeResponse& _return, const GrantRevokePrivilegeRequest& request) +void ThriftHiveMetastoreConcurrentClient::cancel_delegation_token(const std::string& token_str_form) { - int32_t seqid = send_grant_revoke_privileges(request); - recv_grant_revoke_privileges(_return, seqid); + int32_t seqid = send_cancel_delegation_token(token_str_form); + recv_cancel_delegation_token(seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_grant_revoke_privileges(const GrantRevokePrivilegeRequest& request) +int32_t ThriftHiveMetastoreConcurrentClient::send_cancel_delegation_token(const std::string& token_str_form) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("grant_revoke_privileges", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("cancel_delegation_token", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_grant_revoke_privileges_pargs args; - args.request = &request; + ThriftHiveMetastore_cancel_delegation_token_pargs args; + args.token_str_form = &token_str_form; args.write(oprot_); oprot_->writeMessageEnd(); @@ -74710,7 +77027,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_grant_revoke_privileges(const return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_grant_revoke_privileges(GrantRevokePrivilegeResponse& _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_cancel_delegation_token(const int32_t seqid) { int32_t rseqid = 0; @@ -74739,7 +77056,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_grant_revoke_privileges(GrantRevo iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("grant_revoke_privileges") != 0) { + if (fname.compare("cancel_delegation_token") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -74748,23 +77065,17 @@ void ThriftHiveMetastoreConcurrentClient::recv_grant_revoke_privileges(GrantRevo using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_grant_revoke_privileges_presult result; - result.success = &_return; + ThriftHiveMetastore_cancel_delegation_token_presult result; result.read(iprot_); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); - if (result.__isset.success) { - // _return pointer has now been filled - sentry.commit(); - return; - } if (result.__isset.o1) { sentry.commit(); throw result.o1; } - // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "grant_revoke_privileges failed: unknown result"); + sentry.commit(); + return; } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -74774,21 +77085,21 @@ void ThriftHiveMetastoreConcurrentClient::recv_grant_revoke_privileges(GrantRevo } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::set_ugi(std::vector & _return, const std::string& user_name, const std::vector & group_names) +bool ThriftHiveMetastoreConcurrentClient::add_token(const std::string& token_identifier, const std::string& delegation_token) { - int32_t seqid = send_set_ugi(user_name, group_names); - recv_set_ugi(_return, seqid); + int32_t seqid = send_add_token(token_identifier, delegation_token); + return recv_add_token(seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_set_ugi(const std::string& user_name, const std::vector & group_names) +int32_t ThriftHiveMetastoreConcurrentClient::send_add_token(const std::string& token_identifier, const std::string& delegation_token) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("set_ugi", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("add_token", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_set_ugi_pargs args; - args.user_name = &user_name; - args.group_names = &group_names; + ThriftHiveMetastore_add_token_pargs args; + args.token_identifier = &token_identifier; + args.delegation_token = &delegation_token; args.write(oprot_); oprot_->writeMessageEnd(); @@ -74799,7 +77110,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_set_ugi(const std::string& use return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_set_ugi(std::vector & _return, const int32_t seqid) +bool ThriftHiveMetastoreConcurrentClient::recv_add_token(const int32_t seqid) { int32_t rseqid = 0; @@ -74828,7 +77139,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_set_ugi(std::vector iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("set_ugi") != 0) { + if (fname.compare("add_token") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -74837,23 +77148,19 @@ void ThriftHiveMetastoreConcurrentClient::recv_set_ugi(std::vector using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_set_ugi_presult result; + bool _return; + ThriftHiveMetastore_add_token_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; + return _return; } // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "set_ugi failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "add_token failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -74863,21 +77170,20 @@ void ThriftHiveMetastoreConcurrentClient::recv_set_ugi(std::vector } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::get_delegation_token(std::string& _return, const std::string& token_owner, const std::string& renewer_kerberos_principal_name) +bool ThriftHiveMetastoreConcurrentClient::remove_token(const std::string& token_identifier) { - int32_t seqid = send_get_delegation_token(token_owner, renewer_kerberos_principal_name); - recv_get_delegation_token(_return, seqid); + int32_t seqid = send_remove_token(token_identifier); + return recv_remove_token(seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_get_delegation_token(const std::string& token_owner, const std::string& renewer_kerberos_principal_name) +int32_t ThriftHiveMetastoreConcurrentClient::send_remove_token(const std::string& token_identifier) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("get_delegation_token", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("remove_token", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_get_delegation_token_pargs args; - args.token_owner = &token_owner; - args.renewer_kerberos_principal_name = &renewer_kerberos_principal_name; + ThriftHiveMetastore_remove_token_pargs args; + args.token_identifier = &token_identifier; args.write(oprot_); oprot_->writeMessageEnd(); @@ -74888,7 +77194,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_get_delegation_token(const std return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_get_delegation_token(std::string& _return, const int32_t seqid) +bool ThriftHiveMetastoreConcurrentClient::recv_remove_token(const int32_t seqid) { int32_t rseqid = 0; @@ -74917,7 +77223,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_delegation_token(std::string& iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("get_delegation_token") != 0) { + if (fname.compare("remove_token") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -74926,23 +77232,19 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_delegation_token(std::string& using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_get_delegation_token_presult result; + bool _return; + ThriftHiveMetastore_remove_token_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; + return _return; } // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_delegation_token failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "remove_token failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -74952,20 +77254,20 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_delegation_token(std::string& } // end while(true) } -int64_t ThriftHiveMetastoreConcurrentClient::renew_delegation_token(const std::string& token_str_form) +void ThriftHiveMetastoreConcurrentClient::get_token(std::string& _return, const std::string& token_identifier) { - int32_t seqid = send_renew_delegation_token(token_str_form); - return recv_renew_delegation_token(seqid); + int32_t seqid = send_get_token(token_identifier); + recv_get_token(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_renew_delegation_token(const std::string& token_str_form) +int32_t ThriftHiveMetastoreConcurrentClient::send_get_token(const std::string& token_identifier) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("renew_delegation_token", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("get_token", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_renew_delegation_token_pargs args; - args.token_str_form = &token_str_form; + ThriftHiveMetastore_get_token_pargs args; + args.token_identifier = &token_identifier; args.write(oprot_); oprot_->writeMessageEnd(); @@ -74976,7 +77278,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_renew_delegation_token(const s return cseqid; } -int64_t ThriftHiveMetastoreConcurrentClient::recv_renew_delegation_token(const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_get_token(std::string& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -75005,7 +77307,7 @@ int64_t ThriftHiveMetastoreConcurrentClient::recv_renew_delegation_token(const i iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("renew_delegation_token") != 0) { + if (fname.compare("get_token") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -75014,23 +77316,19 @@ int64_t ThriftHiveMetastoreConcurrentClient::recv_renew_delegation_token(const i using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - int64_t _return; - ThriftHiveMetastore_renew_delegation_token_presult result; + ThriftHiveMetastore_get_token_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 _return; - } - if (result.__isset.o1) { - sentry.commit(); - throw result.o1; + return; } // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "renew_delegation_token failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_token failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -75040,20 +77338,19 @@ int64_t ThriftHiveMetastoreConcurrentClient::recv_renew_delegation_token(const i } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::cancel_delegation_token(const std::string& token_str_form) +void ThriftHiveMetastoreConcurrentClient::get_all_token_identifiers(std::vector & _return) { - int32_t seqid = send_cancel_delegation_token(token_str_form); - recv_cancel_delegation_token(seqid); + int32_t seqid = send_get_all_token_identifiers(); + recv_get_all_token_identifiers(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_cancel_delegation_token(const std::string& token_str_form) +int32_t ThriftHiveMetastoreConcurrentClient::send_get_all_token_identifiers() { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("cancel_delegation_token", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("get_all_token_identifiers", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_cancel_delegation_token_pargs args; - args.token_str_form = &token_str_form; + ThriftHiveMetastore_get_all_token_identifiers_pargs args; args.write(oprot_); oprot_->writeMessageEnd(); @@ -75064,7 +77361,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_cancel_delegation_token(const return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_cancel_delegation_token(const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_get_all_token_identifiers(std::vector & _return, const int32_t seqid) { int32_t rseqid = 0; @@ -75093,7 +77390,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_cancel_delegation_token(const int iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("cancel_delegation_token") != 0) { + if (fname.compare("get_all_token_identifiers") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -75102,17 +77399,19 @@ void ThriftHiveMetastoreConcurrentClient::recv_cancel_delegation_token(const int using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_cancel_delegation_token_presult result; + ThriftHiveMetastore_get_all_token_identifiers_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; } - sentry.commit(); - return; + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_all_token_identifiers failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -75122,21 +77421,20 @@ void ThriftHiveMetastoreConcurrentClient::recv_cancel_delegation_token(const int } // end while(true) } -bool ThriftHiveMetastoreConcurrentClient::add_token(const std::string& token_identifier, const std::string& delegation_token) +int32_t ThriftHiveMetastoreConcurrentClient::add_master_key(const std::string& key) { - int32_t seqid = send_add_token(token_identifier, delegation_token); - return recv_add_token(seqid); + int32_t seqid = send_add_master_key(key); + return recv_add_master_key(seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_add_token(const std::string& token_identifier, const std::string& delegation_token) +int32_t ThriftHiveMetastoreConcurrentClient::send_add_master_key(const std::string& key) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("add_token", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("add_master_key", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_add_token_pargs args; - args.token_identifier = &token_identifier; - args.delegation_token = &delegation_token; + ThriftHiveMetastore_add_master_key_pargs args; + args.key = &key; args.write(oprot_); oprot_->writeMessageEnd(); @@ -75147,7 +77445,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_add_token(const std::string& t return cseqid; } -bool ThriftHiveMetastoreConcurrentClient::recv_add_token(const int32_t seqid) +int32_t ThriftHiveMetastoreConcurrentClient::recv_add_master_key(const int32_t seqid) { int32_t rseqid = 0; @@ -75176,7 +77474,7 @@ bool ThriftHiveMetastoreConcurrentClient::recv_add_token(const int32_t seqid) iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("add_token") != 0) { + if (fname.compare("add_master_key") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -75185,8 +77483,8 @@ bool ThriftHiveMetastoreConcurrentClient::recv_add_token(const int32_t seqid) using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - bool _return; - ThriftHiveMetastore_add_token_presult result; + int32_t _return; + ThriftHiveMetastore_add_master_key_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -75196,8 +77494,12 @@ bool ThriftHiveMetastoreConcurrentClient::recv_add_token(const int32_t seqid) sentry.commit(); return _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, "add_token failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "add_master_key failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -75207,20 +77509,21 @@ bool ThriftHiveMetastoreConcurrentClient::recv_add_token(const int32_t seqid) } // end while(true) } -bool ThriftHiveMetastoreConcurrentClient::remove_token(const std::string& token_identifier) +void ThriftHiveMetastoreConcurrentClient::update_master_key(const int32_t seq_number, const std::string& key) { - int32_t seqid = send_remove_token(token_identifier); - return recv_remove_token(seqid); + int32_t seqid = send_update_master_key(seq_number, key); + recv_update_master_key(seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_remove_token(const std::string& token_identifier) +int32_t ThriftHiveMetastoreConcurrentClient::send_update_master_key(const int32_t seq_number, const std::string& key) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("remove_token", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("update_master_key", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_remove_token_pargs args; - args.token_identifier = &token_identifier; + ThriftHiveMetastore_update_master_key_pargs args; + args.seq_number = &seq_number; + args.key = &key; args.write(oprot_); oprot_->writeMessageEnd(); @@ -75231,7 +77534,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_remove_token(const std::string return cseqid; } -bool ThriftHiveMetastoreConcurrentClient::recv_remove_token(const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_update_master_key(const int32_t seqid) { int32_t rseqid = 0; @@ -75260,7 +77563,7 @@ bool ThriftHiveMetastoreConcurrentClient::recv_remove_token(const int32_t seqid) iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("remove_token") != 0) { + if (fname.compare("update_master_key") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -75269,19 +77572,21 @@ bool ThriftHiveMetastoreConcurrentClient::recv_remove_token(const int32_t seqid) using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - bool _return; - ThriftHiveMetastore_remove_token_presult result; - result.success = &_return; + ThriftHiveMetastore_update_master_key_presult result; result.read(iprot_); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); - if (result.__isset.success) { + if (result.__isset.o1) { sentry.commit(); - return _return; + throw result.o1; } - // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "remove_token failed: unknown result"); + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + sentry.commit(); + return; } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -75291,20 +77596,20 @@ bool ThriftHiveMetastoreConcurrentClient::recv_remove_token(const int32_t seqid) } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::get_token(std::string& _return, const std::string& token_identifier) +bool ThriftHiveMetastoreConcurrentClient::remove_master_key(const int32_t key_seq) { - int32_t seqid = send_get_token(token_identifier); - recv_get_token(_return, seqid); + int32_t seqid = send_remove_master_key(key_seq); + return recv_remove_master_key(seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_get_token(const std::string& token_identifier) +int32_t ThriftHiveMetastoreConcurrentClient::send_remove_master_key(const int32_t key_seq) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("get_token", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("remove_master_key", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_get_token_pargs args; - args.token_identifier = &token_identifier; + ThriftHiveMetastore_remove_master_key_pargs args; + args.key_seq = &key_seq; args.write(oprot_); oprot_->writeMessageEnd(); @@ -75315,7 +77620,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_get_token(const std::string& t return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_get_token(std::string& _return, const int32_t seqid) +bool ThriftHiveMetastoreConcurrentClient::recv_remove_master_key(const int32_t seqid) { int32_t rseqid = 0; @@ -75344,7 +77649,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_token(std::string& _return, c iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("get_token") != 0) { + if (fname.compare("remove_master_key") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -75353,19 +77658,19 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_token(std::string& _return, c using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_get_token_presult result; + bool _return; + ThriftHiveMetastore_remove_master_key_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; + return _return; } // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_token failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "remove_master_key failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -75375,19 +77680,19 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_token(std::string& _return, c } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::get_all_token_identifiers(std::vector & _return) +void ThriftHiveMetastoreConcurrentClient::get_master_keys(std::vector & _return) { - int32_t seqid = send_get_all_token_identifiers(); - recv_get_all_token_identifiers(_return, seqid); + int32_t seqid = send_get_master_keys(); + recv_get_master_keys(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_get_all_token_identifiers() +int32_t ThriftHiveMetastoreConcurrentClient::send_get_master_keys() { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("get_all_token_identifiers", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("get_master_keys", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_get_all_token_identifiers_pargs args; + ThriftHiveMetastore_get_master_keys_pargs args; args.write(oprot_); oprot_->writeMessageEnd(); @@ -75398,7 +77703,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_get_all_token_identifiers() return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_get_all_token_identifiers(std::vector & _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_get_master_keys(std::vector & _return, const int32_t seqid) { int32_t rseqid = 0; @@ -75427,7 +77732,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_all_token_identifiers(std::ve iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("get_all_token_identifiers") != 0) { + if (fname.compare("get_master_keys") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -75436,7 +77741,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_all_token_identifiers(std::ve using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_get_all_token_identifiers_presult result; + ThriftHiveMetastore_get_master_keys_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -75448,7 +77753,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_all_token_identifiers(std::ve return; } // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_all_token_identifiers failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_master_keys failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -75458,20 +77763,19 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_all_token_identifiers(std::ve } // end while(true) } -int32_t ThriftHiveMetastoreConcurrentClient::add_master_key(const std::string& key) +void ThriftHiveMetastoreConcurrentClient::get_open_txns(GetOpenTxnsResponse& _return) { - int32_t seqid = send_add_master_key(key); - return recv_add_master_key(seqid); + int32_t seqid = send_get_open_txns(); + recv_get_open_txns(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_add_master_key(const std::string& key) +int32_t ThriftHiveMetastoreConcurrentClient::send_get_open_txns() { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("add_master_key", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("get_open_txns", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_add_master_key_pargs args; - args.key = &key; + ThriftHiveMetastore_get_open_txns_pargs args; args.write(oprot_); oprot_->writeMessageEnd(); @@ -75482,7 +77786,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_add_master_key(const std::stri return cseqid; } -int32_t ThriftHiveMetastoreConcurrentClient::recv_add_master_key(const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_get_open_txns(GetOpenTxnsResponse& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -75511,7 +77815,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::recv_add_master_key(const int32_t s iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("add_master_key") != 0) { + if (fname.compare("get_open_txns") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -75520,23 +77824,19 @@ int32_t ThriftHiveMetastoreConcurrentClient::recv_add_master_key(const int32_t s using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - int32_t _return; - ThriftHiveMetastore_add_master_key_presult result; + ThriftHiveMetastore_get_open_txns_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 _return; - } - if (result.__isset.o1) { - sentry.commit(); - throw result.o1; + return; } // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "add_master_key failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_open_txns failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -75546,21 +77846,19 @@ int32_t ThriftHiveMetastoreConcurrentClient::recv_add_master_key(const int32_t s } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::update_master_key(const int32_t seq_number, const std::string& key) +void ThriftHiveMetastoreConcurrentClient::get_open_txns_info(GetOpenTxnsInfoResponse& _return) { - int32_t seqid = send_update_master_key(seq_number, key); - recv_update_master_key(seqid); + int32_t seqid = send_get_open_txns_info(); + recv_get_open_txns_info(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_update_master_key(const int32_t seq_number, const std::string& key) +int32_t ThriftHiveMetastoreConcurrentClient::send_get_open_txns_info() { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("update_master_key", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("get_open_txns_info", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_update_master_key_pargs args; - args.seq_number = &seq_number; - args.key = &key; + ThriftHiveMetastore_get_open_txns_info_pargs args; args.write(oprot_); oprot_->writeMessageEnd(); @@ -75571,7 +77869,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_update_master_key(const int32_ return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_update_master_key(const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_get_open_txns_info(GetOpenTxnsInfoResponse& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -75600,7 +77898,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_update_master_key(const int32_t s iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("update_master_key") != 0) { + if (fname.compare("get_open_txns_info") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -75609,21 +77907,19 @@ void ThriftHiveMetastoreConcurrentClient::recv_update_master_key(const int32_t s using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_update_master_key_presult result; + ThriftHiveMetastore_get_open_txns_info_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) { + if (result.__isset.success) { + // _return pointer has now been filled sentry.commit(); - throw result.o2; + return; } - sentry.commit(); - return; + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_open_txns_info failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -75633,20 +77929,20 @@ void ThriftHiveMetastoreConcurrentClient::recv_update_master_key(const int32_t s } // end while(true) } -bool ThriftHiveMetastoreConcurrentClient::remove_master_key(const int32_t key_seq) +void ThriftHiveMetastoreConcurrentClient::open_txns(OpenTxnsResponse& _return, const OpenTxnRequest& rqst) { - int32_t seqid = send_remove_master_key(key_seq); - return recv_remove_master_key(seqid); + int32_t seqid = send_open_txns(rqst); + recv_open_txns(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_remove_master_key(const int32_t key_seq) +int32_t ThriftHiveMetastoreConcurrentClient::send_open_txns(const OpenTxnRequest& rqst) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("remove_master_key", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("open_txns", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_remove_master_key_pargs args; - args.key_seq = &key_seq; + ThriftHiveMetastore_open_txns_pargs args; + args.rqst = &rqst; args.write(oprot_); oprot_->writeMessageEnd(); @@ -75657,7 +77953,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_remove_master_key(const int32_ return cseqid; } -bool ThriftHiveMetastoreConcurrentClient::recv_remove_master_key(const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_open_txns(OpenTxnsResponse& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -75686,7 +77982,7 @@ bool ThriftHiveMetastoreConcurrentClient::recv_remove_master_key(const int32_t s iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("remove_master_key") != 0) { + if (fname.compare("open_txns") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -75695,19 +77991,19 @@ bool ThriftHiveMetastoreConcurrentClient::recv_remove_master_key(const int32_t s using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - bool _return; - ThriftHiveMetastore_remove_master_key_presult result; + ThriftHiveMetastore_open_txns_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 _return; + return; } // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "remove_master_key failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "open_txns failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -75717,19 +78013,20 @@ bool ThriftHiveMetastoreConcurrentClient::recv_remove_master_key(const int32_t s } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::get_master_keys(std::vector & _return) +void ThriftHiveMetastoreConcurrentClient::abort_txn(const AbortTxnRequest& rqst) { - int32_t seqid = send_get_master_keys(); - recv_get_master_keys(_return, seqid); + int32_t seqid = send_abort_txn(rqst); + recv_abort_txn(seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_get_master_keys() +int32_t ThriftHiveMetastoreConcurrentClient::send_abort_txn(const AbortTxnRequest& rqst) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("get_master_keys", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("abort_txn", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_get_master_keys_pargs args; + ThriftHiveMetastore_abort_txn_pargs args; + args.rqst = &rqst; args.write(oprot_); oprot_->writeMessageEnd(); @@ -75740,7 +78037,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_get_master_keys() return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_get_master_keys(std::vector & _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_abort_txn(const int32_t seqid) { int32_t rseqid = 0; @@ -75769,7 +78066,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_master_keys(std::vectorreadMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("get_master_keys") != 0) { + if (fname.compare("abort_txn") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -75778,19 +78075,17 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_master_keys(std::vectorreadMessageEnd(); iprot_->getTransport()->readEnd(); - if (result.__isset.success) { - // _return pointer has now been filled + if (result.__isset.o1) { sentry.commit(); - return; + throw result.o1; } - // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_master_keys failed: unknown result"); + sentry.commit(); + return; } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -75800,19 +78095,20 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_master_keys(std::vectorsync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("get_open_txns", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("abort_txns", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_get_open_txns_pargs args; + ThriftHiveMetastore_abort_txns_pargs args; + args.rqst = &rqst; args.write(oprot_); oprot_->writeMessageEnd(); @@ -75823,7 +78119,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_get_open_txns() return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_get_open_txns(GetOpenTxnsResponse& _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_abort_txns(const int32_t seqid) { int32_t rseqid = 0; @@ -75852,7 +78148,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_open_txns(GetOpenTxnsResponse iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("get_open_txns") != 0) { + if (fname.compare("abort_txns") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -75861,19 +78157,17 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_open_txns(GetOpenTxnsResponse using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_get_open_txns_presult result; - result.success = &_return; + ThriftHiveMetastore_abort_txns_presult result; result.read(iprot_); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); - if (result.__isset.success) { - // _return pointer has now been filled + if (result.__isset.o1) { sentry.commit(); - return; + throw result.o1; } - // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_open_txns failed: unknown result"); + sentry.commit(); + return; } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -75883,19 +78177,20 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_open_txns(GetOpenTxnsResponse } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::get_open_txns_info(GetOpenTxnsInfoResponse& _return) +void ThriftHiveMetastoreConcurrentClient::commit_txn(const CommitTxnRequest& rqst) { - int32_t seqid = send_get_open_txns_info(); - recv_get_open_txns_info(_return, seqid); + int32_t seqid = send_commit_txn(rqst); + recv_commit_txn(seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_get_open_txns_info() +int32_t ThriftHiveMetastoreConcurrentClient::send_commit_txn(const CommitTxnRequest& rqst) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("get_open_txns_info", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("commit_txn", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_get_open_txns_info_pargs args; + ThriftHiveMetastore_commit_txn_pargs args; + args.rqst = &rqst; args.write(oprot_); oprot_->writeMessageEnd(); @@ -75906,7 +78201,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_get_open_txns_info() return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_get_open_txns_info(GetOpenTxnsInfoResponse& _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_commit_txn(const int32_t seqid) { int32_t rseqid = 0; @@ -75935,7 +78230,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_open_txns_info(GetOpenTxnsInf iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("get_open_txns_info") != 0) { + if (fname.compare("commit_txn") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -75944,19 +78239,21 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_open_txns_info(GetOpenTxnsInf using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_get_open_txns_info_presult result; - result.success = &_return; + ThriftHiveMetastore_commit_txn_presult result; result.read(iprot_); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); - if (result.__isset.success) { - // _return pointer has now been filled + if (result.__isset.o1) { sentry.commit(); - return; + throw result.o1; } - // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_open_txns_info failed: unknown result"); + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + sentry.commit(); + return; } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -75966,19 +78263,19 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_open_txns_info(GetOpenTxnsInf } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::open_txns(OpenTxnsResponse& _return, const OpenTxnRequest& rqst) +void ThriftHiveMetastoreConcurrentClient::lock(LockResponse& _return, const LockRequest& rqst) { - int32_t seqid = send_open_txns(rqst); - recv_open_txns(_return, seqid); + int32_t seqid = send_lock(rqst); + recv_lock(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_open_txns(const OpenTxnRequest& rqst) +int32_t ThriftHiveMetastoreConcurrentClient::send_lock(const LockRequest& rqst) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("open_txns", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("lock", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_open_txns_pargs args; + ThriftHiveMetastore_lock_pargs args; args.rqst = &rqst; args.write(oprot_); @@ -75990,7 +78287,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_open_txns(const OpenTxnRequest return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_open_txns(OpenTxnsResponse& _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_lock(LockResponse& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -76019,7 +78316,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_open_txns(OpenTxnsResponse& _retu iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("open_txns") != 0) { + if (fname.compare("lock") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -76028,7 +78325,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_open_txns(OpenTxnsResponse& _retu using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_open_txns_presult result; + ThriftHiveMetastore_lock_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -76039,8 +78336,16 @@ void ThriftHiveMetastoreConcurrentClient::recv_open_txns(OpenTxnsResponse& _retu 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, "open_txns failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "lock failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -76050,19 +78355,19 @@ void ThriftHiveMetastoreConcurrentClient::recv_open_txns(OpenTxnsResponse& _retu } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::abort_txn(const AbortTxnRequest& rqst) +void ThriftHiveMetastoreConcurrentClient::check_lock(LockResponse& _return, const CheckLockRequest& rqst) { - int32_t seqid = send_abort_txn(rqst); - recv_abort_txn(seqid); + int32_t seqid = send_check_lock(rqst); + recv_check_lock(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_abort_txn(const AbortTxnRequest& rqst) +int32_t ThriftHiveMetastoreConcurrentClient::send_check_lock(const CheckLockRequest& rqst) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("abort_txn", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("check_lock", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_abort_txn_pargs args; + ThriftHiveMetastore_check_lock_pargs args; args.rqst = &rqst; args.write(oprot_); @@ -76074,7 +78379,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_abort_txn(const AbortTxnReques return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_abort_txn(const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_check_lock(LockResponse& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -76103,7 +78408,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_abort_txn(const int32_t seqid) iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("abort_txn") != 0) { + if (fname.compare("check_lock") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -76112,99 +78417,31 @@ void ThriftHiveMetastoreConcurrentClient::recv_abort_txn(const int32_t seqid) using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_abort_txn_presult result; + ThriftHiveMetastore_check_lock_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; } - 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::abort_txns(const AbortTxnsRequest& rqst) -{ - int32_t seqid = send_abort_txns(rqst); - recv_abort_txns(seqid); -} - -int32_t ThriftHiveMetastoreConcurrentClient::send_abort_txns(const AbortTxnsRequest& rqst) -{ - int32_t cseqid = this->sync_.generateSeqId(); - ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("abort_txns", ::apache::thrift::protocol::T_CALL, cseqid); - - ThriftHiveMetastore_abort_txns_pargs args; - args.rqst = &rqst; - args.write(oprot_); - - oprot_->writeMessageEnd(); - oprot_->getTransport()->writeEnd(); - oprot_->getTransport()->flush(); - - sentry.commit(); - return cseqid; -} - -void ThriftHiveMetastoreConcurrentClient::recv_abort_txns(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(); + if (result.__isset.o2) { 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("abort_txns") != 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); + throw result.o2; } - ThriftHiveMetastore_abort_txns_presult result; - result.read(iprot_); - iprot_->readMessageEnd(); - iprot_->getTransport()->readEnd(); - - if (result.__isset.o1) { + if (result.__isset.o3) { sentry.commit(); - throw result.o1; + throw result.o3; } - sentry.commit(); - return; + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "check_lock failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -76214,19 +78451,19 @@ void ThriftHiveMetastoreConcurrentClient::recv_abort_txns(const int32_t seqid) } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::commit_txn(const CommitTxnRequest& rqst) +void ThriftHiveMetastoreConcurrentClient::unlock(const UnlockRequest& rqst) { - int32_t seqid = send_commit_txn(rqst); - recv_commit_txn(seqid); + int32_t seqid = send_unlock(rqst); + recv_unlock(seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_commit_txn(const CommitTxnRequest& rqst) +int32_t ThriftHiveMetastoreConcurrentClient::send_unlock(const UnlockRequest& rqst) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("commit_txn", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("unlock", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_commit_txn_pargs args; + ThriftHiveMetastore_unlock_pargs args; args.rqst = &rqst; args.write(oprot_); @@ -76238,7 +78475,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_commit_txn(const CommitTxnRequ return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_commit_txn(const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_unlock(const int32_t seqid) { int32_t rseqid = 0; @@ -76267,7 +78504,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_commit_txn(const int32_t seqid) iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("commit_txn") != 0) { + if (fname.compare("unlock") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -76276,7 +78513,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_commit_txn(const int32_t seqid) using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_commit_txn_presult result; + ThriftHiveMetastore_unlock_presult result; result.read(iprot_); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -76300,19 +78537,19 @@ void ThriftHiveMetastoreConcurrentClient::recv_commit_txn(const int32_t seqid) } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::lock(LockResponse& _return, const LockRequest& rqst) +void ThriftHiveMetastoreConcurrentClient::show_locks(ShowLocksResponse& _return, const ShowLocksRequest& rqst) { - int32_t seqid = send_lock(rqst); - recv_lock(_return, seqid); + int32_t seqid = send_show_locks(rqst); + recv_show_locks(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_lock(const LockRequest& rqst) +int32_t ThriftHiveMetastoreConcurrentClient::send_show_locks(const ShowLocksRequest& rqst) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("lock", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("show_locks", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_lock_pargs args; + ThriftHiveMetastore_show_locks_pargs args; args.rqst = &rqst; args.write(oprot_); @@ -76324,7 +78561,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_lock(const LockRequest& rqst) return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_lock(LockResponse& _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_show_locks(ShowLocksResponse& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -76353,7 +78590,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_lock(LockResponse& _return, const iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("lock") != 0) { + if (fname.compare("show_locks") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -76362,7 +78599,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_lock(LockResponse& _return, const using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_lock_presult result; + ThriftHiveMetastore_show_locks_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -76373,16 +78610,8 @@ void ThriftHiveMetastoreConcurrentClient::recv_lock(LockResponse& _return, const 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, "lock failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "show_locks failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -76392,20 +78621,20 @@ void ThriftHiveMetastoreConcurrentClient::recv_lock(LockResponse& _return, const } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::check_lock(LockResponse& _return, const CheckLockRequest& rqst) +void ThriftHiveMetastoreConcurrentClient::heartbeat(const HeartbeatRequest& ids) { - int32_t seqid = send_check_lock(rqst); - recv_check_lock(_return, seqid); + int32_t seqid = send_heartbeat(ids); + recv_heartbeat(seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_check_lock(const CheckLockRequest& rqst) +int32_t ThriftHiveMetastoreConcurrentClient::send_heartbeat(const HeartbeatRequest& ids) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("check_lock", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("heartbeat", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_check_lock_pargs args; - args.rqst = &rqst; + ThriftHiveMetastore_heartbeat_pargs args; + args.ids = &ids; args.write(oprot_); oprot_->writeMessageEnd(); @@ -76416,7 +78645,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_check_lock(const CheckLockRequ return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_check_lock(LockResponse& _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_heartbeat(const int32_t seqid) { int32_t rseqid = 0; @@ -76445,7 +78674,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_check_lock(LockResponse& _return, iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("check_lock") != 0) { + if (fname.compare("heartbeat") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -76454,17 +78683,11 @@ void ThriftHiveMetastoreConcurrentClient::recv_check_lock(LockResponse& _return, using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_check_lock_presult result; - result.success = &_return; + ThriftHiveMetastore_heartbeat_presult result; result.read(iprot_); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); - if (result.__isset.success) { - // _return pointer has now been filled - sentry.commit(); - return; - } if (result.__isset.o1) { sentry.commit(); throw result.o1; @@ -76477,92 +78700,6 @@ void ThriftHiveMetastoreConcurrentClient::recv_check_lock(LockResponse& _return, sentry.commit(); throw result.o3; } - // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "check_lock 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::unlock(const UnlockRequest& rqst) -{ - int32_t seqid = send_unlock(rqst); - recv_unlock(seqid); -} - -int32_t ThriftHiveMetastoreConcurrentClient::send_unlock(const UnlockRequest& rqst) -{ - int32_t cseqid = this->sync_.generateSeqId(); - ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("unlock", ::apache::thrift::protocol::T_CALL, cseqid); - - ThriftHiveMetastore_unlock_pargs args; - args.rqst = &rqst; - args.write(oprot_); - - oprot_->writeMessageEnd(); - oprot_->getTransport()->writeEnd(); - oprot_->getTransport()->flush(); - - sentry.commit(); - return cseqid; -} - -void ThriftHiveMetastoreConcurrentClient::recv_unlock(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("unlock") != 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_unlock_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; } @@ -76574,20 +78711,20 @@ void ThriftHiveMetastoreConcurrentClient::recv_unlock(const int32_t seqid) } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::show_locks(ShowLocksResponse& _return, const ShowLocksRequest& rqst) +void ThriftHiveMetastoreConcurrentClient::heartbeat_txn_range(HeartbeatTxnRangeResponse& _return, const HeartbeatTxnRangeRequest& txns) { - int32_t seqid = send_show_locks(rqst); - recv_show_locks(_return, seqid); + int32_t seqid = send_heartbeat_txn_range(txns); + recv_heartbeat_txn_range(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_show_locks(const ShowLocksRequest& rqst) +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("show_locks", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("heartbeat_txn_range", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_show_locks_pargs args; - args.rqst = &rqst; + ThriftHiveMetastore_heartbeat_txn_range_pargs args; + args.txns = &txns; args.write(oprot_); oprot_->writeMessageEnd(); @@ -76598,7 +78735,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_show_locks(const ShowLocksRequ return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_show_locks(ShowLocksResponse& _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_heartbeat_txn_range(HeartbeatTxnRangeResponse& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -76627,7 +78764,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_show_locks(ShowLocksResponse& _re iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("show_locks") != 0) { + if (fname.compare("heartbeat_txn_range") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -76636,7 +78773,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_show_locks(ShowLocksResponse& _re using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_show_locks_presult result; + ThriftHiveMetastore_heartbeat_txn_range_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -76648,7 +78785,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_show_locks(ShowLocksResponse& _re return; } // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "show_locks failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "heartbeat_txn_range failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -76658,20 +78795,20 @@ void ThriftHiveMetastoreConcurrentClient::recv_show_locks(ShowLocksResponse& _re } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::heartbeat(const HeartbeatRequest& ids) +void ThriftHiveMetastoreConcurrentClient::compact(const CompactionRequest& rqst) { - int32_t seqid = send_heartbeat(ids); - recv_heartbeat(seqid); + int32_t seqid = send_compact(rqst); + recv_compact(seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_heartbeat(const HeartbeatRequest& ids) +int32_t ThriftHiveMetastoreConcurrentClient::send_compact(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("compact", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_heartbeat_pargs args; - args.ids = &ids; + ThriftHiveMetastore_compact_pargs args; + args.rqst = &rqst; args.write(oprot_); oprot_->writeMessageEnd(); @@ -76682,7 +78819,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_heartbeat(const HeartbeatReque return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_heartbeat(const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_compact(const int32_t seqid) { int32_t rseqid = 0; @@ -76711,7 +78848,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_heartbeat(const int32_t seqid) iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("heartbeat") != 0) { + if (fname.compare("compact") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -76720,23 +78857,11 @@ void ThriftHiveMetastoreConcurrentClient::recv_heartbeat(const int32_t seqid) using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_heartbeat_presult result; + ThriftHiveMetastore_compact_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; } @@ -76748,20 +78873,20 @@ void ThriftHiveMetastoreConcurrentClient::recv_heartbeat(const int32_t seqid) } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::heartbeat_txn_range(HeartbeatTxnRangeResponse& _return, const HeartbeatTxnRangeRequest& txns) +void ThriftHiveMetastoreConcurrentClient::compact2(CompactionResponse& _return, const CompactionRequest& rqst) { - int32_t seqid = send_heartbeat_txn_range(txns); - recv_heartbeat_txn_range(_return, seqid); + int32_t seqid = send_compact2(rqst); + recv_compact2(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_heartbeat_txn_range(const HeartbeatTxnRangeRequest& txns) +int32_t ThriftHiveMetastoreConcurrentClient::send_compact2(const CompactionRequest& 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("compact2", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_heartbeat_txn_range_pargs args; - args.txns = &txns; + ThriftHiveMetastore_compact2_pargs args; + args.rqst = &rqst; args.write(oprot_); oprot_->writeMessageEnd(); @@ -76772,7 +78897,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_compact2(CompactionResponse& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -76801,7 +78926,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_heartbeat_txn_range(HeartbeatTxnR iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("heartbeat_txn_range") != 0) { + if (fname.compare("compact2") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -76810,7 +78935,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_compact2_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -76822,7 +78947,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, "compact2 failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -76832,19 +78957,19 @@ void ThriftHiveMetastoreConcurrentClient::recv_heartbeat_txn_range(HeartbeatTxnR } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::compact(const CompactionRequest& rqst) +void ThriftHiveMetastoreConcurrentClient::show_compact(ShowCompactResponse& _return, const ShowCompactRequest& rqst) { - int32_t seqid = send_compact(rqst); - recv_compact(seqid); + int32_t seqid = send_show_compact(rqst); + recv_show_compact(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_compact(const CompactionRequest& rqst) +int32_t ThriftHiveMetastoreConcurrentClient::send_show_compact(const ShowCompactRequest& 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("show_compact", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_compact_pargs args; + ThriftHiveMetastore_show_compact_pargs args; args.rqst = &rqst; args.write(oprot_); @@ -76856,7 +78981,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_compact(const CompactionReques return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_compact(const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_show_compact(ShowCompactResponse& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -76885,7 +79010,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_compact(const int32_t seqid) iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("compact") != 0) { + if (fname.compare("show_compact") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -76894,13 +79019,19 @@ void ThriftHiveMetastoreConcurrentClient::recv_compact(const int32_t seqid) using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_compact_presult result; + ThriftHiveMetastore_show_compact_presult result; + result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); - sentry.commit(); - return; + 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_compact failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -76910,19 +79041,19 @@ void ThriftHiveMetastoreConcurrentClient::recv_compact(const int32_t seqid) } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::compact2(CompactionResponse& _return, const CompactionRequest& rqst) +void ThriftHiveMetastoreConcurrentClient::add_dynamic_partitions(const AddDynamicPartitions& rqst) { - int32_t seqid = send_compact2(rqst); - recv_compact2(_return, seqid); + int32_t seqid = send_add_dynamic_partitions(rqst); + recv_add_dynamic_partitions(seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_compact2(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("compact2", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("add_dynamic_partitions", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_compact2_pargs args; + ThriftHiveMetastore_add_dynamic_partitions_pargs args; args.rqst = &rqst; args.write(oprot_); @@ -76934,7 +79065,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_compact2(const CompactionReque return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_compact2(CompactionResponse& _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_add_dynamic_partitions(const int32_t seqid) { int32_t rseqid = 0; @@ -76963,7 +79094,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_compact2(CompactionResponse& _ret iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("compact2") != 0) { + if (fname.compare("add_dynamic_partitions") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -76972,19 +79103,21 @@ void ThriftHiveMetastoreConcurrentClient::recv_compact2(CompactionResponse& _ret using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_compact2_presult result; - result.success = &_return; + ThriftHiveMetastore_add_dynamic_partitions_presult result; result.read(iprot_); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); - if (result.__isset.success) { - // _return pointer has now been filled + if (result.__isset.o1) { sentry.commit(); - return; + throw result.o1; } - // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "compact2 failed: unknown result"); + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + sentry.commit(); + return; } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -76994,19 +79127,19 @@ void ThriftHiveMetastoreConcurrentClient::recv_compact2(CompactionResponse& _ret } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::show_compact(ShowCompactResponse& _return, const ShowCompactRequest& rqst) +void ThriftHiveMetastoreConcurrentClient::get_next_notification(NotificationEventResponse& _return, const NotificationEventRequest& rqst) { - int32_t seqid = send_show_compact(rqst); - recv_show_compact(_return, seqid); + int32_t seqid = send_get_next_notification(rqst); + recv_get_next_notification(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_show_compact(const ShowCompactRequest& 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("show_compact", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("get_next_notification", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_show_compact_pargs args; + ThriftHiveMetastore_get_next_notification_pargs args; args.rqst = &rqst; args.write(oprot_); @@ -77018,7 +79151,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_next_notification(NotificationEventResponse& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -77047,7 +79180,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_show_compact(ShowCompactResponse& iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("show_compact") != 0) { + if (fname.compare("get_next_notification") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -77056,7 +79189,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_show_compact(ShowCompactResponse& using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_show_compact_presult result; + ThriftHiveMetastore_get_next_notification_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -77068,7 +79201,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_next_notification failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -77078,20 +79211,19 @@ void ThriftHiveMetastoreConcurrentClient::recv_show_compact(ShowCompactResponse& } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::add_dynamic_partitions(const AddDynamicPartitions& rqst) +void ThriftHiveMetastoreConcurrentClient::get_current_notificationEventId(CurrentNotificationEventId& _return) { - int32_t seqid = send_add_dynamic_partitions(rqst); - recv_add_dynamic_partitions(seqid); + int32_t seqid = send_get_current_notificationEventId(); + recv_get_current_notificationEventId(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_add_dynamic_partitions(const AddDynamicPartitions& rqst) +int32_t ThriftHiveMetastoreConcurrentClient::send_get_current_notificationEventId() { 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_current_notificationEventId", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_add_dynamic_partitions_pargs args; - args.rqst = &rqst; + ThriftHiveMetastore_get_current_notificationEventId_pargs args; args.write(oprot_); oprot_->writeMessageEnd(); @@ -77102,7 +79234,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_current_notificationEventId(CurrentNotificationEventId& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -77131,7 +79263,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_current_notificationEventId") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -77140,21 +79272,19 @@ 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_current_notificationEventId_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) { + if (result.__isset.success) { + // _return pointer has now been filled sentry.commit(); - throw result.o2; + return; } - sentry.commit(); - return; + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_current_notificationEventId failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -77164,19 +79294,19 @@ void ThriftHiveMetastoreConcurrentClient::recv_add_dynamic_partitions(const int3 } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::get_next_notification(NotificationEventResponse& _return, const NotificationEventRequest& rqst) +void ThriftHiveMetastoreConcurrentClient::get_notification_events_count(NotificationEventsCountResponse& _return, const NotificationEventsCountRequest& rqst) { - int32_t seqid = send_get_next_notification(rqst); - recv_get_next_notification(_return, seqid); + int32_t seqid = send_get_notification_events_count(rqst); + recv_get_notification_events_count(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_get_next_notification(const NotificationEventRequest& 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("get_next_notification", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("get_notification_events_count", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_get_next_notification_pargs args; + ThriftHiveMetastore_get_notification_events_count_pargs args; args.rqst = &rqst; args.write(oprot_); @@ -77188,7 +79318,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_get_notification_events_count(NotificationEventsCountResponse& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -77217,7 +79347,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_next_notification(Notificatio iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("get_next_notification") != 0) { + if (fname.compare("get_notification_events_count") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -77226,7 +79356,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_next_notification(Notificatio using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_get_next_notification_presult result; + ThriftHiveMetastore_get_notification_events_count_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -77238,7 +79368,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_next_notification(Notificatio return; } // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_next_notification failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_notification_events_count failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -77248,19 +79378,20 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_next_notification(Notificatio } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::get_current_notificationEventId(CurrentNotificationEventId& _return) +void ThriftHiveMetastoreConcurrentClient::fire_listener_event(FireEventResponse& _return, const FireEventRequest& rqst) { - int32_t seqid = send_get_current_notificationEventId(); - recv_get_current_notificationEventId(_return, seqid); + int32_t seqid = send_fire_listener_event(rqst); + recv_fire_listener_event(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_get_current_notificationEventId() +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("get_current_notificationEventId", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("fire_listener_event", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_get_current_notificationEventId_pargs args; + ThriftHiveMetastore_fire_listener_event_pargs args; + args.rqst = &rqst; args.write(oprot_); oprot_->writeMessageEnd(); @@ -77271,7 +79402,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_fire_listener_event(FireEventResponse& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -77300,7 +79431,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_current_notificationEventId(C iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("get_current_notificationEventId") != 0) { + if (fname.compare("fire_listener_event") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -77309,7 +79440,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_fire_listener_event_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -77321,7 +79452,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_current_notificationEventId(C return; } // 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, "fire_listener_event failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -77331,20 +79462,19 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_current_notificationEventId(C } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::get_notification_events_count(NotificationEventsCountResponse& _return, const NotificationEventsCountRequest& rqst) +void ThriftHiveMetastoreConcurrentClient::flushCache() { - int32_t seqid = send_get_notification_events_count(rqst); - recv_get_notification_events_count(_return, seqid); + int32_t seqid = send_flushCache(); + recv_flushCache(seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_get_notification_events_count(const NotificationEventsCountRequest& rqst) +int32_t ThriftHiveMetastoreConcurrentClient::send_flushCache() { 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("flushCache", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_get_notification_events_count_pargs args; - args.rqst = &rqst; + ThriftHiveMetastore_flushCache_pargs args; args.write(oprot_); oprot_->writeMessageEnd(); @@ -77355,7 +79485,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_flushCache(const int32_t seqid) { int32_t rseqid = 0; @@ -77384,7 +79514,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("flushCache") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -77393,7 +79523,85 @@ 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_flushCache_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + 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::cm_recycle(CmRecycleResponse& _return, const CmRecycleRequest& request) +{ + int32_t seqid = send_cm_recycle(request); + recv_cm_recycle(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_cm_recycle(const CmRecycleRequest& request) +{ + int32_t cseqid = this->sync_.generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); + oprot_->writeMessageBegin("cm_recycle", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_cm_recycle_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_cm_recycle(CmRecycleResponse& _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("cm_recycle") != 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_cm_recycle_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -77404,8 +79612,12 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_notification_events_count(Not 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_notification_events_count 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); @@ -77415,20 +79627,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_by_expr(GetFileMetadataByExprResult& _return, const GetFileMetadataByExprRequest& req) { - int32_t seqid = send_fire_listener_event(rqst); - recv_fire_listener_event(_return, seqid); + int32_t seqid = send_get_file_metadata_by_expr(req); + recv_get_file_metadata_by_expr(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_fire_listener_event(const FireEventRequest& 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("fire_listener_event", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("get_file_metadata_by_expr", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_fire_listener_event_pargs args; - args.rqst = &rqst; + ThriftHiveMetastore_get_file_metadata_by_expr_pargs args; + args.req = &req; args.write(oprot_); oprot_->writeMessageEnd(); @@ -77439,7 +79651,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_by_expr(GetFileMetadataByExprResult& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -77468,7 +79680,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_by_expr") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -77477,7 +79689,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_by_expr_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -77489,7 +79701,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"); + 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); @@ -77499,19 +79711,20 @@ void ThriftHiveMetastoreConcurrentClient::recv_fire_listener_event(FireEventResp } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::flushCache() +void ThriftHiveMetastoreConcurrentClient::get_file_metadata(GetFileMetadataResult& _return, const GetFileMetadataRequest& req) { - int32_t seqid = send_flushCache(); - recv_flushCache(seqid); + int32_t seqid = send_get_file_metadata(req); + recv_get_file_metadata(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_flushCache() +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("flushCache", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("get_file_metadata", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_flushCache_pargs args; + ThriftHiveMetastore_get_file_metadata_pargs args; + args.req = &req; args.write(oprot_); oprot_->writeMessageEnd(); @@ -77522,7 +79735,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_flushCache() return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_flushCache(const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_get_file_metadata(GetFileMetadataResult& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -77551,7 +79764,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_flushCache(const int32_t seqid) iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("flushCache") != 0) { + if (fname.compare("get_file_metadata") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -77560,13 +79773,19 @@ void ThriftHiveMetastoreConcurrentClient::recv_flushCache(const int32_t seqid) using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_flushCache_presult result; + ThriftHiveMetastore_get_file_metadata_presult result; + result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); - sentry.commit(); - return; + 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_file_metadata failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -77576,20 +79795,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(); @@ -77600,7 +79819,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; @@ -77629,7 +79848,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(); @@ -77638,7 +79857,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(); @@ -77649,12 +79868,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); @@ -77664,19 +79879,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_); @@ -77688,7 +79903,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; @@ -77717,7 +79932,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(); @@ -77726,7 +79941,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(); @@ -77738,7 +79953,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); @@ -77748,19 +79963,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_); @@ -77772,7 +79987,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; @@ -77801,7 +80016,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(); @@ -77810,7 +80025,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(); @@ -77822,7 +80037,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); @@ -77832,20 +80047,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(); @@ -77856,7 +80070,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; @@ -77885,7 +80099,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(); @@ -77894,7 +80108,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(); @@ -77905,8 +80119,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); @@ -77916,20 +80134,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(); @@ -77940,7 +80158,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; @@ -77969,7 +80187,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(); @@ -77978,7 +80196,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(); @@ -77989,8 +80207,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); @@ -78000,20 +80230,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(); @@ -78024,7 +80254,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; @@ -78053,7 +80283,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(); @@ -78062,7 +80292,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(); @@ -78073,8 +80303,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); @@ -78084,19 +80322,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(); @@ -78107,7 +80346,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; @@ -78136,7 +80375,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(); @@ -78145,7 +80384,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(); @@ -78161,7 +80400,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); @@ -78171,19 +80410,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_); @@ -78195,7 +80434,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; @@ -78224,7 +80463,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(); @@ -78233,7 +80472,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(); @@ -78257,7 +80496,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); @@ -78267,19 +80506,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_); @@ -78291,7 +80530,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; @@ -78320,7 +80559,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(); @@ -78329,7 +80568,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(); @@ -78349,7 +80588,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); @@ -78359,19 +80598,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_); @@ -78383,7 +80622,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; @@ -78412,7 +80651,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(); @@ -78421,7 +80660,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(); @@ -78436,8 +80675,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); @@ -78447,19 +80694,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_); @@ -78471,7 +80718,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; @@ -78500,7 +80747,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(); @@ -78509,7 +80756,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(); @@ -78532,8 +80779,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); @@ -78543,19 +80794,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_); @@ -78567,7 +80818,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; @@ -78596,7 +80847,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(); @@ -78605,7 +80856,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(); @@ -78624,8 +80875,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); @@ -78635,19 +80890,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_); @@ -78659,7 +80914,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; @@ -78688,7 +80943,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(); @@ -78697,7 +80952,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(); @@ -78721,7 +80976,7 @@ 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); @@ -78731,19 +80986,19 @@ void ThriftHiveMetastoreConcurrentClient::recv_drop_resource_plan(WMDropResource } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::create_wm_trigger(WMCreateTriggerResponse& _return, const WMCreateTriggerRequest& request) +void ThriftHiveMetastoreConcurrentClient::get_triggers_for_resourceplan(WMGetTriggersForResourePlanResponse& _return, const WMGetTriggersForResourePlanRequest& request) { - int32_t seqid = send_create_wm_trigger(request); - recv_create_wm_trigger(_return, seqid); + int32_t seqid = send_get_triggers_for_resourceplan(request); + recv_get_triggers_for_resourceplan(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_create_wm_trigger(const WMCreateTriggerRequest& request) +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("create_wm_trigger", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("get_triggers_for_resourceplan", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_create_wm_trigger_pargs args; + ThriftHiveMetastore_get_triggers_for_resourceplan_pargs args; args.request = &request; args.write(oprot_); @@ -78755,7 +81010,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_create_wm_trigger(const WMCrea return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_create_wm_trigger(WMCreateTriggerResponse& _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_get_triggers_for_resourceplan(WMGetTriggersForResourePlanResponse& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -78784,7 +81039,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_create_wm_trigger(WMCreateTrigger iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("create_wm_trigger") != 0) { + if (fname.compare("get_triggers_for_resourceplan") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -78793,7 +81048,99 @@ void ThriftHiveMetastoreConcurrentClient::recv_create_wm_trigger(WMCreateTrigger using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_create_wm_trigger_presult result; + 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); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_.waitForWork(seqid); + } // end while(true) +} + +void ThriftHiveMetastoreConcurrentClient::create_or_update_wm_pool(WMCreateOrUpdatePoolResponse& _return, const WMCreateOrUpdatePoolRequest& request) +{ + int32_t seqid = send_create_or_update_wm_pool(request); + recv_create_or_update_wm_pool(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_create_or_update_wm_pool(const WMCreateOrUpdatePoolRequest& request) +{ + int32_t cseqid = this->sync_.generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); + oprot_->writeMessageBegin("create_or_update_wm_pool", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_create_or_update_wm_pool_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_create_or_update_wm_pool(WMCreateOrUpdatePoolResponse& _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("create_or_update_wm_pool") != 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_create_or_update_wm_pool_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -78821,7 +81168,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_create_wm_trigger(WMCreateTrigger throw result.o4; } // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "create_wm_trigger failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "create_or_update_wm_pool failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -78831,19 +81178,19 @@ void ThriftHiveMetastoreConcurrentClient::recv_create_wm_trigger(WMCreateTrigger } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::alter_wm_trigger(WMAlterTriggerResponse& _return, const WMAlterTriggerRequest& request) +void ThriftHiveMetastoreConcurrentClient::drop_wm_pool(WMDropPoolResponse& _return, const WMDropPoolRequest& request) { - int32_t seqid = send_alter_wm_trigger(request); - recv_alter_wm_trigger(_return, seqid); + int32_t seqid = send_drop_wm_pool(request); + recv_drop_wm_pool(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_alter_wm_trigger(const WMAlterTriggerRequest& request) +int32_t ThriftHiveMetastoreConcurrentClient::send_drop_wm_pool(const WMDropPoolRequest& request) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("alter_wm_trigger", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("drop_wm_pool", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_alter_wm_trigger_pargs args; + ThriftHiveMetastore_drop_wm_pool_pargs args; args.request = &request; args.write(oprot_); @@ -78855,7 +81202,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_alter_wm_trigger(const WMAlter return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_alter_wm_trigger(WMAlterTriggerResponse& _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_drop_wm_pool(WMDropPoolResponse& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -78884,7 +81231,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_alter_wm_trigger(WMAlterTriggerRe iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("alter_wm_trigger") != 0) { + if (fname.compare("drop_wm_pool") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -78893,7 +81240,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_alter_wm_trigger(WMAlterTriggerRe using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_alter_wm_trigger_presult result; + ThriftHiveMetastore_drop_wm_pool_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -78917,7 +81264,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_alter_wm_trigger(WMAlterTriggerRe throw result.o3; } // in a bad state, don't commit - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "alter_wm_trigger failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "drop_wm_pool failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -78927,19 +81274,19 @@ void ThriftHiveMetastoreConcurrentClient::recv_alter_wm_trigger(WMAlterTriggerRe } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::drop_wm_trigger(WMDropTriggerResponse& _return, const WMDropTriggerRequest& request) +void ThriftHiveMetastoreConcurrentClient::create_or_update_wm_mapping(WMCreateOrUpdateMappingResponse& _return, const WMCreateOrUpdateMappingRequest& request) { - int32_t seqid = send_drop_wm_trigger(request); - recv_drop_wm_trigger(_return, seqid); + int32_t seqid = send_create_or_update_wm_mapping(request); + recv_create_or_update_wm_mapping(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_drop_wm_trigger(const WMDropTriggerRequest& request) +int32_t ThriftHiveMetastoreConcurrentClient::send_create_or_update_wm_mapping(const WMCreateOrUpdateMappingRequest& request) { int32_t cseqid = this->sync_.generateSeqId(); ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); - oprot_->writeMessageBegin("drop_wm_trigger", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("create_or_update_wm_mapping", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_drop_wm_trigger_pargs args; + ThriftHiveMetastore_create_or_update_wm_mapping_pargs args; args.request = &request; args.write(oprot_); @@ -78951,7 +81298,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_drop_wm_trigger(const WMDropTr return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_drop_wm_trigger(WMDropTriggerResponse& _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_create_or_update_wm_mapping(WMCreateOrUpdateMappingResponse& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -78980,7 +81327,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_drop_wm_trigger(WMDropTriggerResp iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("drop_wm_trigger") != 0) { + if (fname.compare("create_or_update_wm_mapping") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -78989,7 +81336,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_drop_wm_trigger(WMDropTriggerResp using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_drop_wm_trigger_presult result; + ThriftHiveMetastore_create_or_update_wm_mapping_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -79012,8 +81359,12 @@ void ThriftHiveMetastoreConcurrentClient::recv_drop_wm_trigger(WMDropTriggerResp 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, "drop_wm_trigger failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "create_or_update_wm_mapping failed: unknown result"); } // seqid != rseqid this->sync_.updatePending(fname, mtype, rseqid); @@ -79023,19 +81374,19 @@ void ThriftHiveMetastoreConcurrentClient::recv_drop_wm_trigger(WMDropTriggerResp } // end while(true) } -void ThriftHiveMetastoreConcurrentClient::get_triggers_for_resourceplan(WMGetTriggersForResourePlanResponse& _return, const WMGetTriggersForResourePlanRequest& request) +void ThriftHiveMetastoreConcurrentClient::drop_wm_mapping(WMDropMappingResponse& _return, const WMDropMappingRequest& request) { - int32_t seqid = send_get_triggers_for_resourceplan(request); - recv_get_triggers_for_resourceplan(_return, seqid); + int32_t seqid = send_drop_wm_mapping(request); + recv_drop_wm_mapping(_return, seqid); } -int32_t ThriftHiveMetastoreConcurrentClient::send_get_triggers_for_resourceplan(const WMGetTriggersForResourePlanRequest& request) +int32_t ThriftHiveMetastoreConcurrentClient::send_drop_wm_mapping(const WMDropMappingRequest& 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); + oprot_->writeMessageBegin("drop_wm_mapping", ::apache::thrift::protocol::T_CALL, cseqid); - ThriftHiveMetastore_get_triggers_for_resourceplan_pargs args; + ThriftHiveMetastore_drop_wm_mapping_pargs args; args.request = &request; args.write(oprot_); @@ -79047,7 +81398,7 @@ int32_t ThriftHiveMetastoreConcurrentClient::send_get_triggers_for_resourceplan( return cseqid; } -void ThriftHiveMetastoreConcurrentClient::recv_get_triggers_for_resourceplan(WMGetTriggersForResourePlanResponse& _return, const int32_t seqid) +void ThriftHiveMetastoreConcurrentClient::recv_drop_wm_mapping(WMDropMappingResponse& _return, const int32_t seqid) { int32_t rseqid = 0; @@ -79076,7 +81427,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_triggers_for_resourceplan(WMG iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("get_triggers_for_resourceplan") != 0) { + if (fname.compare("drop_wm_mapping") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); @@ -79085,7 +81436,7 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_triggers_for_resourceplan(WMG using ::apache::thrift::protocol::TProtocolException; throw TProtocolException(TProtocolException::INVALID_DATA); } - ThriftHiveMetastore_get_triggers_for_resourceplan_presult result; + ThriftHiveMetastore_drop_wm_mapping_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -79104,8 +81455,112 @@ void ThriftHiveMetastoreConcurrentClient::recv_get_triggers_for_resourceplan(WMG 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_triggers_for_resourceplan failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "drop_wm_mapping 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::create_or_drop_wm_trigger_to_pool_mapping(WMCreateOrDropTriggerToPoolMappingResponse& _return, const WMCreateOrDropTriggerToPoolMappingRequest& request) +{ + int32_t seqid = send_create_or_drop_wm_trigger_to_pool_mapping(request); + recv_create_or_drop_wm_trigger_to_pool_mapping(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_create_or_drop_wm_trigger_to_pool_mapping(const WMCreateOrDropTriggerToPoolMappingRequest& request) +{ + int32_t cseqid = this->sync_.generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); + oprot_->writeMessageBegin("create_or_drop_wm_trigger_to_pool_mapping", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_create_or_drop_wm_trigger_to_pool_mapping(WMCreateOrDropTriggerToPoolMappingResponse& _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("create_or_drop_wm_trigger_to_pool_mapping") != 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_create_or_drop_wm_trigger_to_pool_mapping_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + 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, "create_or_drop_wm_trigger_to_pool_mapping 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 bea7b4b907..103bf75619 100644 --- standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h +++ standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h @@ -194,6 +194,11 @@ class ThriftHiveMetastoreIf : virtual public ::facebook::fb303::FacebookService 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; + virtual void create_or_update_wm_pool(WMCreateOrUpdatePoolResponse& _return, const WMCreateOrUpdatePoolRequest& request) = 0; + virtual void drop_wm_pool(WMDropPoolResponse& _return, const WMDropPoolRequest& request) = 0; + virtual void create_or_update_wm_mapping(WMCreateOrUpdateMappingResponse& _return, const WMCreateOrUpdateMappingRequest& request) = 0; + virtual void drop_wm_mapping(WMDropMappingResponse& _return, const WMDropMappingRequest& request) = 0; + virtual void create_or_drop_wm_trigger_to_pool_mapping(WMCreateOrDropTriggerToPoolMappingResponse& _return, const WMCreateOrDropTriggerToPoolMappingRequest& request) = 0; }; class ThriftHiveMetastoreIfFactory : virtual public ::facebook::fb303::FacebookServiceIfFactory { @@ -767,6 +772,21 @@ class ThriftHiveMetastoreNull : virtual public ThriftHiveMetastoreIf , virtual p void get_triggers_for_resourceplan(WMGetTriggersForResourePlanResponse& /* _return */, const WMGetTriggersForResourePlanRequest& /* request */) { return; } + void create_or_update_wm_pool(WMCreateOrUpdatePoolResponse& /* _return */, const WMCreateOrUpdatePoolRequest& /* request */) { + return; + } + void drop_wm_pool(WMDropPoolResponse& /* _return */, const WMDropPoolRequest& /* request */) { + return; + } + void create_or_update_wm_mapping(WMCreateOrUpdateMappingResponse& /* _return */, const WMCreateOrUpdateMappingRequest& /* request */) { + return; + } + void drop_wm_mapping(WMDropMappingResponse& /* _return */, const WMDropMappingRequest& /* request */) { + return; + } + void create_or_drop_wm_trigger_to_pool_mapping(WMCreateOrDropTriggerToPoolMappingResponse& /* _return */, const WMCreateOrDropTriggerToPoolMappingRequest& /* request */) { + return; + } }; typedef struct _ThriftHiveMetastore_getMetaConf_args__isset { @@ -21965,244 +21985,908 @@ class ThriftHiveMetastore_get_triggers_for_resourceplan_presult { }; -class ThriftHiveMetastoreClient : virtual public ThriftHiveMetastoreIf, public ::facebook::fb303::FacebookServiceClient { +typedef struct _ThriftHiveMetastore_create_or_update_wm_pool_args__isset { + _ThriftHiveMetastore_create_or_update_wm_pool_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_create_or_update_wm_pool_args__isset; + +class ThriftHiveMetastore_create_or_update_wm_pool_args { public: - ThriftHiveMetastoreClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) : - ::facebook::fb303::FacebookServiceClient(prot, prot) {} - ThriftHiveMetastoreClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) : ::facebook::fb303::FacebookServiceClient(iprot, oprot) {} - boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() { - return piprot_; + + ThriftHiveMetastore_create_or_update_wm_pool_args(const ThriftHiveMetastore_create_or_update_wm_pool_args&); + ThriftHiveMetastore_create_or_update_wm_pool_args& operator=(const ThriftHiveMetastore_create_or_update_wm_pool_args&); + ThriftHiveMetastore_create_or_update_wm_pool_args() { } - boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() { - return poprot_; + + virtual ~ThriftHiveMetastore_create_or_update_wm_pool_args() throw(); + WMCreateOrUpdatePoolRequest request; + + _ThriftHiveMetastore_create_or_update_wm_pool_args__isset __isset; + + void __set_request(const WMCreateOrUpdatePoolRequest& val); + + bool operator == (const ThriftHiveMetastore_create_or_update_wm_pool_args & rhs) const + { + if (!(request == rhs.request)) + return false; + return true; } - void getMetaConf(std::string& _return, const std::string& key); - void send_getMetaConf(const std::string& key); - void recv_getMetaConf(std::string& _return); - void setMetaConf(const std::string& key, const std::string& value); - void send_setMetaConf(const std::string& key, const std::string& value); - void recv_setMetaConf(); - void create_database(const Database& database); - void send_create_database(const Database& database); - void recv_create_database(); - void get_database(Database& _return, const std::string& name); - void send_get_database(const std::string& name); - void recv_get_database(Database& _return); - void drop_database(const std::string& name, const bool deleteData, const bool cascade); - void send_drop_database(const std::string& name, const bool deleteData, const bool cascade); - void recv_drop_database(); - void get_databases(std::vector & _return, const std::string& pattern); - void send_get_databases(const std::string& pattern); - void recv_get_databases(std::vector & _return); - void get_all_databases(std::vector & _return); - void send_get_all_databases(); - void recv_get_all_databases(std::vector & _return); - void alter_database(const std::string& dbname, const Database& db); - void send_alter_database(const std::string& dbname, const Database& db); - void recv_alter_database(); - void get_type(Type& _return, const std::string& name); - void send_get_type(const std::string& name); - void recv_get_type(Type& _return); - bool create_type(const Type& type); - void send_create_type(const Type& type); - bool recv_create_type(); - bool drop_type(const std::string& type); - void send_drop_type(const std::string& type); - bool recv_drop_type(); - void get_type_all(std::map & _return, const std::string& name); - void send_get_type_all(const std::string& name); - void recv_get_type_all(std::map & _return); - void get_fields(std::vector & _return, const std::string& db_name, const std::string& table_name); - void send_get_fields(const std::string& db_name, const std::string& table_name); - void recv_get_fields(std::vector & _return); - void get_fields_with_environment_context(std::vector & _return, const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context); - void send_get_fields_with_environment_context(const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context); - void recv_get_fields_with_environment_context(std::vector & _return); - void get_schema(std::vector & _return, const std::string& db_name, const std::string& table_name); - void send_get_schema(const std::string& db_name, const std::string& table_name); - void recv_get_schema(std::vector & _return); - void get_schema_with_environment_context(std::vector & _return, const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context); - void send_get_schema_with_environment_context(const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context); - void recv_get_schema_with_environment_context(std::vector & _return); - void create_table(const Table& tbl); - void send_create_table(const Table& tbl); - void recv_create_table(); - void create_table_with_environment_context(const Table& tbl, const EnvironmentContext& environment_context); - void send_create_table_with_environment_context(const Table& tbl, const EnvironmentContext& environment_context); - void recv_create_table_with_environment_context(); - void create_table_with_constraints(const Table& tbl, const std::vector & primaryKeys, const std::vector & foreignKeys, const std::vector & uniqueConstraints, const std::vector & notNullConstraints); - void send_create_table_with_constraints(const Table& tbl, const std::vector & primaryKeys, const std::vector & foreignKeys, const std::vector & uniqueConstraints, const std::vector & notNullConstraints); - void recv_create_table_with_constraints(); - void drop_constraint(const DropConstraintRequest& req); - void send_drop_constraint(const DropConstraintRequest& req); - void recv_drop_constraint(); - void add_primary_key(const AddPrimaryKeyRequest& req); - void send_add_primary_key(const AddPrimaryKeyRequest& req); - void recv_add_primary_key(); - void add_foreign_key(const AddForeignKeyRequest& req); - void send_add_foreign_key(const AddForeignKeyRequest& req); - void recv_add_foreign_key(); - void add_unique_constraint(const AddUniqueConstraintRequest& req); - void send_add_unique_constraint(const AddUniqueConstraintRequest& req); - void recv_add_unique_constraint(); - void add_not_null_constraint(const AddNotNullConstraintRequest& req); - void send_add_not_null_constraint(const AddNotNullConstraintRequest& req); - void recv_add_not_null_constraint(); - void drop_table(const std::string& dbname, const std::string& name, const bool deleteData); - void send_drop_table(const std::string& dbname, const std::string& name, const bool deleteData); - void recv_drop_table(); - void drop_table_with_environment_context(const std::string& dbname, const std::string& name, const bool deleteData, const EnvironmentContext& environment_context); - void send_drop_table_with_environment_context(const std::string& dbname, const std::string& name, const bool deleteData, const EnvironmentContext& environment_context); - void recv_drop_table_with_environment_context(); - void truncate_table(const std::string& dbName, const std::string& tableName, const std::vector & partNames); - void send_truncate_table(const std::string& dbName, const std::string& tableName, const std::vector & partNames); - void recv_truncate_table(); - void get_tables(std::vector & _return, const std::string& db_name, const std::string& pattern); - void send_get_tables(const std::string& db_name, const std::string& pattern); - void recv_get_tables(std::vector & _return); - void get_tables_by_type(std::vector & _return, const std::string& db_name, const std::string& pattern, const std::string& tableType); - void send_get_tables_by_type(const std::string& db_name, const std::string& pattern, const std::string& tableType); - void recv_get_tables_by_type(std::vector & _return); - void get_table_meta(std::vector & _return, const std::string& db_patterns, const std::string& tbl_patterns, const std::vector & tbl_types); - void send_get_table_meta(const std::string& db_patterns, const std::string& tbl_patterns, const std::vector & tbl_types); - void recv_get_table_meta(std::vector & _return); - void get_all_tables(std::vector & _return, const std::string& db_name); - void send_get_all_tables(const std::string& db_name); - void recv_get_all_tables(std::vector & _return); - void get_table(Table& _return, const std::string& dbname, const std::string& tbl_name); - void send_get_table(const std::string& dbname, const std::string& tbl_name); - void recv_get_table(Table& _return); - void get_table_objects_by_name(std::vector
& _return, const std::string& dbname, const std::vector & tbl_names); - void send_get_table_objects_by_name(const std::string& dbname, const std::vector & tbl_names); - void recv_get_table_objects_by_name(std::vector
& _return); - void get_table_req(GetTableResult& _return, const GetTableRequest& req); - void send_get_table_req(const GetTableRequest& req); - void recv_get_table_req(GetTableResult& _return); - void get_table_objects_by_name_req(GetTablesResult& _return, const GetTablesRequest& req); - void send_get_table_objects_by_name_req(const GetTablesRequest& req); - void recv_get_table_objects_by_name_req(GetTablesResult& _return); - void get_table_names_by_filter(std::vector & _return, const std::string& dbname, const std::string& filter, const int16_t max_tables); - void send_get_table_names_by_filter(const std::string& dbname, const std::string& filter, const int16_t max_tables); - void recv_get_table_names_by_filter(std::vector & _return); - void alter_table(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl); - void send_alter_table(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl); - void recv_alter_table(); - void alter_table_with_environment_context(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const EnvironmentContext& environment_context); - void send_alter_table_with_environment_context(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const EnvironmentContext& environment_context); - void recv_alter_table_with_environment_context(); - void alter_table_with_cascade(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const bool cascade); - void send_alter_table_with_cascade(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const bool cascade); - void recv_alter_table_with_cascade(); - void add_partition(Partition& _return, const Partition& new_part); - void send_add_partition(const Partition& new_part); - void recv_add_partition(Partition& _return); - void add_partition_with_environment_context(Partition& _return, const Partition& new_part, const EnvironmentContext& environment_context); - void send_add_partition_with_environment_context(const Partition& new_part, const EnvironmentContext& environment_context); - void recv_add_partition_with_environment_context(Partition& _return); - int32_t add_partitions(const std::vector & new_parts); - void send_add_partitions(const std::vector & new_parts); - int32_t recv_add_partitions(); - int32_t add_partitions_pspec(const std::vector & new_parts); - void send_add_partitions_pspec(const std::vector & new_parts); - int32_t recv_add_partitions_pspec(); - void append_partition(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals); - void send_append_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals); - void recv_append_partition(Partition& _return); - void add_partitions_req(AddPartitionsResult& _return, const AddPartitionsRequest& request); - void send_add_partitions_req(const AddPartitionsRequest& request); - void recv_add_partitions_req(AddPartitionsResult& _return); - void append_partition_with_environment_context(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const EnvironmentContext& environment_context); - void send_append_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const EnvironmentContext& environment_context); - void recv_append_partition_with_environment_context(Partition& _return); - void append_partition_by_name(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name); - void send_append_partition_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& part_name); - void recv_append_partition_by_name(Partition& _return); - void append_partition_by_name_with_environment_context(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const EnvironmentContext& environment_context); - void send_append_partition_by_name_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const EnvironmentContext& environment_context); - void recv_append_partition_by_name_with_environment_context(Partition& _return); - bool drop_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const bool deleteData); - void send_drop_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const bool deleteData); - bool recv_drop_partition(); - bool drop_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const bool deleteData, const EnvironmentContext& environment_context); - void send_drop_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const bool deleteData, const EnvironmentContext& environment_context); - bool recv_drop_partition_with_environment_context(); - bool drop_partition_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const bool deleteData); - void send_drop_partition_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const bool deleteData); - bool recv_drop_partition_by_name(); - bool drop_partition_by_name_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const bool deleteData, const EnvironmentContext& environment_context); - void send_drop_partition_by_name_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const bool deleteData, const EnvironmentContext& environment_context); - bool recv_drop_partition_by_name_with_environment_context(); - void drop_partitions_req(DropPartitionsResult& _return, const DropPartitionsRequest& req); - void send_drop_partitions_req(const DropPartitionsRequest& req); - void recv_drop_partitions_req(DropPartitionsResult& _return); - void get_partition(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals); - void send_get_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals); - void recv_get_partition(Partition& _return); - void exchange_partition(Partition& _return, const std::map & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name); - void send_exchange_partition(const std::map & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name); - void recv_exchange_partition(Partition& _return); - void exchange_partitions(std::vector & _return, const std::map & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name); - void send_exchange_partitions(const std::map & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name); - void recv_exchange_partitions(std::vector & _return); - void get_partition_with_auth(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const std::string& user_name, const std::vector & group_names); - void send_get_partition_with_auth(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const std::string& user_name, const std::vector & group_names); - void recv_get_partition_with_auth(Partition& _return); - void get_partition_by_name(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name); - void send_get_partition_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& part_name); - void recv_get_partition_by_name(Partition& _return); - void get_partitions(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const int16_t max_parts); - void send_get_partitions(const std::string& db_name, const std::string& tbl_name, const int16_t max_parts); - void recv_get_partitions(std::vector & _return); - void get_partitions_with_auth(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const int16_t max_parts, const std::string& user_name, const std::vector & group_names); - void send_get_partitions_with_auth(const std::string& db_name, const std::string& tbl_name, const int16_t max_parts, const std::string& user_name, const std::vector & group_names); - void recv_get_partitions_with_auth(std::vector & _return); - void get_partitions_pspec(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const int32_t max_parts); - void send_get_partitions_pspec(const std::string& db_name, const std::string& tbl_name, const int32_t max_parts); - void recv_get_partitions_pspec(std::vector & _return); - void get_partition_names(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const int16_t max_parts); - void send_get_partition_names(const std::string& db_name, const std::string& tbl_name, const int16_t max_parts); - void recv_get_partition_names(std::vector & _return); - void get_partition_values(PartitionValuesResponse& _return, const PartitionValuesRequest& request); - void send_get_partition_values(const PartitionValuesRequest& request); - void recv_get_partition_values(PartitionValuesResponse& _return); - void get_partitions_ps(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const int16_t max_parts); - void send_get_partitions_ps(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const int16_t max_parts); - void recv_get_partitions_ps(std::vector & _return); - void get_partitions_ps_with_auth(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const int16_t max_parts, const std::string& user_name, const std::vector & group_names); - void send_get_partitions_ps_with_auth(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const int16_t max_parts, const std::string& user_name, const std::vector & group_names); - void recv_get_partitions_ps_with_auth(std::vector & _return); - void get_partition_names_ps(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const int16_t max_parts); - void send_get_partition_names_ps(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const int16_t max_parts); - void recv_get_partition_names_ps(std::vector & _return); - void get_partitions_by_filter(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::string& filter, const int16_t max_parts); - void send_get_partitions_by_filter(const std::string& db_name, const std::string& tbl_name, const std::string& filter, const int16_t max_parts); - void recv_get_partitions_by_filter(std::vector & _return); - void get_part_specs_by_filter(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::string& filter, const int32_t max_parts); - void send_get_part_specs_by_filter(const std::string& db_name, const std::string& tbl_name, const std::string& filter, const int32_t max_parts); - void recv_get_part_specs_by_filter(std::vector & _return); - void get_partitions_by_expr(PartitionsByExprResult& _return, const PartitionsByExprRequest& req); - void send_get_partitions_by_expr(const PartitionsByExprRequest& req); - void recv_get_partitions_by_expr(PartitionsByExprResult& _return); - int32_t get_num_partitions_by_filter(const std::string& db_name, const std::string& tbl_name, const std::string& filter); - void send_get_num_partitions_by_filter(const std::string& db_name, const std::string& tbl_name, const std::string& filter); - int32_t recv_get_num_partitions_by_filter(); - void get_partitions_by_names(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::vector & names); - void send_get_partitions_by_names(const std::string& db_name, const std::string& tbl_name, const std::vector & names); - void recv_get_partitions_by_names(std::vector & _return); - void alter_partition(const std::string& db_name, const std::string& tbl_name, const Partition& new_part); - void send_alter_partition(const std::string& db_name, const std::string& tbl_name, const Partition& new_part); - void recv_alter_partition(); - void alter_partitions(const std::string& db_name, const std::string& tbl_name, const std::vector & new_parts); - void send_alter_partitions(const std::string& db_name, const std::string& tbl_name, const std::vector & new_parts); - void recv_alter_partitions(); - void alter_partitions_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector & new_parts, const EnvironmentContext& environment_context); - void send_alter_partitions_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector & new_parts, const EnvironmentContext& environment_context); - void recv_alter_partitions_with_environment_context(); - void alter_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const Partition& new_part, const EnvironmentContext& environment_context); - void send_alter_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const Partition& new_part, const EnvironmentContext& environment_context); - void recv_alter_partition_with_environment_context(); - void rename_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const Partition& new_part); - void send_rename_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const Partition& new_part); + bool operator != (const ThriftHiveMetastore_create_or_update_wm_pool_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_create_or_update_wm_pool_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_create_or_update_wm_pool_pargs { + public: + + + virtual ~ThriftHiveMetastore_create_or_update_wm_pool_pargs() throw(); + const WMCreateOrUpdatePoolRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_create_or_update_wm_pool_result__isset { + _ThriftHiveMetastore_create_or_update_wm_pool_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_or_update_wm_pool_result__isset; + +class ThriftHiveMetastore_create_or_update_wm_pool_result { + public: + + ThriftHiveMetastore_create_or_update_wm_pool_result(const ThriftHiveMetastore_create_or_update_wm_pool_result&); + ThriftHiveMetastore_create_or_update_wm_pool_result& operator=(const ThriftHiveMetastore_create_or_update_wm_pool_result&); + ThriftHiveMetastore_create_or_update_wm_pool_result() { + } + + virtual ~ThriftHiveMetastore_create_or_update_wm_pool_result() throw(); + WMCreateOrUpdatePoolResponse success; + AlreadyExistsException o1; + NoSuchObjectException o2; + InvalidObjectException o3; + MetaException o4; + + _ThriftHiveMetastore_create_or_update_wm_pool_result__isset __isset; + + void __set_success(const WMCreateOrUpdatePoolResponse& 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_or_update_wm_pool_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_or_update_wm_pool_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_create_or_update_wm_pool_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_create_or_update_wm_pool_presult__isset { + _ThriftHiveMetastore_create_or_update_wm_pool_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_or_update_wm_pool_presult__isset; + +class ThriftHiveMetastore_create_or_update_wm_pool_presult { + public: + + + virtual ~ThriftHiveMetastore_create_or_update_wm_pool_presult() throw(); + WMCreateOrUpdatePoolResponse* success; + AlreadyExistsException o1; + NoSuchObjectException o2; + InvalidObjectException o3; + MetaException o4; + + _ThriftHiveMetastore_create_or_update_wm_pool_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_drop_wm_pool_args__isset { + _ThriftHiveMetastore_drop_wm_pool_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_drop_wm_pool_args__isset; + +class ThriftHiveMetastore_drop_wm_pool_args { + public: + + ThriftHiveMetastore_drop_wm_pool_args(const ThriftHiveMetastore_drop_wm_pool_args&); + ThriftHiveMetastore_drop_wm_pool_args& operator=(const ThriftHiveMetastore_drop_wm_pool_args&); + ThriftHiveMetastore_drop_wm_pool_args() { + } + + virtual ~ThriftHiveMetastore_drop_wm_pool_args() throw(); + WMDropPoolRequest request; + + _ThriftHiveMetastore_drop_wm_pool_args__isset __isset; + + void __set_request(const WMDropPoolRequest& val); + + bool operator == (const ThriftHiveMetastore_drop_wm_pool_args & rhs) const + { + if (!(request == rhs.request)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_drop_wm_pool_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_wm_pool_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_drop_wm_pool_pargs { + public: + + + virtual ~ThriftHiveMetastore_drop_wm_pool_pargs() throw(); + const WMDropPoolRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_wm_pool_result__isset { + _ThriftHiveMetastore_drop_wm_pool_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_pool_result__isset; + +class ThriftHiveMetastore_drop_wm_pool_result { + public: + + ThriftHiveMetastore_drop_wm_pool_result(const ThriftHiveMetastore_drop_wm_pool_result&); + ThriftHiveMetastore_drop_wm_pool_result& operator=(const ThriftHiveMetastore_drop_wm_pool_result&); + ThriftHiveMetastore_drop_wm_pool_result() { + } + + virtual ~ThriftHiveMetastore_drop_wm_pool_result() throw(); + WMDropPoolResponse success; + NoSuchObjectException o1; + InvalidOperationException o2; + MetaException o3; + + _ThriftHiveMetastore_drop_wm_pool_result__isset __isset; + + void __set_success(const WMDropPoolResponse& 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_pool_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_pool_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_wm_pool_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_wm_pool_presult__isset { + _ThriftHiveMetastore_drop_wm_pool_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_pool_presult__isset; + +class ThriftHiveMetastore_drop_wm_pool_presult { + public: + + + virtual ~ThriftHiveMetastore_drop_wm_pool_presult() throw(); + WMDropPoolResponse* success; + NoSuchObjectException o1; + InvalidOperationException o2; + MetaException o3; + + _ThriftHiveMetastore_drop_wm_pool_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_create_or_update_wm_mapping_args__isset { + _ThriftHiveMetastore_create_or_update_wm_mapping_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_create_or_update_wm_mapping_args__isset; + +class ThriftHiveMetastore_create_or_update_wm_mapping_args { + public: + + ThriftHiveMetastore_create_or_update_wm_mapping_args(const ThriftHiveMetastore_create_or_update_wm_mapping_args&); + ThriftHiveMetastore_create_or_update_wm_mapping_args& operator=(const ThriftHiveMetastore_create_or_update_wm_mapping_args&); + ThriftHiveMetastore_create_or_update_wm_mapping_args() { + } + + virtual ~ThriftHiveMetastore_create_or_update_wm_mapping_args() throw(); + WMCreateOrUpdateMappingRequest request; + + _ThriftHiveMetastore_create_or_update_wm_mapping_args__isset __isset; + + void __set_request(const WMCreateOrUpdateMappingRequest& val); + + bool operator == (const ThriftHiveMetastore_create_or_update_wm_mapping_args & rhs) const + { + if (!(request == rhs.request)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_create_or_update_wm_mapping_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_create_or_update_wm_mapping_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_create_or_update_wm_mapping_pargs { + public: + + + virtual ~ThriftHiveMetastore_create_or_update_wm_mapping_pargs() throw(); + const WMCreateOrUpdateMappingRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_create_or_update_wm_mapping_result__isset { + _ThriftHiveMetastore_create_or_update_wm_mapping_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_or_update_wm_mapping_result__isset; + +class ThriftHiveMetastore_create_or_update_wm_mapping_result { + public: + + ThriftHiveMetastore_create_or_update_wm_mapping_result(const ThriftHiveMetastore_create_or_update_wm_mapping_result&); + ThriftHiveMetastore_create_or_update_wm_mapping_result& operator=(const ThriftHiveMetastore_create_or_update_wm_mapping_result&); + ThriftHiveMetastore_create_or_update_wm_mapping_result() { + } + + virtual ~ThriftHiveMetastore_create_or_update_wm_mapping_result() throw(); + WMCreateOrUpdateMappingResponse success; + AlreadyExistsException o1; + NoSuchObjectException o2; + InvalidObjectException o3; + MetaException o4; + + _ThriftHiveMetastore_create_or_update_wm_mapping_result__isset __isset; + + void __set_success(const WMCreateOrUpdateMappingResponse& 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_or_update_wm_mapping_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_or_update_wm_mapping_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_create_or_update_wm_mapping_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_create_or_update_wm_mapping_presult__isset { + _ThriftHiveMetastore_create_or_update_wm_mapping_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_or_update_wm_mapping_presult__isset; + +class ThriftHiveMetastore_create_or_update_wm_mapping_presult { + public: + + + virtual ~ThriftHiveMetastore_create_or_update_wm_mapping_presult() throw(); + WMCreateOrUpdateMappingResponse* success; + AlreadyExistsException o1; + NoSuchObjectException o2; + InvalidObjectException o3; + MetaException o4; + + _ThriftHiveMetastore_create_or_update_wm_mapping_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_drop_wm_mapping_args__isset { + _ThriftHiveMetastore_drop_wm_mapping_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_drop_wm_mapping_args__isset; + +class ThriftHiveMetastore_drop_wm_mapping_args { + public: + + ThriftHiveMetastore_drop_wm_mapping_args(const ThriftHiveMetastore_drop_wm_mapping_args&); + ThriftHiveMetastore_drop_wm_mapping_args& operator=(const ThriftHiveMetastore_drop_wm_mapping_args&); + ThriftHiveMetastore_drop_wm_mapping_args() { + } + + virtual ~ThriftHiveMetastore_drop_wm_mapping_args() throw(); + WMDropMappingRequest request; + + _ThriftHiveMetastore_drop_wm_mapping_args__isset __isset; + + void __set_request(const WMDropMappingRequest& val); + + bool operator == (const ThriftHiveMetastore_drop_wm_mapping_args & rhs) const + { + if (!(request == rhs.request)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_drop_wm_mapping_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_wm_mapping_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_drop_wm_mapping_pargs { + public: + + + virtual ~ThriftHiveMetastore_drop_wm_mapping_pargs() throw(); + const WMDropMappingRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_wm_mapping_result__isset { + _ThriftHiveMetastore_drop_wm_mapping_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_mapping_result__isset; + +class ThriftHiveMetastore_drop_wm_mapping_result { + public: + + ThriftHiveMetastore_drop_wm_mapping_result(const ThriftHiveMetastore_drop_wm_mapping_result&); + ThriftHiveMetastore_drop_wm_mapping_result& operator=(const ThriftHiveMetastore_drop_wm_mapping_result&); + ThriftHiveMetastore_drop_wm_mapping_result() { + } + + virtual ~ThriftHiveMetastore_drop_wm_mapping_result() throw(); + WMDropMappingResponse success; + NoSuchObjectException o1; + InvalidOperationException o2; + MetaException o3; + + _ThriftHiveMetastore_drop_wm_mapping_result__isset __isset; + + void __set_success(const WMDropMappingResponse& 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_mapping_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_mapping_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_wm_mapping_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_wm_mapping_presult__isset { + _ThriftHiveMetastore_drop_wm_mapping_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_mapping_presult__isset; + +class ThriftHiveMetastore_drop_wm_mapping_presult { + public: + + + virtual ~ThriftHiveMetastore_drop_wm_mapping_presult() throw(); + WMDropMappingResponse* success; + NoSuchObjectException o1; + InvalidOperationException o2; + MetaException o3; + + _ThriftHiveMetastore_drop_wm_mapping_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args__isset { + _ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args__isset; + +class ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args { + public: + + ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args(const ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args&); + ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args& operator=(const ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args&); + ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args() { + } + + virtual ~ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args() throw(); + WMCreateOrDropTriggerToPoolMappingRequest request; + + _ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args__isset __isset; + + void __set_request(const WMCreateOrDropTriggerToPoolMappingRequest& val); + + bool operator == (const ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args & rhs) const + { + if (!(request == rhs.request)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_pargs { + public: + + + virtual ~ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_pargs() throw(); + const WMCreateOrDropTriggerToPoolMappingRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result__isset { + _ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_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_or_drop_wm_trigger_to_pool_mapping_result__isset; + +class ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result { + public: + + ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result(const ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result&); + ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result& operator=(const ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result&); + ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result() { + } + + virtual ~ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result() throw(); + WMCreateOrDropTriggerToPoolMappingResponse success; + AlreadyExistsException o1; + NoSuchObjectException o2; + InvalidObjectException o3; + MetaException o4; + + _ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result__isset __isset; + + void __set_success(const WMCreateOrDropTriggerToPoolMappingResponse& 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_or_drop_wm_trigger_to_pool_mapping_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_or_drop_wm_trigger_to_pool_mapping_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_presult__isset { + _ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_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_or_drop_wm_trigger_to_pool_mapping_presult__isset; + +class ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_presult { + public: + + + virtual ~ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_presult() throw(); + WMCreateOrDropTriggerToPoolMappingResponse* success; + AlreadyExistsException o1; + NoSuchObjectException o2; + InvalidObjectException o3; + MetaException o4; + + _ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_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) : + ::facebook::fb303::FacebookServiceClient(prot, prot) {} + ThriftHiveMetastoreClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) : ::facebook::fb303::FacebookServiceClient(iprot, oprot) {} + boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() { + return piprot_; + } + boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() { + return poprot_; + } + void getMetaConf(std::string& _return, const std::string& key); + void send_getMetaConf(const std::string& key); + void recv_getMetaConf(std::string& _return); + void setMetaConf(const std::string& key, const std::string& value); + void send_setMetaConf(const std::string& key, const std::string& value); + void recv_setMetaConf(); + void create_database(const Database& database); + void send_create_database(const Database& database); + void recv_create_database(); + void get_database(Database& _return, const std::string& name); + void send_get_database(const std::string& name); + void recv_get_database(Database& _return); + void drop_database(const std::string& name, const bool deleteData, const bool cascade); + void send_drop_database(const std::string& name, const bool deleteData, const bool cascade); + void recv_drop_database(); + void get_databases(std::vector & _return, const std::string& pattern); + void send_get_databases(const std::string& pattern); + void recv_get_databases(std::vector & _return); + void get_all_databases(std::vector & _return); + void send_get_all_databases(); + void recv_get_all_databases(std::vector & _return); + void alter_database(const std::string& dbname, const Database& db); + void send_alter_database(const std::string& dbname, const Database& db); + void recv_alter_database(); + void get_type(Type& _return, const std::string& name); + void send_get_type(const std::string& name); + void recv_get_type(Type& _return); + bool create_type(const Type& type); + void send_create_type(const Type& type); + bool recv_create_type(); + bool drop_type(const std::string& type); + void send_drop_type(const std::string& type); + bool recv_drop_type(); + void get_type_all(std::map & _return, const std::string& name); + void send_get_type_all(const std::string& name); + void recv_get_type_all(std::map & _return); + void get_fields(std::vector & _return, const std::string& db_name, const std::string& table_name); + void send_get_fields(const std::string& db_name, const std::string& table_name); + void recv_get_fields(std::vector & _return); + void get_fields_with_environment_context(std::vector & _return, const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context); + void send_get_fields_with_environment_context(const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context); + void recv_get_fields_with_environment_context(std::vector & _return); + void get_schema(std::vector & _return, const std::string& db_name, const std::string& table_name); + void send_get_schema(const std::string& db_name, const std::string& table_name); + void recv_get_schema(std::vector & _return); + void get_schema_with_environment_context(std::vector & _return, const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context); + void send_get_schema_with_environment_context(const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context); + void recv_get_schema_with_environment_context(std::vector & _return); + void create_table(const Table& tbl); + void send_create_table(const Table& tbl); + void recv_create_table(); + void create_table_with_environment_context(const Table& tbl, const EnvironmentContext& environment_context); + void send_create_table_with_environment_context(const Table& tbl, const EnvironmentContext& environment_context); + void recv_create_table_with_environment_context(); + void create_table_with_constraints(const Table& tbl, const std::vector & primaryKeys, const std::vector & foreignKeys, const std::vector & uniqueConstraints, const std::vector & notNullConstraints); + void send_create_table_with_constraints(const Table& tbl, const std::vector & primaryKeys, const std::vector & foreignKeys, const std::vector & uniqueConstraints, const std::vector & notNullConstraints); + void recv_create_table_with_constraints(); + void drop_constraint(const DropConstraintRequest& req); + void send_drop_constraint(const DropConstraintRequest& req); + void recv_drop_constraint(); + void add_primary_key(const AddPrimaryKeyRequest& req); + void send_add_primary_key(const AddPrimaryKeyRequest& req); + void recv_add_primary_key(); + void add_foreign_key(const AddForeignKeyRequest& req); + void send_add_foreign_key(const AddForeignKeyRequest& req); + void recv_add_foreign_key(); + void add_unique_constraint(const AddUniqueConstraintRequest& req); + void send_add_unique_constraint(const AddUniqueConstraintRequest& req); + void recv_add_unique_constraint(); + void add_not_null_constraint(const AddNotNullConstraintRequest& req); + void send_add_not_null_constraint(const AddNotNullConstraintRequest& req); + void recv_add_not_null_constraint(); + void drop_table(const std::string& dbname, const std::string& name, const bool deleteData); + void send_drop_table(const std::string& dbname, const std::string& name, const bool deleteData); + void recv_drop_table(); + void drop_table_with_environment_context(const std::string& dbname, const std::string& name, const bool deleteData, const EnvironmentContext& environment_context); + void send_drop_table_with_environment_context(const std::string& dbname, const std::string& name, const bool deleteData, const EnvironmentContext& environment_context); + void recv_drop_table_with_environment_context(); + void truncate_table(const std::string& dbName, const std::string& tableName, const std::vector & partNames); + void send_truncate_table(const std::string& dbName, const std::string& tableName, const std::vector & partNames); + void recv_truncate_table(); + void get_tables(std::vector & _return, const std::string& db_name, const std::string& pattern); + void send_get_tables(const std::string& db_name, const std::string& pattern); + void recv_get_tables(std::vector & _return); + void get_tables_by_type(std::vector & _return, const std::string& db_name, const std::string& pattern, const std::string& tableType); + void send_get_tables_by_type(const std::string& db_name, const std::string& pattern, const std::string& tableType); + void recv_get_tables_by_type(std::vector & _return); + void get_table_meta(std::vector & _return, const std::string& db_patterns, const std::string& tbl_patterns, const std::vector & tbl_types); + void send_get_table_meta(const std::string& db_patterns, const std::string& tbl_patterns, const std::vector & tbl_types); + void recv_get_table_meta(std::vector & _return); + void get_all_tables(std::vector & _return, const std::string& db_name); + void send_get_all_tables(const std::string& db_name); + void recv_get_all_tables(std::vector & _return); + void get_table(Table& _return, const std::string& dbname, const std::string& tbl_name); + void send_get_table(const std::string& dbname, const std::string& tbl_name); + void recv_get_table(Table& _return); + void get_table_objects_by_name(std::vector
& _return, const std::string& dbname, const std::vector & tbl_names); + void send_get_table_objects_by_name(const std::string& dbname, const std::vector & tbl_names); + void recv_get_table_objects_by_name(std::vector
& _return); + void get_table_req(GetTableResult& _return, const GetTableRequest& req); + void send_get_table_req(const GetTableRequest& req); + void recv_get_table_req(GetTableResult& _return); + void get_table_objects_by_name_req(GetTablesResult& _return, const GetTablesRequest& req); + void send_get_table_objects_by_name_req(const GetTablesRequest& req); + void recv_get_table_objects_by_name_req(GetTablesResult& _return); + void get_table_names_by_filter(std::vector & _return, const std::string& dbname, const std::string& filter, const int16_t max_tables); + void send_get_table_names_by_filter(const std::string& dbname, const std::string& filter, const int16_t max_tables); + void recv_get_table_names_by_filter(std::vector & _return); + void alter_table(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl); + void send_alter_table(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl); + void recv_alter_table(); + void alter_table_with_environment_context(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const EnvironmentContext& environment_context); + void send_alter_table_with_environment_context(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const EnvironmentContext& environment_context); + void recv_alter_table_with_environment_context(); + void alter_table_with_cascade(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const bool cascade); + void send_alter_table_with_cascade(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const bool cascade); + void recv_alter_table_with_cascade(); + void add_partition(Partition& _return, const Partition& new_part); + void send_add_partition(const Partition& new_part); + void recv_add_partition(Partition& _return); + void add_partition_with_environment_context(Partition& _return, const Partition& new_part, const EnvironmentContext& environment_context); + void send_add_partition_with_environment_context(const Partition& new_part, const EnvironmentContext& environment_context); + void recv_add_partition_with_environment_context(Partition& _return); + int32_t add_partitions(const std::vector & new_parts); + void send_add_partitions(const std::vector & new_parts); + int32_t recv_add_partitions(); + int32_t add_partitions_pspec(const std::vector & new_parts); + void send_add_partitions_pspec(const std::vector & new_parts); + int32_t recv_add_partitions_pspec(); + void append_partition(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals); + void send_append_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals); + void recv_append_partition(Partition& _return); + void add_partitions_req(AddPartitionsResult& _return, const AddPartitionsRequest& request); + void send_add_partitions_req(const AddPartitionsRequest& request); + void recv_add_partitions_req(AddPartitionsResult& _return); + void append_partition_with_environment_context(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const EnvironmentContext& environment_context); + void send_append_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const EnvironmentContext& environment_context); + void recv_append_partition_with_environment_context(Partition& _return); + void append_partition_by_name(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name); + void send_append_partition_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& part_name); + void recv_append_partition_by_name(Partition& _return); + void append_partition_by_name_with_environment_context(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const EnvironmentContext& environment_context); + void send_append_partition_by_name_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const EnvironmentContext& environment_context); + void recv_append_partition_by_name_with_environment_context(Partition& _return); + bool drop_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const bool deleteData); + void send_drop_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const bool deleteData); + bool recv_drop_partition(); + bool drop_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const bool deleteData, const EnvironmentContext& environment_context); + void send_drop_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const bool deleteData, const EnvironmentContext& environment_context); + bool recv_drop_partition_with_environment_context(); + bool drop_partition_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const bool deleteData); + void send_drop_partition_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const bool deleteData); + bool recv_drop_partition_by_name(); + bool drop_partition_by_name_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const bool deleteData, const EnvironmentContext& environment_context); + void send_drop_partition_by_name_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const bool deleteData, const EnvironmentContext& environment_context); + bool recv_drop_partition_by_name_with_environment_context(); + void drop_partitions_req(DropPartitionsResult& _return, const DropPartitionsRequest& req); + void send_drop_partitions_req(const DropPartitionsRequest& req); + void recv_drop_partitions_req(DropPartitionsResult& _return); + void get_partition(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals); + void send_get_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals); + void recv_get_partition(Partition& _return); + void exchange_partition(Partition& _return, const std::map & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name); + void send_exchange_partition(const std::map & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name); + void recv_exchange_partition(Partition& _return); + void exchange_partitions(std::vector & _return, const std::map & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name); + void send_exchange_partitions(const std::map & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name); + void recv_exchange_partitions(std::vector & _return); + void get_partition_with_auth(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const std::string& user_name, const std::vector & group_names); + void send_get_partition_with_auth(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const std::string& user_name, const std::vector & group_names); + void recv_get_partition_with_auth(Partition& _return); + void get_partition_by_name(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name); + void send_get_partition_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& part_name); + void recv_get_partition_by_name(Partition& _return); + void get_partitions(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const int16_t max_parts); + void send_get_partitions(const std::string& db_name, const std::string& tbl_name, const int16_t max_parts); + void recv_get_partitions(std::vector & _return); + void get_partitions_with_auth(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const int16_t max_parts, const std::string& user_name, const std::vector & group_names); + void send_get_partitions_with_auth(const std::string& db_name, const std::string& tbl_name, const int16_t max_parts, const std::string& user_name, const std::vector & group_names); + void recv_get_partitions_with_auth(std::vector & _return); + void get_partitions_pspec(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const int32_t max_parts); + void send_get_partitions_pspec(const std::string& db_name, const std::string& tbl_name, const int32_t max_parts); + void recv_get_partitions_pspec(std::vector & _return); + void get_partition_names(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const int16_t max_parts); + void send_get_partition_names(const std::string& db_name, const std::string& tbl_name, const int16_t max_parts); + void recv_get_partition_names(std::vector & _return); + void get_partition_values(PartitionValuesResponse& _return, const PartitionValuesRequest& request); + void send_get_partition_values(const PartitionValuesRequest& request); + void recv_get_partition_values(PartitionValuesResponse& _return); + void get_partitions_ps(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const int16_t max_parts); + void send_get_partitions_ps(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const int16_t max_parts); + void recv_get_partitions_ps(std::vector & _return); + void get_partitions_ps_with_auth(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const int16_t max_parts, const std::string& user_name, const std::vector & group_names); + void send_get_partitions_ps_with_auth(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const int16_t max_parts, const std::string& user_name, const std::vector & group_names); + void recv_get_partitions_ps_with_auth(std::vector & _return); + void get_partition_names_ps(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const int16_t max_parts); + void send_get_partition_names_ps(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const int16_t max_parts); + void recv_get_partition_names_ps(std::vector & _return); + void get_partitions_by_filter(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::string& filter, const int16_t max_parts); + void send_get_partitions_by_filter(const std::string& db_name, const std::string& tbl_name, const std::string& filter, const int16_t max_parts); + void recv_get_partitions_by_filter(std::vector & _return); + void get_part_specs_by_filter(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::string& filter, const int32_t max_parts); + void send_get_part_specs_by_filter(const std::string& db_name, const std::string& tbl_name, const std::string& filter, const int32_t max_parts); + void recv_get_part_specs_by_filter(std::vector & _return); + void get_partitions_by_expr(PartitionsByExprResult& _return, const PartitionsByExprRequest& req); + void send_get_partitions_by_expr(const PartitionsByExprRequest& req); + void recv_get_partitions_by_expr(PartitionsByExprResult& _return); + int32_t get_num_partitions_by_filter(const std::string& db_name, const std::string& tbl_name, const std::string& filter); + void send_get_num_partitions_by_filter(const std::string& db_name, const std::string& tbl_name, const std::string& filter); + int32_t recv_get_num_partitions_by_filter(); + void get_partitions_by_names(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const std::vector & names); + void send_get_partitions_by_names(const std::string& db_name, const std::string& tbl_name, const std::vector & names); + void recv_get_partitions_by_names(std::vector & _return); + void alter_partition(const std::string& db_name, const std::string& tbl_name, const Partition& new_part); + void send_alter_partition(const std::string& db_name, const std::string& tbl_name, const Partition& new_part); + void recv_alter_partition(); + void alter_partitions(const std::string& db_name, const std::string& tbl_name, const std::vector & new_parts); + void send_alter_partitions(const std::string& db_name, const std::string& tbl_name, const std::vector & new_parts); + void recv_alter_partitions(); + void alter_partitions_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector & new_parts, const EnvironmentContext& environment_context); + void send_alter_partitions_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector & new_parts, const EnvironmentContext& environment_context); + void recv_alter_partitions_with_environment_context(); + void alter_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const Partition& new_part, const EnvironmentContext& environment_context); + void send_alter_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const Partition& new_part, const EnvironmentContext& environment_context); + void recv_alter_partition_with_environment_context(); + void rename_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const Partition& new_part); + void send_rename_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const Partition& new_part); void recv_rename_partition(); bool partition_name_has_valid_characters(const std::vector & part_vals, const bool throw_exception); void send_partition_name_has_valid_characters(const std::vector & part_vals, const bool throw_exception); @@ -22492,6 +23176,21 @@ class ThriftHiveMetastoreClient : virtual public ThriftHiveMetastoreIf, public 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); + void create_or_update_wm_pool(WMCreateOrUpdatePoolResponse& _return, const WMCreateOrUpdatePoolRequest& request); + void send_create_or_update_wm_pool(const WMCreateOrUpdatePoolRequest& request); + void recv_create_or_update_wm_pool(WMCreateOrUpdatePoolResponse& _return); + void drop_wm_pool(WMDropPoolResponse& _return, const WMDropPoolRequest& request); + void send_drop_wm_pool(const WMDropPoolRequest& request); + void recv_drop_wm_pool(WMDropPoolResponse& _return); + void create_or_update_wm_mapping(WMCreateOrUpdateMappingResponse& _return, const WMCreateOrUpdateMappingRequest& request); + void send_create_or_update_wm_mapping(const WMCreateOrUpdateMappingRequest& request); + void recv_create_or_update_wm_mapping(WMCreateOrUpdateMappingResponse& _return); + void drop_wm_mapping(WMDropMappingResponse& _return, const WMDropMappingRequest& request); + void send_drop_wm_mapping(const WMDropMappingRequest& request); + void recv_drop_wm_mapping(WMDropMappingResponse& _return); + void create_or_drop_wm_trigger_to_pool_mapping(WMCreateOrDropTriggerToPoolMappingResponse& _return, const WMCreateOrDropTriggerToPoolMappingRequest& request); + void send_create_or_drop_wm_trigger_to_pool_mapping(const WMCreateOrDropTriggerToPoolMappingRequest& request); + void recv_create_or_drop_wm_trigger_to_pool_mapping(WMCreateOrDropTriggerToPoolMappingResponse& _return); }; class ThriftHiveMetastoreProcessor : public ::facebook::fb303::FacebookServiceProcessor { @@ -22674,6 +23373,11 @@ class ThriftHiveMetastoreProcessor : public ::facebook::fb303::FacebookServiceP 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); + void process_create_or_update_wm_pool(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_drop_wm_pool(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_create_or_update_wm_mapping(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_drop_wm_mapping(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_create_or_drop_wm_trigger_to_pool_mapping(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), @@ -22850,6 +23554,11 @@ class ThriftHiveMetastoreProcessor : public ::facebook::fb303::FacebookServiceP 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; + processMap_["create_or_update_wm_pool"] = &ThriftHiveMetastoreProcessor::process_create_or_update_wm_pool; + processMap_["drop_wm_pool"] = &ThriftHiveMetastoreProcessor::process_drop_wm_pool; + processMap_["create_or_update_wm_mapping"] = &ThriftHiveMetastoreProcessor::process_create_or_update_wm_mapping; + processMap_["drop_wm_mapping"] = &ThriftHiveMetastoreProcessor::process_drop_wm_mapping; + processMap_["create_or_drop_wm_trigger_to_pool_mapping"] = &ThriftHiveMetastoreProcessor::process_create_or_drop_wm_trigger_to_pool_mapping; } virtual ~ThriftHiveMetastoreProcessor() {} @@ -24537,6 +25246,56 @@ class ThriftHiveMetastoreMultiface : virtual public ThriftHiveMetastoreIf, publi return; } + void create_or_update_wm_pool(WMCreateOrUpdatePoolResponse& _return, const WMCreateOrUpdatePoolRequest& request) { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->create_or_update_wm_pool(_return, request); + } + ifaces_[i]->create_or_update_wm_pool(_return, request); + return; + } + + void drop_wm_pool(WMDropPoolResponse& _return, const WMDropPoolRequest& request) { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->drop_wm_pool(_return, request); + } + ifaces_[i]->drop_wm_pool(_return, request); + return; + } + + void create_or_update_wm_mapping(WMCreateOrUpdateMappingResponse& _return, const WMCreateOrUpdateMappingRequest& request) { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->create_or_update_wm_mapping(_return, request); + } + ifaces_[i]->create_or_update_wm_mapping(_return, request); + return; + } + + void drop_wm_mapping(WMDropMappingResponse& _return, const WMDropMappingRequest& request) { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->drop_wm_mapping(_return, request); + } + ifaces_[i]->drop_wm_mapping(_return, request); + return; + } + + void create_or_drop_wm_trigger_to_pool_mapping(WMCreateOrDropTriggerToPoolMappingResponse& _return, const WMCreateOrDropTriggerToPoolMappingRequest& request) { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->create_or_drop_wm_trigger_to_pool_mapping(_return, request); + } + ifaces_[i]->create_or_drop_wm_trigger_to_pool_mapping(_return, request); + return; + } + }; // The 'concurrent' client is a thread safe client that correctly handles @@ -25069,6 +25828,21 @@ class ThriftHiveMetastoreConcurrentClient : virtual public ThriftHiveMetastoreIf 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); + void create_or_update_wm_pool(WMCreateOrUpdatePoolResponse& _return, const WMCreateOrUpdatePoolRequest& request); + int32_t send_create_or_update_wm_pool(const WMCreateOrUpdatePoolRequest& request); + void recv_create_or_update_wm_pool(WMCreateOrUpdatePoolResponse& _return, const int32_t seqid); + void drop_wm_pool(WMDropPoolResponse& _return, const WMDropPoolRequest& request); + int32_t send_drop_wm_pool(const WMDropPoolRequest& request); + void recv_drop_wm_pool(WMDropPoolResponse& _return, const int32_t seqid); + void create_or_update_wm_mapping(WMCreateOrUpdateMappingResponse& _return, const WMCreateOrUpdateMappingRequest& request); + int32_t send_create_or_update_wm_mapping(const WMCreateOrUpdateMappingRequest& request); + void recv_create_or_update_wm_mapping(WMCreateOrUpdateMappingResponse& _return, const int32_t seqid); + void drop_wm_mapping(WMDropMappingResponse& _return, const WMDropMappingRequest& request); + int32_t send_drop_wm_mapping(const WMDropMappingRequest& request); + void recv_drop_wm_mapping(WMDropMappingResponse& _return, const int32_t seqid); + void create_or_drop_wm_trigger_to_pool_mapping(WMCreateOrDropTriggerToPoolMappingResponse& _return, const WMCreateOrDropTriggerToPoolMappingRequest& request); + int32_t send_create_or_drop_wm_trigger_to_pool_mapping(const WMCreateOrDropTriggerToPoolMappingRequest& request); + void recv_create_or_drop_wm_trigger_to_pool_mapping(WMCreateOrDropTriggerToPoolMappingResponse& _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 199b8deb5e..d74245d7fd 100644 --- standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp +++ standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp @@ -882,6 +882,31 @@ class ThriftHiveMetastoreHandler : virtual public ThriftHiveMetastoreIf { printf("get_triggers_for_resourceplan\n"); } + void create_or_update_wm_pool(WMCreateOrUpdatePoolResponse& _return, const WMCreateOrUpdatePoolRequest& request) { + // Your implementation goes here + printf("create_or_update_wm_pool\n"); + } + + void drop_wm_pool(WMDropPoolResponse& _return, const WMDropPoolRequest& request) { + // Your implementation goes here + printf("drop_wm_pool\n"); + } + + void create_or_update_wm_mapping(WMCreateOrUpdateMappingResponse& _return, const WMCreateOrUpdateMappingRequest& request) { + // Your implementation goes here + printf("create_or_update_wm_mapping\n"); + } + + void drop_wm_mapping(WMDropMappingResponse& _return, const WMDropMappingRequest& request) { + // Your implementation goes here + printf("drop_wm_mapping\n"); + } + + void create_or_drop_wm_trigger_to_pool_mapping(WMCreateOrDropTriggerToPoolMappingResponse& _return, const WMCreateOrDropTriggerToPoolMappingRequest& request) { + // Your implementation goes here + printf("create_or_drop_wm_trigger_to_pool_mapping\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 6090fc2888..83a2d23546 100644 --- standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp +++ standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp @@ -20917,13 +20917,8 @@ void WMPool::__set_resourcePlanName(const std::string& val) { this->resourcePlanName = val; } -void WMPool::__set_poolName(const std::string& val) { - this->poolName = val; -} - -void WMPool::__set_parentPoolName(const std::string& val) { - this->parentPoolName = val; -__isset.parentPoolName = true; +void WMPool::__set_path(const std::string& val) { + this->path = val; } void WMPool::__set_allocFraction(const double val) { @@ -20954,7 +20949,7 @@ uint32_t WMPool::read(::apache::thrift::protocol::TProtocol* iprot) { using ::apache::thrift::protocol::TProtocolException; bool isset_resourcePlanName = false; - bool isset_poolName = false; + bool isset_path = false; while (true) { @@ -20974,21 +20969,13 @@ uint32_t WMPool::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->path); + isset_path = true; } else { xfer += iprot->skip(ftype); } break; case 3: - if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->parentPoolName); - this->__isset.parentPoolName = true; - } else { - xfer += iprot->skip(ftype); - } - break; - case 4: if (ftype == ::apache::thrift::protocol::T_DOUBLE) { xfer += iprot->readDouble(this->allocFraction); this->__isset.allocFraction = true; @@ -20996,7 +20983,7 @@ uint32_t WMPool::read(::apache::thrift::protocol::TProtocol* iprot) { xfer += iprot->skip(ftype); } break; - case 5: + case 4: if (ftype == ::apache::thrift::protocol::T_I32) { xfer += iprot->readI32(this->queryParallelism); this->__isset.queryParallelism = true; @@ -21004,7 +20991,7 @@ uint32_t WMPool::read(::apache::thrift::protocol::TProtocol* iprot) { xfer += iprot->skip(ftype); } break; - case 6: + case 5: if (ftype == ::apache::thrift::protocol::T_STRING) { xfer += iprot->readString(this->schedulingPolicy); this->__isset.schedulingPolicy = true; @@ -21023,7 +21010,7 @@ uint32_t WMPool::read(::apache::thrift::protocol::TProtocol* iprot) { if (!isset_resourcePlanName) throw TProtocolException(TProtocolException::INVALID_DATA); - if (!isset_poolName) + if (!isset_path) throw TProtocolException(TProtocolException::INVALID_DATA); return xfer; } @@ -21037,27 +21024,22 @@ uint32_t WMPool::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("path", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->path); xfer += oprot->writeFieldEnd(); - if (this->__isset.parentPoolName) { - xfer += oprot->writeFieldBegin("parentPoolName", ::apache::thrift::protocol::T_STRING, 3); - xfer += oprot->writeString(this->parentPoolName); - xfer += oprot->writeFieldEnd(); - } if (this->__isset.allocFraction) { - xfer += oprot->writeFieldBegin("allocFraction", ::apache::thrift::protocol::T_DOUBLE, 4); + xfer += oprot->writeFieldBegin("allocFraction", ::apache::thrift::protocol::T_DOUBLE, 3); xfer += oprot->writeDouble(this->allocFraction); xfer += oprot->writeFieldEnd(); } if (this->__isset.queryParallelism) { - xfer += oprot->writeFieldBegin("queryParallelism", ::apache::thrift::protocol::T_I32, 5); + xfer += oprot->writeFieldBegin("queryParallelism", ::apache::thrift::protocol::T_I32, 4); xfer += oprot->writeI32(this->queryParallelism); xfer += oprot->writeFieldEnd(); } if (this->__isset.schedulingPolicy) { - xfer += oprot->writeFieldBegin("schedulingPolicy", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeFieldBegin("schedulingPolicy", ::apache::thrift::protocol::T_STRING, 5); xfer += oprot->writeString(this->schedulingPolicy); xfer += oprot->writeFieldEnd(); } @@ -21069,8 +21051,7 @@ uint32_t WMPool::write(::apache::thrift::protocol::TProtocol* oprot) const { void swap(WMPool &a, WMPool &b) { using ::std::swap; swap(a.resourcePlanName, b.resourcePlanName); - swap(a.poolName, b.poolName); - swap(a.parentPoolName, b.parentPoolName); + swap(a.path, b.path); swap(a.allocFraction, b.allocFraction); swap(a.queryParallelism, b.queryParallelism); swap(a.schedulingPolicy, b.schedulingPolicy); @@ -21079,8 +21060,7 @@ void swap(WMPool &a, WMPool &b) { WMPool::WMPool(const WMPool& other866) { resourcePlanName = other866.resourcePlanName; - poolName = other866.poolName; - parentPoolName = other866.parentPoolName; + path = other866.path; allocFraction = other866.allocFraction; queryParallelism = other866.queryParallelism; schedulingPolicy = other866.schedulingPolicy; @@ -21088,8 +21068,7 @@ WMPool::WMPool(const WMPool& other866) { } WMPool& WMPool::operator=(const WMPool& other867) { resourcePlanName = other867.resourcePlanName; - poolName = other867.poolName; - parentPoolName = other867.parentPoolName; + path = other867.path; allocFraction = other867.allocFraction; queryParallelism = other867.queryParallelism; schedulingPolicy = other867.schedulingPolicy; @@ -21100,8 +21079,7 @@ void WMPool::printTo(std::ostream& out) const { using ::apache::thrift::to_string; out << "WMPool("; out << "resourcePlanName=" << to_string(resourcePlanName); - out << ", " << "poolName=" << to_string(poolName); - out << ", " << "parentPoolName="; (__isset.parentPoolName ? (out << to_string(parentPoolName)) : (out << "")); + out << ", " << "path=" << to_string(path); out << ", " << "allocFraction="; (__isset.allocFraction ? (out << to_string(allocFraction)) : (out << "")); out << ", " << "queryParallelism="; (__isset.queryParallelism ? (out << to_string(queryParallelism)) : (out << "")); out << ", " << "schedulingPolicy="; (__isset.schedulingPolicy ? (out << to_string(schedulingPolicy)) : (out << "")); @@ -21281,9 +21259,9 @@ void WMMapping::__set_entityName(const std::string& val) { this->entityName = val; } -void WMMapping::__set_poolName(const std::string& val) { - this->poolName = val; -__isset.poolName = true; +void WMMapping::__set_poolPath(const std::string& val) { + this->poolPath = val; +__isset.poolPath = true; } void WMMapping::__set_ordering(const int32_t val) { @@ -21341,8 +21319,8 @@ uint32_t WMMapping::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 4: if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->poolName); - this->__isset.poolName = true; + xfer += iprot->readString(this->poolPath); + this->__isset.poolPath = true; } else { xfer += iprot->skip(ftype); } @@ -21390,9 +21368,9 @@ uint32_t WMMapping::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeString(this->entityName); xfer += oprot->writeFieldEnd(); - if (this->__isset.poolName) { - xfer += oprot->writeFieldBegin("poolName", ::apache::thrift::protocol::T_STRING, 4); - xfer += oprot->writeString(this->poolName); + if (this->__isset.poolPath) { + xfer += oprot->writeFieldBegin("poolPath", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->poolPath); xfer += oprot->writeFieldEnd(); } if (this->__isset.ordering) { @@ -21410,7 +21388,7 @@ void swap(WMMapping &a, WMMapping &b) { swap(a.resourcePlanName, b.resourcePlanName); swap(a.entityType, b.entityType); swap(a.entityName, b.entityName); - swap(a.poolName, b.poolName); + swap(a.poolPath, b.poolPath); swap(a.ordering, b.ordering); swap(a.__isset, b.__isset); } @@ -21419,7 +21397,7 @@ WMMapping::WMMapping(const WMMapping& other870) { resourcePlanName = other870.resourcePlanName; entityType = other870.entityType; entityName = other870.entityName; - poolName = other870.poolName; + poolPath = other870.poolPath; ordering = other870.ordering; __isset = other870.__isset; } @@ -21427,7 +21405,7 @@ WMMapping& WMMapping::operator=(const WMMapping& other871) { resourcePlanName = other871.resourcePlanName; entityType = other871.entityType; entityName = other871.entityName; - poolName = other871.poolName; + poolPath = other871.poolPath; ordering = other871.ordering; __isset = other871.__isset; return *this; @@ -21438,7 +21416,7 @@ void WMMapping::printTo(std::ostream& out) const { out << "resourcePlanName=" << to_string(resourcePlanName); out << ", " << "entityType=" << to_string(entityType); out << ", " << "entityName=" << to_string(entityName); - out << ", " << "poolName="; (__isset.poolName ? (out << to_string(poolName)) : (out << "")); + out << ", " << "poolPath="; (__isset.poolPath ? (out << to_string(poolPath)) : (out << "")); out << ", " << "ordering="; (__isset.ordering ? (out << to_string(ordering)) : (out << "")); out << ")"; } @@ -23106,15 +23084,26 @@ void WMGetTriggersForResourePlanResponse::printTo(std::ostream& out) const { } -MetaException::~MetaException() throw() { +WMCreateOrUpdatePoolRequest::~WMCreateOrUpdatePoolRequest() throw() { } -void MetaException::__set_message(const std::string& val) { - this->message = val; +void WMCreateOrUpdatePoolRequest::__set_pool(const WMPool& val) { + this->pool = val; +__isset.pool = true; } -uint32_t MetaException::read(::apache::thrift::protocol::TProtocol* iprot) { +void WMCreateOrUpdatePoolRequest::__set_newPoolPath(const std::string& val) { + this->newPoolPath = val; +__isset.newPoolPath = true; +} + +void WMCreateOrUpdatePoolRequest::__set_update(const bool val) { + this->update = val; +__isset.update = true; +} + +uint32_t WMCreateOrUpdatePoolRequest::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -23136,9 +23125,25 @@ uint32_t MetaException::read(::apache::thrift::protocol::TProtocol* iprot) { switch (fid) { case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->pool.read(iprot); + this->__isset.pool = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->message); - this->__isset.message = true; + xfer += iprot->readString(this->newPoolPath); + this->__isset.newPoolPath = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->update); + this->__isset.update = true; } else { xfer += iprot->skip(ftype); } @@ -23155,63 +23160,67 @@ uint32_t MetaException::read(::apache::thrift::protocol::TProtocol* iprot) { return xfer; } -uint32_t MetaException::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t WMCreateOrUpdatePoolRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("MetaException"); - - xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString(this->message); - xfer += oprot->writeFieldEnd(); + xfer += oprot->writeStructBegin("WMCreateOrUpdatePoolRequest"); + if (this->__isset.pool) { + xfer += oprot->writeFieldBegin("pool", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->pool.write(oprot); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.newPoolPath) { + xfer += oprot->writeFieldBegin("newPoolPath", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->newPoolPath); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.update) { + xfer += oprot->writeFieldBegin("update", ::apache::thrift::protocol::T_BOOL, 3); + xfer += oprot->writeBool(this->update); + xfer += oprot->writeFieldEnd(); + } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; } -void swap(MetaException &a, MetaException &b) { +void swap(WMCreateOrUpdatePoolRequest &a, WMCreateOrUpdatePoolRequest &b) { using ::std::swap; - swap(a.message, b.message); + swap(a.pool, b.pool); + swap(a.newPoolPath, b.newPoolPath); + swap(a.update, b.update); swap(a.__isset, b.__isset); } -MetaException::MetaException(const MetaException& other924) : TException() { - message = other924.message; +WMCreateOrUpdatePoolRequest::WMCreateOrUpdatePoolRequest(const WMCreateOrUpdatePoolRequest& other924) { + pool = other924.pool; + newPoolPath = other924.newPoolPath; + update = other924.update; __isset = other924.__isset; } -MetaException& MetaException::operator=(const MetaException& other925) { - message = other925.message; +WMCreateOrUpdatePoolRequest& WMCreateOrUpdatePoolRequest::operator=(const WMCreateOrUpdatePoolRequest& other925) { + pool = other925.pool; + newPoolPath = other925.newPoolPath; + update = other925.update; __isset = other925.__isset; return *this; } -void MetaException::printTo(std::ostream& out) const { +void WMCreateOrUpdatePoolRequest::printTo(std::ostream& out) const { using ::apache::thrift::to_string; - out << "MetaException("; - out << "message=" << to_string(message); + out << "WMCreateOrUpdatePoolRequest("; + out << "pool="; (__isset.pool ? (out << to_string(pool)) : (out << "")); + out << ", " << "newPoolPath="; (__isset.newPoolPath ? (out << to_string(newPoolPath)) : (out << "")); + out << ", " << "update="; (__isset.update ? (out << to_string(update)) : (out << "")); out << ")"; } -const char* MetaException::what() const throw() { - try { - std::stringstream ss; - ss << "TException - service has thrown: " << *this; - this->thriftTExceptionMessageHolder_ = ss.str(); - return this->thriftTExceptionMessageHolder_.c_str(); - } catch (const std::exception&) { - return "TException - service has thrown: MetaException"; - } -} - -UnknownTableException::~UnknownTableException() throw() { +WMCreateOrUpdatePoolResponse::~WMCreateOrUpdatePoolResponse() throw() { } -void UnknownTableException::__set_message(const std::string& val) { - this->message = val; -} - -uint32_t UnknownTableException::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t WMCreateOrUpdatePoolResponse::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -23230,20 +23239,7 @@ uint32_t UnknownTableException::read(::apache::thrift::protocol::TProtocol* ipro if (ftype == ::apache::thrift::protocol::T_STOP) { break; } - switch (fid) - { - case 1: - if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->message); - this->__isset.message = true; - } else { - xfer += iprot->skip(ftype); - } - break; - default: - xfer += iprot->skip(ftype); - break; - } + xfer += iprot->skip(ftype); xfer += iprot->readFieldEnd(); } @@ -23252,63 +23248,51 @@ uint32_t UnknownTableException::read(::apache::thrift::protocol::TProtocol* ipro return xfer; } -uint32_t UnknownTableException::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t WMCreateOrUpdatePoolResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("UnknownTableException"); - - xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString(this->message); - xfer += oprot->writeFieldEnd(); + xfer += oprot->writeStructBegin("WMCreateOrUpdatePoolResponse"); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; } -void swap(UnknownTableException &a, UnknownTableException &b) { +void swap(WMCreateOrUpdatePoolResponse &a, WMCreateOrUpdatePoolResponse &b) { using ::std::swap; - swap(a.message, b.message); - swap(a.__isset, b.__isset); + (void) a; + (void) b; } -UnknownTableException::UnknownTableException(const UnknownTableException& other926) : TException() { - message = other926.message; - __isset = other926.__isset; +WMCreateOrUpdatePoolResponse::WMCreateOrUpdatePoolResponse(const WMCreateOrUpdatePoolResponse& other926) { + (void) other926; } -UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other927) { - message = other927.message; - __isset = other927.__isset; +WMCreateOrUpdatePoolResponse& WMCreateOrUpdatePoolResponse::operator=(const WMCreateOrUpdatePoolResponse& other927) { + (void) other927; return *this; } -void UnknownTableException::printTo(std::ostream& out) const { +void WMCreateOrUpdatePoolResponse::printTo(std::ostream& out) const { using ::apache::thrift::to_string; - out << "UnknownTableException("; - out << "message=" << to_string(message); + out << "WMCreateOrUpdatePoolResponse("; out << ")"; } -const char* UnknownTableException::what() const throw() { - try { - std::stringstream ss; - ss << "TException - service has thrown: " << *this; - this->thriftTExceptionMessageHolder_ = ss.str(); - return this->thriftTExceptionMessageHolder_.c_str(); - } catch (const std::exception&) { - return "TException - service has thrown: UnknownTableException"; - } + +WMDropPoolRequest::~WMDropPoolRequest() throw() { } -UnknownDBException::~UnknownDBException() throw() { +void WMDropPoolRequest::__set_resourcePlanName(const std::string& val) { + this->resourcePlanName = val; +__isset.resourcePlanName = true; } - -void UnknownDBException::__set_message(const std::string& val) { - this->message = val; +void WMDropPoolRequest::__set_poolPath(const std::string& val) { + this->poolPath = val; +__isset.poolPath = true; } -uint32_t UnknownDBException::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t WMDropPoolRequest::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -23331,8 +23315,16 @@ uint32_t UnknownDBException::read(::apache::thrift::protocol::TProtocol* iprot) { case 1: if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->message); - this->__isset.message = true; + xfer += iprot->readString(this->resourcePlanName); + this->__isset.resourcePlanName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->poolPath); + this->__isset.poolPath = true; } else { xfer += iprot->skip(ftype); } @@ -23349,63 +23341,58 @@ uint32_t UnknownDBException::read(::apache::thrift::protocol::TProtocol* iprot) return xfer; } -uint32_t UnknownDBException::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t WMDropPoolRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("UnknownDBException"); - - xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString(this->message); - xfer += oprot->writeFieldEnd(); + xfer += oprot->writeStructBegin("WMDropPoolRequest"); + 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.poolPath) { + xfer += oprot->writeFieldBegin("poolPath", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->poolPath); + xfer += oprot->writeFieldEnd(); + } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; } -void swap(UnknownDBException &a, UnknownDBException &b) { +void swap(WMDropPoolRequest &a, WMDropPoolRequest &b) { using ::std::swap; - swap(a.message, b.message); + swap(a.resourcePlanName, b.resourcePlanName); + swap(a.poolPath, b.poolPath); swap(a.__isset, b.__isset); } -UnknownDBException::UnknownDBException(const UnknownDBException& other928) : TException() { - message = other928.message; +WMDropPoolRequest::WMDropPoolRequest(const WMDropPoolRequest& other928) { + resourcePlanName = other928.resourcePlanName; + poolPath = other928.poolPath; __isset = other928.__isset; } -UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other929) { - message = other929.message; +WMDropPoolRequest& WMDropPoolRequest::operator=(const WMDropPoolRequest& other929) { + resourcePlanName = other929.resourcePlanName; + poolPath = other929.poolPath; __isset = other929.__isset; return *this; } -void UnknownDBException::printTo(std::ostream& out) const { +void WMDropPoolRequest::printTo(std::ostream& out) const { using ::apache::thrift::to_string; - out << "UnknownDBException("; - out << "message=" << to_string(message); + out << "WMDropPoolRequest("; + out << "resourcePlanName="; (__isset.resourcePlanName ? (out << to_string(resourcePlanName)) : (out << "")); + out << ", " << "poolPath="; (__isset.poolPath ? (out << to_string(poolPath)) : (out << "")); out << ")"; } -const char* UnknownDBException::what() const throw() { - try { - std::stringstream ss; - ss << "TException - service has thrown: " << *this; - this->thriftTExceptionMessageHolder_ = ss.str(); - return this->thriftTExceptionMessageHolder_.c_str(); - } catch (const std::exception&) { - return "TException - service has thrown: UnknownDBException"; - } -} - -AlreadyExistsException::~AlreadyExistsException() throw() { +WMDropPoolResponse::~WMDropPoolResponse() throw() { } -void AlreadyExistsException::__set_message(const std::string& val) { - this->message = val; -} - -uint32_t AlreadyExistsException::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t WMDropPoolResponse::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -23424,20 +23411,7 @@ uint32_t AlreadyExistsException::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_STOP) { break; } - switch (fid) - { - case 1: - if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->message); - this->__isset.message = true; - } else { - xfer += iprot->skip(ftype); - } - break; - default: - xfer += iprot->skip(ftype); - break; - } + xfer += iprot->skip(ftype); xfer += iprot->readFieldEnd(); } @@ -23446,63 +23420,51 @@ uint32_t AlreadyExistsException::read(::apache::thrift::protocol::TProtocol* ipr return xfer; } -uint32_t AlreadyExistsException::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t WMDropPoolResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("AlreadyExistsException"); - - xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString(this->message); - xfer += oprot->writeFieldEnd(); + xfer += oprot->writeStructBegin("WMDropPoolResponse"); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; } -void swap(AlreadyExistsException &a, AlreadyExistsException &b) { +void swap(WMDropPoolResponse &a, WMDropPoolResponse &b) { using ::std::swap; - swap(a.message, b.message); - swap(a.__isset, b.__isset); + (void) a; + (void) b; } -AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other930) : TException() { - message = other930.message; - __isset = other930.__isset; +WMDropPoolResponse::WMDropPoolResponse(const WMDropPoolResponse& other930) { + (void) other930; } -AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other931) { - message = other931.message; - __isset = other931.__isset; +WMDropPoolResponse& WMDropPoolResponse::operator=(const WMDropPoolResponse& other931) { + (void) other931; return *this; } -void AlreadyExistsException::printTo(std::ostream& out) const { +void WMDropPoolResponse::printTo(std::ostream& out) const { using ::apache::thrift::to_string; - out << "AlreadyExistsException("; - out << "message=" << to_string(message); + out << "WMDropPoolResponse("; out << ")"; } -const char* AlreadyExistsException::what() const throw() { - try { - std::stringstream ss; - ss << "TException - service has thrown: " << *this; - this->thriftTExceptionMessageHolder_ = ss.str(); - return this->thriftTExceptionMessageHolder_.c_str(); - } catch (const std::exception&) { - return "TException - service has thrown: AlreadyExistsException"; - } + +WMCreateOrUpdateMappingRequest::~WMCreateOrUpdateMappingRequest() throw() { } -InvalidPartitionException::~InvalidPartitionException() throw() { +void WMCreateOrUpdateMappingRequest::__set_mapping(const WMMapping& val) { + this->mapping = val; +__isset.mapping = true; } - -void InvalidPartitionException::__set_message(const std::string& val) { - this->message = val; +void WMCreateOrUpdateMappingRequest::__set_update(const bool val) { + this->update = val; +__isset.update = true; } -uint32_t InvalidPartitionException::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t WMCreateOrUpdateMappingRequest::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -23524,9 +23486,17 @@ uint32_t InvalidPartitionException::read(::apache::thrift::protocol::TProtocol* switch (fid) { case 1: - if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->message); - this->__isset.message = true; + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->mapping.read(iprot); + this->__isset.mapping = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->update); + this->__isset.update = true; } else { xfer += iprot->skip(ftype); } @@ -23543,63 +23513,58 @@ uint32_t InvalidPartitionException::read(::apache::thrift::protocol::TProtocol* return xfer; } -uint32_t InvalidPartitionException::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t WMCreateOrUpdateMappingRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("InvalidPartitionException"); - - xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString(this->message); - xfer += oprot->writeFieldEnd(); + xfer += oprot->writeStructBegin("WMCreateOrUpdateMappingRequest"); + if (this->__isset.mapping) { + xfer += oprot->writeFieldBegin("mapping", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->mapping.write(oprot); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.update) { + xfer += oprot->writeFieldBegin("update", ::apache::thrift::protocol::T_BOOL, 2); + xfer += oprot->writeBool(this->update); + xfer += oprot->writeFieldEnd(); + } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; } -void swap(InvalidPartitionException &a, InvalidPartitionException &b) { +void swap(WMCreateOrUpdateMappingRequest &a, WMCreateOrUpdateMappingRequest &b) { using ::std::swap; - swap(a.message, b.message); + swap(a.mapping, b.mapping); + swap(a.update, b.update); swap(a.__isset, b.__isset); } -InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other932) : TException() { - message = other932.message; +WMCreateOrUpdateMappingRequest::WMCreateOrUpdateMappingRequest(const WMCreateOrUpdateMappingRequest& other932) { + mapping = other932.mapping; + update = other932.update; __isset = other932.__isset; } -InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other933) { - message = other933.message; +WMCreateOrUpdateMappingRequest& WMCreateOrUpdateMappingRequest::operator=(const WMCreateOrUpdateMappingRequest& other933) { + mapping = other933.mapping; + update = other933.update; __isset = other933.__isset; return *this; } -void InvalidPartitionException::printTo(std::ostream& out) const { +void WMCreateOrUpdateMappingRequest::printTo(std::ostream& out) const { using ::apache::thrift::to_string; - out << "InvalidPartitionException("; - out << "message=" << to_string(message); + out << "WMCreateOrUpdateMappingRequest("; + out << "mapping="; (__isset.mapping ? (out << to_string(mapping)) : (out << "")); + out << ", " << "update="; (__isset.update ? (out << to_string(update)) : (out << "")); out << ")"; } -const char* InvalidPartitionException::what() const throw() { - try { - std::stringstream ss; - ss << "TException - service has thrown: " << *this; - this->thriftTExceptionMessageHolder_ = ss.str(); - return this->thriftTExceptionMessageHolder_.c_str(); - } catch (const std::exception&) { - return "TException - service has thrown: InvalidPartitionException"; - } -} - -UnknownPartitionException::~UnknownPartitionException() throw() { +WMCreateOrUpdateMappingResponse::~WMCreateOrUpdateMappingResponse() throw() { } -void UnknownPartitionException::__set_message(const std::string& val) { - this->message = val; -} - -uint32_t UnknownPartitionException::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t WMCreateOrUpdateMappingResponse::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -23618,13 +23583,930 @@ uint32_t UnknownPartitionException::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_STOP) { break; } - switch (fid) - { - case 1: - if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->message); - this->__isset.message = true; - } else { + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WMCreateOrUpdateMappingResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMCreateOrUpdateMappingResponse"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMCreateOrUpdateMappingResponse &a, WMCreateOrUpdateMappingResponse &b) { + using ::std::swap; + (void) a; + (void) b; +} + +WMCreateOrUpdateMappingResponse::WMCreateOrUpdateMappingResponse(const WMCreateOrUpdateMappingResponse& other934) { + (void) other934; +} +WMCreateOrUpdateMappingResponse& WMCreateOrUpdateMappingResponse::operator=(const WMCreateOrUpdateMappingResponse& other935) { + (void) other935; + return *this; +} +void WMCreateOrUpdateMappingResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMCreateOrUpdateMappingResponse("; + out << ")"; +} + + +WMDropMappingRequest::~WMDropMappingRequest() throw() { +} + + +void WMDropMappingRequest::__set_mapping(const WMMapping& val) { + this->mapping = val; +__isset.mapping = true; +} + +uint32_t WMDropMappingRequest::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->mapping.read(iprot); + this->__isset.mapping = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WMDropMappingRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMDropMappingRequest"); + + if (this->__isset.mapping) { + xfer += oprot->writeFieldBegin("mapping", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->mapping.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMDropMappingRequest &a, WMDropMappingRequest &b) { + using ::std::swap; + swap(a.mapping, b.mapping); + swap(a.__isset, b.__isset); +} + +WMDropMappingRequest::WMDropMappingRequest(const WMDropMappingRequest& other936) { + mapping = other936.mapping; + __isset = other936.__isset; +} +WMDropMappingRequest& WMDropMappingRequest::operator=(const WMDropMappingRequest& other937) { + mapping = other937.mapping; + __isset = other937.__isset; + return *this; +} +void WMDropMappingRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMDropMappingRequest("; + out << "mapping="; (__isset.mapping ? (out << to_string(mapping)) : (out << "")); + out << ")"; +} + + +WMDropMappingResponse::~WMDropMappingResponse() throw() { +} + + +uint32_t WMDropMappingResponse::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 WMDropMappingResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMDropMappingResponse"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMDropMappingResponse &a, WMDropMappingResponse &b) { + using ::std::swap; + (void) a; + (void) b; +} + +WMDropMappingResponse::WMDropMappingResponse(const WMDropMappingResponse& other938) { + (void) other938; +} +WMDropMappingResponse& WMDropMappingResponse::operator=(const WMDropMappingResponse& other939) { + (void) other939; + return *this; +} +void WMDropMappingResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMDropMappingResponse("; + out << ")"; +} + + +WMCreateOrDropTriggerToPoolMappingRequest::~WMCreateOrDropTriggerToPoolMappingRequest() throw() { +} + + +void WMCreateOrDropTriggerToPoolMappingRequest::__set_resourcePlanName(const std::string& val) { + this->resourcePlanName = val; +__isset.resourcePlanName = true; +} + +void WMCreateOrDropTriggerToPoolMappingRequest::__set_triggerName(const std::string& val) { + this->triggerName = val; +__isset.triggerName = true; +} + +void WMCreateOrDropTriggerToPoolMappingRequest::__set_poolPath(const std::string& val) { + this->poolPath = val; +__isset.poolPath = true; +} + +void WMCreateOrDropTriggerToPoolMappingRequest::__set_drop(const bool val) { + this->drop = val; +__isset.drop = true; +} + +uint32_t WMCreateOrDropTriggerToPoolMappingRequest::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_STRING) { + xfer += iprot->readString(this->triggerName); + this->__isset.triggerName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->poolPath); + this->__isset.poolPath = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->drop); + this->__isset.drop = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t WMCreateOrDropTriggerToPoolMappingRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMCreateOrDropTriggerToPoolMappingRequest"); + + 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(); + } + if (this->__isset.poolPath) { + xfer += oprot->writeFieldBegin("poolPath", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->poolPath); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.drop) { + xfer += oprot->writeFieldBegin("drop", ::apache::thrift::protocol::T_BOOL, 4); + xfer += oprot->writeBool(this->drop); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMCreateOrDropTriggerToPoolMappingRequest &a, WMCreateOrDropTriggerToPoolMappingRequest &b) { + using ::std::swap; + swap(a.resourcePlanName, b.resourcePlanName); + swap(a.triggerName, b.triggerName); + swap(a.poolPath, b.poolPath); + swap(a.drop, b.drop); + swap(a.__isset, b.__isset); +} + +WMCreateOrDropTriggerToPoolMappingRequest::WMCreateOrDropTriggerToPoolMappingRequest(const WMCreateOrDropTriggerToPoolMappingRequest& other940) { + resourcePlanName = other940.resourcePlanName; + triggerName = other940.triggerName; + poolPath = other940.poolPath; + drop = other940.drop; + __isset = other940.__isset; +} +WMCreateOrDropTriggerToPoolMappingRequest& WMCreateOrDropTriggerToPoolMappingRequest::operator=(const WMCreateOrDropTriggerToPoolMappingRequest& other941) { + resourcePlanName = other941.resourcePlanName; + triggerName = other941.triggerName; + poolPath = other941.poolPath; + drop = other941.drop; + __isset = other941.__isset; + return *this; +} +void WMCreateOrDropTriggerToPoolMappingRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMCreateOrDropTriggerToPoolMappingRequest("; + out << "resourcePlanName="; (__isset.resourcePlanName ? (out << to_string(resourcePlanName)) : (out << "")); + out << ", " << "triggerName="; (__isset.triggerName ? (out << to_string(triggerName)) : (out << "")); + out << ", " << "poolPath="; (__isset.poolPath ? (out << to_string(poolPath)) : (out << "")); + out << ", " << "drop="; (__isset.drop ? (out << to_string(drop)) : (out << "")); + out << ")"; +} + + +WMCreateOrDropTriggerToPoolMappingResponse::~WMCreateOrDropTriggerToPoolMappingResponse() throw() { +} + + +uint32_t WMCreateOrDropTriggerToPoolMappingResponse::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 WMCreateOrDropTriggerToPoolMappingResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMCreateOrDropTriggerToPoolMappingResponse"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMCreateOrDropTriggerToPoolMappingResponse &a, WMCreateOrDropTriggerToPoolMappingResponse &b) { + using ::std::swap; + (void) a; + (void) b; +} + +WMCreateOrDropTriggerToPoolMappingResponse::WMCreateOrDropTriggerToPoolMappingResponse(const WMCreateOrDropTriggerToPoolMappingResponse& other942) { + (void) other942; +} +WMCreateOrDropTriggerToPoolMappingResponse& WMCreateOrDropTriggerToPoolMappingResponse::operator=(const WMCreateOrDropTriggerToPoolMappingResponse& other943) { + (void) other943; + return *this; +} +void WMCreateOrDropTriggerToPoolMappingResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMCreateOrDropTriggerToPoolMappingResponse("; + out << ")"; +} + + +MetaException::~MetaException() throw() { +} + + +void MetaException::__set_message(const std::string& val) { + this->message = val; +} + +uint32_t MetaException::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->message); + this->__isset.message = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t MetaException::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("MetaException"); + + xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->message); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(MetaException &a, MetaException &b) { + using ::std::swap; + swap(a.message, b.message); + swap(a.__isset, b.__isset); +} + +MetaException::MetaException(const MetaException& other944) : TException() { + message = other944.message; + __isset = other944.__isset; +} +MetaException& MetaException::operator=(const MetaException& other945) { + message = other945.message; + __isset = other945.__isset; + return *this; +} +void MetaException::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "MetaException("; + out << "message=" << to_string(message); + out << ")"; +} + +const char* MetaException::what() const throw() { + try { + std::stringstream ss; + ss << "TException - service has thrown: " << *this; + this->thriftTExceptionMessageHolder_ = ss.str(); + return this->thriftTExceptionMessageHolder_.c_str(); + } catch (const std::exception&) { + return "TException - service has thrown: MetaException"; + } +} + + +UnknownTableException::~UnknownTableException() throw() { +} + + +void UnknownTableException::__set_message(const std::string& val) { + this->message = val; +} + +uint32_t UnknownTableException::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->message); + this->__isset.message = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t UnknownTableException::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("UnknownTableException"); + + xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->message); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(UnknownTableException &a, UnknownTableException &b) { + using ::std::swap; + swap(a.message, b.message); + swap(a.__isset, b.__isset); +} + +UnknownTableException::UnknownTableException(const UnknownTableException& other946) : TException() { + message = other946.message; + __isset = other946.__isset; +} +UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other947) { + message = other947.message; + __isset = other947.__isset; + return *this; +} +void UnknownTableException::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "UnknownTableException("; + out << "message=" << to_string(message); + out << ")"; +} + +const char* UnknownTableException::what() const throw() { + try { + std::stringstream ss; + ss << "TException - service has thrown: " << *this; + this->thriftTExceptionMessageHolder_ = ss.str(); + return this->thriftTExceptionMessageHolder_.c_str(); + } catch (const std::exception&) { + return "TException - service has thrown: UnknownTableException"; + } +} + + +UnknownDBException::~UnknownDBException() throw() { +} + + +void UnknownDBException::__set_message(const std::string& val) { + this->message = val; +} + +uint32_t UnknownDBException::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->message); + this->__isset.message = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t UnknownDBException::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("UnknownDBException"); + + xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->message); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(UnknownDBException &a, UnknownDBException &b) { + using ::std::swap; + swap(a.message, b.message); + swap(a.__isset, b.__isset); +} + +UnknownDBException::UnknownDBException(const UnknownDBException& other948) : TException() { + message = other948.message; + __isset = other948.__isset; +} +UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other949) { + message = other949.message; + __isset = other949.__isset; + return *this; +} +void UnknownDBException::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "UnknownDBException("; + out << "message=" << to_string(message); + out << ")"; +} + +const char* UnknownDBException::what() const throw() { + try { + std::stringstream ss; + ss << "TException - service has thrown: " << *this; + this->thriftTExceptionMessageHolder_ = ss.str(); + return this->thriftTExceptionMessageHolder_.c_str(); + } catch (const std::exception&) { + return "TException - service has thrown: UnknownDBException"; + } +} + + +AlreadyExistsException::~AlreadyExistsException() throw() { +} + + +void AlreadyExistsException::__set_message(const std::string& val) { + this->message = val; +} + +uint32_t AlreadyExistsException::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->message); + this->__isset.message = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t AlreadyExistsException::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("AlreadyExistsException"); + + xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->message); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(AlreadyExistsException &a, AlreadyExistsException &b) { + using ::std::swap; + swap(a.message, b.message); + swap(a.__isset, b.__isset); +} + +AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other950) : TException() { + message = other950.message; + __isset = other950.__isset; +} +AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other951) { + message = other951.message; + __isset = other951.__isset; + return *this; +} +void AlreadyExistsException::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "AlreadyExistsException("; + out << "message=" << to_string(message); + out << ")"; +} + +const char* AlreadyExistsException::what() const throw() { + try { + std::stringstream ss; + ss << "TException - service has thrown: " << *this; + this->thriftTExceptionMessageHolder_ = ss.str(); + return this->thriftTExceptionMessageHolder_.c_str(); + } catch (const std::exception&) { + return "TException - service has thrown: AlreadyExistsException"; + } +} + + +InvalidPartitionException::~InvalidPartitionException() throw() { +} + + +void InvalidPartitionException::__set_message(const std::string& val) { + this->message = val; +} + +uint32_t InvalidPartitionException::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->message); + this->__isset.message = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t InvalidPartitionException::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("InvalidPartitionException"); + + xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->message); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(InvalidPartitionException &a, InvalidPartitionException &b) { + using ::std::swap; + swap(a.message, b.message); + swap(a.__isset, b.__isset); +} + +InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other952) : TException() { + message = other952.message; + __isset = other952.__isset; +} +InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other953) { + message = other953.message; + __isset = other953.__isset; + return *this; +} +void InvalidPartitionException::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "InvalidPartitionException("; + out << "message=" << to_string(message); + out << ")"; +} + +const char* InvalidPartitionException::what() const throw() { + try { + std::stringstream ss; + ss << "TException - service has thrown: " << *this; + this->thriftTExceptionMessageHolder_ = ss.str(); + return this->thriftTExceptionMessageHolder_.c_str(); + } catch (const std::exception&) { + return "TException - service has thrown: InvalidPartitionException"; + } +} + + +UnknownPartitionException::~UnknownPartitionException() throw() { +} + + +void UnknownPartitionException::__set_message(const std::string& val) { + this->message = val; +} + +uint32_t UnknownPartitionException::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->message); + this->__isset.message = true; + } else { xfer += iprot->skip(ftype); } break; @@ -23660,13 +24542,13 @@ void swap(UnknownPartitionException &a, UnknownPartitionException &b) { swap(a.__isset, b.__isset); } -UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other934) : TException() { - message = other934.message; - __isset = other934.__isset; +UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other954) : TException() { + message = other954.message; + __isset = other954.__isset; } -UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other935) { - message = other935.message; - __isset = other935.__isset; +UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other955) { + message = other955.message; + __isset = other955.__isset; return *this; } void UnknownPartitionException::printTo(std::ostream& out) const { @@ -23757,13 +24639,13 @@ void swap(InvalidObjectException &a, InvalidObjectException &b) { swap(a.__isset, b.__isset); } -InvalidObjectException::InvalidObjectException(const InvalidObjectException& other936) : TException() { - message = other936.message; - __isset = other936.__isset; +InvalidObjectException::InvalidObjectException(const InvalidObjectException& other956) : TException() { + message = other956.message; + __isset = other956.__isset; } -InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other937) { - message = other937.message; - __isset = other937.__isset; +InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other957) { + message = other957.message; + __isset = other957.__isset; return *this; } void InvalidObjectException::printTo(std::ostream& out) const { @@ -23854,13 +24736,13 @@ void swap(NoSuchObjectException &a, NoSuchObjectException &b) { swap(a.__isset, b.__isset); } -NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other938) : TException() { - message = other938.message; - __isset = other938.__isset; +NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other958) : TException() { + message = other958.message; + __isset = other958.__isset; } -NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other939) { - message = other939.message; - __isset = other939.__isset; +NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other959) { + message = other959.message; + __isset = other959.__isset; return *this; } void NoSuchObjectException::printTo(std::ostream& out) const { @@ -23951,13 +24833,13 @@ void swap(IndexAlreadyExistsException &a, IndexAlreadyExistsException &b) { swap(a.__isset, b.__isset); } -IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other940) : TException() { - message = other940.message; - __isset = other940.__isset; +IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other960) : TException() { + message = other960.message; + __isset = other960.__isset; } -IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other941) { - message = other941.message; - __isset = other941.__isset; +IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other961) { + message = other961.message; + __isset = other961.__isset; return *this; } void IndexAlreadyExistsException::printTo(std::ostream& out) const { @@ -24048,13 +24930,13 @@ void swap(InvalidOperationException &a, InvalidOperationException &b) { swap(a.__isset, b.__isset); } -InvalidOperationException::InvalidOperationException(const InvalidOperationException& other942) : TException() { - message = other942.message; - __isset = other942.__isset; +InvalidOperationException::InvalidOperationException(const InvalidOperationException& other962) : TException() { + message = other962.message; + __isset = other962.__isset; } -InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other943) { - message = other943.message; - __isset = other943.__isset; +InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other963) { + message = other963.message; + __isset = other963.__isset; return *this; } void InvalidOperationException::printTo(std::ostream& out) const { @@ -24145,13 +25027,13 @@ void swap(ConfigValSecurityException &a, ConfigValSecurityException &b) { swap(a.__isset, b.__isset); } -ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other944) : TException() { - message = other944.message; - __isset = other944.__isset; +ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other964) : TException() { + message = other964.message; + __isset = other964.__isset; } -ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other945) { - message = other945.message; - __isset = other945.__isset; +ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other965) { + message = other965.message; + __isset = other965.__isset; return *this; } void ConfigValSecurityException::printTo(std::ostream& out) const { @@ -24242,13 +25124,13 @@ void swap(InvalidInputException &a, InvalidInputException &b) { swap(a.__isset, b.__isset); } -InvalidInputException::InvalidInputException(const InvalidInputException& other946) : TException() { - message = other946.message; - __isset = other946.__isset; +InvalidInputException::InvalidInputException(const InvalidInputException& other966) : TException() { + message = other966.message; + __isset = other966.__isset; } -InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other947) { - message = other947.message; - __isset = other947.__isset; +InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other967) { + message = other967.message; + __isset = other967.__isset; return *this; } void InvalidInputException::printTo(std::ostream& out) const { @@ -24339,13 +25221,13 @@ void swap(NoSuchTxnException &a, NoSuchTxnException &b) { swap(a.__isset, b.__isset); } -NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other948) : TException() { - message = other948.message; - __isset = other948.__isset; +NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other968) : TException() { + message = other968.message; + __isset = other968.__isset; } -NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other949) { - message = other949.message; - __isset = other949.__isset; +NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other969) { + message = other969.message; + __isset = other969.__isset; return *this; } void NoSuchTxnException::printTo(std::ostream& out) const { @@ -24436,13 +25318,13 @@ void swap(TxnAbortedException &a, TxnAbortedException &b) { swap(a.__isset, b.__isset); } -TxnAbortedException::TxnAbortedException(const TxnAbortedException& other950) : TException() { - message = other950.message; - __isset = other950.__isset; +TxnAbortedException::TxnAbortedException(const TxnAbortedException& other970) : TException() { + message = other970.message; + __isset = other970.__isset; } -TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other951) { - message = other951.message; - __isset = other951.__isset; +TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other971) { + message = other971.message; + __isset = other971.__isset; return *this; } void TxnAbortedException::printTo(std::ostream& out) const { @@ -24533,13 +25415,13 @@ void swap(TxnOpenException &a, TxnOpenException &b) { swap(a.__isset, b.__isset); } -TxnOpenException::TxnOpenException(const TxnOpenException& other952) : TException() { - message = other952.message; - __isset = other952.__isset; +TxnOpenException::TxnOpenException(const TxnOpenException& other972) : TException() { + message = other972.message; + __isset = other972.__isset; } -TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other953) { - message = other953.message; - __isset = other953.__isset; +TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other973) { + message = other973.message; + __isset = other973.__isset; return *this; } void TxnOpenException::printTo(std::ostream& out) const { @@ -24630,13 +25512,13 @@ void swap(NoSuchLockException &a, NoSuchLockException &b) { swap(a.__isset, b.__isset); } -NoSuchLockException::NoSuchLockException(const NoSuchLockException& other954) : TException() { - message = other954.message; - __isset = other954.__isset; +NoSuchLockException::NoSuchLockException(const NoSuchLockException& other974) : TException() { + message = other974.message; + __isset = other974.__isset; } -NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other955) { - message = other955.message; - __isset = other955.__isset; +NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other975) { + message = other975.message; + __isset = other975.__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 a46127bb09..5af8e1f084 100644 --- standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h +++ standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h @@ -497,6 +497,26 @@ class WMGetTriggersForResourePlanRequest; class WMGetTriggersForResourePlanResponse; +class WMCreateOrUpdatePoolRequest; + +class WMCreateOrUpdatePoolResponse; + +class WMDropPoolRequest; + +class WMDropPoolResponse; + +class WMCreateOrUpdateMappingRequest; + +class WMCreateOrUpdateMappingResponse; + +class WMDropMappingRequest; + +class WMDropMappingResponse; + +class WMCreateOrDropTriggerToPoolMappingRequest; + +class WMCreateOrDropTriggerToPoolMappingResponse; + class MetaException; class UnknownTableException; @@ -8562,8 +8582,7 @@ inline std::ostream& operator<<(std::ostream& out, const WMResourcePlan& obj) } typedef struct _WMPool__isset { - _WMPool__isset() : parentPoolName(false), allocFraction(false), queryParallelism(false), schedulingPolicy(false) {} - bool parentPoolName :1; + _WMPool__isset() : allocFraction(false), queryParallelism(false), schedulingPolicy(false) {} bool allocFraction :1; bool queryParallelism :1; bool schedulingPolicy :1; @@ -8574,13 +8593,12 @@ class WMPool { WMPool(const WMPool&); WMPool& operator=(const WMPool&); - WMPool() : resourcePlanName(), poolName(), parentPoolName(), allocFraction(0), queryParallelism(0), schedulingPolicy() { + WMPool() : resourcePlanName(), path(), allocFraction(0), queryParallelism(0), schedulingPolicy() { } virtual ~WMPool() throw(); std::string resourcePlanName; - std::string poolName; - std::string parentPoolName; + std::string path; double allocFraction; int32_t queryParallelism; std::string schedulingPolicy; @@ -8589,9 +8607,7 @@ class WMPool { void __set_resourcePlanName(const std::string& val); - void __set_poolName(const std::string& val); - - void __set_parentPoolName(const std::string& val); + void __set_path(const std::string& val); void __set_allocFraction(const double val); @@ -8603,11 +8619,7 @@ class WMPool { { if (!(resourcePlanName == rhs.resourcePlanName)) return false; - if (!(poolName == rhs.poolName)) - return false; - if (__isset.parentPoolName != rhs.__isset.parentPoolName) - return false; - else if (__isset.parentPoolName && !(parentPoolName == rhs.parentPoolName)) + if (!(path == rhs.path)) return false; if (__isset.allocFraction != rhs.__isset.allocFraction) return false; @@ -8710,8 +8722,8 @@ inline std::ostream& operator<<(std::ostream& out, const WMTrigger& obj) } typedef struct _WMMapping__isset { - _WMMapping__isset() : poolName(false), ordering(false) {} - bool poolName :1; + _WMMapping__isset() : poolPath(false), ordering(false) {} + bool poolPath :1; bool ordering :1; } _WMMapping__isset; @@ -8720,14 +8732,14 @@ class WMMapping { WMMapping(const WMMapping&); WMMapping& operator=(const WMMapping&); - WMMapping() : resourcePlanName(), entityType(), entityName(), poolName(), ordering(0) { + WMMapping() : resourcePlanName(), entityType(), entityName(), poolPath(), ordering(0) { } virtual ~WMMapping() throw(); std::string resourcePlanName; std::string entityType; std::string entityName; - std::string poolName; + std::string poolPath; int32_t ordering; _WMMapping__isset __isset; @@ -8738,7 +8750,7 @@ class WMMapping { void __set_entityName(const std::string& val); - void __set_poolName(const std::string& val); + void __set_poolPath(const std::string& val); void __set_ordering(const int32_t val); @@ -8750,9 +8762,9 @@ class WMMapping { return false; if (!(entityName == rhs.entityName)) return false; - if (__isset.poolName != rhs.__isset.poolName) + if (__isset.poolPath != rhs.__isset.poolPath) return false; - else if (__isset.poolName && !(poolName == rhs.poolName)) + else if (__isset.poolPath && !(poolPath == rhs.poolPath)) return false; if (__isset.ordering != rhs.__isset.ordering) return false; @@ -9665,6 +9677,477 @@ inline std::ostream& operator<<(std::ostream& out, const WMGetTriggersForResoure return out; } +typedef struct _WMCreateOrUpdatePoolRequest__isset { + _WMCreateOrUpdatePoolRequest__isset() : pool(false), newPoolPath(false), update(false) {} + bool pool :1; + bool newPoolPath :1; + bool update :1; +} _WMCreateOrUpdatePoolRequest__isset; + +class WMCreateOrUpdatePoolRequest { + public: + + WMCreateOrUpdatePoolRequest(const WMCreateOrUpdatePoolRequest&); + WMCreateOrUpdatePoolRequest& operator=(const WMCreateOrUpdatePoolRequest&); + WMCreateOrUpdatePoolRequest() : newPoolPath(), update(0) { + } + + virtual ~WMCreateOrUpdatePoolRequest() throw(); + WMPool pool; + std::string newPoolPath; + bool update; + + _WMCreateOrUpdatePoolRequest__isset __isset; + + void __set_pool(const WMPool& val); + + void __set_newPoolPath(const std::string& val); + + void __set_update(const bool val); + + bool operator == (const WMCreateOrUpdatePoolRequest & rhs) const + { + if (__isset.pool != rhs.__isset.pool) + return false; + else if (__isset.pool && !(pool == rhs.pool)) + return false; + if (__isset.newPoolPath != rhs.__isset.newPoolPath) + return false; + else if (__isset.newPoolPath && !(newPoolPath == rhs.newPoolPath)) + return false; + if (__isset.update != rhs.__isset.update) + return false; + else if (__isset.update && !(update == rhs.update)) + return false; + return true; + } + bool operator != (const WMCreateOrUpdatePoolRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMCreateOrUpdatePoolRequest & ) 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(WMCreateOrUpdatePoolRequest &a, WMCreateOrUpdatePoolRequest &b); + +inline std::ostream& operator<<(std::ostream& out, const WMCreateOrUpdatePoolRequest& obj) +{ + obj.printTo(out); + return out; +} + + +class WMCreateOrUpdatePoolResponse { + public: + + WMCreateOrUpdatePoolResponse(const WMCreateOrUpdatePoolResponse&); + WMCreateOrUpdatePoolResponse& operator=(const WMCreateOrUpdatePoolResponse&); + WMCreateOrUpdatePoolResponse() { + } + + virtual ~WMCreateOrUpdatePoolResponse() throw(); + + bool operator == (const WMCreateOrUpdatePoolResponse & /* rhs */) const + { + return true; + } + bool operator != (const WMCreateOrUpdatePoolResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMCreateOrUpdatePoolResponse & ) 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(WMCreateOrUpdatePoolResponse &a, WMCreateOrUpdatePoolResponse &b); + +inline std::ostream& operator<<(std::ostream& out, const WMCreateOrUpdatePoolResponse& obj) +{ + obj.printTo(out); + return out; +} + +typedef struct _WMDropPoolRequest__isset { + _WMDropPoolRequest__isset() : resourcePlanName(false), poolPath(false) {} + bool resourcePlanName :1; + bool poolPath :1; +} _WMDropPoolRequest__isset; + +class WMDropPoolRequest { + public: + + WMDropPoolRequest(const WMDropPoolRequest&); + WMDropPoolRequest& operator=(const WMDropPoolRequest&); + WMDropPoolRequest() : resourcePlanName(), poolPath() { + } + + virtual ~WMDropPoolRequest() throw(); + std::string resourcePlanName; + std::string poolPath; + + _WMDropPoolRequest__isset __isset; + + void __set_resourcePlanName(const std::string& val); + + void __set_poolPath(const std::string& val); + + bool operator == (const WMDropPoolRequest & rhs) const + { + if (__isset.resourcePlanName != rhs.__isset.resourcePlanName) + return false; + else if (__isset.resourcePlanName && !(resourcePlanName == rhs.resourcePlanName)) + return false; + if (__isset.poolPath != rhs.__isset.poolPath) + return false; + else if (__isset.poolPath && !(poolPath == rhs.poolPath)) + return false; + return true; + } + bool operator != (const WMDropPoolRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMDropPoolRequest & ) 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(WMDropPoolRequest &a, WMDropPoolRequest &b); + +inline std::ostream& operator<<(std::ostream& out, const WMDropPoolRequest& obj) +{ + obj.printTo(out); + return out; +} + + +class WMDropPoolResponse { + public: + + WMDropPoolResponse(const WMDropPoolResponse&); + WMDropPoolResponse& operator=(const WMDropPoolResponse&); + WMDropPoolResponse() { + } + + virtual ~WMDropPoolResponse() throw(); + + bool operator == (const WMDropPoolResponse & /* rhs */) const + { + return true; + } + bool operator != (const WMDropPoolResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMDropPoolResponse & ) 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(WMDropPoolResponse &a, WMDropPoolResponse &b); + +inline std::ostream& operator<<(std::ostream& out, const WMDropPoolResponse& obj) +{ + obj.printTo(out); + return out; +} + +typedef struct _WMCreateOrUpdateMappingRequest__isset { + _WMCreateOrUpdateMappingRequest__isset() : mapping(false), update(false) {} + bool mapping :1; + bool update :1; +} _WMCreateOrUpdateMappingRequest__isset; + +class WMCreateOrUpdateMappingRequest { + public: + + WMCreateOrUpdateMappingRequest(const WMCreateOrUpdateMappingRequest&); + WMCreateOrUpdateMappingRequest& operator=(const WMCreateOrUpdateMappingRequest&); + WMCreateOrUpdateMappingRequest() : update(0) { + } + + virtual ~WMCreateOrUpdateMappingRequest() throw(); + WMMapping mapping; + bool update; + + _WMCreateOrUpdateMappingRequest__isset __isset; + + void __set_mapping(const WMMapping& val); + + void __set_update(const bool val); + + bool operator == (const WMCreateOrUpdateMappingRequest & rhs) const + { + if (__isset.mapping != rhs.__isset.mapping) + return false; + else if (__isset.mapping && !(mapping == rhs.mapping)) + return false; + if (__isset.update != rhs.__isset.update) + return false; + else if (__isset.update && !(update == rhs.update)) + return false; + return true; + } + bool operator != (const WMCreateOrUpdateMappingRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMCreateOrUpdateMappingRequest & ) 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(WMCreateOrUpdateMappingRequest &a, WMCreateOrUpdateMappingRequest &b); + +inline std::ostream& operator<<(std::ostream& out, const WMCreateOrUpdateMappingRequest& obj) +{ + obj.printTo(out); + return out; +} + + +class WMCreateOrUpdateMappingResponse { + public: + + WMCreateOrUpdateMappingResponse(const WMCreateOrUpdateMappingResponse&); + WMCreateOrUpdateMappingResponse& operator=(const WMCreateOrUpdateMappingResponse&); + WMCreateOrUpdateMappingResponse() { + } + + virtual ~WMCreateOrUpdateMappingResponse() throw(); + + bool operator == (const WMCreateOrUpdateMappingResponse & /* rhs */) const + { + return true; + } + bool operator != (const WMCreateOrUpdateMappingResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMCreateOrUpdateMappingResponse & ) 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(WMCreateOrUpdateMappingResponse &a, WMCreateOrUpdateMappingResponse &b); + +inline std::ostream& operator<<(std::ostream& out, const WMCreateOrUpdateMappingResponse& obj) +{ + obj.printTo(out); + return out; +} + +typedef struct _WMDropMappingRequest__isset { + _WMDropMappingRequest__isset() : mapping(false) {} + bool mapping :1; +} _WMDropMappingRequest__isset; + +class WMDropMappingRequest { + public: + + WMDropMappingRequest(const WMDropMappingRequest&); + WMDropMappingRequest& operator=(const WMDropMappingRequest&); + WMDropMappingRequest() { + } + + virtual ~WMDropMappingRequest() throw(); + WMMapping mapping; + + _WMDropMappingRequest__isset __isset; + + void __set_mapping(const WMMapping& val); + + bool operator == (const WMDropMappingRequest & rhs) const + { + if (__isset.mapping != rhs.__isset.mapping) + return false; + else if (__isset.mapping && !(mapping == rhs.mapping)) + return false; + return true; + } + bool operator != (const WMDropMappingRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMDropMappingRequest & ) 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(WMDropMappingRequest &a, WMDropMappingRequest &b); + +inline std::ostream& operator<<(std::ostream& out, const WMDropMappingRequest& obj) +{ + obj.printTo(out); + return out; +} + + +class WMDropMappingResponse { + public: + + WMDropMappingResponse(const WMDropMappingResponse&); + WMDropMappingResponse& operator=(const WMDropMappingResponse&); + WMDropMappingResponse() { + } + + virtual ~WMDropMappingResponse() throw(); + + bool operator == (const WMDropMappingResponse & /* rhs */) const + { + return true; + } + bool operator != (const WMDropMappingResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMDropMappingResponse & ) 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(WMDropMappingResponse &a, WMDropMappingResponse &b); + +inline std::ostream& operator<<(std::ostream& out, const WMDropMappingResponse& obj) +{ + obj.printTo(out); + return out; +} + +typedef struct _WMCreateOrDropTriggerToPoolMappingRequest__isset { + _WMCreateOrDropTriggerToPoolMappingRequest__isset() : resourcePlanName(false), triggerName(false), poolPath(false), drop(false) {} + bool resourcePlanName :1; + bool triggerName :1; + bool poolPath :1; + bool drop :1; +} _WMCreateOrDropTriggerToPoolMappingRequest__isset; + +class WMCreateOrDropTriggerToPoolMappingRequest { + public: + + WMCreateOrDropTriggerToPoolMappingRequest(const WMCreateOrDropTriggerToPoolMappingRequest&); + WMCreateOrDropTriggerToPoolMappingRequest& operator=(const WMCreateOrDropTriggerToPoolMappingRequest&); + WMCreateOrDropTriggerToPoolMappingRequest() : resourcePlanName(), triggerName(), poolPath(), drop(0) { + } + + virtual ~WMCreateOrDropTriggerToPoolMappingRequest() throw(); + std::string resourcePlanName; + std::string triggerName; + std::string poolPath; + bool drop; + + _WMCreateOrDropTriggerToPoolMappingRequest__isset __isset; + + void __set_resourcePlanName(const std::string& val); + + void __set_triggerName(const std::string& val); + + void __set_poolPath(const std::string& val); + + void __set_drop(const bool val); + + bool operator == (const WMCreateOrDropTriggerToPoolMappingRequest & 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; + if (__isset.poolPath != rhs.__isset.poolPath) + return false; + else if (__isset.poolPath && !(poolPath == rhs.poolPath)) + return false; + if (__isset.drop != rhs.__isset.drop) + return false; + else if (__isset.drop && !(drop == rhs.drop)) + return false; + return true; + } + bool operator != (const WMCreateOrDropTriggerToPoolMappingRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMCreateOrDropTriggerToPoolMappingRequest & ) 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(WMCreateOrDropTriggerToPoolMappingRequest &a, WMCreateOrDropTriggerToPoolMappingRequest &b); + +inline std::ostream& operator<<(std::ostream& out, const WMCreateOrDropTriggerToPoolMappingRequest& obj) +{ + obj.printTo(out); + return out; +} + + +class WMCreateOrDropTriggerToPoolMappingResponse { + public: + + WMCreateOrDropTriggerToPoolMappingResponse(const WMCreateOrDropTriggerToPoolMappingResponse&); + WMCreateOrDropTriggerToPoolMappingResponse& operator=(const WMCreateOrDropTriggerToPoolMappingResponse&); + WMCreateOrDropTriggerToPoolMappingResponse() { + } + + virtual ~WMCreateOrDropTriggerToPoolMappingResponse() throw(); + + bool operator == (const WMCreateOrDropTriggerToPoolMappingResponse & /* rhs */) const + { + return true; + } + bool operator != (const WMCreateOrDropTriggerToPoolMappingResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMCreateOrDropTriggerToPoolMappingResponse & ) 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(WMCreateOrDropTriggerToPoolMappingResponse &a, WMCreateOrDropTriggerToPoolMappingResponse &b); + +inline std::ostream& operator<<(std::ostream& out, const WMCreateOrDropTriggerToPoolMappingResponse& 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 1e5bc0800f..e8bea3a3a8 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 @@ -386,6 +386,16 @@ public WMGetTriggersForResourePlanResponse get_triggers_for_resourceplan(WMGetTriggersForResourePlanRequest request) throws NoSuchObjectException, MetaException, org.apache.thrift.TException; + public WMCreateOrUpdatePoolResponse create_or_update_wm_pool(WMCreateOrUpdatePoolRequest request) throws AlreadyExistsException, NoSuchObjectException, InvalidObjectException, MetaException, org.apache.thrift.TException; + + public WMDropPoolResponse drop_wm_pool(WMDropPoolRequest request) throws NoSuchObjectException, InvalidOperationException, MetaException, org.apache.thrift.TException; + + public WMCreateOrUpdateMappingResponse create_or_update_wm_mapping(WMCreateOrUpdateMappingRequest request) throws AlreadyExistsException, NoSuchObjectException, InvalidObjectException, MetaException, org.apache.thrift.TException; + + public WMDropMappingResponse drop_wm_mapping(WMDropMappingRequest request) throws NoSuchObjectException, InvalidOperationException, MetaException, org.apache.thrift.TException; + + public WMCreateOrDropTriggerToPoolMappingResponse create_or_drop_wm_trigger_to_pool_mapping(WMCreateOrDropTriggerToPoolMappingRequest request) throws AlreadyExistsException, NoSuchObjectException, InvalidObjectException, 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 { @@ -734,6 +744,16 @@ public void get_triggers_for_resourceplan(WMGetTriggersForResourePlanRequest request, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void create_or_update_wm_pool(WMCreateOrUpdatePoolRequest request, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + + public void drop_wm_pool(WMDropPoolRequest request, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + + public void create_or_update_wm_mapping(WMCreateOrUpdateMappingRequest request, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + + public void drop_wm_mapping(WMDropMappingRequest request, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + + public void create_or_drop_wm_trigger_to_pool_mapping(WMCreateOrDropTriggerToPoolMappingRequest 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 { @@ -5709,6 +5729,175 @@ public WMGetTriggersForResourePlanResponse recv_get_triggers_for_resourceplan() throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "get_triggers_for_resourceplan failed: unknown result"); } + public WMCreateOrUpdatePoolResponse create_or_update_wm_pool(WMCreateOrUpdatePoolRequest request) throws AlreadyExistsException, NoSuchObjectException, InvalidObjectException, MetaException, org.apache.thrift.TException + { + send_create_or_update_wm_pool(request); + return recv_create_or_update_wm_pool(); + } + + public void send_create_or_update_wm_pool(WMCreateOrUpdatePoolRequest request) throws org.apache.thrift.TException + { + create_or_update_wm_pool_args args = new create_or_update_wm_pool_args(); + args.setRequest(request); + sendBase("create_or_update_wm_pool", args); + } + + public WMCreateOrUpdatePoolResponse recv_create_or_update_wm_pool() throws AlreadyExistsException, NoSuchObjectException, InvalidObjectException, MetaException, org.apache.thrift.TException + { + create_or_update_wm_pool_result result = new create_or_update_wm_pool_result(); + receiveBase(result, "create_or_update_wm_pool"); + 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_or_update_wm_pool failed: unknown result"); + } + + public WMDropPoolResponse drop_wm_pool(WMDropPoolRequest request) throws NoSuchObjectException, InvalidOperationException, MetaException, org.apache.thrift.TException + { + send_drop_wm_pool(request); + return recv_drop_wm_pool(); + } + + public void send_drop_wm_pool(WMDropPoolRequest request) throws org.apache.thrift.TException + { + drop_wm_pool_args args = new drop_wm_pool_args(); + args.setRequest(request); + sendBase("drop_wm_pool", args); + } + + public WMDropPoolResponse recv_drop_wm_pool() throws NoSuchObjectException, InvalidOperationException, MetaException, org.apache.thrift.TException + { + drop_wm_pool_result result = new drop_wm_pool_result(); + receiveBase(result, "drop_wm_pool"); + 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_pool failed: unknown result"); + } + + public WMCreateOrUpdateMappingResponse create_or_update_wm_mapping(WMCreateOrUpdateMappingRequest request) throws AlreadyExistsException, NoSuchObjectException, InvalidObjectException, MetaException, org.apache.thrift.TException + { + send_create_or_update_wm_mapping(request); + return recv_create_or_update_wm_mapping(); + } + + public void send_create_or_update_wm_mapping(WMCreateOrUpdateMappingRequest request) throws org.apache.thrift.TException + { + create_or_update_wm_mapping_args args = new create_or_update_wm_mapping_args(); + args.setRequest(request); + sendBase("create_or_update_wm_mapping", args); + } + + public WMCreateOrUpdateMappingResponse recv_create_or_update_wm_mapping() throws AlreadyExistsException, NoSuchObjectException, InvalidObjectException, MetaException, org.apache.thrift.TException + { + create_or_update_wm_mapping_result result = new create_or_update_wm_mapping_result(); + receiveBase(result, "create_or_update_wm_mapping"); + 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_or_update_wm_mapping failed: unknown result"); + } + + public WMDropMappingResponse drop_wm_mapping(WMDropMappingRequest request) throws NoSuchObjectException, InvalidOperationException, MetaException, org.apache.thrift.TException + { + send_drop_wm_mapping(request); + return recv_drop_wm_mapping(); + } + + public void send_drop_wm_mapping(WMDropMappingRequest request) throws org.apache.thrift.TException + { + drop_wm_mapping_args args = new drop_wm_mapping_args(); + args.setRequest(request); + sendBase("drop_wm_mapping", args); + } + + public WMDropMappingResponse recv_drop_wm_mapping() throws NoSuchObjectException, InvalidOperationException, MetaException, org.apache.thrift.TException + { + drop_wm_mapping_result result = new drop_wm_mapping_result(); + receiveBase(result, "drop_wm_mapping"); + 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_mapping failed: unknown result"); + } + + public WMCreateOrDropTriggerToPoolMappingResponse create_or_drop_wm_trigger_to_pool_mapping(WMCreateOrDropTriggerToPoolMappingRequest request) throws AlreadyExistsException, NoSuchObjectException, InvalidObjectException, MetaException, org.apache.thrift.TException + { + send_create_or_drop_wm_trigger_to_pool_mapping(request); + return recv_create_or_drop_wm_trigger_to_pool_mapping(); + } + + public void send_create_or_drop_wm_trigger_to_pool_mapping(WMCreateOrDropTriggerToPoolMappingRequest request) throws org.apache.thrift.TException + { + create_or_drop_wm_trigger_to_pool_mapping_args args = new create_or_drop_wm_trigger_to_pool_mapping_args(); + args.setRequest(request); + sendBase("create_or_drop_wm_trigger_to_pool_mapping", args); + } + + public WMCreateOrDropTriggerToPoolMappingResponse recv_create_or_drop_wm_trigger_to_pool_mapping() throws AlreadyExistsException, NoSuchObjectException, InvalidObjectException, MetaException, org.apache.thrift.TException + { + create_or_drop_wm_trigger_to_pool_mapping_result result = new create_or_drop_wm_trigger_to_pool_mapping_result(); + receiveBase(result, "create_or_drop_wm_trigger_to_pool_mapping"); + 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_or_drop_wm_trigger_to_pool_mapping 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 { @@ -11416,7 +11605,7 @@ public void create_resource_plan(WMCreateResourcePlanRequest request, org.apache ___manager.call(method_call); } - public static class create_resource_plan_call extends org.apache.thrift.async.TAsyncMethodCall { + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class create_resource_plan_call extends org.apache.thrift.async.TAsyncMethodCall { private WMCreateResourcePlanRequest request; public create_resource_plan_call(WMCreateResourcePlanRequest 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); @@ -11448,7 +11637,7 @@ public void get_resource_plan(WMGetResourcePlanRequest request, org.apache.thrif ___manager.call(method_call); } - public static class get_resource_plan_call extends org.apache.thrift.async.TAsyncMethodCall { + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class get_resource_plan_call extends org.apache.thrift.async.TAsyncMethodCall { private WMGetResourcePlanRequest request; public get_resource_plan_call(WMGetResourcePlanRequest 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); @@ -11480,7 +11669,7 @@ public void get_all_resource_plans(WMGetAllResourcePlanRequest request, org.apac ___manager.call(method_call); } - public static class get_all_resource_plans_call extends org.apache.thrift.async.TAsyncMethodCall { + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class get_all_resource_plans_call extends org.apache.thrift.async.TAsyncMethodCall { private WMGetAllResourcePlanRequest request; public get_all_resource_plans_call(WMGetAllResourcePlanRequest 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); @@ -11512,7 +11701,7 @@ public void alter_resource_plan(WMAlterResourcePlanRequest request, org.apache.t ___manager.call(method_call); } - public static class alter_resource_plan_call extends org.apache.thrift.async.TAsyncMethodCall { + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class alter_resource_plan_call extends org.apache.thrift.async.TAsyncMethodCall { private WMAlterResourcePlanRequest request; public alter_resource_plan_call(WMAlterResourcePlanRequest 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); @@ -11544,7 +11733,7 @@ public void validate_resource_plan(WMValidateResourcePlanRequest request, org.ap ___manager.call(method_call); } - public static class validate_resource_plan_call extends org.apache.thrift.async.TAsyncMethodCall { + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class validate_resource_plan_call extends org.apache.thrift.async.TAsyncMethodCall { private WMValidateResourcePlanRequest request; public validate_resource_plan_call(WMValidateResourcePlanRequest 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); @@ -11576,7 +11765,7 @@ public void drop_resource_plan(WMDropResourcePlanRequest request, org.apache.thr ___manager.call(method_call); } - public static class drop_resource_plan_call extends org.apache.thrift.async.TAsyncMethodCall { + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class drop_resource_plan_call extends org.apache.thrift.async.TAsyncMethodCall { private WMDropResourcePlanRequest request; public drop_resource_plan_call(WMDropResourcePlanRequest 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); @@ -11608,7 +11797,7 @@ public void create_wm_trigger(WMCreateTriggerRequest request, org.apache.thrift. ___manager.call(method_call); } - public static class create_wm_trigger_call extends org.apache.thrift.async.TAsyncMethodCall { + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable 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); @@ -11640,7 +11829,7 @@ public void alter_wm_trigger(WMAlterTriggerRequest request, org.apache.thrift.as ___manager.call(method_call); } - public static class alter_wm_trigger_call extends org.apache.thrift.async.TAsyncMethodCall { + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable 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); @@ -11672,7 +11861,7 @@ public void drop_wm_trigger(WMDropTriggerRequest request, org.apache.thrift.asyn ___manager.call(method_call); } - public static class drop_wm_trigger_call extends org.apache.thrift.async.TAsyncMethodCall { + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable 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); @@ -11704,7 +11893,7 @@ public void get_triggers_for_resourceplan(WMGetTriggersForResourePlanRequest req ___manager.call(method_call); } - public static class get_triggers_for_resourceplan_call extends org.apache.thrift.async.TAsyncMethodCall { + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable 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); @@ -11729,6 +11918,166 @@ public WMGetTriggersForResourePlanResponse getResult() throws NoSuchObjectExcept } } + public void create_or_update_wm_pool(WMCreateOrUpdatePoolRequest request, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + create_or_update_wm_pool_call method_call = new create_or_update_wm_pool_call(request, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class create_or_update_wm_pool_call extends org.apache.thrift.async.TAsyncMethodCall { + private WMCreateOrUpdatePoolRequest request; + public create_or_update_wm_pool_call(WMCreateOrUpdatePoolRequest 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_or_update_wm_pool", org.apache.thrift.protocol.TMessageType.CALL, 0)); + create_or_update_wm_pool_args args = new create_or_update_wm_pool_args(); + args.setRequest(request); + args.write(prot); + prot.writeMessageEnd(); + } + + public WMCreateOrUpdatePoolResponse 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_or_update_wm_pool(); + } + } + + public void drop_wm_pool(WMDropPoolRequest request, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + drop_wm_pool_call method_call = new drop_wm_pool_call(request, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class drop_wm_pool_call extends org.apache.thrift.async.TAsyncMethodCall { + private WMDropPoolRequest request; + public drop_wm_pool_call(WMDropPoolRequest 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_pool", org.apache.thrift.protocol.TMessageType.CALL, 0)); + drop_wm_pool_args args = new drop_wm_pool_args(); + args.setRequest(request); + args.write(prot); + prot.writeMessageEnd(); + } + + public WMDropPoolResponse 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_pool(); + } + } + + public void create_or_update_wm_mapping(WMCreateOrUpdateMappingRequest request, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + create_or_update_wm_mapping_call method_call = new create_or_update_wm_mapping_call(request, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class create_or_update_wm_mapping_call extends org.apache.thrift.async.TAsyncMethodCall { + private WMCreateOrUpdateMappingRequest request; + public create_or_update_wm_mapping_call(WMCreateOrUpdateMappingRequest 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_or_update_wm_mapping", org.apache.thrift.protocol.TMessageType.CALL, 0)); + create_or_update_wm_mapping_args args = new create_or_update_wm_mapping_args(); + args.setRequest(request); + args.write(prot); + prot.writeMessageEnd(); + } + + public WMCreateOrUpdateMappingResponse 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_or_update_wm_mapping(); + } + } + + public void drop_wm_mapping(WMDropMappingRequest request, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + drop_wm_mapping_call method_call = new drop_wm_mapping_call(request, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class drop_wm_mapping_call extends org.apache.thrift.async.TAsyncMethodCall { + private WMDropMappingRequest request; + public drop_wm_mapping_call(WMDropMappingRequest 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_mapping", org.apache.thrift.protocol.TMessageType.CALL, 0)); + drop_wm_mapping_args args = new drop_wm_mapping_args(); + args.setRequest(request); + args.write(prot); + prot.writeMessageEnd(); + } + + public WMDropMappingResponse 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_mapping(); + } + } + + public void create_or_drop_wm_trigger_to_pool_mapping(WMCreateOrDropTriggerToPoolMappingRequest request, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + create_or_drop_wm_trigger_to_pool_mapping_call method_call = new create_or_drop_wm_trigger_to_pool_mapping_call(request, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class create_or_drop_wm_trigger_to_pool_mapping_call extends org.apache.thrift.async.TAsyncMethodCall { + private WMCreateOrDropTriggerToPoolMappingRequest request; + public create_or_drop_wm_trigger_to_pool_mapping_call(WMCreateOrDropTriggerToPoolMappingRequest 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_or_drop_wm_trigger_to_pool_mapping", org.apache.thrift.protocol.TMessageType.CALL, 0)); + create_or_drop_wm_trigger_to_pool_mapping_args args = new create_or_drop_wm_trigger_to_pool_mapping_args(); + args.setRequest(request); + args.write(prot); + prot.writeMessageEnd(); + } + + public WMCreateOrDropTriggerToPoolMappingResponse 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_or_drop_wm_trigger_to_pool_mapping(); + } + } + } @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 { @@ -11914,6 +12263,11 @@ protected Processor(I iface, Map extends org.apache.thrift.ProcessFunction { + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class create_resource_plan extends org.apache.thrift.ProcessFunction { public create_resource_plan() { super("create_resource_plan"); } @@ -16065,7 +16419,7 @@ public create_resource_plan_result getResult(I iface, create_resource_plan_args } } - public static class get_resource_plan extends org.apache.thrift.ProcessFunction { + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class get_resource_plan extends org.apache.thrift.ProcessFunction { public get_resource_plan() { super("get_resource_plan"); } @@ -16091,7 +16445,7 @@ public get_resource_plan_result getResult(I iface, get_resource_plan_args args) } } - public static class get_all_resource_plans extends org.apache.thrift.ProcessFunction { + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class get_all_resource_plans extends org.apache.thrift.ProcessFunction { public get_all_resource_plans() { super("get_all_resource_plans"); } @@ -16115,7 +16469,7 @@ public get_all_resource_plans_result getResult(I iface, get_all_resource_plans_a } } - public static class alter_resource_plan extends org.apache.thrift.ProcessFunction { + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class alter_resource_plan extends org.apache.thrift.ProcessFunction { public alter_resource_plan() { super("alter_resource_plan"); } @@ -16143,7 +16497,7 @@ public alter_resource_plan_result getResult(I iface, alter_resource_plan_args ar } } - public static class validate_resource_plan extends org.apache.thrift.ProcessFunction { + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class validate_resource_plan extends org.apache.thrift.ProcessFunction { public validate_resource_plan() { super("validate_resource_plan"); } @@ -16169,7 +16523,7 @@ public validate_resource_plan_result getResult(I iface, validate_resource_plan_a } } - public static class drop_resource_plan extends org.apache.thrift.ProcessFunction { + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class drop_resource_plan extends org.apache.thrift.ProcessFunction { public drop_resource_plan() { super("drop_resource_plan"); } @@ -16197,7 +16551,7 @@ public drop_resource_plan_result getResult(I iface, drop_resource_plan_args args } } - public static class create_wm_trigger extends org.apache.thrift.ProcessFunction { + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class create_wm_trigger extends org.apache.thrift.ProcessFunction { public create_wm_trigger() { super("create_wm_trigger"); } @@ -16227,7 +16581,7 @@ public create_wm_trigger_result getResult(I iface, create_wm_trigger_args args) } } - public static class alter_wm_trigger extends org.apache.thrift.ProcessFunction { + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class alter_wm_trigger extends org.apache.thrift.ProcessFunction { public alter_wm_trigger() { super("alter_wm_trigger"); } @@ -16255,7 +16609,7 @@ public alter_wm_trigger_result getResult(I iface, alter_wm_trigger_args args) th } } - public static class drop_wm_trigger extends org.apache.thrift.ProcessFunction { + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class drop_wm_trigger extends org.apache.thrift.ProcessFunction { public drop_wm_trigger() { super("drop_wm_trigger"); } @@ -16283,7 +16637,7 @@ public drop_wm_trigger_result getResult(I iface, drop_wm_trigger_args args) thro } } - public static class get_triggers_for_resourceplan extends org.apache.thrift.ProcessFunction { + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class get_triggers_for_resourceplan extends org.apache.thrift.ProcessFunction { public get_triggers_for_resourceplan() { super("get_triggers_for_resourceplan"); } @@ -16309,6 +16663,152 @@ public get_triggers_for_resourceplan_result getResult(I iface, get_triggers_for_ } } + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class create_or_update_wm_pool extends org.apache.thrift.ProcessFunction { + public create_or_update_wm_pool() { + super("create_or_update_wm_pool"); + } + + public create_or_update_wm_pool_args getEmptyArgsInstance() { + return new create_or_update_wm_pool_args(); + } + + protected boolean isOneway() { + return false; + } + + public create_or_update_wm_pool_result getResult(I iface, create_or_update_wm_pool_args args) throws org.apache.thrift.TException { + create_or_update_wm_pool_result result = new create_or_update_wm_pool_result(); + try { + result.success = iface.create_or_update_wm_pool(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; + } + } + + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class drop_wm_pool extends org.apache.thrift.ProcessFunction { + public drop_wm_pool() { + super("drop_wm_pool"); + } + + public drop_wm_pool_args getEmptyArgsInstance() { + return new drop_wm_pool_args(); + } + + protected boolean isOneway() { + return false; + } + + public drop_wm_pool_result getResult(I iface, drop_wm_pool_args args) throws org.apache.thrift.TException { + drop_wm_pool_result result = new drop_wm_pool_result(); + try { + result.success = iface.drop_wm_pool(args.request); + } catch (NoSuchObjectException o1) { + result.o1 = o1; + } catch (InvalidOperationException o2) { + result.o2 = o2; + } catch (MetaException o3) { + result.o3 = o3; + } + return result; + } + } + + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class create_or_update_wm_mapping extends org.apache.thrift.ProcessFunction { + public create_or_update_wm_mapping() { + super("create_or_update_wm_mapping"); + } + + public create_or_update_wm_mapping_args getEmptyArgsInstance() { + return new create_or_update_wm_mapping_args(); + } + + protected boolean isOneway() { + return false; + } + + public create_or_update_wm_mapping_result getResult(I iface, create_or_update_wm_mapping_args args) throws org.apache.thrift.TException { + create_or_update_wm_mapping_result result = new create_or_update_wm_mapping_result(); + try { + result.success = iface.create_or_update_wm_mapping(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; + } + } + + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class drop_wm_mapping extends org.apache.thrift.ProcessFunction { + public drop_wm_mapping() { + super("drop_wm_mapping"); + } + + public drop_wm_mapping_args getEmptyArgsInstance() { + return new drop_wm_mapping_args(); + } + + protected boolean isOneway() { + return false; + } + + public drop_wm_mapping_result getResult(I iface, drop_wm_mapping_args args) throws org.apache.thrift.TException { + drop_wm_mapping_result result = new drop_wm_mapping_result(); + try { + result.success = iface.drop_wm_mapping(args.request); + } catch (NoSuchObjectException o1) { + result.o1 = o1; + } catch (InvalidOperationException o2) { + result.o2 = o2; + } catch (MetaException o3) { + result.o3 = o3; + } + return result; + } + } + + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class create_or_drop_wm_trigger_to_pool_mapping extends org.apache.thrift.ProcessFunction { + public create_or_drop_wm_trigger_to_pool_mapping() { + super("create_or_drop_wm_trigger_to_pool_mapping"); + } + + public create_or_drop_wm_trigger_to_pool_mapping_args getEmptyArgsInstance() { + return new create_or_drop_wm_trigger_to_pool_mapping_args(); + } + + protected boolean isOneway() { + return false; + } + + public create_or_drop_wm_trigger_to_pool_mapping_result getResult(I iface, create_or_drop_wm_trigger_to_pool_mapping_args args) throws org.apache.thrift.TException { + create_or_drop_wm_trigger_to_pool_mapping_result result = new create_or_drop_wm_trigger_to_pool_mapping_result(); + try { + result.success = iface.create_or_drop_wm_trigger_to_pool_mapping(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; + } + } + } @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class AsyncProcessor extends com.facebook.fb303.FacebookService.AsyncProcessor { @@ -16494,6 +16994,11 @@ protected AsyncProcessor(I iface, Map extends org.apache.thrift.AsyncProcessFunction { + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class create_resource_plan extends org.apache.thrift.AsyncProcessFunction { public create_resource_plan() { super("create_resource_plan"); } @@ -26398,7 +26903,7 @@ public void start(I iface, create_resource_plan_args args, org.apache.thrift.asy } } - public static class get_resource_plan extends org.apache.thrift.AsyncProcessFunction { + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class get_resource_plan extends org.apache.thrift.AsyncProcessFunction { public get_resource_plan() { super("get_resource_plan"); } @@ -26460,7 +26965,7 @@ public void start(I iface, get_resource_plan_args args, org.apache.thrift.async. } } - public static class get_all_resource_plans extends org.apache.thrift.AsyncProcessFunction { + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class get_all_resource_plans extends org.apache.thrift.AsyncProcessFunction { public get_all_resource_plans() { super("get_all_resource_plans"); } @@ -26517,7 +27022,7 @@ public void start(I iface, get_all_resource_plans_args args, org.apache.thrift.a } } - public static class alter_resource_plan extends org.apache.thrift.AsyncProcessFunction { + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class alter_resource_plan extends org.apache.thrift.AsyncProcessFunction { public alter_resource_plan() { super("alter_resource_plan"); } @@ -26584,7 +27089,7 @@ public void start(I iface, alter_resource_plan_args args, org.apache.thrift.asyn } } - public static class validate_resource_plan extends org.apache.thrift.AsyncProcessFunction { + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class validate_resource_plan extends org.apache.thrift.AsyncProcessFunction { public validate_resource_plan() { super("validate_resource_plan"); } @@ -26646,7 +27151,7 @@ public void start(I iface, validate_resource_plan_args args, org.apache.thrift.a } } - public static class drop_resource_plan extends org.apache.thrift.AsyncProcessFunction { + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class drop_resource_plan extends org.apache.thrift.AsyncProcessFunction { public drop_resource_plan() { super("drop_resource_plan"); } @@ -26713,7 +27218,7 @@ public void start(I iface, drop_resource_plan_args args, org.apache.thrift.async } } - public static class create_wm_trigger extends org.apache.thrift.AsyncProcessFunction { + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class create_wm_trigger extends org.apache.thrift.AsyncProcessFunction { public create_wm_trigger() { super("create_wm_trigger"); } @@ -26785,7 +27290,7 @@ public void start(I iface, create_wm_trigger_args args, org.apache.thrift.async. } } - public static class alter_wm_trigger extends org.apache.thrift.AsyncProcessFunction { + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class alter_wm_trigger extends org.apache.thrift.AsyncProcessFunction { public alter_wm_trigger() { super("alter_wm_trigger"); } @@ -26852,7 +27357,7 @@ public void start(I iface, alter_wm_trigger_args args, org.apache.thrift.async.A } } - public static class drop_wm_trigger extends org.apache.thrift.AsyncProcessFunction { + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class drop_wm_trigger extends org.apache.thrift.AsyncProcessFunction { public drop_wm_trigger() { super("drop_wm_trigger"); } @@ -26919,7 +27424,7 @@ public void start(I iface, drop_wm_trigger_args args, org.apache.thrift.async.As } } - public static class get_triggers_for_resourceplan extends org.apache.thrift.AsyncProcessFunction { + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class get_triggers_for_resourceplan extends org.apache.thrift.AsyncProcessFunction { public get_triggers_for_resourceplan() { super("get_triggers_for_resourceplan"); } @@ -26981,6 +27486,356 @@ public void start(I iface, get_triggers_for_resourceplan_args args, org.apache.t } } + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class create_or_update_wm_pool extends org.apache.thrift.AsyncProcessFunction { + public create_or_update_wm_pool() { + super("create_or_update_wm_pool"); + } + + public create_or_update_wm_pool_args getEmptyArgsInstance() { + return new create_or_update_wm_pool_args(); + } + + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback() { + public void onComplete(WMCreateOrUpdatePoolResponse o) { + create_or_update_wm_pool_result result = new create_or_update_wm_pool_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_or_update_wm_pool_result result = new create_or_update_wm_pool_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_or_update_wm_pool_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.create_or_update_wm_pool(args.request,resultHandler); + } + } + + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class drop_wm_pool extends org.apache.thrift.AsyncProcessFunction { + public drop_wm_pool() { + super("drop_wm_pool"); + } + + public drop_wm_pool_args getEmptyArgsInstance() { + return new drop_wm_pool_args(); + } + + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback() { + public void onComplete(WMDropPoolResponse o) { + drop_wm_pool_result result = new drop_wm_pool_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_pool_result result = new drop_wm_pool_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_pool_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.drop_wm_pool(args.request,resultHandler); + } + } + + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class create_or_update_wm_mapping extends org.apache.thrift.AsyncProcessFunction { + public create_or_update_wm_mapping() { + super("create_or_update_wm_mapping"); + } + + public create_or_update_wm_mapping_args getEmptyArgsInstance() { + return new create_or_update_wm_mapping_args(); + } + + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback() { + public void onComplete(WMCreateOrUpdateMappingResponse o) { + create_or_update_wm_mapping_result result = new create_or_update_wm_mapping_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_or_update_wm_mapping_result result = new create_or_update_wm_mapping_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_or_update_wm_mapping_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.create_or_update_wm_mapping(args.request,resultHandler); + } + } + + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class drop_wm_mapping extends org.apache.thrift.AsyncProcessFunction { + public drop_wm_mapping() { + super("drop_wm_mapping"); + } + + public drop_wm_mapping_args getEmptyArgsInstance() { + return new drop_wm_mapping_args(); + } + + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback() { + public void onComplete(WMDropMappingResponse o) { + drop_wm_mapping_result result = new drop_wm_mapping_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_mapping_result result = new drop_wm_mapping_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_mapping_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.drop_wm_mapping(args.request,resultHandler); + } + } + + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class create_or_drop_wm_trigger_to_pool_mapping extends org.apache.thrift.AsyncProcessFunction { + public create_or_drop_wm_trigger_to_pool_mapping() { + super("create_or_drop_wm_trigger_to_pool_mapping"); + } + + public create_or_drop_wm_trigger_to_pool_mapping_args getEmptyArgsInstance() { + return new create_or_drop_wm_trigger_to_pool_mapping_args(); + } + + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback() { + public void onComplete(WMCreateOrDropTriggerToPoolMappingResponse o) { + create_or_drop_wm_trigger_to_pool_mapping_result result = new create_or_drop_wm_trigger_to_pool_mapping_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_or_drop_wm_trigger_to_pool_mapping_result result = new create_or_drop_wm_trigger_to_pool_mapping_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_or_drop_wm_trigger_to_pool_mapping_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.create_or_drop_wm_trigger_to_pool_mapping(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 { @@ -191021,7 +191876,7 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_metastore_db_uui } - public static class create_resource_plan_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class create_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("create_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); @@ -191097,16 +191952,4812 @@ 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, WMCreateResourcePlanRequest.class))); + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, WMCreateResourcePlanRequest.class))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(create_resource_plan_args.class, metaDataMap); + } + + public create_resource_plan_args() { + } + + public create_resource_plan_args( + WMCreateResourcePlanRequest request) + { + this(); + this.request = request; + } + + /** + * Performs a deep copy on other. + */ + public create_resource_plan_args(create_resource_plan_args other) { + if (other.isSetRequest()) { + this.request = new WMCreateResourcePlanRequest(other.request); + } + } + + public create_resource_plan_args deepCopy() { + return new create_resource_plan_args(this); + } + + @Override + public void clear() { + this.request = null; + } + + public WMCreateResourcePlanRequest getRequest() { + return this.request; + } + + public void setRequest(WMCreateResourcePlanRequest 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((WMCreateResourcePlanRequest)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 create_resource_plan_args) + return this.equals((create_resource_plan_args)that); + return false; + } + + public boolean equals(create_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(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); + } + } + } + + } + + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable 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); + } + } + } + + } + + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable 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); + } + } + } + + } + + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable 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); + } + } + } + + } + + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable 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); + } + } + } + + } + + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable 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); + } + } + } + + } + + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable 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); + } + } + } + + } + + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable 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); + } + } + } + + } + + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable 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()); + } + + 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("validate_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 validate_resource_plan_argsStandardSchemeFactory implements SchemeFactory { + public validate_resource_plan_argsStandardScheme getScheme() { + return new validate_resource_plan_argsStandardScheme(); + } + } + + private static class validate_resource_plan_argsStandardScheme extends StandardScheme { + + 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) + { + 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 WMValidateResourcePlanRequest(); + 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, validate_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 validate_resource_plan_argsTupleSchemeFactory implements SchemeFactory { + public validate_resource_plan_argsTupleScheme getScheme() { + return new validate_resource_plan_argsTupleScheme(); + } + } + + private static class validate_resource_plan_argsTupleScheme extends TupleScheme { + + @Override + 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()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetRequest()) { + struct.request.write(oprot); + } + } + + @Override + 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 WMValidateResourcePlanRequest(); + struct.request.read(iprot); + struct.setRequestIsSet(true); + } + } + } + + } + + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable 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 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()); + } + + 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"); + + 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, 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))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(validate_resource_plan_result.class, metaDataMap); + } + + public validate_resource_plan_result() { + } + + public validate_resource_plan_result( + WMValidateResourcePlanResponse success, + NoSuchObjectException o1, + MetaException o2) + { + this(); + this.success = success; + this.o1 = o1; + this.o2 = o2; + } + + /** + * Performs a deep copy on other. + */ + public validate_resource_plan_result(validate_resource_plan_result other) { + if (other.isSetSuccess()) { + this.success = new WMValidateResourcePlanResponse(other.success); + } + if (other.isSetO1()) { + this.o1 = new NoSuchObjectException(other.o1); + } + if (other.isSetO2()) { + this.o2 = new MetaException(other.o2); + } + } + + public validate_resource_plan_result deepCopy() { + return new validate_resource_plan_result(this); + } + + @Override + public void clear() { + this.success = null; + this.o1 = null; + this.o2 = null; + } + + public WMValidateResourcePlanResponse getSuccess() { + return this.success; + } + + public void setSuccess(WMValidateResourcePlanResponse 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((WMValidateResourcePlanResponse)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 validate_resource_plan_result) + return this.equals((validate_resource_plan_result)that); + return false; + } + + public boolean equals(validate_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(validate_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("validate_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 validate_resource_plan_resultStandardSchemeFactory implements SchemeFactory { + public validate_resource_plan_resultStandardScheme getScheme() { + return new validate_resource_plan_resultStandardScheme(); + } + } + + private static class validate_resource_plan_resultStandardScheme extends StandardScheme { + + 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) + { + 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 WMValidateResourcePlanResponse(); + 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, validate_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 validate_resource_plan_resultTupleSchemeFactory implements SchemeFactory { + public validate_resource_plan_resultTupleScheme getScheme() { + return new validate_resource_plan_resultTupleScheme(); + } + } + + private static class validate_resource_plan_resultTupleScheme extends TupleScheme { + + @Override + 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()) { + 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, validate_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 WMValidateResourcePlanResponse(); + 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); + } + } + } + + } + + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable 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 drop_resource_plan_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new drop_resource_plan_argsTupleSchemeFactory()); + } + + 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 { + 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, WMDropResourcePlanRequest.class))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(create_resource_plan_args.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(drop_resource_plan_args.class, metaDataMap); } - public create_resource_plan_args() { + public drop_resource_plan_args() { } - public create_resource_plan_args( - WMCreateResourcePlanRequest request) + public drop_resource_plan_args( + WMDropResourcePlanRequest request) { this(); this.request = request; @@ -191115,14 +196766,14 @@ public create_resource_plan_args( /** * Performs a deep copy on other. */ - public create_resource_plan_args(create_resource_plan_args other) { + public drop_resource_plan_args(drop_resource_plan_args other) { if (other.isSetRequest()) { - this.request = new WMCreateResourcePlanRequest(other.request); + this.request = new WMDropResourcePlanRequest(other.request); } } - public create_resource_plan_args deepCopy() { - return new create_resource_plan_args(this); + public drop_resource_plan_args deepCopy() { + return new drop_resource_plan_args(this); } @Override @@ -191130,11 +196781,11 @@ public void clear() { this.request = null; } - public WMCreateResourcePlanRequest getRequest() { + public WMDropResourcePlanRequest getRequest() { return this.request; } - public void setRequest(WMCreateResourcePlanRequest request) { + public void setRequest(WMDropResourcePlanRequest request) { this.request = request; } @@ -191159,7 +196810,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetRequest(); } else { - setRequest((WMCreateResourcePlanRequest)value); + setRequest((WMDropResourcePlanRequest)value); } break; @@ -191192,12 +196843,12 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof create_resource_plan_args) - return this.equals((create_resource_plan_args)that); + if (that instanceof drop_resource_plan_args) + return this.equals((drop_resource_plan_args)that); return false; } - public boolean equals(create_resource_plan_args that) { + public boolean equals(drop_resource_plan_args that) { if (that == null) return false; @@ -191226,7 +196877,7 @@ public int hashCode() { } @Override - public int compareTo(create_resource_plan_args other) { + public int compareTo(drop_resource_plan_args other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -191260,7 +196911,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("drop_resource_plan_args("); boolean first = true; sb.append("request:"); @@ -191298,15 +196949,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 drop_resource_plan_argsStandardSchemeFactory implements SchemeFactory { + public drop_resource_plan_argsStandardScheme getScheme() { + return new drop_resource_plan_argsStandardScheme(); } } - private static class create_resource_plan_argsStandardScheme extends StandardScheme { + private static class drop_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, drop_resource_plan_args struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -191318,7 +196969,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 WMDropResourcePlanRequest(); struct.request.read(iprot); struct.setRequestIsSet(true); } else { @@ -191334,7 +196985,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, drop_resource_plan_args struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -191349,16 +197000,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 drop_resource_plan_argsTupleSchemeFactory implements SchemeFactory { + public drop_resource_plan_argsTupleScheme getScheme() { + return new drop_resource_plan_argsTupleScheme(); } } - private static class create_resource_plan_argsTupleScheme extends TupleScheme { + private static class drop_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, drop_resource_plan_args struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetRequest()) { @@ -191371,11 +197022,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, 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 WMCreateResourcePlanRequest(); + struct.request = new WMDropResourcePlanRequest(); struct.request.read(iprot); struct.setRequestIsSet(true); } @@ -191384,8 +197035,8 @@ 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"); + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable 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); @@ -191394,13 +197045,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, create_resource_plan 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 drop_resource_plan_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new drop_resource_plan_resultTupleSchemeFactory()); } - private WMCreateResourcePlanResponse success; // required - private AlreadyExistsException o1; // required - private InvalidObjectException o2; // required + private WMDropResourcePlanResponse 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. */ @@ -191475,7 +197126,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, WMCreateResourcePlanResponse.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, @@ -191483,16 +197134,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(create_resource_plan_result.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(drop_resource_plan_result.class, metaDataMap); } - public create_resource_plan_result() { + public drop_resource_plan_result() { } - public create_resource_plan_result( - WMCreateResourcePlanResponse success, - AlreadyExistsException o1, - InvalidObjectException o2, + public drop_resource_plan_result( + WMDropResourcePlanResponse success, + NoSuchObjectException o1, + InvalidOperationException o2, MetaException o3) { this(); @@ -191505,23 +197156,23 @@ public create_resource_plan_result( /** * Performs a deep copy on other. */ - public create_resource_plan_result(create_resource_plan_result other) { + public drop_resource_plan_result(drop_resource_plan_result other) { if (other.isSetSuccess()) { - this.success = new WMCreateResourcePlanResponse(other.success); + this.success = new WMDropResourcePlanResponse(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); + this.o2 = new InvalidOperationException(other.o2); } if (other.isSetO3()) { this.o3 = new MetaException(other.o3); } } - public create_resource_plan_result deepCopy() { - return new create_resource_plan_result(this); + public drop_resource_plan_result deepCopy() { + return new drop_resource_plan_result(this); } @Override @@ -191532,11 +197183,11 @@ public void clear() { this.o3 = null; } - public WMCreateResourcePlanResponse getSuccess() { + public WMDropResourcePlanResponse getSuccess() { return this.success; } - public void setSuccess(WMCreateResourcePlanResponse success) { + public void setSuccess(WMDropResourcePlanResponse success) { this.success = success; } @@ -191555,11 +197206,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; } @@ -191578,11 +197229,11 @@ public void setO1IsSet(boolean value) { } } - public InvalidObjectException getO2() { + public InvalidOperationException getO2() { return this.o2; } - public void setO2(InvalidObjectException o2) { + public void setO2(InvalidOperationException o2) { this.o2 = o2; } @@ -191630,7 +197281,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetSuccess(); } else { - setSuccess((WMCreateResourcePlanResponse)value); + setSuccess((WMDropResourcePlanResponse)value); } break; @@ -191638,7 +197289,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetO1(); } else { - setO1((AlreadyExistsException)value); + setO1((NoSuchObjectException)value); } break; @@ -191646,7 +197297,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetO2(); } else { - setO2((InvalidObjectException)value); + setO2((InvalidOperationException)value); } break; @@ -191702,12 +197353,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 drop_resource_plan_result) + return this.equals((drop_resource_plan_result)that); return false; } - public boolean equals(create_resource_plan_result that) { + public boolean equals(drop_resource_plan_result that) { if (that == null) return false; @@ -191778,7 +197429,7 @@ public int hashCode() { } @Override - public int compareTo(create_resource_plan_result other) { + public int compareTo(drop_resource_plan_result other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -191842,7 +197493,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("drop_resource_plan_result("); boolean first = true; sb.append("success:"); @@ -191904,15 +197555,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 drop_resource_plan_resultStandardSchemeFactory implements SchemeFactory { + public drop_resource_plan_resultStandardScheme getScheme() { + return new drop_resource_plan_resultStandardScheme(); } } - private static class create_resource_plan_resultStandardScheme extends StandardScheme { + private static class drop_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, drop_resource_plan_result struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -191924,7 +197575,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 WMDropResourcePlanResponse(); struct.success.read(iprot); struct.setSuccessIsSet(true); } else { @@ -191933,7 +197584,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 { @@ -191942,7 +197593,7 @@ 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 InvalidOperationException(); struct.o2.read(iprot); struct.setO2IsSet(true); } else { @@ -191967,7 +197618,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, drop_resource_plan_result struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -191997,16 +197648,16 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, create_resource_pl } - private static class create_resource_plan_resultTupleSchemeFactory implements SchemeFactory { - public create_resource_plan_resultTupleScheme getScheme() { - return new create_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 create_resource_plan_resultTupleScheme extends TupleScheme { + private static class drop_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, drop_resource_plan_result struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetSuccess()) { @@ -192037,21 +197688,21 @@ 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_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(4); if (incoming.get(0)) { - struct.success = new WMCreateResourcePlanResponse(); + struct.success = new WMDropResourcePlanResponse(); 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 InvalidOperationException(); struct.o2.read(iprot); struct.setO2IsSet(true); } @@ -192065,18 +197716,18 @@ public void read(org.apache.thrift.protocol.TProtocol prot, create_resource_plan } - 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"); + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable 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_resource_plan_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new get_resource_plan_argsTupleSchemeFactory()); + schemes.put(StandardScheme.class, new create_wm_trigger_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new create_wm_trigger_argsTupleSchemeFactory()); } - private WMGetResourcePlanRequest 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 { @@ -192141,16 +197792,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, WMCreateTriggerRequest.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(create_wm_trigger_args.class, metaDataMap); } - public get_resource_plan_args() { + public create_wm_trigger_args() { } - public get_resource_plan_args( - WMGetResourcePlanRequest request) + public create_wm_trigger_args( + WMCreateTriggerRequest request) { this(); this.request = request; @@ -192159,14 +197810,14 @@ public get_resource_plan_args( /** * Performs a deep copy on other. */ - public get_resource_plan_args(get_resource_plan_args other) { + public create_wm_trigger_args(create_wm_trigger_args other) { if (other.isSetRequest()) { - this.request = new WMGetResourcePlanRequest(other.request); + this.request = new WMCreateTriggerRequest(other.request); } } - public get_resource_plan_args deepCopy() { - return new get_resource_plan_args(this); + public create_wm_trigger_args deepCopy() { + return new create_wm_trigger_args(this); } @Override @@ -192174,11 +197825,11 @@ public void clear() { this.request = null; } - public WMGetResourcePlanRequest getRequest() { + public WMCreateTriggerRequest getRequest() { return this.request; } - public void setRequest(WMGetResourcePlanRequest request) { + public void setRequest(WMCreateTriggerRequest request) { this.request = request; } @@ -192203,7 +197854,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetRequest(); } else { - setRequest((WMGetResourcePlanRequest)value); + setRequest((WMCreateTriggerRequest)value); } break; @@ -192236,12 +197887,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 create_wm_trigger_args) + return this.equals((create_wm_trigger_args)that); return false; } - public boolean equals(get_resource_plan_args that) { + public boolean equals(create_wm_trigger_args that) { if (that == null) return false; @@ -192270,7 +197921,7 @@ public int hashCode() { } @Override - public int compareTo(get_resource_plan_args other) { + public int compareTo(create_wm_trigger_args other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -192304,7 +197955,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("create_wm_trigger_args("); boolean first = true; sb.append("request:"); @@ -192342,15 +197993,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 create_wm_trigger_argsStandardSchemeFactory implements SchemeFactory { + public create_wm_trigger_argsStandardScheme getScheme() { + return new create_wm_trigger_argsStandardScheme(); } } - private static class get_resource_plan_argsStandardScheme extends StandardScheme { + private static class create_wm_trigger_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, create_wm_trigger_args struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -192362,7 +198013,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 WMCreateTriggerRequest(); struct.request.read(iprot); struct.setRequestIsSet(true); } else { @@ -192378,7 +198029,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, create_wm_trigger_args struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -192393,16 +198044,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 create_wm_trigger_argsTupleSchemeFactory implements SchemeFactory { + public create_wm_trigger_argsTupleScheme getScheme() { + return new create_wm_trigger_argsTupleScheme(); } } - private static class get_resource_plan_argsTupleScheme extends TupleScheme { + private static class create_wm_trigger_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, create_wm_trigger_args struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetRequest()) { @@ -192415,11 +198066,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, 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 WMGetResourcePlanRequest(); + struct.request = new WMCreateTriggerRequest(); struct.request.read(iprot); struct.setRequestIsSet(true); } @@ -192428,28 +198079,34 @@ 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"); + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable 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_resource_plan_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new get_resource_plan_resultTupleSchemeFactory()); + schemes.put(StandardScheme.class, new create_wm_trigger_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new create_wm_trigger_resultTupleSchemeFactory()); } - private WMGetResourcePlanResponse success; // required - private NoSuchObjectException o1; // required - private MetaException o2; // 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"), - O2((short)2, "o2"); + O2((short)2, "o2"), + O3((short)3, "o3"), + O4((short)4, "o4"); private static final Map byName = new HashMap(); @@ -192470,6 +198127,10 @@ public static _Fields findByThriftId(int fieldId) { return O1; case 2: // O2 return O2; + case 3: // O3 + return O3; + case 4: // O4 + return O4; default: return null; } @@ -192514,46 +198175,60 @@ 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, 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_resource_plan_result.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(create_wm_trigger_result.class, metaDataMap); } - public get_resource_plan_result() { + public create_wm_trigger_result() { } - public get_resource_plan_result( - WMGetResourcePlanResponse success, - NoSuchObjectException o1, - MetaException o2) + 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_resource_plan_result(get_resource_plan_result other) { + public create_wm_trigger_result(create_wm_trigger_result other) { if (other.isSetSuccess()) { - this.success = new WMGetResourcePlanResponse(other.success); + this.success = new WMCreateTriggerResponse(other.success); } if (other.isSetO1()) { - this.o1 = new NoSuchObjectException(other.o1); + this.o1 = new AlreadyExistsException(other.o1); } if (other.isSetO2()) { - this.o2 = new MetaException(other.o2); + 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_resource_plan_result deepCopy() { - return new get_resource_plan_result(this); + public create_wm_trigger_result deepCopy() { + return new create_wm_trigger_result(this); } @Override @@ -192561,13 +198236,15 @@ public void clear() { this.success = null; this.o1 = null; this.o2 = null; + this.o3 = null; + this.o4 = null; } - public WMGetResourcePlanResponse getSuccess() { + public WMCreateTriggerResponse getSuccess() { return this.success; } - public void setSuccess(WMGetResourcePlanResponse success) { + public void setSuccess(WMCreateTriggerResponse success) { this.success = success; } @@ -192586,11 +198263,11 @@ public void setSuccessIsSet(boolean value) { } } - public NoSuchObjectException getO1() { + public AlreadyExistsException getO1() { return this.o1; } - public void setO1(NoSuchObjectException o1) { + public void setO1(AlreadyExistsException o1) { this.o1 = o1; } @@ -192609,11 +198286,11 @@ public void setO1IsSet(boolean value) { } } - public MetaException getO2() { + public NoSuchObjectException getO2() { return this.o2; } - public void setO2(MetaException o2) { + public void setO2(NoSuchObjectException o2) { this.o2 = o2; } @@ -192632,13 +198309,59 @@ public void setO2IsSet(boolean value) { } } + 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((WMGetResourcePlanResponse)value); + setSuccess((WMCreateTriggerResponse)value); } break; @@ -192646,7 +198369,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetO1(); } else { - setO1((NoSuchObjectException)value); + setO1((AlreadyExistsException)value); } break; @@ -192654,7 +198377,23 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetO2(); } else { - setO2((MetaException)value); + 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; @@ -192672,6 +198411,12 @@ public Object getFieldValue(_Fields field) { case O2: return getO2(); + case O3: + return getO3(); + + case O4: + return getO4(); + } throw new IllegalStateException(); } @@ -192689,6 +198434,10 @@ public boolean isSet(_Fields field) { return isSetO1(); case O2: return isSetO2(); + case O3: + return isSetO3(); + case O4: + return isSetO4(); } throw new IllegalStateException(); } @@ -192697,12 +198446,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 create_wm_trigger_result) + return this.equals((create_wm_trigger_result)that); return false; } - public boolean equals(get_resource_plan_result that) { + public boolean equals(create_wm_trigger_result that) { if (that == null) return false; @@ -192733,6 +198482,24 @@ 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; + } + + 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; } @@ -192755,11 +198522,21 @@ public int hashCode() { 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_resource_plan_result other) { + public int compareTo(create_wm_trigger_result other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -192796,6 +198573,26 @@ 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; + } + } + 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; } @@ -192813,7 +198610,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("create_wm_trigger_result("); boolean first = true; sb.append("success:"); @@ -192839,6 +198636,22 @@ 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; + 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(); } @@ -192867,15 +198680,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 create_wm_trigger_resultStandardSchemeFactory implements SchemeFactory { + public create_wm_trigger_resultStandardScheme getScheme() { + return new create_wm_trigger_resultStandardScheme(); } } - private static class get_resource_plan_resultStandardScheme extends StandardScheme { + private static class create_wm_trigger_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, create_wm_trigger_result struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -192887,7 +198700,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 WMCreateTriggerResponse(); struct.success.read(iprot); struct.setSuccessIsSet(true); } else { @@ -192896,7 +198709,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_resource_plan_r break; case 1: // O1 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.o1 = new NoSuchObjectException(); + struct.o1 = new AlreadyExistsException(); struct.o1.read(iprot); struct.setO1IsSet(true); } else { @@ -192905,13 +198718,31 @@ 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 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); } @@ -192921,7 +198752,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, create_wm_trigger_result struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -192940,22 +198771,32 @@ 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(); + } + if (struct.o4 != null) { + oprot.writeFieldBegin(O4_FIELD_DESC); + struct.o4.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 create_wm_trigger_resultTupleSchemeFactory implements SchemeFactory { + public create_wm_trigger_resultTupleScheme getScheme() { + return new create_wm_trigger_resultTupleScheme(); } } - private static class get_resource_plan_resultTupleScheme extends TupleScheme { + private static class create_wm_trigger_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, create_wm_trigger_result struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetSuccess()) { @@ -192967,7 +198808,13 @@ 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); + } + if (struct.isSetO4()) { + optionals.set(4); + } + oprot.writeBitSet(optionals, 5); if (struct.isSetSuccess()) { struct.success.write(oprot); } @@ -192977,44 +198824,60 @@ 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); + } + if (struct.isSetO4()) { + struct.o4.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, create_wm_trigger_result struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(3); + BitSet incoming = iprot.readBitSet(5); if (incoming.get(0)) { - struct.success = new WMGetResourcePlanResponse(); + struct.success = new WMCreateTriggerResponse(); struct.success.read(iprot); struct.setSuccessIsSet(true); } if (incoming.get(1)) { - struct.o1 = new NoSuchObjectException(); + struct.o1 = new AlreadyExistsException(); struct.o1.read(iprot); struct.setO1IsSet(true); } if (incoming.get(2)) { - struct.o2 = new MetaException(); + 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 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"); + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable 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 get_all_resource_plans_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new get_all_resource_plans_argsTupleSchemeFactory()); + schemes.put(StandardScheme.class, new alter_wm_trigger_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new alter_wm_trigger_argsTupleSchemeFactory()); } - private WMGetAllResourcePlanRequest 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 { @@ -193079,16 +198942,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, WMAlterTriggerRequest.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(alter_wm_trigger_args.class, metaDataMap); } - public get_all_resource_plans_args() { + public alter_wm_trigger_args() { } - public get_all_resource_plans_args( - WMGetAllResourcePlanRequest request) + public alter_wm_trigger_args( + WMAlterTriggerRequest request) { this(); this.request = request; @@ -193097,14 +198960,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 alter_wm_trigger_args(alter_wm_trigger_args other) { if (other.isSetRequest()) { - this.request = new WMGetAllResourcePlanRequest(other.request); + this.request = new WMAlterTriggerRequest(other.request); } } - public get_all_resource_plans_args deepCopy() { - return new get_all_resource_plans_args(this); + public alter_wm_trigger_args deepCopy() { + return new alter_wm_trigger_args(this); } @Override @@ -193112,11 +198975,11 @@ public void clear() { this.request = null; } - public WMGetAllResourcePlanRequest getRequest() { + public WMAlterTriggerRequest getRequest() { return this.request; } - public void setRequest(WMGetAllResourcePlanRequest request) { + public void setRequest(WMAlterTriggerRequest request) { this.request = request; } @@ -193141,7 +199004,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetRequest(); } else { - setRequest((WMGetAllResourcePlanRequest)value); + setRequest((WMAlterTriggerRequest)value); } break; @@ -193174,12 +199037,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 alter_wm_trigger_args) + return this.equals((alter_wm_trigger_args)that); return false; } - public boolean equals(get_all_resource_plans_args that) { + public boolean equals(alter_wm_trigger_args that) { if (that == null) return false; @@ -193208,7 +199071,7 @@ public int hashCode() { } @Override - public int compareTo(get_all_resource_plans_args other) { + public int compareTo(alter_wm_trigger_args other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -193242,7 +199105,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("alter_wm_trigger_args("); boolean first = true; sb.append("request:"); @@ -193280,15 +199143,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 alter_wm_trigger_argsStandardSchemeFactory implements SchemeFactory { + public alter_wm_trigger_argsStandardScheme getScheme() { + return new alter_wm_trigger_argsStandardScheme(); } } - private static class get_all_resource_plans_argsStandardScheme extends StandardScheme { + private static class alter_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, alter_wm_trigger_args struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -193300,7 +199163,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 WMAlterTriggerRequest(); struct.request.read(iprot); struct.setRequestIsSet(true); } else { @@ -193316,7 +199179,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, alter_wm_trigger_args struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -193331,16 +199194,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 alter_wm_trigger_argsTupleSchemeFactory implements SchemeFactory { + public alter_wm_trigger_argsTupleScheme getScheme() { + return new alter_wm_trigger_argsTupleScheme(); } } - private static class get_all_resource_plans_argsTupleScheme extends TupleScheme { + private static class alter_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, alter_wm_trigger_args struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetRequest()) { @@ -193353,11 +199216,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, 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 WMGetAllResourcePlanRequest(); + struct.request = new WMAlterTriggerRequest(); struct.request.read(iprot); struct.setRequestIsSet(true); } @@ -193366,25 +199229,31 @@ 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"); + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable 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); + 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_all_resource_plans_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new get_all_resource_plans_resultTupleSchemeFactory()); + schemes.put(StandardScheme.class, new alter_wm_trigger_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new alter_wm_trigger_resultTupleSchemeFactory()); } - private WMGetAllResourcePlanResponse success; // required - private MetaException o1; // required + private WMAlterTriggerResponse success; // required + private NoSuchObjectException 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"); + O1((short)1, "o1"), + O2((short)2, "o2"), + O3((short)3, "o3"); private static final Map byName = new HashMap(); @@ -193403,6 +199272,10 @@ public static _Fields findByThriftId(int fieldId) { return SUCCESS; case 1: // O1 return O1; + case 2: // O2 + return O2; + case 3: // O3 + return O3; default: return null; } @@ -193447,52 +199320,68 @@ 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, 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, + 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_all_resource_plans_result.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(alter_wm_trigger_result.class, metaDataMap); } - public get_all_resource_plans_result() { + public alter_wm_trigger_result() { } - public get_all_resource_plans_result( - WMGetAllResourcePlanResponse success, - MetaException o1) + public alter_wm_trigger_result( + WMAlterTriggerResponse success, + NoSuchObjectException 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 get_all_resource_plans_result(get_all_resource_plans_result other) { + public alter_wm_trigger_result(alter_wm_trigger_result other) { if (other.isSetSuccess()) { - this.success = new WMGetAllResourcePlanResponse(other.success); + this.success = new WMAlterTriggerResponse(other.success); } if (other.isSetO1()) { - this.o1 = new MetaException(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); } } - public get_all_resource_plans_result deepCopy() { - return new get_all_resource_plans_result(this); + public alter_wm_trigger_result deepCopy() { + return new alter_wm_trigger_result(this); } @Override public void clear() { this.success = null; this.o1 = null; + this.o2 = null; + this.o3 = null; } - public WMGetAllResourcePlanResponse getSuccess() { + public WMAlterTriggerResponse getSuccess() { return this.success; } - public void setSuccess(WMGetAllResourcePlanResponse success) { + public void setSuccess(WMAlterTriggerResponse success) { this.success = success; } @@ -193511,11 +199400,11 @@ public void setSuccessIsSet(boolean value) { } } - public MetaException getO1() { + public NoSuchObjectException getO1() { return this.o1; } - public void setO1(MetaException o1) { + public void setO1(NoSuchObjectException o1) { this.o1 = o1; } @@ -193534,13 +199423,59 @@ public void setO1IsSet(boolean value) { } } + 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((WMGetAllResourcePlanResponse)value); + setSuccess((WMAlterTriggerResponse)value); } break; @@ -193548,7 +199483,23 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetO1(); } else { - setO1((MetaException)value); + setO1((NoSuchObjectException)value); + } + break; + + case O2: + if (value == null) { + unsetO2(); + } else { + setO2((InvalidObjectException)value); + } + break; + + case O3: + if (value == null) { + unsetO3(); + } else { + setO3((MetaException)value); } break; @@ -193563,6 +199514,12 @@ public Object getFieldValue(_Fields field) { case O1: return getO1(); + case O2: + return getO2(); + + case O3: + return getO3(); + } throw new IllegalStateException(); } @@ -193578,6 +199535,10 @@ public boolean isSet(_Fields field) { return isSetSuccess(); case O1: return isSetO1(); + case O2: + return isSetO2(); + case O3: + return isSetO3(); } throw new IllegalStateException(); } @@ -193586,12 +199547,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 alter_wm_trigger_result) + return this.equals((alter_wm_trigger_result)that); return false; } - public boolean equals(get_all_resource_plans_result that) { + public boolean equals(alter_wm_trigger_result that) { if (that == null) return false; @@ -193613,6 +199574,24 @@ 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; + } + return true; } @@ -193630,11 +199609,21 @@ 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); + return list.hashCode(); } @Override - public int compareTo(get_all_resource_plans_result other) { + public int compareTo(alter_wm_trigger_result other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -193661,6 +199650,26 @@ 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; + } + } return 0; } @@ -193678,7 +199687,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("alter_wm_trigger_result("); boolean first = true; sb.append("success:"); @@ -193696,6 +199705,22 @@ 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; sb.append(")"); return sb.toString(); } @@ -193724,15 +199749,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 alter_wm_trigger_resultStandardSchemeFactory implements SchemeFactory { + public alter_wm_trigger_resultStandardScheme getScheme() { + return new alter_wm_trigger_resultStandardScheme(); } } - private static class get_all_resource_plans_resultStandardScheme extends StandardScheme { + private static class alter_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, alter_wm_trigger_result struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -193744,7 +199769,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 WMAlterTriggerResponse(); struct.success.read(iprot); struct.setSuccessIsSet(true); } else { @@ -193753,13 +199778,31 @@ 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 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 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); } @@ -193769,7 +199812,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, alter_wm_trigger_result struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -193783,22 +199826,32 @@ 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(); + } 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 alter_wm_trigger_resultTupleSchemeFactory implements SchemeFactory { + public alter_wm_trigger_resultTupleScheme getScheme() { + return new alter_wm_trigger_resultTupleScheme(); } } - private static class get_all_resource_plans_resultTupleScheme extends TupleScheme { + private static class alter_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, alter_wm_trigger_result struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetSuccess()) { @@ -193807,46 +199860,68 @@ 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); + } + 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, get_all_resource_plans_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(2); + BitSet incoming = iprot.readBitSet(4); if (incoming.get(0)) { - struct.success = new WMGetAllResourcePlanResponse(); + struct.success = new WMAlterTriggerResponse(); struct.success.read(iprot); struct.setSuccessIsSet(true); } if (incoming.get(1)) { - struct.o1 = new MetaException(); + struct.o1 = new NoSuchObjectException(); 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 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"); + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable 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 alter_resource_plan_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new alter_resource_plan_argsTupleSchemeFactory()); + schemes.put(StandardScheme.class, new drop_wm_trigger_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new drop_wm_trigger_argsTupleSchemeFactory()); } - private WMAlterResourcePlanRequest 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 { @@ -193911,16 +199986,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, WMDropTriggerRequest.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(drop_wm_trigger_args.class, metaDataMap); } - public alter_resource_plan_args() { + public drop_wm_trigger_args() { } - public alter_resource_plan_args( - WMAlterResourcePlanRequest request) + public drop_wm_trigger_args( + WMDropTriggerRequest request) { this(); this.request = request; @@ -193929,14 +200004,14 @@ public alter_resource_plan_args( /** * Performs a deep copy on other. */ - public alter_resource_plan_args(alter_resource_plan_args other) { + public drop_wm_trigger_args(drop_wm_trigger_args other) { if (other.isSetRequest()) { - this.request = new WMAlterResourcePlanRequest(other.request); + this.request = new WMDropTriggerRequest(other.request); } } - public alter_resource_plan_args deepCopy() { - return new alter_resource_plan_args(this); + public drop_wm_trigger_args deepCopy() { + return new drop_wm_trigger_args(this); } @Override @@ -193944,11 +200019,11 @@ public void clear() { this.request = null; } - public WMAlterResourcePlanRequest getRequest() { + public WMDropTriggerRequest getRequest() { return this.request; } - public void setRequest(WMAlterResourcePlanRequest request) { + public void setRequest(WMDropTriggerRequest request) { this.request = request; } @@ -193973,7 +200048,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetRequest(); } else { - setRequest((WMAlterResourcePlanRequest)value); + setRequest((WMDropTriggerRequest)value); } break; @@ -194006,12 +200081,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 drop_wm_trigger_args) + return this.equals((drop_wm_trigger_args)that); return false; } - public boolean equals(alter_resource_plan_args that) { + public boolean equals(drop_wm_trigger_args that) { if (that == null) return false; @@ -194040,7 +200115,7 @@ public int hashCode() { } @Override - public int compareTo(alter_resource_plan_args other) { + public int compareTo(drop_wm_trigger_args other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -194074,7 +200149,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("drop_wm_trigger_args("); boolean first = true; sb.append("request:"); @@ -194112,15 +200187,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 drop_wm_trigger_argsStandardSchemeFactory implements SchemeFactory { + public drop_wm_trigger_argsStandardScheme getScheme() { + return new drop_wm_trigger_argsStandardScheme(); } } - private static class alter_resource_plan_argsStandardScheme extends StandardScheme { + private static class drop_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, drop_wm_trigger_args struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -194132,7 +200207,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 WMDropTriggerRequest(); struct.request.read(iprot); struct.setRequestIsSet(true); } else { @@ -194148,7 +200223,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, drop_wm_trigger_args struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -194163,16 +200238,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 drop_wm_trigger_argsTupleSchemeFactory implements SchemeFactory { + public drop_wm_trigger_argsTupleScheme getScheme() { + return new drop_wm_trigger_argsTupleScheme(); } } - private static class alter_resource_plan_argsTupleScheme extends TupleScheme { + private static class drop_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, drop_wm_trigger_args struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetRequest()) { @@ -194185,11 +200260,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, 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 WMAlterResourcePlanRequest(); + struct.request = new WMDropTriggerRequest(); struct.request.read(iprot); struct.setRequestIsSet(true); } @@ -194198,8 +200273,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"); + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable 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); @@ -194208,11 +200283,11 @@ 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 drop_wm_trigger_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new drop_wm_trigger_resultTupleSchemeFactory()); } - private WMAlterResourcePlanResponse success; // required + private WMDropTriggerResponse success; // required private NoSuchObjectException o1; // required private InvalidOperationException o2; // required private MetaException o3; // required @@ -194289,7 +200364,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, 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, @@ -194297,14 +200372,14 @@ 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(drop_wm_trigger_result.class, metaDataMap); } - public alter_resource_plan_result() { + public drop_wm_trigger_result() { } - public alter_resource_plan_result( - WMAlterResourcePlanResponse success, + public drop_wm_trigger_result( + WMDropTriggerResponse success, NoSuchObjectException o1, InvalidOperationException o2, MetaException o3) @@ -194319,9 +200394,9 @@ public alter_resource_plan_result( /** * Performs a deep copy on other. */ - public alter_resource_plan_result(alter_resource_plan_result other) { + public drop_wm_trigger_result(drop_wm_trigger_result other) { if (other.isSetSuccess()) { - this.success = new WMAlterResourcePlanResponse(other.success); + this.success = new WMDropTriggerResponse(other.success); } if (other.isSetO1()) { this.o1 = new NoSuchObjectException(other.o1); @@ -194334,8 +200409,8 @@ public alter_resource_plan_result(alter_resource_plan_result other) { } } - public alter_resource_plan_result deepCopy() { - return new alter_resource_plan_result(this); + public drop_wm_trigger_result deepCopy() { + return new drop_wm_trigger_result(this); } @Override @@ -194346,11 +200421,11 @@ public void clear() { this.o3 = null; } - public WMAlterResourcePlanResponse getSuccess() { + public WMDropTriggerResponse getSuccess() { return this.success; } - public void setSuccess(WMAlterResourcePlanResponse success) { + public void setSuccess(WMDropTriggerResponse success) { this.success = success; } @@ -194444,7 +200519,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetSuccess(); } else { - setSuccess((WMAlterResourcePlanResponse)value); + setSuccess((WMDropTriggerResponse)value); } break; @@ -194516,12 +200591,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 drop_wm_trigger_result) + return this.equals((drop_wm_trigger_result)that); return false; } - public boolean equals(alter_resource_plan_result that) { + public boolean equals(drop_wm_trigger_result that) { if (that == null) return false; @@ -194592,7 +200667,7 @@ public int hashCode() { } @Override - public int compareTo(alter_resource_plan_result other) { + public int compareTo(drop_wm_trigger_result other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -194656,7 +200731,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("drop_wm_trigger_result("); boolean first = true; sb.append("success:"); @@ -194718,15 +200793,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 drop_wm_trigger_resultStandardSchemeFactory implements SchemeFactory { + public drop_wm_trigger_resultStandardScheme getScheme() { + return new drop_wm_trigger_resultStandardScheme(); } } - private static class alter_resource_plan_resultStandardScheme extends StandardScheme { + private static class drop_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, drop_wm_trigger_result struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -194738,7 +200813,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 WMDropTriggerResponse(); struct.success.read(iprot); struct.setSuccessIsSet(true); } else { @@ -194781,7 +200856,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, drop_wm_trigger_result struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -194811,16 +200886,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 drop_wm_trigger_resultTupleSchemeFactory implements SchemeFactory { + public drop_wm_trigger_resultTupleScheme getScheme() { + return new drop_wm_trigger_resultTupleScheme(); } } - private static class alter_resource_plan_resultTupleScheme extends TupleScheme { + private static class drop_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, drop_wm_trigger_result struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetSuccess()) { @@ -194851,11 +200926,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, drop_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 WMDropTriggerResponse(); struct.success.read(iprot); struct.setSuccessIsSet(true); } @@ -194879,18 +200954,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"); + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable 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 validate_resource_plan_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new validate_resource_plan_argsTupleSchemeFactory()); + schemes.put(StandardScheme.class, new get_triggers_for_resourceplan_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new get_triggers_for_resourceplan_argsTupleSchemeFactory()); } - private WMValidateResourcePlanRequest 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 { @@ -194955,16 +201030,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, WMGetTriggersForResourePlanRequest.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(get_triggers_for_resourceplan_args.class, metaDataMap); } - public validate_resource_plan_args() { + public get_triggers_for_resourceplan_args() { } - public validate_resource_plan_args( - WMValidateResourcePlanRequest request) + public get_triggers_for_resourceplan_args( + WMGetTriggersForResourePlanRequest request) { this(); this.request = request; @@ -194973,14 +201048,14 @@ public validate_resource_plan_args( /** * Performs a deep copy on other. */ - public validate_resource_plan_args(validate_resource_plan_args other) { + public get_triggers_for_resourceplan_args(get_triggers_for_resourceplan_args other) { if (other.isSetRequest()) { - this.request = new WMValidateResourcePlanRequest(other.request); + this.request = new WMGetTriggersForResourePlanRequest(other.request); } } - public validate_resource_plan_args deepCopy() { - return new validate_resource_plan_args(this); + public get_triggers_for_resourceplan_args deepCopy() { + return new get_triggers_for_resourceplan_args(this); } @Override @@ -194988,11 +201063,11 @@ public void clear() { this.request = null; } - public WMValidateResourcePlanRequest getRequest() { + public WMGetTriggersForResourePlanRequest getRequest() { return this.request; } - public void setRequest(WMValidateResourcePlanRequest request) { + public void setRequest(WMGetTriggersForResourePlanRequest request) { this.request = request; } @@ -195017,7 +201092,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetRequest(); } else { - setRequest((WMValidateResourcePlanRequest)value); + setRequest((WMGetTriggersForResourePlanRequest)value); } break; @@ -195050,12 +201125,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 get_triggers_for_resourceplan_args) + return this.equals((get_triggers_for_resourceplan_args)that); return false; } - public boolean equals(validate_resource_plan_args that) { + public boolean equals(get_triggers_for_resourceplan_args that) { if (that == null) return false; @@ -195084,7 +201159,7 @@ public int hashCode() { } @Override - public int compareTo(validate_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()); } @@ -195118,7 +201193,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("get_triggers_for_resourceplan_args("); boolean first = true; sb.append("request:"); @@ -195156,15 +201231,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 get_triggers_for_resourceplan_argsStandardSchemeFactory implements SchemeFactory { + public get_triggers_for_resourceplan_argsStandardScheme getScheme() { + return new get_triggers_for_resourceplan_argsStandardScheme(); } } - private static class validate_resource_plan_argsStandardScheme extends StandardScheme { + private static class get_triggers_for_resourceplan_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, get_triggers_for_resourceplan_args struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -195176,7 +201251,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 WMGetTriggersForResourePlanRequest(); struct.request.read(iprot); struct.setRequestIsSet(true); } else { @@ -195192,7 +201267,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, get_triggers_for_resourceplan_args struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -195207,16 +201282,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 get_triggers_for_resourceplan_argsTupleSchemeFactory implements SchemeFactory { + public get_triggers_for_resourceplan_argsTupleScheme getScheme() { + return new get_triggers_for_resourceplan_argsTupleScheme(); } } - private static class validate_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, validate_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()) { @@ -195229,11 +201304,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, 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 WMValidateResourcePlanRequest(); + struct.request = new WMGetTriggersForResourePlanRequest(); struct.request.read(iprot); struct.setRequestIsSet(true); } @@ -195242,8 +201317,8 @@ 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"); + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable 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); @@ -195251,11 +201326,11 @@ public void read(org.apache.thrift.protocol.TProtocol prot, validate_resource_pl 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 get_triggers_for_resourceplan_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new get_triggers_for_resourceplan_resultTupleSchemeFactory()); } - private WMValidateResourcePlanResponse success; // required + private WMGetTriggersForResourePlanResponse success; // required private NoSuchObjectException o1; // required private MetaException o2; // required @@ -195328,20 +201403,20 @@ 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, 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))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(validate_resource_plan_result.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(get_triggers_for_resourceplan_result.class, metaDataMap); } - public validate_resource_plan_result() { + public get_triggers_for_resourceplan_result() { } - public validate_resource_plan_result( - WMValidateResourcePlanResponse success, + public get_triggers_for_resourceplan_result( + WMGetTriggersForResourePlanResponse success, NoSuchObjectException o1, MetaException o2) { @@ -195354,9 +201429,9 @@ public validate_resource_plan_result( /** * Performs a deep copy on other. */ - public validate_resource_plan_result(validate_resource_plan_result other) { + public get_triggers_for_resourceplan_result(get_triggers_for_resourceplan_result other) { if (other.isSetSuccess()) { - this.success = new WMValidateResourcePlanResponse(other.success); + this.success = new WMGetTriggersForResourePlanResponse(other.success); } if (other.isSetO1()) { this.o1 = new NoSuchObjectException(other.o1); @@ -195366,8 +201441,8 @@ public validate_resource_plan_result(validate_resource_plan_result other) { } } - public validate_resource_plan_result deepCopy() { - return new validate_resource_plan_result(this); + public get_triggers_for_resourceplan_result deepCopy() { + return new get_triggers_for_resourceplan_result(this); } @Override @@ -195377,11 +201452,11 @@ public void clear() { this.o2 = null; } - public WMValidateResourcePlanResponse getSuccess() { + public WMGetTriggersForResourePlanResponse getSuccess() { return this.success; } - public void setSuccess(WMValidateResourcePlanResponse success) { + public void setSuccess(WMGetTriggersForResourePlanResponse success) { this.success = success; } @@ -195452,7 +201527,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetSuccess(); } else { - setSuccess((WMValidateResourcePlanResponse)value); + setSuccess((WMGetTriggersForResourePlanResponse)value); } break; @@ -195511,12 +201586,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 get_triggers_for_resourceplan_result) + return this.equals((get_triggers_for_resourceplan_result)that); return false; } - public boolean equals(validate_resource_plan_result that) { + public boolean equals(get_triggers_for_resourceplan_result that) { if (that == null) return false; @@ -195573,7 +201648,7 @@ public int hashCode() { } @Override - public int compareTo(validate_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()); } @@ -195627,7 +201702,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("get_triggers_for_resourceplan_result("); boolean first = true; sb.append("success:"); @@ -195681,15 +201756,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 get_triggers_for_resourceplan_resultStandardSchemeFactory implements SchemeFactory { + public get_triggers_for_resourceplan_resultStandardScheme getScheme() { + return new get_triggers_for_resourceplan_resultStandardScheme(); } } - private static class validate_resource_plan_resultStandardScheme extends StandardScheme { + private static class get_triggers_for_resourceplan_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, get_triggers_for_resourceplan_result struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -195701,7 +201776,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 WMGetTriggersForResourePlanResponse(); struct.success.read(iprot); struct.setSuccessIsSet(true); } else { @@ -195735,7 +201810,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, get_triggers_for_resourceplan_result struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -195760,16 +201835,16 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, validate_resource_ } - private static class validate_resource_plan_resultTupleSchemeFactory implements SchemeFactory { - public validate_resource_plan_resultTupleScheme getScheme() { - return new validate_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 validate_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, validate_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()) { @@ -195794,11 +201869,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_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(3); if (incoming.get(0)) { - struct.success = new WMValidateResourcePlanResponse(); + struct.success = new WMGetTriggersForResourePlanResponse(); struct.success.read(iprot); struct.setSuccessIsSet(true); } @@ -195817,18 +201892,18 @@ public void read(org.apache.thrift.protocol.TProtocol prot, validate_resource_pl } - 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"); + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class create_or_update_wm_pool_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_or_update_wm_pool_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 create_or_update_wm_pool_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new create_or_update_wm_pool_argsTupleSchemeFactory()); } - private WMDropResourcePlanRequest request; // required + private WMCreateOrUpdatePoolRequest 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 { @@ -195893,16 +201968,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, WMCreateOrUpdatePoolRequest.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(create_or_update_wm_pool_args.class, metaDataMap); } - public drop_resource_plan_args() { + public create_or_update_wm_pool_args() { } - public drop_resource_plan_args( - WMDropResourcePlanRequest request) + public create_or_update_wm_pool_args( + WMCreateOrUpdatePoolRequest request) { this(); this.request = request; @@ -195911,14 +201986,14 @@ public drop_resource_plan_args( /** * Performs a deep copy on other. */ - public drop_resource_plan_args(drop_resource_plan_args other) { + public create_or_update_wm_pool_args(create_or_update_wm_pool_args other) { if (other.isSetRequest()) { - this.request = new WMDropResourcePlanRequest(other.request); + this.request = new WMCreateOrUpdatePoolRequest(other.request); } } - public drop_resource_plan_args deepCopy() { - return new drop_resource_plan_args(this); + public create_or_update_wm_pool_args deepCopy() { + return new create_or_update_wm_pool_args(this); } @Override @@ -195926,11 +202001,11 @@ public void clear() { this.request = null; } - public WMDropResourcePlanRequest getRequest() { + public WMCreateOrUpdatePoolRequest getRequest() { return this.request; } - public void setRequest(WMDropResourcePlanRequest request) { + public void setRequest(WMCreateOrUpdatePoolRequest request) { this.request = request; } @@ -195955,7 +202030,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetRequest(); } else { - setRequest((WMDropResourcePlanRequest)value); + setRequest((WMCreateOrUpdatePoolRequest)value); } break; @@ -195988,12 +202063,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 create_or_update_wm_pool_args) + return this.equals((create_or_update_wm_pool_args)that); return false; } - public boolean equals(drop_resource_plan_args that) { + public boolean equals(create_or_update_wm_pool_args that) { if (that == null) return false; @@ -196022,7 +202097,7 @@ public int hashCode() { } @Override - public int compareTo(drop_resource_plan_args other) { + public int compareTo(create_or_update_wm_pool_args other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -196056,7 +202131,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("create_or_update_wm_pool_args("); boolean first = true; sb.append("request:"); @@ -196094,15 +202169,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 create_or_update_wm_pool_argsStandardSchemeFactory implements SchemeFactory { + public create_or_update_wm_pool_argsStandardScheme getScheme() { + return new create_or_update_wm_pool_argsStandardScheme(); } } - private static class drop_resource_plan_argsStandardScheme extends StandardScheme { + private static class create_or_update_wm_pool_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, create_or_update_wm_pool_args struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -196114,7 +202189,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 WMCreateOrUpdatePoolRequest(); struct.request.read(iprot); struct.setRequestIsSet(true); } else { @@ -196130,7 +202205,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, create_or_update_wm_pool_args struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -196145,16 +202220,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 create_or_update_wm_pool_argsTupleSchemeFactory implements SchemeFactory { + public create_or_update_wm_pool_argsTupleScheme getScheme() { + return new create_or_update_wm_pool_argsTupleScheme(); } } - private static class drop_resource_plan_argsTupleScheme extends TupleScheme { + private static class create_or_update_wm_pool_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, create_or_update_wm_pool_args struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetRequest()) { @@ -196167,11 +202242,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, create_or_update_wm_pool_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 WMCreateOrUpdatePoolRequest(); struct.request.read(iprot); struct.setRequestIsSet(true); } @@ -196180,31 +202255,34 @@ 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"); + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class create_or_update_wm_pool_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_or_update_wm_pool_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 drop_resource_plan_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new drop_resource_plan_resultTupleSchemeFactory()); + schemes.put(StandardScheme.class, new create_or_update_wm_pool_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new create_or_update_wm_pool_resultTupleSchemeFactory()); } - private WMDropResourcePlanResponse success; // required - private NoSuchObjectException o1; // required - private InvalidOperationException o2; // required - private MetaException o3; // required + private WMCreateOrUpdatePoolResponse 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"), O2((short)2, "o2"), - O3((short)3, "o3"); + O3((short)3, "o3"), + O4((short)4, "o4"); private static final Map byName = new HashMap(); @@ -196227,6 +202305,8 @@ public static _Fields findByThriftId(int fieldId) { return O2; case 3: // O3 return O3; + case 4: // O4 + return O4; default: return null; } @@ -196271,53 +202351,60 @@ 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, WMCreateOrUpdatePoolResponse.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(drop_resource_plan_result.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(create_or_update_wm_pool_result.class, metaDataMap); } - public drop_resource_plan_result() { + public create_or_update_wm_pool_result() { } - public drop_resource_plan_result( - WMDropResourcePlanResponse success, - NoSuchObjectException o1, - InvalidOperationException o2, - MetaException o3) + public create_or_update_wm_pool_result( + WMCreateOrUpdatePoolResponse 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 drop_resource_plan_result(drop_resource_plan_result other) { + public create_or_update_wm_pool_result(create_or_update_wm_pool_result other) { if (other.isSetSuccess()) { - this.success = new WMDropResourcePlanResponse(other.success); + this.success = new WMCreateOrUpdatePoolResponse(other.success); } if (other.isSetO1()) { - this.o1 = new NoSuchObjectException(other.o1); + this.o1 = new AlreadyExistsException(other.o1); } if (other.isSetO2()) { - this.o2 = new InvalidOperationException(other.o2); + this.o2 = new NoSuchObjectException(other.o2); } if (other.isSetO3()) { - this.o3 = new MetaException(other.o3); + this.o3 = new InvalidObjectException(other.o3); + } + if (other.isSetO4()) { + this.o4 = new MetaException(other.o4); } } - public drop_resource_plan_result deepCopy() { - return new drop_resource_plan_result(this); + public create_or_update_wm_pool_result deepCopy() { + return new create_or_update_wm_pool_result(this); } @Override @@ -196326,13 +202413,14 @@ public void clear() { this.o1 = null; this.o2 = null; this.o3 = null; + this.o4 = null; } - public WMDropResourcePlanResponse getSuccess() { + public WMCreateOrUpdatePoolResponse getSuccess() { return this.success; } - public void setSuccess(WMDropResourcePlanResponse success) { + public void setSuccess(WMCreateOrUpdatePoolResponse success) { this.success = success; } @@ -196351,11 +202439,11 @@ public void setSuccessIsSet(boolean value) { } } - public NoSuchObjectException getO1() { + public AlreadyExistsException getO1() { return this.o1; } - public void setO1(NoSuchObjectException o1) { + public void setO1(AlreadyExistsException o1) { this.o1 = o1; } @@ -196374,11 +202462,11 @@ public void setO1IsSet(boolean value) { } } - public InvalidOperationException getO2() { + public NoSuchObjectException getO2() { return this.o2; } - public void setO2(InvalidOperationException o2) { + public void setO2(NoSuchObjectException o2) { this.o2 = o2; } @@ -196397,11 +202485,11 @@ public void setO2IsSet(boolean value) { } } - public MetaException getO3() { + public InvalidObjectException getO3() { return this.o3; } - public void setO3(MetaException o3) { + public void setO3(InvalidObjectException o3) { this.o3 = o3; } @@ -196420,13 +202508,36 @@ public void setO3IsSet(boolean value) { } } + 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((WMDropResourcePlanResponse)value); + setSuccess((WMCreateOrUpdatePoolResponse)value); } break; @@ -196434,7 +202545,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetO1(); } else { - setO1((NoSuchObjectException)value); + setO1((AlreadyExistsException)value); } break; @@ -196442,7 +202553,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetO2(); } else { - setO2((InvalidOperationException)value); + setO2((NoSuchObjectException)value); } break; @@ -196450,7 +202561,15 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetO3(); } else { - setO3((MetaException)value); + setO3((InvalidObjectException)value); + } + break; + + case O4: + if (value == null) { + unsetO4(); + } else { + setO4((MetaException)value); } break; @@ -196471,6 +202590,9 @@ public Object getFieldValue(_Fields field) { case O3: return getO3(); + case O4: + return getO4(); + } throw new IllegalStateException(); } @@ -196490,6 +202612,8 @@ public boolean isSet(_Fields field) { return isSetO2(); case O3: return isSetO3(); + case O4: + return isSetO4(); } throw new IllegalStateException(); } @@ -196498,12 +202622,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 create_or_update_wm_pool_result) + return this.equals((create_or_update_wm_pool_result)that); return false; } - public boolean equals(drop_resource_plan_result that) { + public boolean equals(create_or_update_wm_pool_result that) { if (that == null) return false; @@ -196543,6 +202667,15 @@ public boolean equals(drop_resource_plan_result that) { 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; } @@ -196570,11 +202703,16 @@ public int hashCode() { 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(drop_resource_plan_result other) { + public int compareTo(create_or_update_wm_pool_result other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -196621,6 +202759,16 @@ public int compareTo(drop_resource_plan_result other) { 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; } @@ -196638,7 +202786,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("create_or_update_wm_pool_result("); boolean first = true; sb.append("success:"); @@ -196672,6 +202820,14 @@ public String toString() { 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(); } @@ -196700,15 +202856,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 create_or_update_wm_pool_resultStandardSchemeFactory implements SchemeFactory { + public create_or_update_wm_pool_resultStandardScheme getScheme() { + return new create_or_update_wm_pool_resultStandardScheme(); } } - private static class drop_resource_plan_resultStandardScheme extends StandardScheme { + private static class create_or_update_wm_pool_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, create_or_update_wm_pool_result struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -196720,7 +202876,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 WMCreateOrUpdatePoolResponse(); struct.success.read(iprot); struct.setSuccessIsSet(true); } else { @@ -196729,7 +202885,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, drop_resource_plan_ break; case 1: // O1 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.o1 = new NoSuchObjectException(); + struct.o1 = new AlreadyExistsException(); struct.o1.read(iprot); struct.setO1IsSet(true); } else { @@ -196738,7 +202894,7 @@ 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 NoSuchObjectException(); struct.o2.read(iprot); struct.setO2IsSet(true); } else { @@ -196747,13 +202903,22 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, drop_resource_plan_ break; case 3: // O3 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.o3 = new MetaException(); + 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); } @@ -196763,7 +202928,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, create_or_update_wm_pool_result struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -196787,22 +202952,27 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, drop_resource_plan 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 drop_resource_plan_resultTupleSchemeFactory implements SchemeFactory { - public drop_resource_plan_resultTupleScheme getScheme() { - return new drop_resource_plan_resultTupleScheme(); + private static class create_or_update_wm_pool_resultTupleSchemeFactory implements SchemeFactory { + public create_or_update_wm_pool_resultTupleScheme getScheme() { + return new create_or_update_wm_pool_resultTupleScheme(); } } - private static class drop_resource_plan_resultTupleScheme extends TupleScheme { + private static class create_or_update_wm_pool_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, create_or_update_wm_pool_result struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetSuccess()) { @@ -196817,7 +202987,10 @@ public void write(org.apache.thrift.protocol.TProtocol prot, drop_resource_plan_ if (struct.isSetO3()) { optionals.set(3); } - oprot.writeBitSet(optionals, 4); + if (struct.isSetO4()) { + optionals.set(4); + } + oprot.writeBitSet(optionals, 5); if (struct.isSetSuccess()) { struct.success.write(oprot); } @@ -196830,49 +203003,57 @@ public void write(org.apache.thrift.protocol.TProtocol prot, drop_resource_plan_ if (struct.isSetO3()) { struct.o3.write(oprot); } + if (struct.isSetO4()) { + struct.o4.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, create_or_update_wm_pool_result struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(4); + BitSet incoming = iprot.readBitSet(5); if (incoming.get(0)) { - struct.success = new WMDropResourcePlanResponse(); + struct.success = new WMCreateOrUpdatePoolResponse(); struct.success.read(iprot); struct.setSuccessIsSet(true); } if (incoming.get(1)) { - struct.o1 = new NoSuchObjectException(); + struct.o1 = new AlreadyExistsException(); struct.o1.read(iprot); struct.setO1IsSet(true); } if (incoming.get(2)) { - struct.o2 = new InvalidOperationException(); + struct.o2 = new NoSuchObjectException(); struct.o2.read(iprot); struct.setO2IsSet(true); } if (incoming.get(3)) { - struct.o3 = new MetaException(); + 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 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"); + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class drop_wm_pool_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_pool_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 create_wm_trigger_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new create_wm_trigger_argsTupleSchemeFactory()); + schemes.put(StandardScheme.class, new drop_wm_pool_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new drop_wm_pool_argsTupleSchemeFactory()); } - private WMCreateTriggerRequest request; // required + private WMDropPoolRequest 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 { @@ -196937,16 +203118,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, WMCreateTriggerRequest.class))); + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, WMDropPoolRequest.class))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(create_wm_trigger_args.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(drop_wm_pool_args.class, metaDataMap); } - public create_wm_trigger_args() { + public drop_wm_pool_args() { } - public create_wm_trigger_args( - WMCreateTriggerRequest request) + public drop_wm_pool_args( + WMDropPoolRequest request) { this(); this.request = request; @@ -196955,14 +203136,14 @@ public create_wm_trigger_args( /** * Performs a deep copy on other. */ - public create_wm_trigger_args(create_wm_trigger_args other) { + public drop_wm_pool_args(drop_wm_pool_args other) { if (other.isSetRequest()) { - this.request = new WMCreateTriggerRequest(other.request); + this.request = new WMDropPoolRequest(other.request); } } - public create_wm_trigger_args deepCopy() { - return new create_wm_trigger_args(this); + public drop_wm_pool_args deepCopy() { + return new drop_wm_pool_args(this); } @Override @@ -196970,11 +203151,11 @@ public void clear() { this.request = null; } - public WMCreateTriggerRequest getRequest() { + public WMDropPoolRequest getRequest() { return this.request; } - public void setRequest(WMCreateTriggerRequest request) { + public void setRequest(WMDropPoolRequest request) { this.request = request; } @@ -196999,7 +203180,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetRequest(); } else { - setRequest((WMCreateTriggerRequest)value); + setRequest((WMDropPoolRequest)value); } break; @@ -197032,12 +203213,12 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof create_wm_trigger_args) - return this.equals((create_wm_trigger_args)that); + if (that instanceof drop_wm_pool_args) + return this.equals((drop_wm_pool_args)that); return false; } - public boolean equals(create_wm_trigger_args that) { + public boolean equals(drop_wm_pool_args that) { if (that == null) return false; @@ -197066,7 +203247,7 @@ public int hashCode() { } @Override - public int compareTo(create_wm_trigger_args other) { + public int compareTo(drop_wm_pool_args other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -197100,7 +203281,7 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("create_wm_trigger_args("); + StringBuilder sb = new StringBuilder("drop_wm_pool_args("); boolean first = true; sb.append("request:"); @@ -197138,15 +203319,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class create_wm_trigger_argsStandardSchemeFactory implements SchemeFactory { - public create_wm_trigger_argsStandardScheme getScheme() { - return new create_wm_trigger_argsStandardScheme(); + private static class drop_wm_pool_argsStandardSchemeFactory implements SchemeFactory { + public drop_wm_pool_argsStandardScheme getScheme() { + return new drop_wm_pool_argsStandardScheme(); } } - private static class create_wm_trigger_argsStandardScheme extends StandardScheme { + private static class drop_wm_pool_argsStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, create_wm_trigger_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, drop_wm_pool_args struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -197158,7 +203339,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, create_wm_trigger_a switch (schemeField.id) { case 1: // REQUEST if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.request = new WMCreateTriggerRequest(); + struct.request = new WMDropPoolRequest(); struct.request.read(iprot); struct.setRequestIsSet(true); } else { @@ -197174,7 +203355,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, create_wm_trigger_a struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, create_wm_trigger_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, drop_wm_pool_args struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -197189,16 +203370,16 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, create_wm_trigger_ } - private static class create_wm_trigger_argsTupleSchemeFactory implements SchemeFactory { - public create_wm_trigger_argsTupleScheme getScheme() { - return new create_wm_trigger_argsTupleScheme(); + private static class drop_wm_pool_argsTupleSchemeFactory implements SchemeFactory { + public drop_wm_pool_argsTupleScheme getScheme() { + return new drop_wm_pool_argsTupleScheme(); } } - private static class create_wm_trigger_argsTupleScheme extends TupleScheme { + private static class drop_wm_pool_argsTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, create_wm_trigger_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, drop_wm_pool_args struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetRequest()) { @@ -197211,11 +203392,11 @@ public void write(org.apache.thrift.protocol.TProtocol prot, create_wm_trigger_a } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, create_wm_trigger_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, drop_wm_pool_args struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { - struct.request = new WMCreateTriggerRequest(); + struct.request = new WMDropPoolRequest(); struct.request.read(iprot); struct.setRequestIsSet(true); } @@ -197224,34 +203405,31 @@ public void read(org.apache.thrift.protocol.TProtocol prot, create_wm_trigger_ar } - 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"); + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class drop_wm_pool_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_pool_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 create_wm_trigger_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new create_wm_trigger_resultTupleSchemeFactory()); + schemes.put(StandardScheme.class, new drop_wm_pool_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new drop_wm_pool_resultTupleSchemeFactory()); } - private WMCreateTriggerResponse success; // required - private AlreadyExistsException o1; // required - private NoSuchObjectException o2; // required - private InvalidObjectException o3; // required - private MetaException o4; // required + private WMDropPoolResponse 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"), - O4((short)4, "o4"); + O3((short)3, "o3"); private static final Map byName = new HashMap(); @@ -197274,8 +203452,6 @@ public static _Fields findByThriftId(int fieldId) { return O2; case 3: // O3 return O3; - case 4: // O4 - return O4; default: return null; } @@ -197320,60 +203496,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, WMCreateTriggerResponse.class))); + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, WMDropPoolResponse.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(create_wm_trigger_result.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(drop_wm_pool_result.class, metaDataMap); } - public create_wm_trigger_result() { + public drop_wm_pool_result() { } - public create_wm_trigger_result( - WMCreateTriggerResponse success, - AlreadyExistsException o1, - NoSuchObjectException o2, - InvalidObjectException o3, - MetaException o4) + public drop_wm_pool_result( + WMDropPoolResponse success, + NoSuchObjectException o1, + InvalidOperationException o2, + MetaException o3) { this(); this.success = success; this.o1 = o1; this.o2 = o2; this.o3 = o3; - this.o4 = o4; } /** * Performs a deep copy on other. */ - public create_wm_trigger_result(create_wm_trigger_result other) { + public drop_wm_pool_result(drop_wm_pool_result other) { if (other.isSetSuccess()) { - this.success = new WMCreateTriggerResponse(other.success); + this.success = new WMDropPoolResponse(other.success); } if (other.isSetO1()) { - this.o1 = new AlreadyExistsException(other.o1); + this.o1 = new NoSuchObjectException(other.o1); } if (other.isSetO2()) { - this.o2 = new NoSuchObjectException(other.o2); + this.o2 = new InvalidOperationException(other.o2); } if (other.isSetO3()) { - this.o3 = new InvalidObjectException(other.o3); - } - if (other.isSetO4()) { - this.o4 = new MetaException(other.o4); + this.o3 = new MetaException(other.o3); } } - public create_wm_trigger_result deepCopy() { - return new create_wm_trigger_result(this); + public drop_wm_pool_result deepCopy() { + return new drop_wm_pool_result(this); } @Override @@ -197382,14 +203551,13 @@ public void clear() { this.o1 = null; this.o2 = null; this.o3 = null; - this.o4 = null; } - public WMCreateTriggerResponse getSuccess() { + public WMDropPoolResponse getSuccess() { return this.success; } - public void setSuccess(WMCreateTriggerResponse success) { + public void setSuccess(WMDropPoolResponse success) { this.success = success; } @@ -197408,11 +203576,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; } @@ -197431,11 +203599,11 @@ public void setO1IsSet(boolean value) { } } - public NoSuchObjectException getO2() { + public InvalidOperationException getO2() { return this.o2; } - public void setO2(NoSuchObjectException o2) { + public void setO2(InvalidOperationException o2) { this.o2 = o2; } @@ -197454,11 +203622,11 @@ public void setO2IsSet(boolean value) { } } - public InvalidObjectException getO3() { + public MetaException getO3() { return this.o3; } - public void setO3(InvalidObjectException o3) { + public void setO3(MetaException o3) { this.o3 = o3; } @@ -197477,36 +203645,13 @@ public void setO3IsSet(boolean value) { } } - 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((WMCreateTriggerResponse)value); + setSuccess((WMDropPoolResponse)value); } break; @@ -197514,7 +203659,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetO1(); } else { - setO1((AlreadyExistsException)value); + setO1((NoSuchObjectException)value); } break; @@ -197522,7 +203667,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetO2(); } else { - setO2((NoSuchObjectException)value); + setO2((InvalidOperationException)value); } break; @@ -197530,15 +203675,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetO3(); } else { - setO3((InvalidObjectException)value); - } - break; - - case O4: - if (value == null) { - unsetO4(); - } else { - setO4((MetaException)value); + setO3((MetaException)value); } break; @@ -197559,9 +203696,6 @@ public Object getFieldValue(_Fields field) { case O3: return getO3(); - case O4: - return getO4(); - } throw new IllegalStateException(); } @@ -197581,8 +203715,6 @@ public boolean isSet(_Fields field) { return isSetO2(); case O3: return isSetO3(); - case O4: - return isSetO4(); } throw new IllegalStateException(); } @@ -197591,12 +203723,12 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof create_wm_trigger_result) - return this.equals((create_wm_trigger_result)that); + if (that instanceof drop_wm_pool_result) + return this.equals((drop_wm_pool_result)that); return false; } - public boolean equals(create_wm_trigger_result that) { + public boolean equals(drop_wm_pool_result that) { if (that == null) return false; @@ -197636,15 +203768,6 @@ public boolean equals(create_wm_trigger_result that) { 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; } @@ -197672,16 +203795,11 @@ public int hashCode() { 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(create_wm_trigger_result other) { + public int compareTo(drop_wm_pool_result other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -197728,16 +203846,6 @@ public int compareTo(create_wm_trigger_result other) { 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; } @@ -197755,7 +203863,7 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("create_wm_trigger_result("); + StringBuilder sb = new StringBuilder("drop_wm_pool_result("); boolean first = true; sb.append("success:"); @@ -197789,14 +203897,6 @@ public String toString() { 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(); } @@ -197825,15 +203925,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class create_wm_trigger_resultStandardSchemeFactory implements SchemeFactory { - public create_wm_trigger_resultStandardScheme getScheme() { - return new create_wm_trigger_resultStandardScheme(); + private static class drop_wm_pool_resultStandardSchemeFactory implements SchemeFactory { + public drop_wm_pool_resultStandardScheme getScheme() { + return new drop_wm_pool_resultStandardScheme(); } } - private static class create_wm_trigger_resultStandardScheme extends StandardScheme { + private static class drop_wm_pool_resultStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, create_wm_trigger_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, drop_wm_pool_result struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -197845,7 +203945,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, create_wm_trigger_r switch (schemeField.id) { case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.success = new WMCreateTriggerResponse(); + struct.success = new WMDropPoolResponse(); struct.success.read(iprot); struct.setSuccessIsSet(true); } else { @@ -197854,7 +203954,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, create_wm_trigger_r 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 { @@ -197863,7 +203963,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, create_wm_trigger_r break; case 2: // O2 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.o2 = new NoSuchObjectException(); + struct.o2 = new InvalidOperationException(); struct.o2.read(iprot); struct.setO2IsSet(true); } else { @@ -197872,22 +203972,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, create_wm_trigger_r break; case 3: // O3 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.o3 = new InvalidObjectException(); + struct.o3 = new MetaException(); 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); } @@ -197897,7 +203988,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, create_wm_trigger_r struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, create_wm_trigger_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, drop_wm_pool_result struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -197921,27 +204012,22 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, create_wm_trigger_ 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 create_wm_trigger_resultTupleSchemeFactory implements SchemeFactory { - public create_wm_trigger_resultTupleScheme getScheme() { - return new create_wm_trigger_resultTupleScheme(); + private static class drop_wm_pool_resultTupleSchemeFactory implements SchemeFactory { + public drop_wm_pool_resultTupleScheme getScheme() { + return new drop_wm_pool_resultTupleScheme(); } } - private static class create_wm_trigger_resultTupleScheme extends TupleScheme { + private static class drop_wm_pool_resultTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, create_wm_trigger_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, drop_wm_pool_result struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetSuccess()) { @@ -197956,10 +204042,7 @@ public void write(org.apache.thrift.protocol.TProtocol prot, create_wm_trigger_r if (struct.isSetO3()) { optionals.set(3); } - if (struct.isSetO4()) { - optionals.set(4); - } - oprot.writeBitSet(optionals, 5); + oprot.writeBitSet(optionals, 4); if (struct.isSetSuccess()) { struct.success.write(oprot); } @@ -197972,57 +204055,49 @@ public void write(org.apache.thrift.protocol.TProtocol prot, create_wm_trigger_r if (struct.isSetO3()) { struct.o3.write(oprot); } - if (struct.isSetO4()) { - struct.o4.write(oprot); - } } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, create_wm_trigger_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, drop_wm_pool_result struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(5); + BitSet incoming = iprot.readBitSet(4); if (incoming.get(0)) { - struct.success = new WMCreateTriggerResponse(); + struct.success = new WMDropPoolResponse(); 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 NoSuchObjectException(); + struct.o2 = new InvalidOperationException(); struct.o2.read(iprot); struct.setO2IsSet(true); } if (incoming.get(3)) { - struct.o3 = new InvalidObjectException(); + struct.o3 = new MetaException(); 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_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"); + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class create_or_update_wm_mapping_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_or_update_wm_mapping_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_wm_trigger_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new alter_wm_trigger_argsTupleSchemeFactory()); + schemes.put(StandardScheme.class, new create_or_update_wm_mapping_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new create_or_update_wm_mapping_argsTupleSchemeFactory()); } - private WMAlterTriggerRequest request; // required + private WMCreateOrUpdateMappingRequest 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 { @@ -198087,16 +204162,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, WMAlterTriggerRequest.class))); + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, WMCreateOrUpdateMappingRequest.class))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(alter_wm_trigger_args.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(create_or_update_wm_mapping_args.class, metaDataMap); } - public alter_wm_trigger_args() { + public create_or_update_wm_mapping_args() { } - public alter_wm_trigger_args( - WMAlterTriggerRequest request) + public create_or_update_wm_mapping_args( + WMCreateOrUpdateMappingRequest request) { this(); this.request = request; @@ -198105,14 +204180,14 @@ public alter_wm_trigger_args( /** * Performs a deep copy on other. */ - public alter_wm_trigger_args(alter_wm_trigger_args other) { + public create_or_update_wm_mapping_args(create_or_update_wm_mapping_args other) { if (other.isSetRequest()) { - this.request = new WMAlterTriggerRequest(other.request); + this.request = new WMCreateOrUpdateMappingRequest(other.request); } } - public alter_wm_trigger_args deepCopy() { - return new alter_wm_trigger_args(this); + public create_or_update_wm_mapping_args deepCopy() { + return new create_or_update_wm_mapping_args(this); } @Override @@ -198120,11 +204195,11 @@ public void clear() { this.request = null; } - public WMAlterTriggerRequest getRequest() { + public WMCreateOrUpdateMappingRequest getRequest() { return this.request; } - public void setRequest(WMAlterTriggerRequest request) { + public void setRequest(WMCreateOrUpdateMappingRequest request) { this.request = request; } @@ -198149,7 +204224,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetRequest(); } else { - setRequest((WMAlterTriggerRequest)value); + setRequest((WMCreateOrUpdateMappingRequest)value); } break; @@ -198182,12 +204257,12 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof alter_wm_trigger_args) - return this.equals((alter_wm_trigger_args)that); + if (that instanceof create_or_update_wm_mapping_args) + return this.equals((create_or_update_wm_mapping_args)that); return false; } - public boolean equals(alter_wm_trigger_args that) { + public boolean equals(create_or_update_wm_mapping_args that) { if (that == null) return false; @@ -198216,7 +204291,7 @@ public int hashCode() { } @Override - public int compareTo(alter_wm_trigger_args other) { + public int compareTo(create_or_update_wm_mapping_args other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -198250,7 +204325,7 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("alter_wm_trigger_args("); + StringBuilder sb = new StringBuilder("create_or_update_wm_mapping_args("); boolean first = true; sb.append("request:"); @@ -198288,15 +204363,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class alter_wm_trigger_argsStandardSchemeFactory implements SchemeFactory { - public alter_wm_trigger_argsStandardScheme getScheme() { - return new alter_wm_trigger_argsStandardScheme(); + private static class create_or_update_wm_mapping_argsStandardSchemeFactory implements SchemeFactory { + public create_or_update_wm_mapping_argsStandardScheme getScheme() { + return new create_or_update_wm_mapping_argsStandardScheme(); } } - private static class alter_wm_trigger_argsStandardScheme extends StandardScheme { + private static class create_or_update_wm_mapping_argsStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, alter_wm_trigger_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, create_or_update_wm_mapping_args struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -198308,7 +204383,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, alter_wm_trigger_ar switch (schemeField.id) { case 1: // REQUEST if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.request = new WMAlterTriggerRequest(); + struct.request = new WMCreateOrUpdateMappingRequest(); struct.request.read(iprot); struct.setRequestIsSet(true); } else { @@ -198324,7 +204399,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, alter_wm_trigger_ar struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, alter_wm_trigger_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, create_or_update_wm_mapping_args struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -198339,16 +204414,16 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, alter_wm_trigger_a } - private static class alter_wm_trigger_argsTupleSchemeFactory implements SchemeFactory { - public alter_wm_trigger_argsTupleScheme getScheme() { - return new alter_wm_trigger_argsTupleScheme(); + private static class create_or_update_wm_mapping_argsTupleSchemeFactory implements SchemeFactory { + public create_or_update_wm_mapping_argsTupleScheme getScheme() { + return new create_or_update_wm_mapping_argsTupleScheme(); } } - private static class alter_wm_trigger_argsTupleScheme extends TupleScheme { + private static class create_or_update_wm_mapping_argsTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, alter_wm_trigger_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, create_or_update_wm_mapping_args struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetRequest()) { @@ -198361,11 +204436,11 @@ public void write(org.apache.thrift.protocol.TProtocol prot, alter_wm_trigger_ar } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, alter_wm_trigger_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, create_or_update_wm_mapping_args struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { - struct.request = new WMAlterTriggerRequest(); + struct.request = new WMCreateOrUpdateMappingRequest(); struct.request.read(iprot); struct.setRequestIsSet(true); } @@ -198374,31 +204449,34 @@ public void read(org.apache.thrift.protocol.TProtocol prot, alter_wm_trigger_arg } - 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"); + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class create_or_update_wm_mapping_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_or_update_wm_mapping_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 alter_wm_trigger_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new alter_wm_trigger_resultTupleSchemeFactory()); + schemes.put(StandardScheme.class, new create_or_update_wm_mapping_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new create_or_update_wm_mapping_resultTupleSchemeFactory()); } - private WMAlterTriggerResponse success; // required - private NoSuchObjectException o1; // required - private InvalidObjectException o2; // required - private MetaException o3; // required + private WMCreateOrUpdateMappingResponse 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"), O2((short)2, "o2"), - O3((short)3, "o3"); + O3((short)3, "o3"), + O4((short)4, "o4"); private static final Map byName = new HashMap(); @@ -198421,6 +204499,8 @@ public static _Fields findByThriftId(int fieldId) { return O2; case 3: // O3 return O3; + case 4: // O4 + return O4; default: return null; } @@ -198465,53 +204545,60 @@ 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, WMAlterTriggerResponse.class))); + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, WMCreateOrUpdateMappingResponse.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(alter_wm_trigger_result.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(create_or_update_wm_mapping_result.class, metaDataMap); } - public alter_wm_trigger_result() { + public create_or_update_wm_mapping_result() { } - public alter_wm_trigger_result( - WMAlterTriggerResponse success, - NoSuchObjectException o1, - InvalidObjectException o2, - MetaException o3) + public create_or_update_wm_mapping_result( + WMCreateOrUpdateMappingResponse 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 alter_wm_trigger_result(alter_wm_trigger_result other) { + public create_or_update_wm_mapping_result(create_or_update_wm_mapping_result other) { if (other.isSetSuccess()) { - this.success = new WMAlterTriggerResponse(other.success); + this.success = new WMCreateOrUpdateMappingResponse(other.success); } if (other.isSetO1()) { - this.o1 = new NoSuchObjectException(other.o1); + this.o1 = new AlreadyExistsException(other.o1); } if (other.isSetO2()) { - this.o2 = new InvalidObjectException(other.o2); + this.o2 = new NoSuchObjectException(other.o2); } if (other.isSetO3()) { - this.o3 = new MetaException(other.o3); + this.o3 = new InvalidObjectException(other.o3); + } + if (other.isSetO4()) { + this.o4 = new MetaException(other.o4); } } - public alter_wm_trigger_result deepCopy() { - return new alter_wm_trigger_result(this); + public create_or_update_wm_mapping_result deepCopy() { + return new create_or_update_wm_mapping_result(this); } @Override @@ -198520,13 +204607,14 @@ public void clear() { this.o1 = null; this.o2 = null; this.o3 = null; + this.o4 = null; } - public WMAlterTriggerResponse getSuccess() { + public WMCreateOrUpdateMappingResponse getSuccess() { return this.success; } - public void setSuccess(WMAlterTriggerResponse success) { + public void setSuccess(WMCreateOrUpdateMappingResponse success) { this.success = success; } @@ -198545,11 +204633,11 @@ public void setSuccessIsSet(boolean value) { } } - public NoSuchObjectException getO1() { + public AlreadyExistsException getO1() { return this.o1; } - public void setO1(NoSuchObjectException o1) { + public void setO1(AlreadyExistsException o1) { this.o1 = o1; } @@ -198568,11 +204656,11 @@ public void setO1IsSet(boolean value) { } } - public InvalidObjectException getO2() { + public NoSuchObjectException getO2() { return this.o2; } - public void setO2(InvalidObjectException o2) { + public void setO2(NoSuchObjectException o2) { this.o2 = o2; } @@ -198591,11 +204679,11 @@ public void setO2IsSet(boolean value) { } } - public MetaException getO3() { + public InvalidObjectException getO3() { return this.o3; } - public void setO3(MetaException o3) { + public void setO3(InvalidObjectException o3) { this.o3 = o3; } @@ -198614,13 +204702,36 @@ public void setO3IsSet(boolean value) { } } + 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((WMAlterTriggerResponse)value); + setSuccess((WMCreateOrUpdateMappingResponse)value); } break; @@ -198628,7 +204739,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetO1(); } else { - setO1((NoSuchObjectException)value); + setO1((AlreadyExistsException)value); } break; @@ -198636,7 +204747,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetO2(); } else { - setO2((InvalidObjectException)value); + setO2((NoSuchObjectException)value); } break; @@ -198644,7 +204755,15 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetO3(); } else { - setO3((MetaException)value); + setO3((InvalidObjectException)value); + } + break; + + case O4: + if (value == null) { + unsetO4(); + } else { + setO4((MetaException)value); } break; @@ -198665,6 +204784,9 @@ public Object getFieldValue(_Fields field) { case O3: return getO3(); + case O4: + return getO4(); + } throw new IllegalStateException(); } @@ -198684,6 +204806,8 @@ public boolean isSet(_Fields field) { return isSetO2(); case O3: return isSetO3(); + case O4: + return isSetO4(); } throw new IllegalStateException(); } @@ -198692,12 +204816,12 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof alter_wm_trigger_result) - return this.equals((alter_wm_trigger_result)that); + if (that instanceof create_or_update_wm_mapping_result) + return this.equals((create_or_update_wm_mapping_result)that); return false; } - public boolean equals(alter_wm_trigger_result that) { + public boolean equals(create_or_update_wm_mapping_result that) { if (that == null) return false; @@ -198737,6 +204861,15 @@ public boolean equals(alter_wm_trigger_result that) { 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; } @@ -198764,11 +204897,16 @@ public int hashCode() { 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(alter_wm_trigger_result other) { + public int compareTo(create_or_update_wm_mapping_result other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -198815,6 +204953,16 @@ public int compareTo(alter_wm_trigger_result other) { 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; } @@ -198832,7 +204980,7 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("alter_wm_trigger_result("); + StringBuilder sb = new StringBuilder("create_or_update_wm_mapping_result("); boolean first = true; sb.append("success:"); @@ -198866,6 +205014,14 @@ public String toString() { 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(); } @@ -198894,15 +205050,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class alter_wm_trigger_resultStandardSchemeFactory implements SchemeFactory { - public alter_wm_trigger_resultStandardScheme getScheme() { - return new alter_wm_trigger_resultStandardScheme(); + private static class create_or_update_wm_mapping_resultStandardSchemeFactory implements SchemeFactory { + public create_or_update_wm_mapping_resultStandardScheme getScheme() { + return new create_or_update_wm_mapping_resultStandardScheme(); } } - private static class alter_wm_trigger_resultStandardScheme extends StandardScheme { + private static class create_or_update_wm_mapping_resultStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, alter_wm_trigger_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, create_or_update_wm_mapping_result struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -198914,7 +205070,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, alter_wm_trigger_re switch (schemeField.id) { case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.success = new WMAlterTriggerResponse(); + struct.success = new WMCreateOrUpdateMappingResponse(); struct.success.read(iprot); struct.setSuccessIsSet(true); } else { @@ -198923,7 +205079,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, alter_wm_trigger_re break; case 1: // O1 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.o1 = new NoSuchObjectException(); + struct.o1 = new AlreadyExistsException(); struct.o1.read(iprot); struct.setO1IsSet(true); } else { @@ -198932,7 +205088,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, alter_wm_trigger_re break; case 2: // O2 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.o2 = new InvalidObjectException(); + struct.o2 = new NoSuchObjectException(); struct.o2.read(iprot); struct.setO2IsSet(true); } else { @@ -198941,13 +205097,22 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, alter_wm_trigger_re break; case 3: // O3 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.o3 = new MetaException(); + 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); } @@ -198957,7 +205122,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, alter_wm_trigger_re struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, alter_wm_trigger_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, create_or_update_wm_mapping_result struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -198981,22 +205146,27 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, alter_wm_trigger_r 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 alter_wm_trigger_resultTupleSchemeFactory implements SchemeFactory { - public alter_wm_trigger_resultTupleScheme getScheme() { - return new alter_wm_trigger_resultTupleScheme(); + private static class create_or_update_wm_mapping_resultTupleSchemeFactory implements SchemeFactory { + public create_or_update_wm_mapping_resultTupleScheme getScheme() { + return new create_or_update_wm_mapping_resultTupleScheme(); } } - private static class alter_wm_trigger_resultTupleScheme extends TupleScheme { + private static class create_or_update_wm_mapping_resultTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, alter_wm_trigger_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, create_or_update_wm_mapping_result struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetSuccess()) { @@ -199011,7 +205181,10 @@ public void write(org.apache.thrift.protocol.TProtocol prot, alter_wm_trigger_re if (struct.isSetO3()) { optionals.set(3); } - oprot.writeBitSet(optionals, 4); + if (struct.isSetO4()) { + optionals.set(4); + } + oprot.writeBitSet(optionals, 5); if (struct.isSetSuccess()) { struct.success.write(oprot); } @@ -199024,49 +205197,57 @@ public void write(org.apache.thrift.protocol.TProtocol prot, alter_wm_trigger_re if (struct.isSetO3()) { struct.o3.write(oprot); } + if (struct.isSetO4()) { + struct.o4.write(oprot); + } } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, alter_wm_trigger_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, create_or_update_wm_mapping_result struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(4); + BitSet incoming = iprot.readBitSet(5); if (incoming.get(0)) { - struct.success = new WMAlterTriggerResponse(); + struct.success = new WMCreateOrUpdateMappingResponse(); struct.success.read(iprot); struct.setSuccessIsSet(true); } if (incoming.get(1)) { - struct.o1 = new NoSuchObjectException(); + struct.o1 = new AlreadyExistsException(); struct.o1.read(iprot); struct.setO1IsSet(true); } if (incoming.get(2)) { - struct.o2 = new InvalidObjectException(); + struct.o2 = new NoSuchObjectException(); struct.o2.read(iprot); struct.setO2IsSet(true); } if (incoming.get(3)) { - struct.o3 = new MetaException(); + 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 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"); + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class drop_wm_mapping_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_mapping_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_wm_trigger_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new drop_wm_trigger_argsTupleSchemeFactory()); + schemes.put(StandardScheme.class, new drop_wm_mapping_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new drop_wm_mapping_argsTupleSchemeFactory()); } - private WMDropTriggerRequest request; // required + private WMDropMappingRequest 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 { @@ -199131,16 +205312,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, WMDropTriggerRequest.class))); + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, WMDropMappingRequest.class))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(drop_wm_trigger_args.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(drop_wm_mapping_args.class, metaDataMap); } - public drop_wm_trigger_args() { + public drop_wm_mapping_args() { } - public drop_wm_trigger_args( - WMDropTriggerRequest request) + public drop_wm_mapping_args( + WMDropMappingRequest request) { this(); this.request = request; @@ -199149,14 +205330,14 @@ public drop_wm_trigger_args( /** * Performs a deep copy on other. */ - public drop_wm_trigger_args(drop_wm_trigger_args other) { + public drop_wm_mapping_args(drop_wm_mapping_args other) { if (other.isSetRequest()) { - this.request = new WMDropTriggerRequest(other.request); + this.request = new WMDropMappingRequest(other.request); } } - public drop_wm_trigger_args deepCopy() { - return new drop_wm_trigger_args(this); + public drop_wm_mapping_args deepCopy() { + return new drop_wm_mapping_args(this); } @Override @@ -199164,11 +205345,11 @@ public void clear() { this.request = null; } - public WMDropTriggerRequest getRequest() { + public WMDropMappingRequest getRequest() { return this.request; } - public void setRequest(WMDropTriggerRequest request) { + public void setRequest(WMDropMappingRequest request) { this.request = request; } @@ -199193,7 +205374,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetRequest(); } else { - setRequest((WMDropTriggerRequest)value); + setRequest((WMDropMappingRequest)value); } break; @@ -199226,12 +205407,12 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof drop_wm_trigger_args) - return this.equals((drop_wm_trigger_args)that); + if (that instanceof drop_wm_mapping_args) + return this.equals((drop_wm_mapping_args)that); return false; } - public boolean equals(drop_wm_trigger_args that) { + public boolean equals(drop_wm_mapping_args that) { if (that == null) return false; @@ -199260,7 +205441,7 @@ public int hashCode() { } @Override - public int compareTo(drop_wm_trigger_args other) { + public int compareTo(drop_wm_mapping_args other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -199294,7 +205475,7 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("drop_wm_trigger_args("); + StringBuilder sb = new StringBuilder("drop_wm_mapping_args("); boolean first = true; sb.append("request:"); @@ -199332,15 +205513,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class drop_wm_trigger_argsStandardSchemeFactory implements SchemeFactory { - public drop_wm_trigger_argsStandardScheme getScheme() { - return new drop_wm_trigger_argsStandardScheme(); + private static class drop_wm_mapping_argsStandardSchemeFactory implements SchemeFactory { + public drop_wm_mapping_argsStandardScheme getScheme() { + return new drop_wm_mapping_argsStandardScheme(); } } - private static class drop_wm_trigger_argsStandardScheme extends StandardScheme { + private static class drop_wm_mapping_argsStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, drop_wm_trigger_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, drop_wm_mapping_args struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -199352,7 +205533,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, drop_wm_trigger_arg switch (schemeField.id) { case 1: // REQUEST if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.request = new WMDropTriggerRequest(); + struct.request = new WMDropMappingRequest(); struct.request.read(iprot); struct.setRequestIsSet(true); } else { @@ -199368,7 +205549,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, drop_wm_trigger_arg struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, drop_wm_trigger_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, drop_wm_mapping_args struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -199383,16 +205564,16 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, drop_wm_trigger_ar } - private static class drop_wm_trigger_argsTupleSchemeFactory implements SchemeFactory { - public drop_wm_trigger_argsTupleScheme getScheme() { - return new drop_wm_trigger_argsTupleScheme(); + private static class drop_wm_mapping_argsTupleSchemeFactory implements SchemeFactory { + public drop_wm_mapping_argsTupleScheme getScheme() { + return new drop_wm_mapping_argsTupleScheme(); } } - private static class drop_wm_trigger_argsTupleScheme extends TupleScheme { + private static class drop_wm_mapping_argsTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, drop_wm_trigger_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, drop_wm_mapping_args struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetRequest()) { @@ -199405,11 +205586,11 @@ public void write(org.apache.thrift.protocol.TProtocol prot, drop_wm_trigger_arg } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, drop_wm_trigger_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, drop_wm_mapping_args struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { - struct.request = new WMDropTriggerRequest(); + struct.request = new WMDropMappingRequest(); struct.request.read(iprot); struct.setRequestIsSet(true); } @@ -199418,8 +205599,8 @@ public void read(org.apache.thrift.protocol.TProtocol prot, drop_wm_trigger_args } - 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"); + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class drop_wm_mapping_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_mapping_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); @@ -199428,11 +205609,11 @@ public void read(org.apache.thrift.protocol.TProtocol prot, drop_wm_trigger_args private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { - schemes.put(StandardScheme.class, new drop_wm_trigger_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new drop_wm_trigger_resultTupleSchemeFactory()); + schemes.put(StandardScheme.class, new drop_wm_mapping_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new drop_wm_mapping_resultTupleSchemeFactory()); } - private WMDropTriggerResponse success; // required + private WMDropMappingResponse success; // required private NoSuchObjectException o1; // required private InvalidOperationException o2; // required private MetaException o3; // required @@ -199509,7 +205690,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, WMDropTriggerResponse.class))); + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, WMDropMappingResponse.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, @@ -199517,14 +205698,14 @@ 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(drop_wm_trigger_result.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(drop_wm_mapping_result.class, metaDataMap); } - public drop_wm_trigger_result() { + public drop_wm_mapping_result() { } - public drop_wm_trigger_result( - WMDropTriggerResponse success, + public drop_wm_mapping_result( + WMDropMappingResponse success, NoSuchObjectException o1, InvalidOperationException o2, MetaException o3) @@ -199539,9 +205720,9 @@ public drop_wm_trigger_result( /** * Performs a deep copy on other. */ - public drop_wm_trigger_result(drop_wm_trigger_result other) { + public drop_wm_mapping_result(drop_wm_mapping_result other) { if (other.isSetSuccess()) { - this.success = new WMDropTriggerResponse(other.success); + this.success = new WMDropMappingResponse(other.success); } if (other.isSetO1()) { this.o1 = new NoSuchObjectException(other.o1); @@ -199554,8 +205735,8 @@ public drop_wm_trigger_result(drop_wm_trigger_result other) { } } - public drop_wm_trigger_result deepCopy() { - return new drop_wm_trigger_result(this); + public drop_wm_mapping_result deepCopy() { + return new drop_wm_mapping_result(this); } @Override @@ -199566,11 +205747,11 @@ public void clear() { this.o3 = null; } - public WMDropTriggerResponse getSuccess() { + public WMDropMappingResponse getSuccess() { return this.success; } - public void setSuccess(WMDropTriggerResponse success) { + public void setSuccess(WMDropMappingResponse success) { this.success = success; } @@ -199664,7 +205845,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetSuccess(); } else { - setSuccess((WMDropTriggerResponse)value); + setSuccess((WMDropMappingResponse)value); } break; @@ -199736,12 +205917,12 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof drop_wm_trigger_result) - return this.equals((drop_wm_trigger_result)that); + if (that instanceof drop_wm_mapping_result) + return this.equals((drop_wm_mapping_result)that); return false; } - public boolean equals(drop_wm_trigger_result that) { + public boolean equals(drop_wm_mapping_result that) { if (that == null) return false; @@ -199812,7 +205993,7 @@ public int hashCode() { } @Override - public int compareTo(drop_wm_trigger_result other) { + public int compareTo(drop_wm_mapping_result other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -199876,7 +206057,7 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("drop_wm_trigger_result("); + StringBuilder sb = new StringBuilder("drop_wm_mapping_result("); boolean first = true; sb.append("success:"); @@ -199938,15 +206119,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class drop_wm_trigger_resultStandardSchemeFactory implements SchemeFactory { - public drop_wm_trigger_resultStandardScheme getScheme() { - return new drop_wm_trigger_resultStandardScheme(); + private static class drop_wm_mapping_resultStandardSchemeFactory implements SchemeFactory { + public drop_wm_mapping_resultStandardScheme getScheme() { + return new drop_wm_mapping_resultStandardScheme(); } } - private static class drop_wm_trigger_resultStandardScheme extends StandardScheme { + private static class drop_wm_mapping_resultStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, drop_wm_trigger_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, drop_wm_mapping_result struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -199958,7 +206139,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, drop_wm_trigger_res switch (schemeField.id) { case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.success = new WMDropTriggerResponse(); + struct.success = new WMDropMappingResponse(); struct.success.read(iprot); struct.setSuccessIsSet(true); } else { @@ -200001,7 +206182,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, drop_wm_trigger_res struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, drop_wm_trigger_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, drop_wm_mapping_result struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -200031,16 +206212,16 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, drop_wm_trigger_re } - private static class drop_wm_trigger_resultTupleSchemeFactory implements SchemeFactory { - public drop_wm_trigger_resultTupleScheme getScheme() { - return new drop_wm_trigger_resultTupleScheme(); + private static class drop_wm_mapping_resultTupleSchemeFactory implements SchemeFactory { + public drop_wm_mapping_resultTupleScheme getScheme() { + return new drop_wm_mapping_resultTupleScheme(); } } - private static class drop_wm_trigger_resultTupleScheme extends TupleScheme { + private static class drop_wm_mapping_resultTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, drop_wm_trigger_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, drop_wm_mapping_result struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetSuccess()) { @@ -200071,11 +206252,11 @@ public void write(org.apache.thrift.protocol.TProtocol prot, drop_wm_trigger_res } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, drop_wm_trigger_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, drop_wm_mapping_result struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; BitSet incoming = iprot.readBitSet(4); if (incoming.get(0)) { - struct.success = new WMDropTriggerResponse(); + struct.success = new WMDropMappingResponse(); struct.success.read(iprot); struct.setSuccessIsSet(true); } @@ -200099,18 +206280,18 @@ public void read(org.apache.thrift.protocol.TProtocol prot, drop_wm_trigger_resu } - 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"); + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class create_or_drop_wm_trigger_to_pool_mapping_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_or_drop_wm_trigger_to_pool_mapping_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_triggers_for_resourceplan_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new get_triggers_for_resourceplan_argsTupleSchemeFactory()); + schemes.put(StandardScheme.class, new create_or_drop_wm_trigger_to_pool_mapping_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new create_or_drop_wm_trigger_to_pool_mapping_argsTupleSchemeFactory()); } - private WMGetTriggersForResourePlanRequest request; // required + private WMCreateOrDropTriggerToPoolMappingRequest 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 { @@ -200175,16 +206356,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, WMGetTriggersForResourePlanRequest.class))); + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, WMCreateOrDropTriggerToPoolMappingRequest.class))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(get_triggers_for_resourceplan_args.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(create_or_drop_wm_trigger_to_pool_mapping_args.class, metaDataMap); } - public get_triggers_for_resourceplan_args() { + public create_or_drop_wm_trigger_to_pool_mapping_args() { } - public get_triggers_for_resourceplan_args( - WMGetTriggersForResourePlanRequest request) + public create_or_drop_wm_trigger_to_pool_mapping_args( + WMCreateOrDropTriggerToPoolMappingRequest request) { this(); this.request = request; @@ -200193,14 +206374,14 @@ public get_triggers_for_resourceplan_args( /** * Performs a deep copy on other. */ - public get_triggers_for_resourceplan_args(get_triggers_for_resourceplan_args other) { + public create_or_drop_wm_trigger_to_pool_mapping_args(create_or_drop_wm_trigger_to_pool_mapping_args other) { if (other.isSetRequest()) { - this.request = new WMGetTriggersForResourePlanRequest(other.request); + this.request = new WMCreateOrDropTriggerToPoolMappingRequest(other.request); } } - public get_triggers_for_resourceplan_args deepCopy() { - return new get_triggers_for_resourceplan_args(this); + public create_or_drop_wm_trigger_to_pool_mapping_args deepCopy() { + return new create_or_drop_wm_trigger_to_pool_mapping_args(this); } @Override @@ -200208,11 +206389,11 @@ public void clear() { this.request = null; } - public WMGetTriggersForResourePlanRequest getRequest() { + public WMCreateOrDropTriggerToPoolMappingRequest getRequest() { return this.request; } - public void setRequest(WMGetTriggersForResourePlanRequest request) { + public void setRequest(WMCreateOrDropTriggerToPoolMappingRequest request) { this.request = request; } @@ -200237,7 +206418,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetRequest(); } else { - setRequest((WMGetTriggersForResourePlanRequest)value); + setRequest((WMCreateOrDropTriggerToPoolMappingRequest)value); } break; @@ -200270,12 +206451,12 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof get_triggers_for_resourceplan_args) - return this.equals((get_triggers_for_resourceplan_args)that); + if (that instanceof create_or_drop_wm_trigger_to_pool_mapping_args) + return this.equals((create_or_drop_wm_trigger_to_pool_mapping_args)that); return false; } - public boolean equals(get_triggers_for_resourceplan_args that) { + public boolean equals(create_or_drop_wm_trigger_to_pool_mapping_args that) { if (that == null) return false; @@ -200304,7 +206485,7 @@ public int hashCode() { } @Override - public int compareTo(get_triggers_for_resourceplan_args other) { + public int compareTo(create_or_drop_wm_trigger_to_pool_mapping_args other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -200338,7 +206519,7 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("get_triggers_for_resourceplan_args("); + StringBuilder sb = new StringBuilder("create_or_drop_wm_trigger_to_pool_mapping_args("); boolean first = true; sb.append("request:"); @@ -200376,15 +206557,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - 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 create_or_drop_wm_trigger_to_pool_mapping_argsStandardSchemeFactory implements SchemeFactory { + public create_or_drop_wm_trigger_to_pool_mapping_argsStandardScheme getScheme() { + return new create_or_drop_wm_trigger_to_pool_mapping_argsStandardScheme(); } } - private static class get_triggers_for_resourceplan_argsStandardScheme extends StandardScheme { + private static class create_or_drop_wm_trigger_to_pool_mapping_argsStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, get_triggers_for_resourceplan_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, create_or_drop_wm_trigger_to_pool_mapping_args struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -200396,7 +206577,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_triggers_for_re switch (schemeField.id) { case 1: // REQUEST if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.request = new WMGetTriggersForResourePlanRequest(); + struct.request = new WMCreateOrDropTriggerToPoolMappingRequest(); struct.request.read(iprot); struct.setRequestIsSet(true); } else { @@ -200412,7 +206593,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_triggers_for_re struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, get_triggers_for_resourceplan_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, create_or_drop_wm_trigger_to_pool_mapping_args struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -200427,16 +206608,16 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_triggers_for_r } - 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 create_or_drop_wm_trigger_to_pool_mapping_argsTupleSchemeFactory implements SchemeFactory { + public create_or_drop_wm_trigger_to_pool_mapping_argsTupleScheme getScheme() { + return new create_or_drop_wm_trigger_to_pool_mapping_argsTupleScheme(); } } - private static class get_triggers_for_resourceplan_argsTupleScheme extends TupleScheme { + private static class create_or_drop_wm_trigger_to_pool_mapping_argsTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, get_triggers_for_resourceplan_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, create_or_drop_wm_trigger_to_pool_mapping_args struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetRequest()) { @@ -200449,11 +206630,11 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_triggers_for_re } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, get_triggers_for_resourceplan_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, create_or_drop_wm_trigger_to_pool_mapping_args struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { - struct.request = new WMGetTriggersForResourePlanRequest(); + struct.request = new WMCreateOrDropTriggerToPoolMappingRequest(); struct.request.read(iprot); struct.setRequestIsSet(true); } @@ -200462,28 +206643,34 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_triggers_for_res } - 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"); + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class create_or_drop_wm_trigger_to_pool_mapping_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_or_drop_wm_trigger_to_pool_mapping_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_triggers_for_resourceplan_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new get_triggers_for_resourceplan_resultTupleSchemeFactory()); + schemes.put(StandardScheme.class, new create_or_drop_wm_trigger_to_pool_mapping_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new create_or_drop_wm_trigger_to_pool_mapping_resultTupleSchemeFactory()); } - private WMGetTriggersForResourePlanResponse success; // required - private NoSuchObjectException o1; // required - private MetaException o2; // required + private WMCreateOrDropTriggerToPoolMappingResponse 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"), - O2((short)2, "o2"); + O2((short)2, "o2"), + O3((short)3, "o3"), + O4((short)4, "o4"); private static final Map byName = new HashMap(); @@ -200504,6 +206691,10 @@ public static _Fields findByThriftId(int fieldId) { return O1; case 2: // O2 return O2; + case 3: // O3 + return O3; + case 4: // O4 + return O4; default: return null; } @@ -200548,46 +206739,60 @@ 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, WMGetTriggersForResourePlanResponse.class))); + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, WMCreateOrDropTriggerToPoolMappingResponse.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_triggers_for_resourceplan_result.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(create_or_drop_wm_trigger_to_pool_mapping_result.class, metaDataMap); } - public get_triggers_for_resourceplan_result() { + public create_or_drop_wm_trigger_to_pool_mapping_result() { } - public get_triggers_for_resourceplan_result( - WMGetTriggersForResourePlanResponse success, - NoSuchObjectException o1, - MetaException o2) + public create_or_drop_wm_trigger_to_pool_mapping_result( + WMCreateOrDropTriggerToPoolMappingResponse 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_triggers_for_resourceplan_result(get_triggers_for_resourceplan_result other) { + public create_or_drop_wm_trigger_to_pool_mapping_result(create_or_drop_wm_trigger_to_pool_mapping_result other) { if (other.isSetSuccess()) { - this.success = new WMGetTriggersForResourePlanResponse(other.success); + this.success = new WMCreateOrDropTriggerToPoolMappingResponse(other.success); } if (other.isSetO1()) { - this.o1 = new NoSuchObjectException(other.o1); + this.o1 = new AlreadyExistsException(other.o1); } if (other.isSetO2()) { - this.o2 = new MetaException(other.o2); + 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_triggers_for_resourceplan_result deepCopy() { - return new get_triggers_for_resourceplan_result(this); + public create_or_drop_wm_trigger_to_pool_mapping_result deepCopy() { + return new create_or_drop_wm_trigger_to_pool_mapping_result(this); } @Override @@ -200595,13 +206800,15 @@ public void clear() { this.success = null; this.o1 = null; this.o2 = null; + this.o3 = null; + this.o4 = null; } - public WMGetTriggersForResourePlanResponse getSuccess() { + public WMCreateOrDropTriggerToPoolMappingResponse getSuccess() { return this.success; } - public void setSuccess(WMGetTriggersForResourePlanResponse success) { + public void setSuccess(WMCreateOrDropTriggerToPoolMappingResponse success) { this.success = success; } @@ -200620,11 +206827,11 @@ public void setSuccessIsSet(boolean value) { } } - public NoSuchObjectException getO1() { + public AlreadyExistsException getO1() { return this.o1; } - public void setO1(NoSuchObjectException o1) { + public void setO1(AlreadyExistsException o1) { this.o1 = o1; } @@ -200643,11 +206850,11 @@ public void setO1IsSet(boolean value) { } } - public MetaException getO2() { + public NoSuchObjectException getO2() { return this.o2; } - public void setO2(MetaException o2) { + public void setO2(NoSuchObjectException o2) { this.o2 = o2; } @@ -200666,13 +206873,59 @@ public void setO2IsSet(boolean value) { } } + 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((WMGetTriggersForResourePlanResponse)value); + setSuccess((WMCreateOrDropTriggerToPoolMappingResponse)value); } break; @@ -200680,7 +206933,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetO1(); } else { - setO1((NoSuchObjectException)value); + setO1((AlreadyExistsException)value); } break; @@ -200688,7 +206941,23 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetO2(); } else { - setO2((MetaException)value); + 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; @@ -200706,6 +206975,12 @@ public Object getFieldValue(_Fields field) { case O2: return getO2(); + case O3: + return getO3(); + + case O4: + return getO4(); + } throw new IllegalStateException(); } @@ -200723,6 +206998,10 @@ public boolean isSet(_Fields field) { return isSetO1(); case O2: return isSetO2(); + case O3: + return isSetO3(); + case O4: + return isSetO4(); } throw new IllegalStateException(); } @@ -200731,12 +207010,12 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof get_triggers_for_resourceplan_result) - return this.equals((get_triggers_for_resourceplan_result)that); + if (that instanceof create_or_drop_wm_trigger_to_pool_mapping_result) + return this.equals((create_or_drop_wm_trigger_to_pool_mapping_result)that); return false; } - public boolean equals(get_triggers_for_resourceplan_result that) { + public boolean equals(create_or_drop_wm_trigger_to_pool_mapping_result that) { if (that == null) return false; @@ -200767,6 +207046,24 @@ public boolean equals(get_triggers_for_resourceplan_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; + } + + 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; } @@ -200789,11 +207086,21 @@ public int hashCode() { 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_triggers_for_resourceplan_result other) { + public int compareTo(create_or_drop_wm_trigger_to_pool_mapping_result other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -200830,6 +207137,26 @@ public int compareTo(get_triggers_for_resourceplan_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; + } + } + 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; } @@ -200847,7 +207174,7 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("get_triggers_for_resourceplan_result("); + StringBuilder sb = new StringBuilder("create_or_drop_wm_trigger_to_pool_mapping_result("); boolean first = true; sb.append("success:"); @@ -200873,6 +207200,22 @@ 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; + 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(); } @@ -200901,15 +207244,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - 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 create_or_drop_wm_trigger_to_pool_mapping_resultStandardSchemeFactory implements SchemeFactory { + public create_or_drop_wm_trigger_to_pool_mapping_resultStandardScheme getScheme() { + return new create_or_drop_wm_trigger_to_pool_mapping_resultStandardScheme(); } } - private static class get_triggers_for_resourceplan_resultStandardScheme extends StandardScheme { + private static class create_or_drop_wm_trigger_to_pool_mapping_resultStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, get_triggers_for_resourceplan_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, create_or_drop_wm_trigger_to_pool_mapping_result struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -200921,7 +207264,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_triggers_for_re switch (schemeField.id) { case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.success = new WMGetTriggersForResourePlanResponse(); + struct.success = new WMCreateOrDropTriggerToPoolMappingResponse(); struct.success.read(iprot); struct.setSuccessIsSet(true); } else { @@ -200930,7 +207273,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_triggers_for_re break; case 1: // O1 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.o1 = new NoSuchObjectException(); + struct.o1 = new AlreadyExistsException(); struct.o1.read(iprot); struct.setO1IsSet(true); } else { @@ -200939,13 +207282,31 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_triggers_for_re break; case 2: // O2 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.o2 = new MetaException(); + 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); } @@ -200955,7 +207316,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_triggers_for_re struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, get_triggers_for_resourceplan_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, create_or_drop_wm_trigger_to_pool_mapping_result struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -200974,22 +207335,32 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_triggers_for_r 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_triggers_for_resourceplan_resultTupleSchemeFactory implements SchemeFactory { - public get_triggers_for_resourceplan_resultTupleScheme getScheme() { - return new get_triggers_for_resourceplan_resultTupleScheme(); + private static class create_or_drop_wm_trigger_to_pool_mapping_resultTupleSchemeFactory implements SchemeFactory { + public create_or_drop_wm_trigger_to_pool_mapping_resultTupleScheme getScheme() { + return new create_or_drop_wm_trigger_to_pool_mapping_resultTupleScheme(); } } - private static class get_triggers_for_resourceplan_resultTupleScheme extends TupleScheme { + private static class create_or_drop_wm_trigger_to_pool_mapping_resultTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, get_triggers_for_resourceplan_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, create_or_drop_wm_trigger_to_pool_mapping_result struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetSuccess()) { @@ -201001,7 +207372,13 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_triggers_for_re if (struct.isSetO2()) { optionals.set(2); } - oprot.writeBitSet(optionals, 3); + if (struct.isSetO3()) { + optionals.set(3); + } + if (struct.isSetO4()) { + optionals.set(4); + } + oprot.writeBitSet(optionals, 5); if (struct.isSetSuccess()) { struct.success.write(oprot); } @@ -201011,27 +207388,43 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_triggers_for_re 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_triggers_for_resourceplan_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, create_or_drop_wm_trigger_to_pool_mapping_result struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(3); + BitSet incoming = iprot.readBitSet(5); if (incoming.get(0)) { - struct.success = new WMGetTriggersForResourePlanResponse(); + struct.success = new WMCreateOrDropTriggerToPoolMappingResponse(); struct.success.read(iprot); struct.setSuccessIsSet(true); } if (incoming.get(1)) { - struct.o1 = new NoSuchObjectException(); + struct.o1 = new AlreadyExistsException(); struct.o1.read(iprot); struct.setO1IsSet(true); } if (incoming.get(2)) { - struct.o2 = new MetaException(); + 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); + } } } diff --git standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMAlterResourcePlanRequest.java standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMAlterResourcePlanRequest.java index fa694f0cec..1c568991ce 100644 --- standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMAlterResourcePlanRequest.java +++ standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMAlterResourcePlanRequest.java @@ -35,7 +35,7 @@ @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) @Generated(value = "Autogenerated by Thrift Compiler (0.9.3)") -public class WMAlterResourcePlanRequest implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { +@org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public class WMAlterResourcePlanRequest 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("WMAlterResourcePlanRequest"); 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); diff --git standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMAlterResourcePlanResponse.java standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMAlterResourcePlanResponse.java index 73fc638672..1b8b635b4e 100644 --- standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMAlterResourcePlanResponse.java +++ standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMAlterResourcePlanResponse.java @@ -35,7 +35,7 @@ @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) @Generated(value = "Autogenerated by Thrift Compiler (0.9.3)") -public class WMAlterResourcePlanResponse implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { +@org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public class WMAlterResourcePlanResponse 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("WMAlterResourcePlanResponse"); 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 index d9938dc20e..dc0d3556c1 100644 --- 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 @@ -35,7 +35,7 @@ @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 { +@org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable 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); 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 index d66aeaaa69..eb8326108d 100644 --- 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 @@ -35,7 +35,7 @@ @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 { +@org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable 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"); diff --git standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMCreateOrDropTriggerToPoolMappingRequest.java standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMCreateOrDropTriggerToPoolMappingRequest.java new file mode 100644 index 0000000000..f807be9854 --- /dev/null +++ standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMCreateOrDropTriggerToPoolMappingRequest.java @@ -0,0 +1,708 @@ +/** + * Autogenerated by Thrift Compiler (0.9.3) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +package org.apache.hadoop.hive.metastore.api; + +import org.apache.thrift.scheme.IScheme; +import org.apache.thrift.scheme.SchemeFactory; +import org.apache.thrift.scheme.StandardScheme; + +import org.apache.thrift.scheme.TupleScheme; +import org.apache.thrift.protocol.TTupleProtocol; +import org.apache.thrift.protocol.TProtocolException; +import org.apache.thrift.EncodingUtils; +import org.apache.thrift.TException; +import org.apache.thrift.async.AsyncMethodCallback; +import org.apache.thrift.server.AbstractNonblockingServer.*; +import java.util.List; +import java.util.ArrayList; +import java.util.Map; +import java.util.HashMap; +import java.util.EnumMap; +import java.util.Set; +import java.util.HashSet; +import java.util.EnumSet; +import java.util.Collections; +import java.util.BitSet; +import java.nio.ByteBuffer; +import java.util.Arrays; +import javax.annotation.Generated; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) +@Generated(value = "Autogenerated by Thrift Compiler (0.9.3)") +@org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public class WMCreateOrDropTriggerToPoolMappingRequest 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("WMCreateOrDropTriggerToPoolMappingRequest"); + + 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 org.apache.thrift.protocol.TField POOL_PATH_FIELD_DESC = new org.apache.thrift.protocol.TField("poolPath", org.apache.thrift.protocol.TType.STRING, (short)3); + private static final org.apache.thrift.protocol.TField DROP_FIELD_DESC = new org.apache.thrift.protocol.TField("drop", org.apache.thrift.protocol.TType.BOOL, (short)4); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new WMCreateOrDropTriggerToPoolMappingRequestStandardSchemeFactory()); + schemes.put(TupleScheme.class, new WMCreateOrDropTriggerToPoolMappingRequestTupleSchemeFactory()); + } + + private String resourcePlanName; // optional + private String triggerName; // optional + private String poolPath; // optional + private boolean drop; // 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"), + POOL_PATH((short)3, "poolPath"), + DROP((short)4, "drop"); + + 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; + case 3: // POOL_PATH + return POOL_PATH; + case 4: // DROP + return DROP; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + private static final int __DROP_ISSET_ID = 0; + private byte __isset_bitfield = 0; + private static final _Fields optionals[] = {_Fields.RESOURCE_PLAN_NAME,_Fields.TRIGGER_NAME,_Fields.POOL_PATH,_Fields.DROP}; + 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))); + tmpMap.put(_Fields.POOL_PATH, new org.apache.thrift.meta_data.FieldMetaData("poolPath", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.DROP, new org.apache.thrift.meta_data.FieldMetaData("drop", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(WMCreateOrDropTriggerToPoolMappingRequest.class, metaDataMap); + } + + public WMCreateOrDropTriggerToPoolMappingRequest() { + } + + /** + * Performs a deep copy on other. + */ + public WMCreateOrDropTriggerToPoolMappingRequest(WMCreateOrDropTriggerToPoolMappingRequest other) { + __isset_bitfield = other.__isset_bitfield; + if (other.isSetResourcePlanName()) { + this.resourcePlanName = other.resourcePlanName; + } + if (other.isSetTriggerName()) { + this.triggerName = other.triggerName; + } + if (other.isSetPoolPath()) { + this.poolPath = other.poolPath; + } + this.drop = other.drop; + } + + public WMCreateOrDropTriggerToPoolMappingRequest deepCopy() { + return new WMCreateOrDropTriggerToPoolMappingRequest(this); + } + + @Override + public void clear() { + this.resourcePlanName = null; + this.triggerName = null; + this.poolPath = null; + setDropIsSet(false); + this.drop = false; + } + + 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 String getPoolPath() { + return this.poolPath; + } + + public void setPoolPath(String poolPath) { + this.poolPath = poolPath; + } + + public void unsetPoolPath() { + this.poolPath = null; + } + + /** Returns true if field poolPath is set (has been assigned a value) and false otherwise */ + public boolean isSetPoolPath() { + return this.poolPath != null; + } + + public void setPoolPathIsSet(boolean value) { + if (!value) { + this.poolPath = null; + } + } + + public boolean isDrop() { + return this.drop; + } + + public void setDrop(boolean drop) { + this.drop = drop; + setDropIsSet(true); + } + + public void unsetDrop() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __DROP_ISSET_ID); + } + + /** Returns true if field drop is set (has been assigned a value) and false otherwise */ + public boolean isSetDrop() { + return EncodingUtils.testBit(__isset_bitfield, __DROP_ISSET_ID); + } + + public void setDropIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __DROP_ISSET_ID, value); + } + + 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; + + case POOL_PATH: + if (value == null) { + unsetPoolPath(); + } else { + setPoolPath((String)value); + } + break; + + case DROP: + if (value == null) { + unsetDrop(); + } else { + setDrop((Boolean)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case RESOURCE_PLAN_NAME: + return getResourcePlanName(); + + case TRIGGER_NAME: + return getTriggerName(); + + case POOL_PATH: + return getPoolPath(); + + case DROP: + return isDrop(); + + } + 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(); + case POOL_PATH: + return isSetPoolPath(); + case DROP: + return isSetDrop(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof WMCreateOrDropTriggerToPoolMappingRequest) + return this.equals((WMCreateOrDropTriggerToPoolMappingRequest)that); + return false; + } + + public boolean equals(WMCreateOrDropTriggerToPoolMappingRequest 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; + } + + boolean this_present_poolPath = true && this.isSetPoolPath(); + boolean that_present_poolPath = true && that.isSetPoolPath(); + if (this_present_poolPath || that_present_poolPath) { + if (!(this_present_poolPath && that_present_poolPath)) + return false; + if (!this.poolPath.equals(that.poolPath)) + return false; + } + + boolean this_present_drop = true && this.isSetDrop(); + boolean that_present_drop = true && that.isSetDrop(); + if (this_present_drop || that_present_drop) { + if (!(this_present_drop && that_present_drop)) + return false; + if (this.drop != that.drop) + 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); + + boolean present_poolPath = true && (isSetPoolPath()); + list.add(present_poolPath); + if (present_poolPath) + list.add(poolPath); + + boolean present_drop = true && (isSetDrop()); + list.add(present_drop); + if (present_drop) + list.add(drop); + + return list.hashCode(); + } + + @Override + public int compareTo(WMCreateOrDropTriggerToPoolMappingRequest 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; + } + } + lastComparison = Boolean.valueOf(isSetPoolPath()).compareTo(other.isSetPoolPath()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPoolPath()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.poolPath, other.poolPath); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetDrop()).compareTo(other.isSetDrop()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetDrop()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.drop, other.drop); + 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("WMCreateOrDropTriggerToPoolMappingRequest("); + 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; + } + if (isSetPoolPath()) { + if (!first) sb.append(", "); + sb.append("poolPath:"); + if (this.poolPath == null) { + sb.append("null"); + } else { + sb.append(this.poolPath); + } + first = false; + } + if (isSetDrop()) { + if (!first) sb.append(", "); + sb.append("drop:"); + sb.append(this.drop); + 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 { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_bitfield = 0; + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class WMCreateOrDropTriggerToPoolMappingRequestStandardSchemeFactory implements SchemeFactory { + public WMCreateOrDropTriggerToPoolMappingRequestStandardScheme getScheme() { + return new WMCreateOrDropTriggerToPoolMappingRequestStandardScheme(); + } + } + + private static class WMCreateOrDropTriggerToPoolMappingRequestStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, WMCreateOrDropTriggerToPoolMappingRequest 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; + case 3: // POOL_PATH + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.poolPath = iprot.readString(); + struct.setPoolPathIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 4: // DROP + if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) { + struct.drop = iprot.readBool(); + struct.setDropIsSet(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, WMCreateOrDropTriggerToPoolMappingRequest 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(); + } + } + if (struct.poolPath != null) { + if (struct.isSetPoolPath()) { + oprot.writeFieldBegin(POOL_PATH_FIELD_DESC); + oprot.writeString(struct.poolPath); + oprot.writeFieldEnd(); + } + } + if (struct.isSetDrop()) { + oprot.writeFieldBegin(DROP_FIELD_DESC); + oprot.writeBool(struct.drop); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class WMCreateOrDropTriggerToPoolMappingRequestTupleSchemeFactory implements SchemeFactory { + public WMCreateOrDropTriggerToPoolMappingRequestTupleScheme getScheme() { + return new WMCreateOrDropTriggerToPoolMappingRequestTupleScheme(); + } + } + + private static class WMCreateOrDropTriggerToPoolMappingRequestTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, WMCreateOrDropTriggerToPoolMappingRequest 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); + } + if (struct.isSetPoolPath()) { + optionals.set(2); + } + if (struct.isSetDrop()) { + optionals.set(3); + } + oprot.writeBitSet(optionals, 4); + if (struct.isSetResourcePlanName()) { + oprot.writeString(struct.resourcePlanName); + } + if (struct.isSetTriggerName()) { + oprot.writeString(struct.triggerName); + } + if (struct.isSetPoolPath()) { + oprot.writeString(struct.poolPath); + } + if (struct.isSetDrop()) { + oprot.writeBool(struct.drop); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, WMCreateOrDropTriggerToPoolMappingRequest struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(4); + if (incoming.get(0)) { + struct.resourcePlanName = iprot.readString(); + struct.setResourcePlanNameIsSet(true); + } + if (incoming.get(1)) { + struct.triggerName = iprot.readString(); + struct.setTriggerNameIsSet(true); + } + if (incoming.get(2)) { + struct.poolPath = iprot.readString(); + struct.setPoolPathIsSet(true); + } + if (incoming.get(3)) { + struct.drop = iprot.readBool(); + struct.setDropIsSet(true); + } + } + } + +} + diff --git standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMCreateOrDropTriggerToPoolMappingResponse.java standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMCreateOrDropTriggerToPoolMappingResponse.java new file mode 100644 index 0000000000..33b28cd04f --- /dev/null +++ standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMCreateOrDropTriggerToPoolMappingResponse.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)") +@org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public class WMCreateOrDropTriggerToPoolMappingResponse 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("WMCreateOrDropTriggerToPoolMappingResponse"); + + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new WMCreateOrDropTriggerToPoolMappingResponseStandardSchemeFactory()); + schemes.put(TupleScheme.class, new WMCreateOrDropTriggerToPoolMappingResponseTupleSchemeFactory()); + } + + + /** 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(WMCreateOrDropTriggerToPoolMappingResponse.class, metaDataMap); + } + + public WMCreateOrDropTriggerToPoolMappingResponse() { + } + + /** + * Performs a deep copy on other. + */ + public WMCreateOrDropTriggerToPoolMappingResponse(WMCreateOrDropTriggerToPoolMappingResponse other) { + } + + public WMCreateOrDropTriggerToPoolMappingResponse deepCopy() { + return new WMCreateOrDropTriggerToPoolMappingResponse(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 WMCreateOrDropTriggerToPoolMappingResponse) + return this.equals((WMCreateOrDropTriggerToPoolMappingResponse)that); + return false; + } + + public boolean equals(WMCreateOrDropTriggerToPoolMappingResponse that) { + if (that == null) + return false; + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + return list.hashCode(); + } + + @Override + public int compareTo(WMCreateOrDropTriggerToPoolMappingResponse 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("WMCreateOrDropTriggerToPoolMappingResponse("); + 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 WMCreateOrDropTriggerToPoolMappingResponseStandardSchemeFactory implements SchemeFactory { + public WMCreateOrDropTriggerToPoolMappingResponseStandardScheme getScheme() { + return new WMCreateOrDropTriggerToPoolMappingResponseStandardScheme(); + } + } + + private static class WMCreateOrDropTriggerToPoolMappingResponseStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, WMCreateOrDropTriggerToPoolMappingResponse 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, WMCreateOrDropTriggerToPoolMappingResponse struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class WMCreateOrDropTriggerToPoolMappingResponseTupleSchemeFactory implements SchemeFactory { + public WMCreateOrDropTriggerToPoolMappingResponseTupleScheme getScheme() { + return new WMCreateOrDropTriggerToPoolMappingResponseTupleScheme(); + } + } + + private static class WMCreateOrDropTriggerToPoolMappingResponseTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, WMCreateOrDropTriggerToPoolMappingResponse struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, WMCreateOrDropTriggerToPoolMappingResponse 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/WMCreateOrUpdateMappingRequest.java standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMCreateOrUpdateMappingRequest.java new file mode 100644 index 0000000000..2fbe10eb26 --- /dev/null +++ standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMCreateOrUpdateMappingRequest.java @@ -0,0 +1,501 @@ +/** + * Autogenerated by Thrift Compiler (0.9.3) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +package org.apache.hadoop.hive.metastore.api; + +import org.apache.thrift.scheme.IScheme; +import org.apache.thrift.scheme.SchemeFactory; +import org.apache.thrift.scheme.StandardScheme; + +import org.apache.thrift.scheme.TupleScheme; +import org.apache.thrift.protocol.TTupleProtocol; +import org.apache.thrift.protocol.TProtocolException; +import org.apache.thrift.EncodingUtils; +import org.apache.thrift.TException; +import org.apache.thrift.async.AsyncMethodCallback; +import org.apache.thrift.server.AbstractNonblockingServer.*; +import java.util.List; +import java.util.ArrayList; +import java.util.Map; +import java.util.HashMap; +import java.util.EnumMap; +import java.util.Set; +import java.util.HashSet; +import java.util.EnumSet; +import java.util.Collections; +import java.util.BitSet; +import java.nio.ByteBuffer; +import java.util.Arrays; +import javax.annotation.Generated; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) +@Generated(value = "Autogenerated by Thrift Compiler (0.9.3)") +@org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public class WMCreateOrUpdateMappingRequest 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("WMCreateOrUpdateMappingRequest"); + + private static final org.apache.thrift.protocol.TField MAPPING_FIELD_DESC = new org.apache.thrift.protocol.TField("mapping", org.apache.thrift.protocol.TType.STRUCT, (short)1); + private static final org.apache.thrift.protocol.TField UPDATE_FIELD_DESC = new org.apache.thrift.protocol.TField("update", org.apache.thrift.protocol.TType.BOOL, (short)2); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new WMCreateOrUpdateMappingRequestStandardSchemeFactory()); + schemes.put(TupleScheme.class, new WMCreateOrUpdateMappingRequestTupleSchemeFactory()); + } + + private WMMapping mapping; // optional + private boolean update; // 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 { + MAPPING((short)1, "mapping"), + UPDATE((short)2, "update"); + + 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: // MAPPING + return MAPPING; + case 2: // UPDATE + return UPDATE; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + private static final int __UPDATE_ISSET_ID = 0; + private byte __isset_bitfield = 0; + private static final _Fields optionals[] = {_Fields.MAPPING,_Fields.UPDATE}; + 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.MAPPING, new org.apache.thrift.meta_data.FieldMetaData("mapping", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, WMMapping.class))); + tmpMap.put(_Fields.UPDATE, new org.apache.thrift.meta_data.FieldMetaData("update", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(WMCreateOrUpdateMappingRequest.class, metaDataMap); + } + + public WMCreateOrUpdateMappingRequest() { + } + + /** + * Performs a deep copy on other. + */ + public WMCreateOrUpdateMappingRequest(WMCreateOrUpdateMappingRequest other) { + __isset_bitfield = other.__isset_bitfield; + if (other.isSetMapping()) { + this.mapping = new WMMapping(other.mapping); + } + this.update = other.update; + } + + public WMCreateOrUpdateMappingRequest deepCopy() { + return new WMCreateOrUpdateMappingRequest(this); + } + + @Override + public void clear() { + this.mapping = null; + setUpdateIsSet(false); + this.update = false; + } + + public WMMapping getMapping() { + return this.mapping; + } + + public void setMapping(WMMapping mapping) { + this.mapping = mapping; + } + + public void unsetMapping() { + this.mapping = null; + } + + /** Returns true if field mapping is set (has been assigned a value) and false otherwise */ + public boolean isSetMapping() { + return this.mapping != null; + } + + public void setMappingIsSet(boolean value) { + if (!value) { + this.mapping = null; + } + } + + public boolean isUpdate() { + return this.update; + } + + public void setUpdate(boolean update) { + this.update = update; + setUpdateIsSet(true); + } + + public void unsetUpdate() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __UPDATE_ISSET_ID); + } + + /** Returns true if field update is set (has been assigned a value) and false otherwise */ + public boolean isSetUpdate() { + return EncodingUtils.testBit(__isset_bitfield, __UPDATE_ISSET_ID); + } + + public void setUpdateIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __UPDATE_ISSET_ID, value); + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case MAPPING: + if (value == null) { + unsetMapping(); + } else { + setMapping((WMMapping)value); + } + break; + + case UPDATE: + if (value == null) { + unsetUpdate(); + } else { + setUpdate((Boolean)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case MAPPING: + return getMapping(); + + case UPDATE: + return isUpdate(); + + } + 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 MAPPING: + return isSetMapping(); + case UPDATE: + return isSetUpdate(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof WMCreateOrUpdateMappingRequest) + return this.equals((WMCreateOrUpdateMappingRequest)that); + return false; + } + + public boolean equals(WMCreateOrUpdateMappingRequest that) { + if (that == null) + return false; + + boolean this_present_mapping = true && this.isSetMapping(); + boolean that_present_mapping = true && that.isSetMapping(); + if (this_present_mapping || that_present_mapping) { + if (!(this_present_mapping && that_present_mapping)) + return false; + if (!this.mapping.equals(that.mapping)) + return false; + } + + boolean this_present_update = true && this.isSetUpdate(); + boolean that_present_update = true && that.isSetUpdate(); + if (this_present_update || that_present_update) { + if (!(this_present_update && that_present_update)) + return false; + if (this.update != that.update) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + boolean present_mapping = true && (isSetMapping()); + list.add(present_mapping); + if (present_mapping) + list.add(mapping); + + boolean present_update = true && (isSetUpdate()); + list.add(present_update); + if (present_update) + list.add(update); + + return list.hashCode(); + } + + @Override + public int compareTo(WMCreateOrUpdateMappingRequest other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetMapping()).compareTo(other.isSetMapping()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetMapping()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.mapping, other.mapping); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetUpdate()).compareTo(other.isSetUpdate()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetUpdate()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.update, other.update); + 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("WMCreateOrUpdateMappingRequest("); + boolean first = true; + + if (isSetMapping()) { + sb.append("mapping:"); + if (this.mapping == null) { + sb.append("null"); + } else { + sb.append(this.mapping); + } + first = false; + } + if (isSetUpdate()) { + if (!first) sb.append(", "); + sb.append("update:"); + sb.append(this.update); + 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 (mapping != null) { + mapping.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 { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_bitfield = 0; + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class WMCreateOrUpdateMappingRequestStandardSchemeFactory implements SchemeFactory { + public WMCreateOrUpdateMappingRequestStandardScheme getScheme() { + return new WMCreateOrUpdateMappingRequestStandardScheme(); + } + } + + private static class WMCreateOrUpdateMappingRequestStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, WMCreateOrUpdateMappingRequest 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: // MAPPING + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.mapping = new WMMapping(); + struct.mapping.read(iprot); + struct.setMappingIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // UPDATE + if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) { + struct.update = iprot.readBool(); + struct.setUpdateIsSet(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, WMCreateOrUpdateMappingRequest struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.mapping != null) { + if (struct.isSetMapping()) { + oprot.writeFieldBegin(MAPPING_FIELD_DESC); + struct.mapping.write(oprot); + oprot.writeFieldEnd(); + } + } + if (struct.isSetUpdate()) { + oprot.writeFieldBegin(UPDATE_FIELD_DESC); + oprot.writeBool(struct.update); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class WMCreateOrUpdateMappingRequestTupleSchemeFactory implements SchemeFactory { + public WMCreateOrUpdateMappingRequestTupleScheme getScheme() { + return new WMCreateOrUpdateMappingRequestTupleScheme(); + } + } + + private static class WMCreateOrUpdateMappingRequestTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, WMCreateOrUpdateMappingRequest struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetMapping()) { + optionals.set(0); + } + if (struct.isSetUpdate()) { + optionals.set(1); + } + oprot.writeBitSet(optionals, 2); + if (struct.isSetMapping()) { + struct.mapping.write(oprot); + } + if (struct.isSetUpdate()) { + oprot.writeBool(struct.update); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, WMCreateOrUpdateMappingRequest struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(2); + if (incoming.get(0)) { + struct.mapping = new WMMapping(); + struct.mapping.read(iprot); + struct.setMappingIsSet(true); + } + if (incoming.get(1)) { + struct.update = iprot.readBool(); + struct.setUpdateIsSet(true); + } + } + } + +} + diff --git standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMCreateOrUpdateMappingResponse.java standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMCreateOrUpdateMappingResponse.java new file mode 100644 index 0000000000..5b8041f7b9 --- /dev/null +++ standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMCreateOrUpdateMappingResponse.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)") +@org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public class WMCreateOrUpdateMappingResponse 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("WMCreateOrUpdateMappingResponse"); + + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new WMCreateOrUpdateMappingResponseStandardSchemeFactory()); + schemes.put(TupleScheme.class, new WMCreateOrUpdateMappingResponseTupleSchemeFactory()); + } + + + /** 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(WMCreateOrUpdateMappingResponse.class, metaDataMap); + } + + public WMCreateOrUpdateMappingResponse() { + } + + /** + * Performs a deep copy on other. + */ + public WMCreateOrUpdateMappingResponse(WMCreateOrUpdateMappingResponse other) { + } + + public WMCreateOrUpdateMappingResponse deepCopy() { + return new WMCreateOrUpdateMappingResponse(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 WMCreateOrUpdateMappingResponse) + return this.equals((WMCreateOrUpdateMappingResponse)that); + return false; + } + + public boolean equals(WMCreateOrUpdateMappingResponse that) { + if (that == null) + return false; + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + return list.hashCode(); + } + + @Override + public int compareTo(WMCreateOrUpdateMappingResponse 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("WMCreateOrUpdateMappingResponse("); + 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 WMCreateOrUpdateMappingResponseStandardSchemeFactory implements SchemeFactory { + public WMCreateOrUpdateMappingResponseStandardScheme getScheme() { + return new WMCreateOrUpdateMappingResponseStandardScheme(); + } + } + + private static class WMCreateOrUpdateMappingResponseStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, WMCreateOrUpdateMappingResponse 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, WMCreateOrUpdateMappingResponse struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class WMCreateOrUpdateMappingResponseTupleSchemeFactory implements SchemeFactory { + public WMCreateOrUpdateMappingResponseTupleScheme getScheme() { + return new WMCreateOrUpdateMappingResponseTupleScheme(); + } + } + + private static class WMCreateOrUpdateMappingResponseTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, WMCreateOrUpdateMappingResponse struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, WMCreateOrUpdateMappingResponse 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/WMCreateOrUpdatePoolRequest.java standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMCreateOrUpdatePoolRequest.java new file mode 100644 index 0000000000..9e96c0a71e --- /dev/null +++ standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMCreateOrUpdatePoolRequest.java @@ -0,0 +1,607 @@ +/** + * Autogenerated by Thrift Compiler (0.9.3) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +package org.apache.hadoop.hive.metastore.api; + +import org.apache.thrift.scheme.IScheme; +import org.apache.thrift.scheme.SchemeFactory; +import org.apache.thrift.scheme.StandardScheme; + +import org.apache.thrift.scheme.TupleScheme; +import org.apache.thrift.protocol.TTupleProtocol; +import org.apache.thrift.protocol.TProtocolException; +import org.apache.thrift.EncodingUtils; +import org.apache.thrift.TException; +import org.apache.thrift.async.AsyncMethodCallback; +import org.apache.thrift.server.AbstractNonblockingServer.*; +import java.util.List; +import java.util.ArrayList; +import java.util.Map; +import java.util.HashMap; +import java.util.EnumMap; +import java.util.Set; +import java.util.HashSet; +import java.util.EnumSet; +import java.util.Collections; +import java.util.BitSet; +import java.nio.ByteBuffer; +import java.util.Arrays; +import javax.annotation.Generated; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) +@Generated(value = "Autogenerated by Thrift Compiler (0.9.3)") +@org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public class WMCreateOrUpdatePoolRequest 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("WMCreateOrUpdatePoolRequest"); + + private static final org.apache.thrift.protocol.TField POOL_FIELD_DESC = new org.apache.thrift.protocol.TField("pool", org.apache.thrift.protocol.TType.STRUCT, (short)1); + private static final org.apache.thrift.protocol.TField NEW_POOL_PATH_FIELD_DESC = new org.apache.thrift.protocol.TField("newPoolPath", org.apache.thrift.protocol.TType.STRING, (short)2); + private static final org.apache.thrift.protocol.TField UPDATE_FIELD_DESC = new org.apache.thrift.protocol.TField("update", org.apache.thrift.protocol.TType.BOOL, (short)3); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new WMCreateOrUpdatePoolRequestStandardSchemeFactory()); + schemes.put(TupleScheme.class, new WMCreateOrUpdatePoolRequestTupleSchemeFactory()); + } + + private WMPool pool; // optional + private String newPoolPath; // optional + private boolean update; // 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 { + POOL((short)1, "pool"), + NEW_POOL_PATH((short)2, "newPoolPath"), + UPDATE((short)3, "update"); + + 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: // POOL + return POOL; + case 2: // NEW_POOL_PATH + return NEW_POOL_PATH; + case 3: // UPDATE + return UPDATE; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + private static final int __UPDATE_ISSET_ID = 0; + private byte __isset_bitfield = 0; + private static final _Fields optionals[] = {_Fields.POOL,_Fields.NEW_POOL_PATH,_Fields.UPDATE}; + 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.POOL, new org.apache.thrift.meta_data.FieldMetaData("pool", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, WMPool.class))); + tmpMap.put(_Fields.NEW_POOL_PATH, new org.apache.thrift.meta_data.FieldMetaData("newPoolPath", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.UPDATE, new org.apache.thrift.meta_data.FieldMetaData("update", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(WMCreateOrUpdatePoolRequest.class, metaDataMap); + } + + public WMCreateOrUpdatePoolRequest() { + } + + /** + * Performs a deep copy on other. + */ + public WMCreateOrUpdatePoolRequest(WMCreateOrUpdatePoolRequest other) { + __isset_bitfield = other.__isset_bitfield; + if (other.isSetPool()) { + this.pool = new WMPool(other.pool); + } + if (other.isSetNewPoolPath()) { + this.newPoolPath = other.newPoolPath; + } + this.update = other.update; + } + + public WMCreateOrUpdatePoolRequest deepCopy() { + return new WMCreateOrUpdatePoolRequest(this); + } + + @Override + public void clear() { + this.pool = null; + this.newPoolPath = null; + setUpdateIsSet(false); + this.update = false; + } + + public WMPool getPool() { + return this.pool; + } + + public void setPool(WMPool pool) { + this.pool = pool; + } + + public void unsetPool() { + this.pool = null; + } + + /** Returns true if field pool is set (has been assigned a value) and false otherwise */ + public boolean isSetPool() { + return this.pool != null; + } + + public void setPoolIsSet(boolean value) { + if (!value) { + this.pool = null; + } + } + + public String getNewPoolPath() { + return this.newPoolPath; + } + + public void setNewPoolPath(String newPoolPath) { + this.newPoolPath = newPoolPath; + } + + public void unsetNewPoolPath() { + this.newPoolPath = null; + } + + /** Returns true if field newPoolPath is set (has been assigned a value) and false otherwise */ + public boolean isSetNewPoolPath() { + return this.newPoolPath != null; + } + + public void setNewPoolPathIsSet(boolean value) { + if (!value) { + this.newPoolPath = null; + } + } + + public boolean isUpdate() { + return this.update; + } + + public void setUpdate(boolean update) { + this.update = update; + setUpdateIsSet(true); + } + + public void unsetUpdate() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __UPDATE_ISSET_ID); + } + + /** Returns true if field update is set (has been assigned a value) and false otherwise */ + public boolean isSetUpdate() { + return EncodingUtils.testBit(__isset_bitfield, __UPDATE_ISSET_ID); + } + + public void setUpdateIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __UPDATE_ISSET_ID, value); + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case POOL: + if (value == null) { + unsetPool(); + } else { + setPool((WMPool)value); + } + break; + + case NEW_POOL_PATH: + if (value == null) { + unsetNewPoolPath(); + } else { + setNewPoolPath((String)value); + } + break; + + case UPDATE: + if (value == null) { + unsetUpdate(); + } else { + setUpdate((Boolean)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case POOL: + return getPool(); + + case NEW_POOL_PATH: + return getNewPoolPath(); + + case UPDATE: + return isUpdate(); + + } + 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 POOL: + return isSetPool(); + case NEW_POOL_PATH: + return isSetNewPoolPath(); + case UPDATE: + return isSetUpdate(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof WMCreateOrUpdatePoolRequest) + return this.equals((WMCreateOrUpdatePoolRequest)that); + return false; + } + + public boolean equals(WMCreateOrUpdatePoolRequest that) { + if (that == null) + return false; + + boolean this_present_pool = true && this.isSetPool(); + boolean that_present_pool = true && that.isSetPool(); + if (this_present_pool || that_present_pool) { + if (!(this_present_pool && that_present_pool)) + return false; + if (!this.pool.equals(that.pool)) + return false; + } + + boolean this_present_newPoolPath = true && this.isSetNewPoolPath(); + boolean that_present_newPoolPath = true && that.isSetNewPoolPath(); + if (this_present_newPoolPath || that_present_newPoolPath) { + if (!(this_present_newPoolPath && that_present_newPoolPath)) + return false; + if (!this.newPoolPath.equals(that.newPoolPath)) + return false; + } + + boolean this_present_update = true && this.isSetUpdate(); + boolean that_present_update = true && that.isSetUpdate(); + if (this_present_update || that_present_update) { + if (!(this_present_update && that_present_update)) + return false; + if (this.update != that.update) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + boolean present_pool = true && (isSetPool()); + list.add(present_pool); + if (present_pool) + list.add(pool); + + boolean present_newPoolPath = true && (isSetNewPoolPath()); + list.add(present_newPoolPath); + if (present_newPoolPath) + list.add(newPoolPath); + + boolean present_update = true && (isSetUpdate()); + list.add(present_update); + if (present_update) + list.add(update); + + return list.hashCode(); + } + + @Override + public int compareTo(WMCreateOrUpdatePoolRequest other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetPool()).compareTo(other.isSetPool()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPool()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.pool, other.pool); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetNewPoolPath()).compareTo(other.isSetNewPoolPath()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetNewPoolPath()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.newPoolPath, other.newPoolPath); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetUpdate()).compareTo(other.isSetUpdate()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetUpdate()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.update, other.update); + 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("WMCreateOrUpdatePoolRequest("); + boolean first = true; + + if (isSetPool()) { + sb.append("pool:"); + if (this.pool == null) { + sb.append("null"); + } else { + sb.append(this.pool); + } + first = false; + } + if (isSetNewPoolPath()) { + if (!first) sb.append(", "); + sb.append("newPoolPath:"); + if (this.newPoolPath == null) { + sb.append("null"); + } else { + sb.append(this.newPoolPath); + } + first = false; + } + if (isSetUpdate()) { + if (!first) sb.append(", "); + sb.append("update:"); + sb.append(this.update); + 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 (pool != null) { + pool.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 { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_bitfield = 0; + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class WMCreateOrUpdatePoolRequestStandardSchemeFactory implements SchemeFactory { + public WMCreateOrUpdatePoolRequestStandardScheme getScheme() { + return new WMCreateOrUpdatePoolRequestStandardScheme(); + } + } + + private static class WMCreateOrUpdatePoolRequestStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, WMCreateOrUpdatePoolRequest 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: // POOL + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.pool = new WMPool(); + struct.pool.read(iprot); + struct.setPoolIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // NEW_POOL_PATH + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.newPoolPath = iprot.readString(); + struct.setNewPoolPathIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 3: // UPDATE + if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) { + struct.update = iprot.readBool(); + struct.setUpdateIsSet(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, WMCreateOrUpdatePoolRequest struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.pool != null) { + if (struct.isSetPool()) { + oprot.writeFieldBegin(POOL_FIELD_DESC); + struct.pool.write(oprot); + oprot.writeFieldEnd(); + } + } + if (struct.newPoolPath != null) { + if (struct.isSetNewPoolPath()) { + oprot.writeFieldBegin(NEW_POOL_PATH_FIELD_DESC); + oprot.writeString(struct.newPoolPath); + oprot.writeFieldEnd(); + } + } + if (struct.isSetUpdate()) { + oprot.writeFieldBegin(UPDATE_FIELD_DESC); + oprot.writeBool(struct.update); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class WMCreateOrUpdatePoolRequestTupleSchemeFactory implements SchemeFactory { + public WMCreateOrUpdatePoolRequestTupleScheme getScheme() { + return new WMCreateOrUpdatePoolRequestTupleScheme(); + } + } + + private static class WMCreateOrUpdatePoolRequestTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, WMCreateOrUpdatePoolRequest struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetPool()) { + optionals.set(0); + } + if (struct.isSetNewPoolPath()) { + optionals.set(1); + } + if (struct.isSetUpdate()) { + optionals.set(2); + } + oprot.writeBitSet(optionals, 3); + if (struct.isSetPool()) { + struct.pool.write(oprot); + } + if (struct.isSetNewPoolPath()) { + oprot.writeString(struct.newPoolPath); + } + if (struct.isSetUpdate()) { + oprot.writeBool(struct.update); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, WMCreateOrUpdatePoolRequest struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(3); + if (incoming.get(0)) { + struct.pool = new WMPool(); + struct.pool.read(iprot); + struct.setPoolIsSet(true); + } + if (incoming.get(1)) { + struct.newPoolPath = iprot.readString(); + struct.setNewPoolPathIsSet(true); + } + if (incoming.get(2)) { + struct.update = iprot.readBool(); + struct.setUpdateIsSet(true); + } + } + } + +} + diff --git standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMCreateOrUpdatePoolResponse.java standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMCreateOrUpdatePoolResponse.java new file mode 100644 index 0000000000..a8712165bf --- /dev/null +++ standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMCreateOrUpdatePoolResponse.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)") +@org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public class WMCreateOrUpdatePoolResponse 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("WMCreateOrUpdatePoolResponse"); + + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new WMCreateOrUpdatePoolResponseStandardSchemeFactory()); + schemes.put(TupleScheme.class, new WMCreateOrUpdatePoolResponseTupleSchemeFactory()); + } + + + /** 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(WMCreateOrUpdatePoolResponse.class, metaDataMap); + } + + public WMCreateOrUpdatePoolResponse() { + } + + /** + * Performs a deep copy on other. + */ + public WMCreateOrUpdatePoolResponse(WMCreateOrUpdatePoolResponse other) { + } + + public WMCreateOrUpdatePoolResponse deepCopy() { + return new WMCreateOrUpdatePoolResponse(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 WMCreateOrUpdatePoolResponse) + return this.equals((WMCreateOrUpdatePoolResponse)that); + return false; + } + + public boolean equals(WMCreateOrUpdatePoolResponse that) { + if (that == null) + return false; + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + return list.hashCode(); + } + + @Override + public int compareTo(WMCreateOrUpdatePoolResponse 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("WMCreateOrUpdatePoolResponse("); + 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 WMCreateOrUpdatePoolResponseStandardSchemeFactory implements SchemeFactory { + public WMCreateOrUpdatePoolResponseStandardScheme getScheme() { + return new WMCreateOrUpdatePoolResponseStandardScheme(); + } + } + + private static class WMCreateOrUpdatePoolResponseStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, WMCreateOrUpdatePoolResponse 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, WMCreateOrUpdatePoolResponse struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class WMCreateOrUpdatePoolResponseTupleSchemeFactory implements SchemeFactory { + public WMCreateOrUpdatePoolResponseTupleScheme getScheme() { + return new WMCreateOrUpdatePoolResponseTupleScheme(); + } + } + + private static class WMCreateOrUpdatePoolResponseTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, WMCreateOrUpdatePoolResponse struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, WMCreateOrUpdatePoolResponse 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/WMCreateResourcePlanRequest.java standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMCreateResourcePlanRequest.java index c5fb10b85f..1af2159f4c 100644 --- standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMCreateResourcePlanRequest.java +++ standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMCreateResourcePlanRequest.java @@ -35,7 +35,7 @@ @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) @Generated(value = "Autogenerated by Thrift Compiler (0.9.3)") -public class WMCreateResourcePlanRequest implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { +@org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public class WMCreateResourcePlanRequest 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("WMCreateResourcePlanRequest"); private static final org.apache.thrift.protocol.TField RESOURCE_PLAN_FIELD_DESC = new org.apache.thrift.protocol.TField("resourcePlan", org.apache.thrift.protocol.TType.STRUCT, (short)1); diff --git standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMCreateResourcePlanResponse.java standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMCreateResourcePlanResponse.java index c6769f85dc..cb3aa6d70e 100644 --- standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMCreateResourcePlanResponse.java +++ standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMCreateResourcePlanResponse.java @@ -35,7 +35,7 @@ @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) @Generated(value = "Autogenerated by Thrift Compiler (0.9.3)") -public class WMCreateResourcePlanResponse implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { +@org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public class WMCreateResourcePlanResponse 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("WMCreateResourcePlanResponse"); 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 index be72429401..2508129d2d 100644 --- 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 @@ -35,7 +35,7 @@ @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 { +@org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable 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); 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 index 53e0082a67..068bc11e2c 100644 --- 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 @@ -35,7 +35,7 @@ @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 { +@org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable 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"); diff --git standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMDropMappingRequest.java standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMDropMappingRequest.java new file mode 100644 index 0000000000..4fdf4029dd --- /dev/null +++ standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMDropMappingRequest.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)") +@org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public class WMDropMappingRequest 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("WMDropMappingRequest"); + + private static final org.apache.thrift.protocol.TField MAPPING_FIELD_DESC = new org.apache.thrift.protocol.TField("mapping", org.apache.thrift.protocol.TType.STRUCT, (short)1); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new WMDropMappingRequestStandardSchemeFactory()); + schemes.put(TupleScheme.class, new WMDropMappingRequestTupleSchemeFactory()); + } + + private WMMapping mapping; // 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 { + MAPPING((short)1, "mapping"); + + 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: // MAPPING + return MAPPING; + 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.MAPPING}; + 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.MAPPING, new org.apache.thrift.meta_data.FieldMetaData("mapping", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, WMMapping.class))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(WMDropMappingRequest.class, metaDataMap); + } + + public WMDropMappingRequest() { + } + + /** + * Performs a deep copy on other. + */ + public WMDropMappingRequest(WMDropMappingRequest other) { + if (other.isSetMapping()) { + this.mapping = new WMMapping(other.mapping); + } + } + + public WMDropMappingRequest deepCopy() { + return new WMDropMappingRequest(this); + } + + @Override + public void clear() { + this.mapping = null; + } + + public WMMapping getMapping() { + return this.mapping; + } + + public void setMapping(WMMapping mapping) { + this.mapping = mapping; + } + + public void unsetMapping() { + this.mapping = null; + } + + /** Returns true if field mapping is set (has been assigned a value) and false otherwise */ + public boolean isSetMapping() { + return this.mapping != null; + } + + public void setMappingIsSet(boolean value) { + if (!value) { + this.mapping = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case MAPPING: + if (value == null) { + unsetMapping(); + } else { + setMapping((WMMapping)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case MAPPING: + return getMapping(); + + } + 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 MAPPING: + return isSetMapping(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof WMDropMappingRequest) + return this.equals((WMDropMappingRequest)that); + return false; + } + + public boolean equals(WMDropMappingRequest that) { + if (that == null) + return false; + + boolean this_present_mapping = true && this.isSetMapping(); + boolean that_present_mapping = true && that.isSetMapping(); + if (this_present_mapping || that_present_mapping) { + if (!(this_present_mapping && that_present_mapping)) + return false; + if (!this.mapping.equals(that.mapping)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + boolean present_mapping = true && (isSetMapping()); + list.add(present_mapping); + if (present_mapping) + list.add(mapping); + + return list.hashCode(); + } + + @Override + public int compareTo(WMDropMappingRequest other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetMapping()).compareTo(other.isSetMapping()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetMapping()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.mapping, other.mapping); + 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("WMDropMappingRequest("); + boolean first = true; + + if (isSetMapping()) { + sb.append("mapping:"); + if (this.mapping == null) { + sb.append("null"); + } else { + sb.append(this.mapping); + } + 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 (mapping != null) { + mapping.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 WMDropMappingRequestStandardSchemeFactory implements SchemeFactory { + public WMDropMappingRequestStandardScheme getScheme() { + return new WMDropMappingRequestStandardScheme(); + } + } + + private static class WMDropMappingRequestStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, WMDropMappingRequest 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: // MAPPING + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.mapping = new WMMapping(); + struct.mapping.read(iprot); + struct.setMappingIsSet(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, WMDropMappingRequest struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.mapping != null) { + if (struct.isSetMapping()) { + oprot.writeFieldBegin(MAPPING_FIELD_DESC); + struct.mapping.write(oprot); + oprot.writeFieldEnd(); + } + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class WMDropMappingRequestTupleSchemeFactory implements SchemeFactory { + public WMDropMappingRequestTupleScheme getScheme() { + return new WMDropMappingRequestTupleScheme(); + } + } + + private static class WMDropMappingRequestTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, WMDropMappingRequest struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetMapping()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetMapping()) { + struct.mapping.write(oprot); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, WMDropMappingRequest struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.mapping = new WMMapping(); + struct.mapping.read(iprot); + struct.setMappingIsSet(true); + } + } + } + +} + diff --git standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMDropMappingResponse.java standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMDropMappingResponse.java new file mode 100644 index 0000000000..f3fd4b3160 --- /dev/null +++ standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMDropMappingResponse.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)") +@org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public class WMDropMappingResponse 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("WMDropMappingResponse"); + + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new WMDropMappingResponseStandardSchemeFactory()); + schemes.put(TupleScheme.class, new WMDropMappingResponseTupleSchemeFactory()); + } + + + /** 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(WMDropMappingResponse.class, metaDataMap); + } + + public WMDropMappingResponse() { + } + + /** + * Performs a deep copy on other. + */ + public WMDropMappingResponse(WMDropMappingResponse other) { + } + + public WMDropMappingResponse deepCopy() { + return new WMDropMappingResponse(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 WMDropMappingResponse) + return this.equals((WMDropMappingResponse)that); + return false; + } + + public boolean equals(WMDropMappingResponse that) { + if (that == null) + return false; + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + return list.hashCode(); + } + + @Override + public int compareTo(WMDropMappingResponse 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("WMDropMappingResponse("); + 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 WMDropMappingResponseStandardSchemeFactory implements SchemeFactory { + public WMDropMappingResponseStandardScheme getScheme() { + return new WMDropMappingResponseStandardScheme(); + } + } + + private static class WMDropMappingResponseStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, WMDropMappingResponse 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, WMDropMappingResponse struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class WMDropMappingResponseTupleSchemeFactory implements SchemeFactory { + public WMDropMappingResponseTupleScheme getScheme() { + return new WMDropMappingResponseTupleScheme(); + } + } + + private static class WMDropMappingResponseTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, WMDropMappingResponse struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, WMDropMappingResponse 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/WMDropPoolRequest.java standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMDropPoolRequest.java new file mode 100644 index 0000000000..114cdde46a --- /dev/null +++ standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMDropPoolRequest.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)") +@org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public class WMDropPoolRequest 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("WMDropPoolRequest"); + + 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_PATH_FIELD_DESC = new org.apache.thrift.protocol.TField("poolPath", org.apache.thrift.protocol.TType.STRING, (short)2); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new WMDropPoolRequestStandardSchemeFactory()); + schemes.put(TupleScheme.class, new WMDropPoolRequestTupleSchemeFactory()); + } + + private String resourcePlanName; // optional + private String poolPath; // 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_PATH((short)2, "poolPath"); + + 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: // POOL_PATH + return POOL_PATH; + 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.POOL_PATH}; + 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.POOL_PATH, new org.apache.thrift.meta_data.FieldMetaData("poolPath", 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(WMDropPoolRequest.class, metaDataMap); + } + + public WMDropPoolRequest() { + } + + /** + * Performs a deep copy on other. + */ + public WMDropPoolRequest(WMDropPoolRequest other) { + if (other.isSetResourcePlanName()) { + this.resourcePlanName = other.resourcePlanName; + } + if (other.isSetPoolPath()) { + this.poolPath = other.poolPath; + } + } + + public WMDropPoolRequest deepCopy() { + return new WMDropPoolRequest(this); + } + + @Override + public void clear() { + this.resourcePlanName = null; + this.poolPath = 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 getPoolPath() { + return this.poolPath; + } + + public void setPoolPath(String poolPath) { + this.poolPath = poolPath; + } + + public void unsetPoolPath() { + this.poolPath = null; + } + + /** Returns true if field poolPath is set (has been assigned a value) and false otherwise */ + public boolean isSetPoolPath() { + return this.poolPath != null; + } + + public void setPoolPathIsSet(boolean value) { + if (!value) { + this.poolPath = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case RESOURCE_PLAN_NAME: + if (value == null) { + unsetResourcePlanName(); + } else { + setResourcePlanName((String)value); + } + break; + + case POOL_PATH: + if (value == null) { + unsetPoolPath(); + } else { + setPoolPath((String)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case RESOURCE_PLAN_NAME: + return getResourcePlanName(); + + case POOL_PATH: + return getPoolPath(); + + } + 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 POOL_PATH: + return isSetPoolPath(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof WMDropPoolRequest) + return this.equals((WMDropPoolRequest)that); + return false; + } + + public boolean equals(WMDropPoolRequest 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_poolPath = true && this.isSetPoolPath(); + boolean that_present_poolPath = true && that.isSetPoolPath(); + if (this_present_poolPath || that_present_poolPath) { + if (!(this_present_poolPath && that_present_poolPath)) + return false; + if (!this.poolPath.equals(that.poolPath)) + 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_poolPath = true && (isSetPoolPath()); + list.add(present_poolPath); + if (present_poolPath) + list.add(poolPath); + + return list.hashCode(); + } + + @Override + public int compareTo(WMDropPoolRequest 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(isSetPoolPath()).compareTo(other.isSetPoolPath()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPoolPath()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.poolPath, other.poolPath); + 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("WMDropPoolRequest("); + boolean first = true; + + if (isSetResourcePlanName()) { + sb.append("resourcePlanName:"); + if (this.resourcePlanName == null) { + sb.append("null"); + } else { + sb.append(this.resourcePlanName); + } + first = false; + } + if (isSetPoolPath()) { + if (!first) sb.append(", "); + sb.append("poolPath:"); + if (this.poolPath == null) { + sb.append("null"); + } else { + sb.append(this.poolPath); + } + 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 WMDropPoolRequestStandardSchemeFactory implements SchemeFactory { + public WMDropPoolRequestStandardScheme getScheme() { + return new WMDropPoolRequestStandardScheme(); + } + } + + private static class WMDropPoolRequestStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, WMDropPoolRequest 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: // POOL_PATH + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.poolPath = iprot.readString(); + struct.setPoolPathIsSet(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, WMDropPoolRequest 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.poolPath != null) { + if (struct.isSetPoolPath()) { + oprot.writeFieldBegin(POOL_PATH_FIELD_DESC); + oprot.writeString(struct.poolPath); + oprot.writeFieldEnd(); + } + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class WMDropPoolRequestTupleSchemeFactory implements SchemeFactory { + public WMDropPoolRequestTupleScheme getScheme() { + return new WMDropPoolRequestTupleScheme(); + } + } + + private static class WMDropPoolRequestTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, WMDropPoolRequest struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetResourcePlanName()) { + optionals.set(0); + } + if (struct.isSetPoolPath()) { + optionals.set(1); + } + oprot.writeBitSet(optionals, 2); + if (struct.isSetResourcePlanName()) { + oprot.writeString(struct.resourcePlanName); + } + if (struct.isSetPoolPath()) { + oprot.writeString(struct.poolPath); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, WMDropPoolRequest 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.poolPath = iprot.readString(); + struct.setPoolPathIsSet(true); + } + } + } + +} + diff --git standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMDropPoolResponse.java standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMDropPoolResponse.java new file mode 100644 index 0000000000..602754c959 --- /dev/null +++ standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMDropPoolResponse.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)") +@org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public class WMDropPoolResponse 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("WMDropPoolResponse"); + + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new WMDropPoolResponseStandardSchemeFactory()); + schemes.put(TupleScheme.class, new WMDropPoolResponseTupleSchemeFactory()); + } + + + /** 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(WMDropPoolResponse.class, metaDataMap); + } + + public WMDropPoolResponse() { + } + + /** + * Performs a deep copy on other. + */ + public WMDropPoolResponse(WMDropPoolResponse other) { + } + + public WMDropPoolResponse deepCopy() { + return new WMDropPoolResponse(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 WMDropPoolResponse) + return this.equals((WMDropPoolResponse)that); + return false; + } + + public boolean equals(WMDropPoolResponse that) { + if (that == null) + return false; + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + return list.hashCode(); + } + + @Override + public int compareTo(WMDropPoolResponse 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("WMDropPoolResponse("); + 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 WMDropPoolResponseStandardSchemeFactory implements SchemeFactory { + public WMDropPoolResponseStandardScheme getScheme() { + return new WMDropPoolResponseStandardScheme(); + } + } + + private static class WMDropPoolResponseStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, WMDropPoolResponse 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, WMDropPoolResponse struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class WMDropPoolResponseTupleSchemeFactory implements SchemeFactory { + public WMDropPoolResponseTupleScheme getScheme() { + return new WMDropPoolResponseTupleScheme(); + } + } + + private static class WMDropPoolResponseTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, WMDropPoolResponse struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, WMDropPoolResponse 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/WMDropResourcePlanRequest.java standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMDropResourcePlanRequest.java index 2f8d7d29ff..779b2d1e61 100644 --- standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMDropResourcePlanRequest.java +++ standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMDropResourcePlanRequest.java @@ -35,7 +35,7 @@ @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) @Generated(value = "Autogenerated by Thrift Compiler (0.9.3)") -public class WMDropResourcePlanRequest implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { +@org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public class WMDropResourcePlanRequest 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("WMDropResourcePlanRequest"); 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); diff --git standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMDropResourcePlanResponse.java standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMDropResourcePlanResponse.java index 9e58fa0638..6edab04b8e 100644 --- standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMDropResourcePlanResponse.java +++ standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMDropResourcePlanResponse.java @@ -35,7 +35,7 @@ @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) @Generated(value = "Autogenerated by Thrift Compiler (0.9.3)") -public class WMDropResourcePlanResponse implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { +@org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public class WMDropResourcePlanResponse 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("WMDropResourcePlanResponse"); 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 index 05f9c43f6b..9cde38d49b 100644 --- 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 @@ -35,7 +35,7 @@ @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 { +@org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable 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); 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 index 363018e5d2..419a5e3b46 100644 --- 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 @@ -35,7 +35,7 @@ @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 { +@org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable 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"); diff --git standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMGetAllResourcePlanRequest.java standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMGetAllResourcePlanRequest.java index bdb6e0f982..3df8610c90 100644 --- standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMGetAllResourcePlanRequest.java +++ standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMGetAllResourcePlanRequest.java @@ -35,7 +35,7 @@ @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) @Generated(value = "Autogenerated by Thrift Compiler (0.9.3)") -public class WMGetAllResourcePlanRequest implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { +@org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public class WMGetAllResourcePlanRequest 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("WMGetAllResourcePlanRequest"); diff --git standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMGetAllResourcePlanResponse.java standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMGetAllResourcePlanResponse.java index 9fba8a1f28..494a8f767d 100644 --- standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMGetAllResourcePlanResponse.java +++ standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMGetAllResourcePlanResponse.java @@ -35,7 +35,7 @@ @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) @Generated(value = "Autogenerated by Thrift Compiler (0.9.3)") -public class WMGetAllResourcePlanResponse implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { +@org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public class WMGetAllResourcePlanResponse 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("WMGetAllResourcePlanResponse"); private static final org.apache.thrift.protocol.TField RESOURCE_PLANS_FIELD_DESC = new org.apache.thrift.protocol.TField("resourcePlans", org.apache.thrift.protocol.TType.LIST, (short)1); diff --git standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMGetResourcePlanRequest.java standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMGetResourcePlanRequest.java index c4948aba58..d051634a40 100644 --- standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMGetResourcePlanRequest.java +++ standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMGetResourcePlanRequest.java @@ -35,7 +35,7 @@ @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) @Generated(value = "Autogenerated by Thrift Compiler (0.9.3)") -public class WMGetResourcePlanRequest implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { +@org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public class WMGetResourcePlanRequest 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("WMGetResourcePlanRequest"); 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); diff --git standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMGetResourcePlanResponse.java standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMGetResourcePlanResponse.java index 4b88a2230f..638728e92c 100644 --- standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMGetResourcePlanResponse.java +++ standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMGetResourcePlanResponse.java @@ -35,7 +35,7 @@ @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) @Generated(value = "Autogenerated by Thrift Compiler (0.9.3)") -public class WMGetResourcePlanResponse implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { +@org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public class WMGetResourcePlanResponse 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("WMGetResourcePlanResponse"); private static final org.apache.thrift.protocol.TField RESOURCE_PLAN_FIELD_DESC = new org.apache.thrift.protocol.TField("resourcePlan", org.apache.thrift.protocol.TType.STRUCT, (short)1); 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 index a9daf439ca..ce64a0414c 100644 --- 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 @@ -35,7 +35,7 @@ @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 { +@org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable 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); 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 index c7f62ad0c4..7e165dad6b 100644 --- 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 @@ -35,7 +35,7 @@ @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 { +@org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable 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); diff --git standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMMapping.java standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMMapping.java index cbf4f3867b..8b7d41a85f 100644 --- standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMMapping.java +++ standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMMapping.java @@ -35,13 +35,13 @@ @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) @Generated(value = "Autogenerated by Thrift Compiler (0.9.3)") -public class WMMapping implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { +@org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public class WMMapping 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("WMMapping"); 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 ENTITY_TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("entityType", org.apache.thrift.protocol.TType.STRING, (short)2); private static final org.apache.thrift.protocol.TField ENTITY_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("entityName", org.apache.thrift.protocol.TType.STRING, (short)3); - 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)4); + private static final org.apache.thrift.protocol.TField POOL_PATH_FIELD_DESC = new org.apache.thrift.protocol.TField("poolPath", org.apache.thrift.protocol.TType.STRING, (short)4); private static final org.apache.thrift.protocol.TField ORDERING_FIELD_DESC = new org.apache.thrift.protocol.TField("ordering", org.apache.thrift.protocol.TType.I32, (short)5); private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); @@ -53,7 +53,7 @@ private String resourcePlanName; // required private String entityType; // required private String entityName; // required - private String poolName; // optional + private String poolPath; // optional private int ordering; // optional /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ @@ -61,7 +61,7 @@ RESOURCE_PLAN_NAME((short)1, "resourcePlanName"), ENTITY_TYPE((short)2, "entityType"), ENTITY_NAME((short)3, "entityName"), - POOL_NAME((short)4, "poolName"), + POOL_PATH((short)4, "poolPath"), ORDERING((short)5, "ordering"); private static final Map byName = new HashMap(); @@ -83,8 +83,8 @@ public static _Fields findByThriftId(int fieldId) { return ENTITY_TYPE; case 3: // ENTITY_NAME return ENTITY_NAME; - case 4: // POOL_NAME - return POOL_NAME; + case 4: // POOL_PATH + return POOL_PATH; case 5: // ORDERING return ORDERING; default: @@ -129,7 +129,7 @@ public String getFieldName() { // isset id assignments private static final int __ORDERING_ISSET_ID = 0; private byte __isset_bitfield = 0; - private static final _Fields optionals[] = {_Fields.POOL_NAME,_Fields.ORDERING}; + private static final _Fields optionals[] = {_Fields.POOL_PATH,_Fields.ORDERING}; 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); @@ -139,7 +139,7 @@ public String getFieldName() { new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); tmpMap.put(_Fields.ENTITY_NAME, new org.apache.thrift.meta_data.FieldMetaData("entityName", 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.OPTIONAL, + tmpMap.put(_Fields.POOL_PATH, new org.apache.thrift.meta_data.FieldMetaData("poolPath", org.apache.thrift.TFieldRequirementType.OPTIONAL, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); tmpMap.put(_Fields.ORDERING, new org.apache.thrift.meta_data.FieldMetaData("ordering", org.apache.thrift.TFieldRequirementType.OPTIONAL, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); @@ -175,8 +175,8 @@ public WMMapping(WMMapping other) { if (other.isSetEntityName()) { this.entityName = other.entityName; } - if (other.isSetPoolName()) { - this.poolName = other.poolName; + if (other.isSetPoolPath()) { + this.poolPath = other.poolPath; } this.ordering = other.ordering; } @@ -190,7 +190,7 @@ public void clear() { this.resourcePlanName = null; this.entityType = null; this.entityName = null; - this.poolName = null; + this.poolPath = null; setOrderingIsSet(false); this.ordering = 0; } @@ -264,26 +264,26 @@ public void setEntityNameIsSet(boolean value) { } } - public String getPoolName() { - return this.poolName; + public String getPoolPath() { + return this.poolPath; } - public void setPoolName(String poolName) { - this.poolName = poolName; + public void setPoolPath(String poolPath) { + this.poolPath = poolPath; } - public void unsetPoolName() { - this.poolName = null; + public void unsetPoolPath() { + this.poolPath = 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 poolPath is set (has been assigned a value) and false otherwise */ + public boolean isSetPoolPath() { + return this.poolPath != null; } - public void setPoolNameIsSet(boolean value) { + public void setPoolPathIsSet(boolean value) { if (!value) { - this.poolName = null; + this.poolPath = null; } } @@ -335,11 +335,11 @@ public void setFieldValue(_Fields field, Object value) { } break; - case POOL_NAME: + case POOL_PATH: if (value == null) { - unsetPoolName(); + unsetPoolPath(); } else { - setPoolName((String)value); + setPoolPath((String)value); } break; @@ -365,8 +365,8 @@ public Object getFieldValue(_Fields field) { case ENTITY_NAME: return getEntityName(); - case POOL_NAME: - return getPoolName(); + case POOL_PATH: + return getPoolPath(); case ORDERING: return getOrdering(); @@ -388,8 +388,8 @@ public boolean isSet(_Fields field) { return isSetEntityType(); case ENTITY_NAME: return isSetEntityName(); - case POOL_NAME: - return isSetPoolName(); + case POOL_PATH: + return isSetPoolPath(); case ORDERING: return isSetOrdering(); } @@ -436,12 +436,12 @@ public boolean equals(WMMapping 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_poolPath = true && this.isSetPoolPath(); + boolean that_present_poolPath = true && that.isSetPoolPath(); + if (this_present_poolPath || that_present_poolPath) { + if (!(this_present_poolPath && that_present_poolPath)) return false; - if (!this.poolName.equals(that.poolName)) + if (!this.poolPath.equals(that.poolPath)) return false; } @@ -476,10 +476,10 @@ public int hashCode() { if (present_entityName) list.add(entityName); - boolean present_poolName = true && (isSetPoolName()); - list.add(present_poolName); - if (present_poolName) - list.add(poolName); + boolean present_poolPath = true && (isSetPoolPath()); + list.add(present_poolPath); + if (present_poolPath) + list.add(poolPath); boolean present_ordering = true && (isSetOrdering()); list.add(present_ordering); @@ -527,12 +527,12 @@ public int compareTo(WMMapping other) { return lastComparison; } } - lastComparison = Boolean.valueOf(isSetPoolName()).compareTo(other.isSetPoolName()); + lastComparison = Boolean.valueOf(isSetPoolPath()).compareTo(other.isSetPoolPath()); if (lastComparison != 0) { return lastComparison; } - if (isSetPoolName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.poolName, other.poolName); + if (isSetPoolPath()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.poolPath, other.poolPath); if (lastComparison != 0) { return lastComparison; } @@ -590,13 +590,13 @@ public String toString() { sb.append(this.entityName); } first = false; - if (isSetPoolName()) { + if (isSetPoolPath()) { if (!first) sb.append(", "); - sb.append("poolName:"); - if (this.poolName == null) { + sb.append("poolPath:"); + if (this.poolPath == null) { sb.append("null"); } else { - sb.append(this.poolName); + sb.append(this.poolPath); } first = false; } @@ -687,10 +687,10 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, WMMapping struct) t org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } break; - case 4: // POOL_NAME + case 4: // POOL_PATH if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.poolName = iprot.readString(); - struct.setPoolNameIsSet(true); + struct.poolPath = iprot.readString(); + struct.setPoolPathIsSet(true); } else { org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } @@ -731,10 +731,10 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, WMMapping struct) oprot.writeString(struct.entityName); oprot.writeFieldEnd(); } - if (struct.poolName != null) { - if (struct.isSetPoolName()) { - oprot.writeFieldBegin(POOL_NAME_FIELD_DESC); - oprot.writeString(struct.poolName); + if (struct.poolPath != null) { + if (struct.isSetPoolPath()) { + oprot.writeFieldBegin(POOL_PATH_FIELD_DESC); + oprot.writeString(struct.poolPath); oprot.writeFieldEnd(); } } @@ -764,15 +764,15 @@ public void write(org.apache.thrift.protocol.TProtocol prot, WMMapping struct) t oprot.writeString(struct.entityType); oprot.writeString(struct.entityName); BitSet optionals = new BitSet(); - if (struct.isSetPoolName()) { + if (struct.isSetPoolPath()) { optionals.set(0); } if (struct.isSetOrdering()) { optionals.set(1); } oprot.writeBitSet(optionals, 2); - if (struct.isSetPoolName()) { - oprot.writeString(struct.poolName); + if (struct.isSetPoolPath()) { + oprot.writeString(struct.poolPath); } if (struct.isSetOrdering()) { oprot.writeI32(struct.ordering); @@ -790,8 +790,8 @@ public void read(org.apache.thrift.protocol.TProtocol prot, WMMapping struct) th struct.setEntityNameIsSet(true); BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { - struct.poolName = iprot.readString(); - struct.setPoolNameIsSet(true); + struct.poolPath = iprot.readString(); + struct.setPoolPathIsSet(true); } if (incoming.get(1)) { struct.ordering = iprot.readI32(); diff --git standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMPool.java standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMPool.java index a89e030370..b63ba7cdc1 100644 --- standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMPool.java +++ standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMPool.java @@ -35,15 +35,14 @@ @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) @Generated(value = "Autogenerated by Thrift Compiler (0.9.3)") -public class WMPool implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { +@org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public class WMPool 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("WMPool"); 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 PARENT_POOL_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("parentPoolName", org.apache.thrift.protocol.TType.STRING, (short)3); - private static final org.apache.thrift.protocol.TField ALLOC_FRACTION_FIELD_DESC = new org.apache.thrift.protocol.TField("allocFraction", org.apache.thrift.protocol.TType.DOUBLE, (short)4); - private static final org.apache.thrift.protocol.TField QUERY_PARALLELISM_FIELD_DESC = new org.apache.thrift.protocol.TField("queryParallelism", org.apache.thrift.protocol.TType.I32, (short)5); - private static final org.apache.thrift.protocol.TField SCHEDULING_POLICY_FIELD_DESC = new org.apache.thrift.protocol.TField("schedulingPolicy", org.apache.thrift.protocol.TType.STRING, (short)6); + private static final org.apache.thrift.protocol.TField PATH_FIELD_DESC = new org.apache.thrift.protocol.TField("path", org.apache.thrift.protocol.TType.STRING, (short)2); + private static final org.apache.thrift.protocol.TField ALLOC_FRACTION_FIELD_DESC = new org.apache.thrift.protocol.TField("allocFraction", org.apache.thrift.protocol.TType.DOUBLE, (short)3); + private static final org.apache.thrift.protocol.TField QUERY_PARALLELISM_FIELD_DESC = new org.apache.thrift.protocol.TField("queryParallelism", org.apache.thrift.protocol.TType.I32, (short)4); + private static final org.apache.thrift.protocol.TField SCHEDULING_POLICY_FIELD_DESC = new org.apache.thrift.protocol.TField("schedulingPolicy", org.apache.thrift.protocol.TType.STRING, (short)5); private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { @@ -52,8 +51,7 @@ } private String resourcePlanName; // required - private String poolName; // required - private String parentPoolName; // optional + private String path; // required private double allocFraction; // optional private int queryParallelism; // optional private String schedulingPolicy; // optional @@ -61,11 +59,10 @@ /** 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"), - PARENT_POOL_NAME((short)3, "parentPoolName"), - ALLOC_FRACTION((short)4, "allocFraction"), - QUERY_PARALLELISM((short)5, "queryParallelism"), - SCHEDULING_POLICY((short)6, "schedulingPolicy"); + PATH((short)2, "path"), + ALLOC_FRACTION((short)3, "allocFraction"), + QUERY_PARALLELISM((short)4, "queryParallelism"), + SCHEDULING_POLICY((short)5, "schedulingPolicy"); private static final Map byName = new HashMap(); @@ -82,15 +79,13 @@ 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 3: // PARENT_POOL_NAME - return PARENT_POOL_NAME; - case 4: // ALLOC_FRACTION + case 2: // PATH + return PATH; + case 3: // ALLOC_FRACTION return ALLOC_FRACTION; - case 5: // QUERY_PARALLELISM + case 4: // QUERY_PARALLELISM return QUERY_PARALLELISM; - case 6: // SCHEDULING_POLICY + case 5: // SCHEDULING_POLICY return SCHEDULING_POLICY; default: return null; @@ -135,15 +130,13 @@ public String getFieldName() { private static final int __ALLOCFRACTION_ISSET_ID = 0; private static final int __QUERYPARALLELISM_ISSET_ID = 1; private byte __isset_bitfield = 0; - private static final _Fields optionals[] = {_Fields.PARENT_POOL_NAME,_Fields.ALLOC_FRACTION,_Fields.QUERY_PARALLELISM,_Fields.SCHEDULING_POLICY}; + private static final _Fields optionals[] = {_Fields.ALLOC_FRACTION,_Fields.QUERY_PARALLELISM,_Fields.SCHEDULING_POLICY}; public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; static { Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); tmpMap.put(_Fields.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, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - tmpMap.put(_Fields.PARENT_POOL_NAME, new org.apache.thrift.meta_data.FieldMetaData("parentPoolName", org.apache.thrift.TFieldRequirementType.OPTIONAL, + tmpMap.put(_Fields.PATH, new org.apache.thrift.meta_data.FieldMetaData("path", org.apache.thrift.TFieldRequirementType.REQUIRED, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); tmpMap.put(_Fields.ALLOC_FRACTION, new org.apache.thrift.meta_data.FieldMetaData("allocFraction", org.apache.thrift.TFieldRequirementType.OPTIONAL, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.DOUBLE))); @@ -160,11 +153,11 @@ public WMPool() { public WMPool( String resourcePlanName, - String poolName) + String path) { this(); this.resourcePlanName = resourcePlanName; - this.poolName = poolName; + this.path = path; } /** @@ -175,11 +168,8 @@ public WMPool(WMPool other) { if (other.isSetResourcePlanName()) { this.resourcePlanName = other.resourcePlanName; } - if (other.isSetPoolName()) { - this.poolName = other.poolName; - } - if (other.isSetParentPoolName()) { - this.parentPoolName = other.parentPoolName; + if (other.isSetPath()) { + this.path = other.path; } this.allocFraction = other.allocFraction; this.queryParallelism = other.queryParallelism; @@ -195,8 +185,7 @@ public WMPool deepCopy() { @Override public void clear() { this.resourcePlanName = null; - this.poolName = null; - this.parentPoolName = null; + this.path = null; setAllocFractionIsSet(false); this.allocFraction = 0.0; setQueryParallelismIsSet(false); @@ -227,49 +216,26 @@ public void setResourcePlanNameIsSet(boolean value) { } } - public String getPoolName() { - return this.poolName; + public String getPath() { + return this.path; } - public void setPoolName(String poolName) { - this.poolName = poolName; + public void setPath(String path) { + this.path = path; } - public void unsetPoolName() { - this.poolName = null; + public void unsetPath() { + this.path = 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 path is set (has been assigned a value) and false otherwise */ + public boolean isSetPath() { + return this.path != null; } - public void setPoolNameIsSet(boolean value) { + public void setPathIsSet(boolean value) { if (!value) { - this.poolName = null; - } - } - - public String getParentPoolName() { - return this.parentPoolName; - } - - public void setParentPoolName(String parentPoolName) { - this.parentPoolName = parentPoolName; - } - - public void unsetParentPoolName() { - this.parentPoolName = null; - } - - /** Returns true if field parentPoolName is set (has been assigned a value) and false otherwise */ - public boolean isSetParentPoolName() { - return this.parentPoolName != null; - } - - public void setParentPoolNameIsSet(boolean value) { - if (!value) { - this.parentPoolName = null; + this.path = null; } } @@ -350,19 +316,11 @@ public void setFieldValue(_Fields field, Object value) { } break; - case POOL_NAME: - if (value == null) { - unsetPoolName(); - } else { - setPoolName((String)value); - } - break; - - case PARENT_POOL_NAME: + case PATH: if (value == null) { - unsetParentPoolName(); + unsetPath(); } else { - setParentPoolName((String)value); + setPath((String)value); } break; @@ -398,11 +356,8 @@ public Object getFieldValue(_Fields field) { case RESOURCE_PLAN_NAME: return getResourcePlanName(); - case POOL_NAME: - return getPoolName(); - - case PARENT_POOL_NAME: - return getParentPoolName(); + case PATH: + return getPath(); case ALLOC_FRACTION: return getAllocFraction(); @@ -426,10 +381,8 @@ public boolean isSet(_Fields field) { switch (field) { case RESOURCE_PLAN_NAME: return isSetResourcePlanName(); - case POOL_NAME: - return isSetPoolName(); - case PARENT_POOL_NAME: - return isSetParentPoolName(); + case PATH: + return isSetPath(); case ALLOC_FRACTION: return isSetAllocFraction(); case QUERY_PARALLELISM: @@ -462,21 +415,12 @@ public boolean equals(WMPool 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_path = true && this.isSetPath(); + boolean that_present_path = true && that.isSetPath(); + if (this_present_path || that_present_path) { + if (!(this_present_path && that_present_path)) return false; - if (!this.poolName.equals(that.poolName)) - return false; - } - - boolean this_present_parentPoolName = true && this.isSetParentPoolName(); - boolean that_present_parentPoolName = true && that.isSetParentPoolName(); - if (this_present_parentPoolName || that_present_parentPoolName) { - if (!(this_present_parentPoolName && that_present_parentPoolName)) - return false; - if (!this.parentPoolName.equals(that.parentPoolName)) + if (!this.path.equals(that.path)) return false; } @@ -519,15 +463,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_parentPoolName = true && (isSetParentPoolName()); - list.add(present_parentPoolName); - if (present_parentPoolName) - list.add(parentPoolName); + boolean present_path = true && (isSetPath()); + list.add(present_path); + if (present_path) + list.add(path); boolean present_allocFraction = true && (isSetAllocFraction()); list.add(present_allocFraction); @@ -565,22 +504,12 @@ public int compareTo(WMPool other) { return lastComparison; } } - lastComparison = Boolean.valueOf(isSetPoolName()).compareTo(other.isSetPoolName()); + lastComparison = Boolean.valueOf(isSetPath()).compareTo(other.isSetPath()); if (lastComparison != 0) { return lastComparison; } - if (isSetPoolName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.poolName, other.poolName); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetParentPoolName()).compareTo(other.isSetParentPoolName()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetParentPoolName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.parentPoolName, other.parentPoolName); + if (isSetPath()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.path, other.path); if (lastComparison != 0) { return lastComparison; } @@ -643,23 +572,13 @@ public String toString() { } first = false; if (!first) sb.append(", "); - sb.append("poolName:"); - if (this.poolName == null) { + sb.append("path:"); + if (this.path == null) { sb.append("null"); } else { - sb.append(this.poolName); + sb.append(this.path); } first = false; - if (isSetParentPoolName()) { - if (!first) sb.append(", "); - sb.append("parentPoolName:"); - if (this.parentPoolName == null) { - sb.append("null"); - } else { - sb.append(this.parentPoolName); - } - first = false; - } if (isSetAllocFraction()) { if (!first) sb.append(", "); sb.append("allocFraction:"); @@ -692,8 +611,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 (!isSetPath()) { + throw new org.apache.thrift.protocol.TProtocolException("Required field 'path' is unset! Struct:" + toString()); } // check for sub-struct validity @@ -743,23 +662,15 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, WMPool struct) thro org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } break; - case 2: // POOL_NAME + case 2: // PATH if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.poolName = iprot.readString(); - struct.setPoolNameIsSet(true); + struct.path = iprot.readString(); + struct.setPathIsSet(true); } else { org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } break; - case 3: // PARENT_POOL_NAME - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.parentPoolName = iprot.readString(); - struct.setParentPoolNameIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 4: // ALLOC_FRACTION + case 3: // ALLOC_FRACTION if (schemeField.type == org.apache.thrift.protocol.TType.DOUBLE) { struct.allocFraction = iprot.readDouble(); struct.setAllocFractionIsSet(true); @@ -767,7 +678,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, WMPool struct) thro org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } break; - case 5: // QUERY_PARALLELISM + case 4: // QUERY_PARALLELISM if (schemeField.type == org.apache.thrift.protocol.TType.I32) { struct.queryParallelism = iprot.readI32(); struct.setQueryParallelismIsSet(true); @@ -775,7 +686,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, WMPool struct) thro org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } break; - case 6: // SCHEDULING_POLICY + case 5: // SCHEDULING_POLICY if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { struct.schedulingPolicy = iprot.readString(); struct.setSchedulingPolicyIsSet(true); @@ -801,18 +712,11 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, WMPool struct) thr oprot.writeString(struct.resourcePlanName); oprot.writeFieldEnd(); } - if (struct.poolName != null) { - oprot.writeFieldBegin(POOL_NAME_FIELD_DESC); - oprot.writeString(struct.poolName); + if (struct.path != null) { + oprot.writeFieldBegin(PATH_FIELD_DESC); + oprot.writeString(struct.path); oprot.writeFieldEnd(); } - if (struct.parentPoolName != null) { - if (struct.isSetParentPoolName()) { - oprot.writeFieldBegin(PARENT_POOL_NAME_FIELD_DESC); - oprot.writeString(struct.parentPoolName); - oprot.writeFieldEnd(); - } - } if (struct.isSetAllocFraction()) { oprot.writeFieldBegin(ALLOC_FRACTION_FIELD_DESC); oprot.writeDouble(struct.allocFraction); @@ -848,24 +752,18 @@ public WMPoolTupleScheme getScheme() { public void write(org.apache.thrift.protocol.TProtocol prot, WMPool struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; oprot.writeString(struct.resourcePlanName); - oprot.writeString(struct.poolName); + oprot.writeString(struct.path); BitSet optionals = new BitSet(); - if (struct.isSetParentPoolName()) { - optionals.set(0); - } if (struct.isSetAllocFraction()) { - optionals.set(1); + optionals.set(0); } if (struct.isSetQueryParallelism()) { - optionals.set(2); + optionals.set(1); } if (struct.isSetSchedulingPolicy()) { - optionals.set(3); - } - oprot.writeBitSet(optionals, 4); - if (struct.isSetParentPoolName()) { - oprot.writeString(struct.parentPoolName); + optionals.set(2); } + oprot.writeBitSet(optionals, 3); if (struct.isSetAllocFraction()) { oprot.writeDouble(struct.allocFraction); } @@ -882,22 +780,18 @@ public void read(org.apache.thrift.protocol.TProtocol prot, WMPool struct) throw TTupleProtocol iprot = (TTupleProtocol) prot; struct.resourcePlanName = iprot.readString(); struct.setResourcePlanNameIsSet(true); - struct.poolName = iprot.readString(); - struct.setPoolNameIsSet(true); - BitSet incoming = iprot.readBitSet(4); + struct.path = iprot.readString(); + struct.setPathIsSet(true); + BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { - struct.parentPoolName = iprot.readString(); - struct.setParentPoolNameIsSet(true); - } - if (incoming.get(1)) { struct.allocFraction = iprot.readDouble(); struct.setAllocFractionIsSet(true); } - if (incoming.get(2)) { + if (incoming.get(1)) { struct.queryParallelism = iprot.readI32(); struct.setQueryParallelismIsSet(true); } - if (incoming.get(3)) { + if (incoming.get(2)) { struct.schedulingPolicy = iprot.readString(); struct.setSchedulingPolicyIsSet(true); } diff --git standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMResourcePlan.java standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMResourcePlan.java index 5dfb153b2a..795ece6055 100644 --- standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMResourcePlan.java +++ standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMResourcePlan.java @@ -35,7 +35,7 @@ @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) @Generated(value = "Autogenerated by Thrift Compiler (0.9.3)") -public class WMResourcePlan implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { +@org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public class WMResourcePlan 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("WMResourcePlan"); private static final org.apache.thrift.protocol.TField NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("name", org.apache.thrift.protocol.TType.STRING, (short)1); 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 eb745d6de2..02c55c3656 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 @@ -35,7 +35,7 @@ @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) @Generated(value = "Autogenerated by Thrift Compiler (0.9.3)") -public class WMTrigger implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { +@org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public class WMTrigger 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("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); diff --git standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMValidateResourcePlanRequest.java standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMValidateResourcePlanRequest.java index 184912e1d3..aad6d439f1 100644 --- standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMValidateResourcePlanRequest.java +++ standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMValidateResourcePlanRequest.java @@ -35,7 +35,7 @@ @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) @Generated(value = "Autogenerated by Thrift Compiler (0.9.3)") -public class WMValidateResourcePlanRequest implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { +@org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public class WMValidateResourcePlanRequest 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("WMValidateResourcePlanRequest"); 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); diff --git standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMValidateResourcePlanResponse.java standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMValidateResourcePlanResponse.java index fe8a64bcd5..17938aee96 100644 --- standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMValidateResourcePlanResponse.java +++ standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMValidateResourcePlanResponse.java @@ -35,7 +35,7 @@ @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) @Generated(value = "Autogenerated by Thrift Compiler (0.9.3)") -public class WMValidateResourcePlanResponse implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { +@org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public class WMValidateResourcePlanResponse 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("WMValidateResourcePlanResponse"); private static final org.apache.thrift.protocol.TField IS_VALID_FIELD_DESC = new org.apache.thrift.protocol.TField("isValid", org.apache.thrift.protocol.TType.BOOL, (short)1); diff --git standalone-metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php standalone-metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php index cc813cd099..554f7270b5 100644 --- standalone-metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php +++ standalone-metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php @@ -1323,6 +1323,49 @@ interface ThriftHiveMetastoreIf extends \FacebookServiceIf { * @throws \metastore\MetaException */ public function get_triggers_for_resourceplan(\metastore\WMGetTriggersForResourePlanRequest $request); + /** + * @param \metastore\WMCreateOrUpdatePoolRequest $request + * @return \metastore\WMCreateOrUpdatePoolResponse + * @throws \metastore\AlreadyExistsException + * @throws \metastore\NoSuchObjectException + * @throws \metastore\InvalidObjectException + * @throws \metastore\MetaException + */ + public function create_or_update_wm_pool(\metastore\WMCreateOrUpdatePoolRequest $request); + /** + * @param \metastore\WMDropPoolRequest $request + * @return \metastore\WMDropPoolResponse + * @throws \metastore\NoSuchObjectException + * @throws \metastore\InvalidOperationException + * @throws \metastore\MetaException + */ + public function drop_wm_pool(\metastore\WMDropPoolRequest $request); + /** + * @param \metastore\WMCreateOrUpdateMappingRequest $request + * @return \metastore\WMCreateOrUpdateMappingResponse + * @throws \metastore\AlreadyExistsException + * @throws \metastore\NoSuchObjectException + * @throws \metastore\InvalidObjectException + * @throws \metastore\MetaException + */ + public function create_or_update_wm_mapping(\metastore\WMCreateOrUpdateMappingRequest $request); + /** + * @param \metastore\WMDropMappingRequest $request + * @return \metastore\WMDropMappingResponse + * @throws \metastore\NoSuchObjectException + * @throws \metastore\InvalidOperationException + * @throws \metastore\MetaException + */ + public function drop_wm_mapping(\metastore\WMDropMappingRequest $request); + /** + * @param \metastore\WMCreateOrDropTriggerToPoolMappingRequest $request + * @return \metastore\WMCreateOrDropTriggerToPoolMappingResponse + * @throws \metastore\AlreadyExistsException + * @throws \metastore\NoSuchObjectException + * @throws \metastore\InvalidObjectException + * @throws \metastore\MetaException + */ + public function create_or_drop_wm_trigger_to_pool_mapping(\metastore\WMCreateOrDropTriggerToPoolMappingRequest $request); } class ThriftHiveMetastoreClient extends \FacebookServiceClient implements \metastore\ThriftHiveMetastoreIf { @@ -11099,196 +11142,326 @@ class ThriftHiveMetastoreClient extends \FacebookServiceClient implements \metas throw new \Exception("get_triggers_for_resourceplan failed: unknown result"); } -} - -// HELPER FUNCTIONS AND STRUCTURES + public function create_or_update_wm_pool(\metastore\WMCreateOrUpdatePoolRequest $request) + { + $this->send_create_or_update_wm_pool($request); + return $this->recv_create_or_update_wm_pool(); + } -class ThriftHiveMetastore_getMetaConf_args { - static $_TSPEC; + public function send_create_or_update_wm_pool(\metastore\WMCreateOrUpdatePoolRequest $request) + { + $args = new \metastore\ThriftHiveMetastore_create_or_update_wm_pool_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_or_update_wm_pool', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite()); + } + else + { + $this->output_->writeMessageBegin('create_or_update_wm_pool', TMessageType::CALL, $this->seqid_); + $args->write($this->output_); + $this->output_->writeMessageEnd(); + $this->output_->getTransport()->flush(); + } + } - /** - * @var string - */ - public $key = null; + public function recv_create_or_update_wm_pool() + { + $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_or_update_wm_pool_result', $this->input_->isStrictRead()); + else + { + $rseqid = 0; + $fname = null; + $mtype = 0; - public function __construct($vals=null) { - if (!isset(self::$_TSPEC)) { - self::$_TSPEC = array( - 1 => array( - 'var' => 'key', - 'type' => TType::STRING, - ), - ); - } - if (is_array($vals)) { - if (isset($vals['key'])) { - $this->key = $vals['key']; + $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_or_update_wm_pool_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_or_update_wm_pool failed: unknown result"); } - public function getName() { - return 'ThriftHiveMetastore_getMetaConf_args'; + public function drop_wm_pool(\metastore\WMDropPoolRequest $request) + { + $this->send_drop_wm_pool($request); + return $this->recv_drop_wm_pool(); } - public function read($input) + public function send_drop_wm_pool(\metastore\WMDropPoolRequest $request) { - $xfer = 0; - $fname = null; - $ftype = 0; - $fid = 0; - $xfer += $input->readStructBegin($fname); - while (true) + $args = new \metastore\ThriftHiveMetastore_drop_wm_pool_args(); + $args->request = $request; + $bin_accel = ($this->output_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_write_binary'); + if ($bin_accel) { - $xfer += $input->readFieldBegin($fname, $ftype, $fid); - if ($ftype == TType::STOP) { - break; - } - switch ($fid) - { - case 1: - if ($ftype == TType::STRING) { - $xfer += $input->readString($this->key); - } else { - $xfer += $input->skip($ftype); - } - break; - default: - $xfer += $input->skip($ftype); - break; + thrift_protocol_write_binary($this->output_, 'drop_wm_pool', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite()); + } + else + { + $this->output_->writeMessageBegin('drop_wm_pool', TMessageType::CALL, $this->seqid_); + $args->write($this->output_); + $this->output_->writeMessageEnd(); + $this->output_->getTransport()->flush(); + } + } + + public function recv_drop_wm_pool() + { + $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_pool_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; } - $xfer += $input->readFieldEnd(); + $result = new \metastore\ThriftHiveMetastore_drop_wm_pool_result(); + $result->read($this->input_); + $this->input_->readMessageEnd(); } - $xfer += $input->readStructEnd(); - return $xfer; + 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_pool failed: unknown result"); } - public function write($output) { - $xfer = 0; - $xfer += $output->writeStructBegin('ThriftHiveMetastore_getMetaConf_args'); - if ($this->key !== null) { - $xfer += $output->writeFieldBegin('key', TType::STRING, 1); - $xfer += $output->writeString($this->key); - $xfer += $output->writeFieldEnd(); + public function create_or_update_wm_mapping(\metastore\WMCreateOrUpdateMappingRequest $request) + { + $this->send_create_or_update_wm_mapping($request); + return $this->recv_create_or_update_wm_mapping(); + } + + public function send_create_or_update_wm_mapping(\metastore\WMCreateOrUpdateMappingRequest $request) + { + $args = new \metastore\ThriftHiveMetastore_create_or_update_wm_mapping_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_or_update_wm_mapping', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite()); + } + else + { + $this->output_->writeMessageBegin('create_or_update_wm_mapping', TMessageType::CALL, $this->seqid_); + $args->write($this->output_); + $this->output_->writeMessageEnd(); + $this->output_->getTransport()->flush(); } - $xfer += $output->writeFieldStop(); - $xfer += $output->writeStructEnd(); - return $xfer; } -} + public function recv_create_or_update_wm_mapping() + { + $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_or_update_wm_mapping_result', $this->input_->isStrictRead()); + else + { + $rseqid = 0; + $fname = null; + $mtype = 0; -class ThriftHiveMetastore_getMetaConf_result { - static $_TSPEC; + $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_or_update_wm_mapping_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_or_update_wm_mapping failed: unknown result"); + } - /** - * @var string - */ - public $success = null; - /** - * @var \metastore\MetaException - */ - public $o1 = null; + public function drop_wm_mapping(\metastore\WMDropMappingRequest $request) + { + $this->send_drop_wm_mapping($request); + return $this->recv_drop_wm_mapping(); + } - public function __construct($vals=null) { - if (!isset(self::$_TSPEC)) { - self::$_TSPEC = array( - 0 => array( - 'var' => 'success', - 'type' => TType::STRING, - ), - 1 => array( - 'var' => 'o1', - 'type' => TType::STRUCT, - 'class' => '\metastore\MetaException', - ), - ); + public function send_drop_wm_mapping(\metastore\WMDropMappingRequest $request) + { + $args = new \metastore\ThriftHiveMetastore_drop_wm_mapping_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_mapping', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite()); } - if (is_array($vals)) { - if (isset($vals['success'])) { - $this->success = $vals['success']; - } - if (isset($vals['o1'])) { - $this->o1 = $vals['o1']; + else + { + $this->output_->writeMessageBegin('drop_wm_mapping', TMessageType::CALL, $this->seqid_); + $args->write($this->output_); + $this->output_->writeMessageEnd(); + $this->output_->getTransport()->flush(); + } + } + + public function recv_drop_wm_mapping() + { + $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_mapping_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_mapping_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_mapping failed: unknown result"); } - public function getName() { - return 'ThriftHiveMetastore_getMetaConf_result'; + public function create_or_drop_wm_trigger_to_pool_mapping(\metastore\WMCreateOrDropTriggerToPoolMappingRequest $request) + { + $this->send_create_or_drop_wm_trigger_to_pool_mapping($request); + return $this->recv_create_or_drop_wm_trigger_to_pool_mapping(); } - public function read($input) + public function send_create_or_drop_wm_trigger_to_pool_mapping(\metastore\WMCreateOrDropTriggerToPoolMappingRequest $request) { - $xfer = 0; - $fname = null; - $ftype = 0; - $fid = 0; - $xfer += $input->readStructBegin($fname); - while (true) + $args = new \metastore\ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args(); + $args->request = $request; + $bin_accel = ($this->output_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_write_binary'); + if ($bin_accel) { - $xfer += $input->readFieldBegin($fname, $ftype, $fid); - if ($ftype == TType::STOP) { - break; - } - switch ($fid) - { - case 0: - if ($ftype == TType::STRING) { - $xfer += $input->readString($this->success); - } 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(); + thrift_protocol_write_binary($this->output_, 'create_or_drop_wm_trigger_to_pool_mapping', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite()); + } + else + { + $this->output_->writeMessageBegin('create_or_drop_wm_trigger_to_pool_mapping', TMessageType::CALL, $this->seqid_); + $args->write($this->output_); + $this->output_->writeMessageEnd(); + $this->output_->getTransport()->flush(); } - $xfer += $input->readStructEnd(); - return $xfer; } - public function write($output) { - $xfer = 0; - $xfer += $output->writeStructBegin('ThriftHiveMetastore_getMetaConf_result'); - if ($this->success !== null) { - $xfer += $output->writeFieldBegin('success', TType::STRING, 0); - $xfer += $output->writeString($this->success); - $xfer += $output->writeFieldEnd(); + public function recv_create_or_drop_wm_trigger_to_pool_mapping() + { + $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_or_drop_wm_trigger_to_pool_mapping_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_or_drop_wm_trigger_to_pool_mapping_result(); + $result->read($this->input_); + $this->input_->readMessageEnd(); } - if ($this->o1 !== null) { - $xfer += $output->writeFieldBegin('o1', TType::STRUCT, 1); - $xfer += $this->o1->write($output); - $xfer += $output->writeFieldEnd(); + if ($result->success !== null) { + return $result->success; } - $xfer += $output->writeFieldStop(); - $xfer += $output->writeStructEnd(); - return $xfer; + 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_or_drop_wm_trigger_to_pool_mapping failed: unknown result"); } } -class ThriftHiveMetastore_setMetaConf_args { +// HELPER FUNCTIONS AND STRUCTURES + +class ThriftHiveMetastore_getMetaConf_args { static $_TSPEC; /** * @var string */ public $key = null; - /** - * @var string - */ - public $value = null; public function __construct($vals=null) { if (!isset(self::$_TSPEC)) { @@ -11297,24 +11470,203 @@ class ThriftHiveMetastore_setMetaConf_args { 'var' => 'key', 'type' => TType::STRING, ), - 2 => array( - 'var' => 'value', - 'type' => TType::STRING, - ), ); } if (is_array($vals)) { if (isset($vals['key'])) { $this->key = $vals['key']; } - if (isset($vals['value'])) { - $this->value = $vals['value']; - } } } public function getName() { - return 'ThriftHiveMetastore_setMetaConf_args'; + return 'ThriftHiveMetastore_getMetaConf_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::STRING) { + $xfer += $input->readString($this->key); + } 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_getMetaConf_args'); + if ($this->key !== null) { + $xfer += $output->writeFieldBegin('key', TType::STRING, 1); + $xfer += $output->writeString($this->key); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class ThriftHiveMetastore_getMetaConf_result { + static $_TSPEC; + + /** + * @var string + */ + 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::STRING, + ), + 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_getMetaConf_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::STRING) { + $xfer += $input->readString($this->success); + } 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_getMetaConf_result'); + if ($this->success !== null) { + $xfer += $output->writeFieldBegin('success', TType::STRING, 0); + $xfer += $output->writeString($this->success); + $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_setMetaConf_args { + static $_TSPEC; + + /** + * @var string + */ + public $key = null; + /** + * @var string + */ + public $value = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'key', + 'type' => TType::STRING, + ), + 2 => array( + 'var' => 'value', + 'type' => TType::STRING, + ), + ); + } + if (is_array($vals)) { + if (isset($vals['key'])) { + $this->key = $vals['key']; + } + if (isset($vals['value'])) { + $this->value = $vals['value']; + } + } + } + + public function getName() { + return 'ThriftHiveMetastore_setMetaConf_args'; } public function read($input) @@ -48957,11 +49309,1186 @@ class ThriftHiveMetastore_alter_resource_plan_result { } -class ThriftHiveMetastore_validate_resource_plan_args { +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\WMCreateTriggerRequest + */ + public $request = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'request', + 'type' => TType::STRUCT, + 'class' => '\metastore\WMCreateTriggerRequest', + ), + ); + } + if (is_array($vals)) { + if (isset($vals['request'])) { + $this->request = $vals['request']; + } + } + } + + public function getName() { + return 'ThriftHiveMetastore_create_wm_trigger_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\WMCreateTriggerRequest(); + $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_create_wm_trigger_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_create_wm_trigger_result { + static $_TSPEC; + + /** + * @var \metastore\WMCreateTriggerResponse + */ + public $success = null; + /** + * @var \metastore\AlreadyExistsException + */ + public $o1 = null; + /** + * @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)) { + self::$_TSPEC = array( + 0 => array( + 'var' => 'success', + 'type' => TType::STRUCT, + 'class' => '\metastore\WMCreateTriggerResponse', + ), + 1 => array( + 'var' => 'o1', + 'type' => TType::STRUCT, + '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', + ), + ); + } + 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']; + } + if (isset($vals['o4'])) { + $this->o4 = $vals['o4']; + } + } + } + + public function getName() { + return 'ThriftHiveMetastore_create_wm_trigger_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\WMCreateTriggerResponse(); + $xfer += $this->success->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + case 1: + if ($ftype == TType::STRUCT) { + $this->o1 = new \metastore\AlreadyExistsException(); + $xfer += $this->o1->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + case 2: + if ($ftype == TType::STRUCT) { + $this->o2 = new \metastore\NoSuchObjectException(); + $xfer += $this->o2->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + case 3: + if ($ftype == TType::STRUCT) { + $this->o3 = new \metastore\InvalidObjectException(); + $xfer += $this->o3->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + case 4: + if ($ftype == TType::STRUCT) { + $this->o4 = new \metastore\MetaException(); + $xfer += $this->o4->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_create_wm_trigger_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(); + } + 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; + } + +} + +class ThriftHiveMetastore_alter_wm_trigger_args { + static $_TSPEC; + + /** + * @var \metastore\WMAlterTriggerRequest + */ + public $request = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'request', + 'type' => TType::STRUCT, + 'class' => '\metastore\WMAlterTriggerRequest', + ), + ); + } + if (is_array($vals)) { + if (isset($vals['request'])) { + $this->request = $vals['request']; + } + } + } + + public function getName() { + return 'ThriftHiveMetastore_alter_wm_trigger_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\WMAlterTriggerRequest(); + $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_wm_trigger_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_wm_trigger_result { + static $_TSPEC; + + /** + * @var \metastore\WMAlterTriggerResponse + */ + public $success = null; + /** + * @var \metastore\NoSuchObjectException + */ + public $o1 = null; + /** + * @var \metastore\InvalidObjectException + */ + 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\WMAlterTriggerResponse', + ), + 1 => array( + 'var' => 'o1', + 'type' => TType::STRUCT, + 'class' => '\metastore\NoSuchObjectException', + ), + 2 => array( + 'var' => 'o2', + 'type' => TType::STRUCT, + 'class' => '\metastore\InvalidObjectException', + ), + 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_wm_trigger_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\WMAlterTriggerResponse(); + $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\InvalidObjectException(); + $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_wm_trigger_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_drop_wm_trigger_args { + static $_TSPEC; + + /** + * @var \metastore\WMDropTriggerRequest + */ + public $request = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'request', + 'type' => TType::STRUCT, + 'class' => '\metastore\WMDropTriggerRequest', + ), + ); + } + if (is_array($vals)) { + if (isset($vals['request'])) { + $this->request = $vals['request']; + } + } + } + + public function getName() { + return 'ThriftHiveMetastore_drop_wm_trigger_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\WMDropTriggerRequest(); + $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_wm_trigger_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_wm_trigger_result { + static $_TSPEC; + + /** + * @var \metastore\WMDropTriggerResponse + */ + 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\WMDropTriggerResponse', + ), + 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_wm_trigger_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\WMDropTriggerResponse(); + $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_wm_trigger_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_get_triggers_for_resourceplan_args { static $_TSPEC; /** - * @var \metastore\WMValidateResourcePlanRequest + * @var \metastore\WMGetTriggersForResourePlanRequest */ public $request = null; @@ -48971,7 +50498,7 @@ class ThriftHiveMetastore_validate_resource_plan_args { 1 => array( 'var' => 'request', 'type' => TType::STRUCT, - 'class' => '\metastore\WMValidateResourcePlanRequest', + 'class' => '\metastore\WMGetTriggersForResourePlanRequest', ), ); } @@ -48983,7 +50510,7 @@ class ThriftHiveMetastore_validate_resource_plan_args { } public function getName() { - return 'ThriftHiveMetastore_validate_resource_plan_args'; + return 'ThriftHiveMetastore_get_triggers_for_resourceplan_args'; } public function read($input) @@ -49003,7 +50530,7 @@ class ThriftHiveMetastore_validate_resource_plan_args { { case 1: if ($ftype == TType::STRUCT) { - $this->request = new \metastore\WMValidateResourcePlanRequest(); + $this->request = new \metastore\WMGetTriggersForResourePlanRequest(); $xfer += $this->request->read($input); } else { $xfer += $input->skip($ftype); @@ -49021,7 +50548,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_get_triggers_for_resourceplan_args'); if ($this->request !== null) { if (!is_object($this->request)) { throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); @@ -49037,11 +50564,11 @@ class ThriftHiveMetastore_validate_resource_plan_args { } -class ThriftHiveMetastore_validate_resource_plan_result { +class ThriftHiveMetastore_get_triggers_for_resourceplan_result { static $_TSPEC; /** - * @var \metastore\WMValidateResourcePlanResponse + * @var \metastore\WMGetTriggersForResourePlanResponse */ public $success = null; /** @@ -49059,7 +50586,7 @@ class ThriftHiveMetastore_validate_resource_plan_result { 0 => array( 'var' => 'success', 'type' => TType::STRUCT, - 'class' => '\metastore\WMValidateResourcePlanResponse', + 'class' => '\metastore\WMGetTriggersForResourePlanResponse', ), 1 => array( 'var' => 'o1', @@ -49087,7 +50614,7 @@ class ThriftHiveMetastore_validate_resource_plan_result { } public function getName() { - return 'ThriftHiveMetastore_validate_resource_plan_result'; + return 'ThriftHiveMetastore_get_triggers_for_resourceplan_result'; } public function read($input) @@ -49107,7 +50634,7 @@ class ThriftHiveMetastore_validate_resource_plan_result { { case 0: if ($ftype == TType::STRUCT) { - $this->success = new \metastore\WMValidateResourcePlanResponse(); + $this->success = new \metastore\WMGetTriggersForResourePlanResponse(); $xfer += $this->success->read($input); } else { $xfer += $input->skip($ftype); @@ -49141,7 +50668,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_get_triggers_for_resourceplan_result'); if ($this->success !== null) { if (!is_object($this->success)) { throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); @@ -49167,11 +50694,11 @@ class ThriftHiveMetastore_validate_resource_plan_result { } -class ThriftHiveMetastore_drop_resource_plan_args { +class ThriftHiveMetastore_create_or_update_wm_pool_args { static $_TSPEC; /** - * @var \metastore\WMDropResourcePlanRequest + * @var \metastore\WMCreateOrUpdatePoolRequest */ public $request = null; @@ -49181,7 +50708,7 @@ class ThriftHiveMetastore_drop_resource_plan_args { 1 => array( 'var' => 'request', 'type' => TType::STRUCT, - 'class' => '\metastore\WMDropResourcePlanRequest', + 'class' => '\metastore\WMCreateOrUpdatePoolRequest', ), ); } @@ -49193,7 +50720,7 @@ class ThriftHiveMetastore_drop_resource_plan_args { } public function getName() { - return 'ThriftHiveMetastore_drop_resource_plan_args'; + return 'ThriftHiveMetastore_create_or_update_wm_pool_args'; } public function read($input) @@ -49213,7 +50740,7 @@ class ThriftHiveMetastore_drop_resource_plan_args { { case 1: if ($ftype == TType::STRUCT) { - $this->request = new \metastore\WMDropResourcePlanRequest(); + $this->request = new \metastore\WMCreateOrUpdatePoolRequest(); $xfer += $this->request->read($input); } else { $xfer += $input->skip($ftype); @@ -49231,7 +50758,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_create_or_update_wm_pool_args'); if ($this->request !== null) { if (!is_object($this->request)) { throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); @@ -49247,25 +50774,29 @@ class ThriftHiveMetastore_drop_resource_plan_args { } -class ThriftHiveMetastore_drop_resource_plan_result { +class ThriftHiveMetastore_create_or_update_wm_pool_result { static $_TSPEC; /** - * @var \metastore\WMDropResourcePlanResponse + * @var \metastore\WMCreateOrUpdatePoolResponse */ public $success = null; /** - * @var \metastore\NoSuchObjectException + * @var \metastore\AlreadyExistsException */ public $o1 = null; /** - * @var \metastore\InvalidOperationException + * @var \metastore\NoSuchObjectException */ public $o2 = null; /** - * @var \metastore\MetaException + * @var \metastore\InvalidObjectException */ public $o3 = null; + /** + * @var \metastore\MetaException + */ + public $o4 = null; public function __construct($vals=null) { if (!isset(self::$_TSPEC)) { @@ -49273,21 +50804,26 @@ class ThriftHiveMetastore_drop_resource_plan_result { 0 => array( 'var' => 'success', 'type' => TType::STRUCT, - 'class' => '\metastore\WMDropResourcePlanResponse', + 'class' => '\metastore\WMCreateOrUpdatePoolResponse', ), 1 => array( 'var' => 'o1', 'type' => TType::STRUCT, - 'class' => '\metastore\NoSuchObjectException', + 'class' => '\metastore\AlreadyExistsException', ), 2 => array( 'var' => 'o2', 'type' => TType::STRUCT, - 'class' => '\metastore\InvalidOperationException', + 'class' => '\metastore\NoSuchObjectException', ), 3 => array( 'var' => 'o3', 'type' => TType::STRUCT, + 'class' => '\metastore\InvalidObjectException', + ), + 4 => array( + 'var' => 'o4', + 'type' => TType::STRUCT, 'class' => '\metastore\MetaException', ), ); @@ -49305,11 +50841,14 @@ class ThriftHiveMetastore_drop_resource_plan_result { if (isset($vals['o3'])) { $this->o3 = $vals['o3']; } + if (isset($vals['o4'])) { + $this->o4 = $vals['o4']; + } } } public function getName() { - return 'ThriftHiveMetastore_drop_resource_plan_result'; + return 'ThriftHiveMetastore_create_or_update_wm_pool_result'; } public function read($input) @@ -49329,7 +50868,7 @@ class ThriftHiveMetastore_drop_resource_plan_result { { case 0: if ($ftype == TType::STRUCT) { - $this->success = new \metastore\WMDropResourcePlanResponse(); + $this->success = new \metastore\WMCreateOrUpdatePoolResponse(); $xfer += $this->success->read($input); } else { $xfer += $input->skip($ftype); @@ -49337,7 +50876,7 @@ class ThriftHiveMetastore_drop_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); @@ -49345,7 +50884,7 @@ class ThriftHiveMetastore_drop_resource_plan_result { break; case 2: if ($ftype == TType::STRUCT) { - $this->o2 = new \metastore\InvalidOperationException(); + $this->o2 = new \metastore\NoSuchObjectException(); $xfer += $this->o2->read($input); } else { $xfer += $input->skip($ftype); @@ -49353,12 +50892,20 @@ class ThriftHiveMetastore_drop_resource_plan_result { break; case 3: if ($ftype == TType::STRUCT) { - $this->o3 = new \metastore\MetaException(); + $this->o3 = new \metastore\InvalidObjectException(); $xfer += $this->o3->read($input); } else { $xfer += $input->skip($ftype); } break; + case 4: + if ($ftype == TType::STRUCT) { + $this->o4 = new \metastore\MetaException(); + $xfer += $this->o4->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; default: $xfer += $input->skip($ftype); break; @@ -49371,7 +50918,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_create_or_update_wm_pool_result'); if ($this->success !== null) { if (!is_object($this->success)) { throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); @@ -49395,6 +50942,11 @@ class ThriftHiveMetastore_drop_resource_plan_result { $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; @@ -49402,11 +50954,11 @@ class ThriftHiveMetastore_drop_resource_plan_result { } -class ThriftHiveMetastore_create_wm_trigger_args { +class ThriftHiveMetastore_drop_wm_pool_args { static $_TSPEC; /** - * @var \metastore\WMCreateTriggerRequest + * @var \metastore\WMDropPoolRequest */ public $request = null; @@ -49416,7 +50968,7 @@ class ThriftHiveMetastore_create_wm_trigger_args { 1 => array( 'var' => 'request', 'type' => TType::STRUCT, - 'class' => '\metastore\WMCreateTriggerRequest', + 'class' => '\metastore\WMDropPoolRequest', ), ); } @@ -49428,7 +50980,7 @@ class ThriftHiveMetastore_create_wm_trigger_args { } public function getName() { - return 'ThriftHiveMetastore_create_wm_trigger_args'; + return 'ThriftHiveMetastore_drop_wm_pool_args'; } public function read($input) @@ -49448,7 +51000,7 @@ class ThriftHiveMetastore_create_wm_trigger_args { { case 1: if ($ftype == TType::STRUCT) { - $this->request = new \metastore\WMCreateTriggerRequest(); + $this->request = new \metastore\WMDropPoolRequest(); $xfer += $this->request->read($input); } else { $xfer += $input->skip($ftype); @@ -49466,7 +51018,7 @@ class ThriftHiveMetastore_create_wm_trigger_args { public function write($output) { $xfer = 0; - $xfer += $output->writeStructBegin('ThriftHiveMetastore_create_wm_trigger_args'); + $xfer += $output->writeStructBegin('ThriftHiveMetastore_drop_wm_pool_args'); if ($this->request !== null) { if (!is_object($this->request)) { throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); @@ -49482,29 +51034,25 @@ class ThriftHiveMetastore_create_wm_trigger_args { } -class ThriftHiveMetastore_create_wm_trigger_result { +class ThriftHiveMetastore_drop_wm_pool_result { static $_TSPEC; /** - * @var \metastore\WMCreateTriggerResponse + * @var \metastore\WMDropPoolResponse */ public $success = null; /** - * @var \metastore\AlreadyExistsException + * @var \metastore\NoSuchObjectException */ public $o1 = null; /** - * @var \metastore\NoSuchObjectException + * @var \metastore\InvalidOperationException */ public $o2 = null; - /** - * @var \metastore\InvalidObjectException - */ - public $o3 = null; /** * @var \metastore\MetaException */ - public $o4 = null; + public $o3 = null; public function __construct($vals=null) { if (!isset(self::$_TSPEC)) { @@ -49512,26 +51060,21 @@ class ThriftHiveMetastore_create_wm_trigger_result { 0 => array( 'var' => 'success', 'type' => TType::STRUCT, - 'class' => '\metastore\WMCreateTriggerResponse', + 'class' => '\metastore\WMDropPoolResponse', ), 1 => array( 'var' => 'o1', 'type' => TType::STRUCT, - 'class' => '\metastore\AlreadyExistsException', + 'class' => '\metastore\NoSuchObjectException', ), 2 => array( 'var' => 'o2', 'type' => TType::STRUCT, - 'class' => '\metastore\NoSuchObjectException', + 'class' => '\metastore\InvalidOperationException', ), 3 => array( 'var' => 'o3', 'type' => TType::STRUCT, - 'class' => '\metastore\InvalidObjectException', - ), - 4 => array( - 'var' => 'o4', - 'type' => TType::STRUCT, 'class' => '\metastore\MetaException', ), ); @@ -49549,14 +51092,11 @@ class ThriftHiveMetastore_create_wm_trigger_result { if (isset($vals['o3'])) { $this->o3 = $vals['o3']; } - if (isset($vals['o4'])) { - $this->o4 = $vals['o4']; - } } } public function getName() { - return 'ThriftHiveMetastore_create_wm_trigger_result'; + return 'ThriftHiveMetastore_drop_wm_pool_result'; } public function read($input) @@ -49576,7 +51116,7 @@ class ThriftHiveMetastore_create_wm_trigger_result { { case 0: if ($ftype == TType::STRUCT) { - $this->success = new \metastore\WMCreateTriggerResponse(); + $this->success = new \metastore\WMDropPoolResponse(); $xfer += $this->success->read($input); } else { $xfer += $input->skip($ftype); @@ -49584,7 +51124,7 @@ class ThriftHiveMetastore_create_wm_trigger_result { break; case 1: if ($ftype == TType::STRUCT) { - $this->o1 = new \metastore\AlreadyExistsException(); + $this->o1 = new \metastore\NoSuchObjectException(); $xfer += $this->o1->read($input); } else { $xfer += $input->skip($ftype); @@ -49592,7 +51132,7 @@ class ThriftHiveMetastore_create_wm_trigger_result { break; case 2: if ($ftype == TType::STRUCT) { - $this->o2 = new \metastore\NoSuchObjectException(); + $this->o2 = new \metastore\InvalidOperationException(); $xfer += $this->o2->read($input); } else { $xfer += $input->skip($ftype); @@ -49600,20 +51140,12 @@ class ThriftHiveMetastore_create_wm_trigger_result { break; case 3: if ($ftype == TType::STRUCT) { - $this->o3 = new \metastore\InvalidObjectException(); + $this->o3 = new \metastore\MetaException(); $xfer += $this->o3->read($input); } else { $xfer += $input->skip($ftype); } break; - case 4: - if ($ftype == TType::STRUCT) { - $this->o4 = new \metastore\MetaException(); - $xfer += $this->o4->read($input); - } else { - $xfer += $input->skip($ftype); - } - break; default: $xfer += $input->skip($ftype); break; @@ -49626,7 +51158,7 @@ class ThriftHiveMetastore_create_wm_trigger_result { public function write($output) { $xfer = 0; - $xfer += $output->writeStructBegin('ThriftHiveMetastore_create_wm_trigger_result'); + $xfer += $output->writeStructBegin('ThriftHiveMetastore_drop_wm_pool_result'); if ($this->success !== null) { if (!is_object($this->success)) { throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); @@ -49650,11 +51182,6 @@ class ThriftHiveMetastore_create_wm_trigger_result { $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; @@ -49662,11 +51189,11 @@ class ThriftHiveMetastore_create_wm_trigger_result { } -class ThriftHiveMetastore_alter_wm_trigger_args { +class ThriftHiveMetastore_create_or_update_wm_mapping_args { static $_TSPEC; /** - * @var \metastore\WMAlterTriggerRequest + * @var \metastore\WMCreateOrUpdateMappingRequest */ public $request = null; @@ -49676,7 +51203,7 @@ class ThriftHiveMetastore_alter_wm_trigger_args { 1 => array( 'var' => 'request', 'type' => TType::STRUCT, - 'class' => '\metastore\WMAlterTriggerRequest', + 'class' => '\metastore\WMCreateOrUpdateMappingRequest', ), ); } @@ -49688,7 +51215,7 @@ class ThriftHiveMetastore_alter_wm_trigger_args { } public function getName() { - return 'ThriftHiveMetastore_alter_wm_trigger_args'; + return 'ThriftHiveMetastore_create_or_update_wm_mapping_args'; } public function read($input) @@ -49708,7 +51235,7 @@ class ThriftHiveMetastore_alter_wm_trigger_args { { case 1: if ($ftype == TType::STRUCT) { - $this->request = new \metastore\WMAlterTriggerRequest(); + $this->request = new \metastore\WMCreateOrUpdateMappingRequest(); $xfer += $this->request->read($input); } else { $xfer += $input->skip($ftype); @@ -49726,7 +51253,7 @@ class ThriftHiveMetastore_alter_wm_trigger_args { public function write($output) { $xfer = 0; - $xfer += $output->writeStructBegin('ThriftHiveMetastore_alter_wm_trigger_args'); + $xfer += $output->writeStructBegin('ThriftHiveMetastore_create_or_update_wm_mapping_args'); if ($this->request !== null) { if (!is_object($this->request)) { throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); @@ -49742,25 +51269,29 @@ class ThriftHiveMetastore_alter_wm_trigger_args { } -class ThriftHiveMetastore_alter_wm_trigger_result { +class ThriftHiveMetastore_create_or_update_wm_mapping_result { static $_TSPEC; /** - * @var \metastore\WMAlterTriggerResponse + * @var \metastore\WMCreateOrUpdateMappingResponse */ public $success = null; /** - * @var \metastore\NoSuchObjectException + * @var \metastore\AlreadyExistsException */ public $o1 = null; /** - * @var \metastore\InvalidObjectException + * @var \metastore\NoSuchObjectException */ public $o2 = null; /** - * @var \metastore\MetaException + * @var \metastore\InvalidObjectException */ public $o3 = null; + /** + * @var \metastore\MetaException + */ + public $o4 = null; public function __construct($vals=null) { if (!isset(self::$_TSPEC)) { @@ -49768,21 +51299,26 @@ class ThriftHiveMetastore_alter_wm_trigger_result { 0 => array( 'var' => 'success', 'type' => TType::STRUCT, - 'class' => '\metastore\WMAlterTriggerResponse', + 'class' => '\metastore\WMCreateOrUpdateMappingResponse', ), 1 => array( 'var' => 'o1', 'type' => TType::STRUCT, - 'class' => '\metastore\NoSuchObjectException', + 'class' => '\metastore\AlreadyExistsException', ), 2 => array( 'var' => 'o2', 'type' => TType::STRUCT, - 'class' => '\metastore\InvalidObjectException', + 'class' => '\metastore\NoSuchObjectException', ), 3 => array( 'var' => 'o3', 'type' => TType::STRUCT, + 'class' => '\metastore\InvalidObjectException', + ), + 4 => array( + 'var' => 'o4', + 'type' => TType::STRUCT, 'class' => '\metastore\MetaException', ), ); @@ -49800,11 +51336,14 @@ class ThriftHiveMetastore_alter_wm_trigger_result { if (isset($vals['o3'])) { $this->o3 = $vals['o3']; } + if (isset($vals['o4'])) { + $this->o4 = $vals['o4']; + } } } public function getName() { - return 'ThriftHiveMetastore_alter_wm_trigger_result'; + return 'ThriftHiveMetastore_create_or_update_wm_mapping_result'; } public function read($input) @@ -49824,7 +51363,7 @@ class ThriftHiveMetastore_alter_wm_trigger_result { { case 0: if ($ftype == TType::STRUCT) { - $this->success = new \metastore\WMAlterTriggerResponse(); + $this->success = new \metastore\WMCreateOrUpdateMappingResponse(); $xfer += $this->success->read($input); } else { $xfer += $input->skip($ftype); @@ -49832,7 +51371,7 @@ class ThriftHiveMetastore_alter_wm_trigger_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); @@ -49840,7 +51379,7 @@ class ThriftHiveMetastore_alter_wm_trigger_result { break; case 2: if ($ftype == TType::STRUCT) { - $this->o2 = new \metastore\InvalidObjectException(); + $this->o2 = new \metastore\NoSuchObjectException(); $xfer += $this->o2->read($input); } else { $xfer += $input->skip($ftype); @@ -49848,12 +51387,20 @@ class ThriftHiveMetastore_alter_wm_trigger_result { break; case 3: if ($ftype == TType::STRUCT) { - $this->o3 = new \metastore\MetaException(); + $this->o3 = new \metastore\InvalidObjectException(); $xfer += $this->o3->read($input); } else { $xfer += $input->skip($ftype); } break; + case 4: + if ($ftype == TType::STRUCT) { + $this->o4 = new \metastore\MetaException(); + $xfer += $this->o4->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; default: $xfer += $input->skip($ftype); break; @@ -49866,7 +51413,7 @@ class ThriftHiveMetastore_alter_wm_trigger_result { public function write($output) { $xfer = 0; - $xfer += $output->writeStructBegin('ThriftHiveMetastore_alter_wm_trigger_result'); + $xfer += $output->writeStructBegin('ThriftHiveMetastore_create_or_update_wm_mapping_result'); if ($this->success !== null) { if (!is_object($this->success)) { throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); @@ -49890,6 +51437,11 @@ class ThriftHiveMetastore_alter_wm_trigger_result { $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; @@ -49897,11 +51449,11 @@ class ThriftHiveMetastore_alter_wm_trigger_result { } -class ThriftHiveMetastore_drop_wm_trigger_args { +class ThriftHiveMetastore_drop_wm_mapping_args { static $_TSPEC; /** - * @var \metastore\WMDropTriggerRequest + * @var \metastore\WMDropMappingRequest */ public $request = null; @@ -49911,7 +51463,7 @@ class ThriftHiveMetastore_drop_wm_trigger_args { 1 => array( 'var' => 'request', 'type' => TType::STRUCT, - 'class' => '\metastore\WMDropTriggerRequest', + 'class' => '\metastore\WMDropMappingRequest', ), ); } @@ -49923,7 +51475,7 @@ class ThriftHiveMetastore_drop_wm_trigger_args { } public function getName() { - return 'ThriftHiveMetastore_drop_wm_trigger_args'; + return 'ThriftHiveMetastore_drop_wm_mapping_args'; } public function read($input) @@ -49943,7 +51495,7 @@ class ThriftHiveMetastore_drop_wm_trigger_args { { case 1: if ($ftype == TType::STRUCT) { - $this->request = new \metastore\WMDropTriggerRequest(); + $this->request = new \metastore\WMDropMappingRequest(); $xfer += $this->request->read($input); } else { $xfer += $input->skip($ftype); @@ -49961,7 +51513,7 @@ class ThriftHiveMetastore_drop_wm_trigger_args { public function write($output) { $xfer = 0; - $xfer += $output->writeStructBegin('ThriftHiveMetastore_drop_wm_trigger_args'); + $xfer += $output->writeStructBegin('ThriftHiveMetastore_drop_wm_mapping_args'); if ($this->request !== null) { if (!is_object($this->request)) { throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); @@ -49977,11 +51529,11 @@ class ThriftHiveMetastore_drop_wm_trigger_args { } -class ThriftHiveMetastore_drop_wm_trigger_result { +class ThriftHiveMetastore_drop_wm_mapping_result { static $_TSPEC; /** - * @var \metastore\WMDropTriggerResponse + * @var \metastore\WMDropMappingResponse */ public $success = null; /** @@ -50003,7 +51555,7 @@ class ThriftHiveMetastore_drop_wm_trigger_result { 0 => array( 'var' => 'success', 'type' => TType::STRUCT, - 'class' => '\metastore\WMDropTriggerResponse', + 'class' => '\metastore\WMDropMappingResponse', ), 1 => array( 'var' => 'o1', @@ -50039,7 +51591,7 @@ class ThriftHiveMetastore_drop_wm_trigger_result { } public function getName() { - return 'ThriftHiveMetastore_drop_wm_trigger_result'; + return 'ThriftHiveMetastore_drop_wm_mapping_result'; } public function read($input) @@ -50059,7 +51611,7 @@ class ThriftHiveMetastore_drop_wm_trigger_result { { case 0: if ($ftype == TType::STRUCT) { - $this->success = new \metastore\WMDropTriggerResponse(); + $this->success = new \metastore\WMDropMappingResponse(); $xfer += $this->success->read($input); } else { $xfer += $input->skip($ftype); @@ -50101,7 +51653,7 @@ class ThriftHiveMetastore_drop_wm_trigger_result { public function write($output) { $xfer = 0; - $xfer += $output->writeStructBegin('ThriftHiveMetastore_drop_wm_trigger_result'); + $xfer += $output->writeStructBegin('ThriftHiveMetastore_drop_wm_mapping_result'); if ($this->success !== null) { if (!is_object($this->success)) { throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); @@ -50132,11 +51684,11 @@ class ThriftHiveMetastore_drop_wm_trigger_result { } -class ThriftHiveMetastore_get_triggers_for_resourceplan_args { +class ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args { static $_TSPEC; /** - * @var \metastore\WMGetTriggersForResourePlanRequest + * @var \metastore\WMCreateOrDropTriggerToPoolMappingRequest */ public $request = null; @@ -50146,7 +51698,7 @@ class ThriftHiveMetastore_get_triggers_for_resourceplan_args { 1 => array( 'var' => 'request', 'type' => TType::STRUCT, - 'class' => '\metastore\WMGetTriggersForResourePlanRequest', + 'class' => '\metastore\WMCreateOrDropTriggerToPoolMappingRequest', ), ); } @@ -50158,7 +51710,7 @@ class ThriftHiveMetastore_get_triggers_for_resourceplan_args { } public function getName() { - return 'ThriftHiveMetastore_get_triggers_for_resourceplan_args'; + return 'ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args'; } public function read($input) @@ -50178,7 +51730,7 @@ class ThriftHiveMetastore_get_triggers_for_resourceplan_args { { case 1: if ($ftype == TType::STRUCT) { - $this->request = new \metastore\WMGetTriggersForResourePlanRequest(); + $this->request = new \metastore\WMCreateOrDropTriggerToPoolMappingRequest(); $xfer += $this->request->read($input); } else { $xfer += $input->skip($ftype); @@ -50196,7 +51748,7 @@ class ThriftHiveMetastore_get_triggers_for_resourceplan_args { public function write($output) { $xfer = 0; - $xfer += $output->writeStructBegin('ThriftHiveMetastore_get_triggers_for_resourceplan_args'); + $xfer += $output->writeStructBegin('ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args'); if ($this->request !== null) { if (!is_object($this->request)) { throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); @@ -50212,21 +51764,29 @@ class ThriftHiveMetastore_get_triggers_for_resourceplan_args { } -class ThriftHiveMetastore_get_triggers_for_resourceplan_result { +class ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result { static $_TSPEC; /** - * @var \metastore\WMGetTriggersForResourePlanResponse + * @var \metastore\WMCreateOrDropTriggerToPoolMappingResponse */ 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)) { @@ -50234,16 +51794,26 @@ class ThriftHiveMetastore_get_triggers_for_resourceplan_result { 0 => array( 'var' => 'success', 'type' => TType::STRUCT, - 'class' => '\metastore\WMGetTriggersForResourePlanResponse', + 'class' => '\metastore\WMCreateOrDropTriggerToPoolMappingResponse', ), 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', ), ); @@ -50258,11 +51828,17 @@ class ThriftHiveMetastore_get_triggers_for_resourceplan_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_triggers_for_resourceplan_result'; + return 'ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result'; } public function read($input) @@ -50282,7 +51858,7 @@ class ThriftHiveMetastore_get_triggers_for_resourceplan_result { { case 0: if ($ftype == TType::STRUCT) { - $this->success = new \metastore\WMGetTriggersForResourePlanResponse(); + $this->success = new \metastore\WMCreateOrDropTriggerToPoolMappingResponse(); $xfer += $this->success->read($input); } else { $xfer += $input->skip($ftype); @@ -50290,7 +51866,7 @@ class ThriftHiveMetastore_get_triggers_for_resourceplan_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); @@ -50298,12 +51874,28 @@ class ThriftHiveMetastore_get_triggers_for_resourceplan_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; + case 3: + if ($ftype == TType::STRUCT) { + $this->o3 = new \metastore\InvalidObjectException(); + $xfer += $this->o3->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + case 4: + if ($ftype == TType::STRUCT) { + $this->o4 = new \metastore\MetaException(); + $xfer += $this->o4->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; default: $xfer += $input->skip($ftype); break; @@ -50316,7 +51908,7 @@ class ThriftHiveMetastore_get_triggers_for_resourceplan_result { public function write($output) { $xfer = 0; - $xfer += $output->writeStructBegin('ThriftHiveMetastore_get_triggers_for_resourceplan_result'); + $xfer += $output->writeStructBegin('ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result'); if ($this->success !== null) { if (!is_object($this->success)) { throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); @@ -50335,6 +51927,16 @@ class ThriftHiveMetastore_get_triggers_for_resourceplan_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(); + } + 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; diff --git standalone-metastore/src/gen/thrift/gen-php/metastore/Types.php standalone-metastore/src/gen/thrift/gen-php/metastore/Types.php index 55498bd484..28e5871196 100644 --- standalone-metastore/src/gen/thrift/gen-php/metastore/Types.php +++ standalone-metastore/src/gen/thrift/gen-php/metastore/Types.php @@ -20574,11 +20574,7 @@ class WMPool { /** * @var string */ - public $poolName = null; - /** - * @var string - */ - public $parentPoolName = null; + public $path = null; /** * @var double */ @@ -20600,22 +20596,18 @@ class WMPool { 'type' => TType::STRING, ), 2 => array( - 'var' => 'poolName', + 'var' => 'path', 'type' => TType::STRING, ), 3 => array( - 'var' => 'parentPoolName', - 'type' => TType::STRING, - ), - 4 => array( 'var' => 'allocFraction', 'type' => TType::DOUBLE, ), - 5 => array( + 4 => array( 'var' => 'queryParallelism', 'type' => TType::I32, ), - 6 => array( + 5 => array( 'var' => 'schedulingPolicy', 'type' => TType::STRING, ), @@ -20625,11 +20617,8 @@ class WMPool { if (isset($vals['resourcePlanName'])) { $this->resourcePlanName = $vals['resourcePlanName']; } - if (isset($vals['poolName'])) { - $this->poolName = $vals['poolName']; - } - if (isset($vals['parentPoolName'])) { - $this->parentPoolName = $vals['parentPoolName']; + if (isset($vals['path'])) { + $this->path = $vals['path']; } if (isset($vals['allocFraction'])) { $this->allocFraction = $vals['allocFraction']; @@ -20671,33 +20660,26 @@ class WMPool { break; case 2: if ($ftype == TType::STRING) { - $xfer += $input->readString($this->poolName); + $xfer += $input->readString($this->path); } else { $xfer += $input->skip($ftype); } break; case 3: - if ($ftype == TType::STRING) { - $xfer += $input->readString($this->parentPoolName); - } else { - $xfer += $input->skip($ftype); - } - break; - case 4: if ($ftype == TType::DOUBLE) { $xfer += $input->readDouble($this->allocFraction); } else { $xfer += $input->skip($ftype); } break; - case 5: + case 4: if ($ftype == TType::I32) { $xfer += $input->readI32($this->queryParallelism); } else { $xfer += $input->skip($ftype); } break; - case 6: + case 5: if ($ftype == TType::STRING) { $xfer += $input->readString($this->schedulingPolicy); } else { @@ -20722,28 +20704,23 @@ class WMPool { $xfer += $output->writeString($this->resourcePlanName); $xfer += $output->writeFieldEnd(); } - if ($this->poolName !== null) { - $xfer += $output->writeFieldBegin('poolName', TType::STRING, 2); - $xfer += $output->writeString($this->poolName); - $xfer += $output->writeFieldEnd(); - } - if ($this->parentPoolName !== null) { - $xfer += $output->writeFieldBegin('parentPoolName', TType::STRING, 3); - $xfer += $output->writeString($this->parentPoolName); + if ($this->path !== null) { + $xfer += $output->writeFieldBegin('path', TType::STRING, 2); + $xfer += $output->writeString($this->path); $xfer += $output->writeFieldEnd(); } if ($this->allocFraction !== null) { - $xfer += $output->writeFieldBegin('allocFraction', TType::DOUBLE, 4); + $xfer += $output->writeFieldBegin('allocFraction', TType::DOUBLE, 3); $xfer += $output->writeDouble($this->allocFraction); $xfer += $output->writeFieldEnd(); } if ($this->queryParallelism !== null) { - $xfer += $output->writeFieldBegin('queryParallelism', TType::I32, 5); + $xfer += $output->writeFieldBegin('queryParallelism', TType::I32, 4); $xfer += $output->writeI32($this->queryParallelism); $xfer += $output->writeFieldEnd(); } if ($this->schedulingPolicy !== null) { - $xfer += $output->writeFieldBegin('schedulingPolicy', TType::STRING, 6); + $xfer += $output->writeFieldBegin('schedulingPolicy', TType::STRING, 5); $xfer += $output->writeString($this->schedulingPolicy); $xfer += $output->writeFieldEnd(); } @@ -20916,7 +20893,7 @@ class WMMapping { /** * @var string */ - public $poolName = null; + public $poolPath = null; /** * @var int */ @@ -20938,7 +20915,7 @@ class WMMapping { 'type' => TType::STRING, ), 4 => array( - 'var' => 'poolName', + 'var' => 'poolPath', 'type' => TType::STRING, ), 5 => array( @@ -20957,8 +20934,8 @@ class WMMapping { if (isset($vals['entityName'])) { $this->entityName = $vals['entityName']; } - if (isset($vals['poolName'])) { - $this->poolName = $vals['poolName']; + if (isset($vals['poolPath'])) { + $this->poolPath = $vals['poolPath']; } if (isset($vals['ordering'])) { $this->ordering = $vals['ordering']; @@ -21008,7 +20985,7 @@ class WMMapping { break; case 4: if ($ftype == TType::STRING) { - $xfer += $input->readString($this->poolName); + $xfer += $input->readString($this->poolPath); } else { $xfer += $input->skip($ftype); } @@ -21048,9 +21025,9 @@ class WMMapping { $xfer += $output->writeString($this->entityName); $xfer += $output->writeFieldEnd(); } - if ($this->poolName !== null) { - $xfer += $output->writeFieldBegin('poolName', TType::STRING, 4); - $xfer += $output->writeString($this->poolName); + if ($this->poolPath !== null) { + $xfer += $output->writeFieldBegin('poolPath', TType::STRING, 4); + $xfer += $output->writeString($this->poolPath); $xfer += $output->writeFieldEnd(); } if ($this->ordering !== null) { @@ -22517,6 +22494,807 @@ class WMGetTriggersForResourePlanResponse { } +class WMCreateOrUpdatePoolRequest { + static $_TSPEC; + + /** + * @var \metastore\WMPool + */ + public $pool = null; + /** + * @var string + */ + public $newPoolPath = null; + /** + * @var bool + */ + public $update = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'pool', + 'type' => TType::STRUCT, + 'class' => '\metastore\WMPool', + ), + 2 => array( + 'var' => 'newPoolPath', + 'type' => TType::STRING, + ), + 3 => array( + 'var' => 'update', + 'type' => TType::BOOL, + ), + ); + } + if (is_array($vals)) { + if (isset($vals['pool'])) { + $this->pool = $vals['pool']; + } + if (isset($vals['newPoolPath'])) { + $this->newPoolPath = $vals['newPoolPath']; + } + if (isset($vals['update'])) { + $this->update = $vals['update']; + } + } + } + + public function getName() { + return 'WMCreateOrUpdatePoolRequest'; + } + + 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->pool = new \metastore\WMPool(); + $xfer += $this->pool->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + case 2: + if ($ftype == TType::STRING) { + $xfer += $input->readString($this->newPoolPath); + } else { + $xfer += $input->skip($ftype); + } + break; + case 3: + if ($ftype == TType::BOOL) { + $xfer += $input->readBool($this->update); + } 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('WMCreateOrUpdatePoolRequest'); + if ($this->pool !== null) { + if (!is_object($this->pool)) { + throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); + } + $xfer += $output->writeFieldBegin('pool', TType::STRUCT, 1); + $xfer += $this->pool->write($output); + $xfer += $output->writeFieldEnd(); + } + if ($this->newPoolPath !== null) { + $xfer += $output->writeFieldBegin('newPoolPath', TType::STRING, 2); + $xfer += $output->writeString($this->newPoolPath); + $xfer += $output->writeFieldEnd(); + } + if ($this->update !== null) { + $xfer += $output->writeFieldBegin('update', TType::BOOL, 3); + $xfer += $output->writeBool($this->update); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class WMCreateOrUpdatePoolResponse { + static $_TSPEC; + + + public function __construct() { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + ); + } + } + + public function getName() { + return 'WMCreateOrUpdatePoolResponse'; + } + + 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('WMCreateOrUpdatePoolResponse'); + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class WMDropPoolRequest { + static $_TSPEC; + + /** + * @var string + */ + public $resourcePlanName = null; + /** + * @var string + */ + public $poolPath = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'resourcePlanName', + 'type' => TType::STRING, + ), + 2 => array( + 'var' => 'poolPath', + 'type' => TType::STRING, + ), + ); + } + if (is_array($vals)) { + if (isset($vals['resourcePlanName'])) { + $this->resourcePlanName = $vals['resourcePlanName']; + } + if (isset($vals['poolPath'])) { + $this->poolPath = $vals['poolPath']; + } + } + } + + public function getName() { + return 'WMDropPoolRequest'; + } + + 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->poolPath); + } 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('WMDropPoolRequest'); + if ($this->resourcePlanName !== null) { + $xfer += $output->writeFieldBegin('resourcePlanName', TType::STRING, 1); + $xfer += $output->writeString($this->resourcePlanName); + $xfer += $output->writeFieldEnd(); + } + if ($this->poolPath !== null) { + $xfer += $output->writeFieldBegin('poolPath', TType::STRING, 2); + $xfer += $output->writeString($this->poolPath); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class WMDropPoolResponse { + static $_TSPEC; + + + public function __construct() { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + ); + } + } + + public function getName() { + return 'WMDropPoolResponse'; + } + + 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('WMDropPoolResponse'); + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class WMCreateOrUpdateMappingRequest { + static $_TSPEC; + + /** + * @var \metastore\WMMapping + */ + public $mapping = null; + /** + * @var bool + */ + public $update = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'mapping', + 'type' => TType::STRUCT, + 'class' => '\metastore\WMMapping', + ), + 2 => array( + 'var' => 'update', + 'type' => TType::BOOL, + ), + ); + } + if (is_array($vals)) { + if (isset($vals['mapping'])) { + $this->mapping = $vals['mapping']; + } + if (isset($vals['update'])) { + $this->update = $vals['update']; + } + } + } + + public function getName() { + return 'WMCreateOrUpdateMappingRequest'; + } + + 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->mapping = new \metastore\WMMapping(); + $xfer += $this->mapping->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + case 2: + if ($ftype == TType::BOOL) { + $xfer += $input->readBool($this->update); + } 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('WMCreateOrUpdateMappingRequest'); + if ($this->mapping !== null) { + if (!is_object($this->mapping)) { + throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); + } + $xfer += $output->writeFieldBegin('mapping', TType::STRUCT, 1); + $xfer += $this->mapping->write($output); + $xfer += $output->writeFieldEnd(); + } + if ($this->update !== null) { + $xfer += $output->writeFieldBegin('update', TType::BOOL, 2); + $xfer += $output->writeBool($this->update); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class WMCreateOrUpdateMappingResponse { + static $_TSPEC; + + + public function __construct() { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + ); + } + } + + public function getName() { + return 'WMCreateOrUpdateMappingResponse'; + } + + 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('WMCreateOrUpdateMappingResponse'); + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class WMDropMappingRequest { + static $_TSPEC; + + /** + * @var \metastore\WMMapping + */ + public $mapping = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'mapping', + 'type' => TType::STRUCT, + 'class' => '\metastore\WMMapping', + ), + ); + } + if (is_array($vals)) { + if (isset($vals['mapping'])) { + $this->mapping = $vals['mapping']; + } + } + } + + public function getName() { + return 'WMDropMappingRequest'; + } + + 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->mapping = new \metastore\WMMapping(); + $xfer += $this->mapping->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('WMDropMappingRequest'); + if ($this->mapping !== null) { + if (!is_object($this->mapping)) { + throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); + } + $xfer += $output->writeFieldBegin('mapping', TType::STRUCT, 1); + $xfer += $this->mapping->write($output); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class WMDropMappingResponse { + static $_TSPEC; + + + public function __construct() { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + ); + } + } + + public function getName() { + return 'WMDropMappingResponse'; + } + + 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('WMDropMappingResponse'); + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class WMCreateOrDropTriggerToPoolMappingRequest { + static $_TSPEC; + + /** + * @var string + */ + public $resourcePlanName = null; + /** + * @var string + */ + public $triggerName = null; + /** + * @var string + */ + public $poolPath = null; + /** + * @var bool + */ + public $drop = 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, + ), + 3 => array( + 'var' => 'poolPath', + 'type' => TType::STRING, + ), + 4 => array( + 'var' => 'drop', + 'type' => TType::BOOL, + ), + ); + } + if (is_array($vals)) { + if (isset($vals['resourcePlanName'])) { + $this->resourcePlanName = $vals['resourcePlanName']; + } + if (isset($vals['triggerName'])) { + $this->triggerName = $vals['triggerName']; + } + if (isset($vals['poolPath'])) { + $this->poolPath = $vals['poolPath']; + } + if (isset($vals['drop'])) { + $this->drop = $vals['drop']; + } + } + } + + public function getName() { + return 'WMCreateOrDropTriggerToPoolMappingRequest'; + } + + 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; + case 3: + if ($ftype == TType::STRING) { + $xfer += $input->readString($this->poolPath); + } else { + $xfer += $input->skip($ftype); + } + break; + case 4: + if ($ftype == TType::BOOL) { + $xfer += $input->readBool($this->drop); + } 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('WMCreateOrDropTriggerToPoolMappingRequest'); + 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(); + } + if ($this->poolPath !== null) { + $xfer += $output->writeFieldBegin('poolPath', TType::STRING, 3); + $xfer += $output->writeString($this->poolPath); + $xfer += $output->writeFieldEnd(); + } + if ($this->drop !== null) { + $xfer += $output->writeFieldBegin('drop', TType::BOOL, 4); + $xfer += $output->writeBool($this->drop); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class WMCreateOrDropTriggerToPoolMappingResponse { + static $_TSPEC; + + + public function __construct() { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + ); + } + } + + public function getName() { + return 'WMCreateOrDropTriggerToPoolMappingResponse'; + } + + 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('WMCreateOrDropTriggerToPoolMappingResponse'); + $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 7dc34dd7fa..edefb4b1ef 100755 --- standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote +++ standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote @@ -196,6 +196,11 @@ if len(sys.argv) <= 1 or sys.argv[1] == '--help': print(' WMAlterTriggerResponse alter_wm_trigger(WMAlterTriggerRequest request)') print(' WMDropTriggerResponse drop_wm_trigger(WMDropTriggerRequest request)') print(' WMGetTriggersForResourePlanResponse get_triggers_for_resourceplan(WMGetTriggersForResourePlanRequest request)') + print(' WMCreateOrUpdatePoolResponse create_or_update_wm_pool(WMCreateOrUpdatePoolRequest request)') + print(' WMDropPoolResponse drop_wm_pool(WMDropPoolRequest request)') + print(' WMCreateOrUpdateMappingResponse create_or_update_wm_mapping(WMCreateOrUpdateMappingRequest request)') + print(' WMDropMappingResponse drop_wm_mapping(WMDropMappingRequest request)') + print(' WMCreateOrDropTriggerToPoolMappingResponse create_or_drop_wm_trigger_to_pool_mapping(WMCreateOrDropTriggerToPoolMappingRequest request)') print(' string getName()') print(' string getVersion()') print(' fb_status getStatus()') @@ -1297,6 +1302,36 @@ elif cmd == 'get_triggers_for_resourceplan': sys.exit(1) pp.pprint(client.get_triggers_for_resourceplan(eval(args[0]),)) +elif cmd == 'create_or_update_wm_pool': + if len(args) != 1: + print('create_or_update_wm_pool requires 1 args') + sys.exit(1) + pp.pprint(client.create_or_update_wm_pool(eval(args[0]),)) + +elif cmd == 'drop_wm_pool': + if len(args) != 1: + print('drop_wm_pool requires 1 args') + sys.exit(1) + pp.pprint(client.drop_wm_pool(eval(args[0]),)) + +elif cmd == 'create_or_update_wm_mapping': + if len(args) != 1: + print('create_or_update_wm_mapping requires 1 args') + sys.exit(1) + pp.pprint(client.create_or_update_wm_mapping(eval(args[0]),)) + +elif cmd == 'drop_wm_mapping': + if len(args) != 1: + print('drop_wm_mapping requires 1 args') + sys.exit(1) + pp.pprint(client.drop_wm_mapping(eval(args[0]),)) + +elif cmd == 'create_or_drop_wm_trigger_to_pool_mapping': + if len(args) != 1: + print('create_or_drop_wm_trigger_to_pool_mapping requires 1 args') + sys.exit(1) + pp.pprint(client.create_or_drop_wm_trigger_to_pool_mapping(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 e627952444..bdd6cfff03 100644 --- standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py +++ standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py @@ -1363,6 +1363,41 @@ def get_triggers_for_resourceplan(self, request): """ pass + def create_or_update_wm_pool(self, request): + """ + Parameters: + - request + """ + pass + + def drop_wm_pool(self, request): + """ + Parameters: + - request + """ + pass + + def create_or_update_wm_mapping(self, request): + """ + Parameters: + - request + """ + pass + + def drop_wm_mapping(self, request): + """ + Parameters: + - request + """ + pass + + def create_or_drop_wm_trigger_to_pool_mapping(self, request): + """ + Parameters: + - request + """ + pass + class Client(fb303.FacebookService.Client, Iface): """ @@ -7559,6 +7594,197 @@ def recv_get_triggers_for_resourceplan(self): raise result.o2 raise TApplicationException(TApplicationException.MISSING_RESULT, "get_triggers_for_resourceplan failed: unknown result") + def create_or_update_wm_pool(self, request): + """ + Parameters: + - request + """ + self.send_create_or_update_wm_pool(request) + return self.recv_create_or_update_wm_pool() + + def send_create_or_update_wm_pool(self, request): + self._oprot.writeMessageBegin('create_or_update_wm_pool', TMessageType.CALL, self._seqid) + args = create_or_update_wm_pool_args() + args.request = request + args.write(self._oprot) + self._oprot.writeMessageEnd() + self._oprot.trans.flush() + + def recv_create_or_update_wm_pool(self): + iprot = self._iprot + (fname, mtype, rseqid) = iprot.readMessageBegin() + if mtype == TMessageType.EXCEPTION: + x = TApplicationException() + x.read(iprot) + iprot.readMessageEnd() + raise x + result = create_or_update_wm_pool_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_or_update_wm_pool failed: unknown result") + + def drop_wm_pool(self, request): + """ + Parameters: + - request + """ + self.send_drop_wm_pool(request) + return self.recv_drop_wm_pool() + + def send_drop_wm_pool(self, request): + self._oprot.writeMessageBegin('drop_wm_pool', TMessageType.CALL, self._seqid) + args = drop_wm_pool_args() + args.request = request + args.write(self._oprot) + self._oprot.writeMessageEnd() + self._oprot.trans.flush() + + def recv_drop_wm_pool(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_pool_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_pool failed: unknown result") + + def create_or_update_wm_mapping(self, request): + """ + Parameters: + - request + """ + self.send_create_or_update_wm_mapping(request) + return self.recv_create_or_update_wm_mapping() + + def send_create_or_update_wm_mapping(self, request): + self._oprot.writeMessageBegin('create_or_update_wm_mapping', TMessageType.CALL, self._seqid) + args = create_or_update_wm_mapping_args() + args.request = request + args.write(self._oprot) + self._oprot.writeMessageEnd() + self._oprot.trans.flush() + + def recv_create_or_update_wm_mapping(self): + iprot = self._iprot + (fname, mtype, rseqid) = iprot.readMessageBegin() + if mtype == TMessageType.EXCEPTION: + x = TApplicationException() + x.read(iprot) + iprot.readMessageEnd() + raise x + result = create_or_update_wm_mapping_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_or_update_wm_mapping failed: unknown result") + + def drop_wm_mapping(self, request): + """ + Parameters: + - request + """ + self.send_drop_wm_mapping(request) + return self.recv_drop_wm_mapping() + + def send_drop_wm_mapping(self, request): + self._oprot.writeMessageBegin('drop_wm_mapping', TMessageType.CALL, self._seqid) + args = drop_wm_mapping_args() + args.request = request + args.write(self._oprot) + self._oprot.writeMessageEnd() + self._oprot.trans.flush() + + def recv_drop_wm_mapping(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_mapping_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_mapping failed: unknown result") + + def create_or_drop_wm_trigger_to_pool_mapping(self, request): + """ + Parameters: + - request + """ + self.send_create_or_drop_wm_trigger_to_pool_mapping(request) + return self.recv_create_or_drop_wm_trigger_to_pool_mapping() + + def send_create_or_drop_wm_trigger_to_pool_mapping(self, request): + self._oprot.writeMessageBegin('create_or_drop_wm_trigger_to_pool_mapping', TMessageType.CALL, self._seqid) + args = create_or_drop_wm_trigger_to_pool_mapping_args() + args.request = request + args.write(self._oprot) + self._oprot.writeMessageEnd() + self._oprot.trans.flush() + + def recv_create_or_drop_wm_trigger_to_pool_mapping(self): + iprot = self._iprot + (fname, mtype, rseqid) = iprot.readMessageBegin() + if mtype == TMessageType.EXCEPTION: + x = TApplicationException() + x.read(iprot) + iprot.readMessageEnd() + raise x + result = create_or_drop_wm_trigger_to_pool_mapping_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_or_drop_wm_trigger_to_pool_mapping failed: unknown result") + class Processor(fb303.FacebookService.Processor, Iface, TProcessor): def __init__(self, handler): @@ -7735,6 +7961,11 @@ def __init__(self, handler): 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 + self._processMap["create_or_update_wm_pool"] = Processor.process_create_or_update_wm_pool + self._processMap["drop_wm_pool"] = Processor.process_drop_wm_pool + self._processMap["create_or_update_wm_mapping"] = Processor.process_create_or_update_wm_mapping + self._processMap["drop_wm_mapping"] = Processor.process_drop_wm_mapping + self._processMap["create_or_drop_wm_trigger_to_pool_mapping"] = Processor.process_create_or_drop_wm_trigger_to_pool_mapping def process(self, iprot, oprot): (name, type, seqid) = iprot.readMessageBegin() @@ -11964,6 +12195,155 @@ def process_get_triggers_for_resourceplan(self, seqid, iprot, oprot): oprot.writeMessageEnd() oprot.trans.flush() + def process_create_or_update_wm_pool(self, seqid, iprot, oprot): + args = create_or_update_wm_pool_args() + args.read(iprot) + iprot.readMessageEnd() + result = create_or_update_wm_pool_result() + try: + result.success = self._handler.create_or_update_wm_pool(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_or_update_wm_pool", msg_type, seqid) + result.write(oprot) + oprot.writeMessageEnd() + oprot.trans.flush() + + def process_drop_wm_pool(self, seqid, iprot, oprot): + args = drop_wm_pool_args() + args.read(iprot) + iprot.readMessageEnd() + result = drop_wm_pool_result() + try: + result.success = self._handler.drop_wm_pool(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_pool", msg_type, seqid) + result.write(oprot) + oprot.writeMessageEnd() + oprot.trans.flush() + + def process_create_or_update_wm_mapping(self, seqid, iprot, oprot): + args = create_or_update_wm_mapping_args() + args.read(iprot) + iprot.readMessageEnd() + result = create_or_update_wm_mapping_result() + try: + result.success = self._handler.create_or_update_wm_mapping(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_or_update_wm_mapping", msg_type, seqid) + result.write(oprot) + oprot.writeMessageEnd() + oprot.trans.flush() + + def process_drop_wm_mapping(self, seqid, iprot, oprot): + args = drop_wm_mapping_args() + args.read(iprot) + iprot.readMessageEnd() + result = drop_wm_mapping_result() + try: + result.success = self._handler.drop_wm_mapping(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_mapping", msg_type, seqid) + result.write(oprot) + oprot.writeMessageEnd() + oprot.trans.flush() + + def process_create_or_drop_wm_trigger_to_pool_mapping(self, seqid, iprot, oprot): + args = create_or_drop_wm_trigger_to_pool_mapping_args() + args.read(iprot) + iprot.readMessageEnd() + result = create_or_drop_wm_trigger_to_pool_mapping_result() + try: + result.success = self._handler.create_or_drop_wm_trigger_to_pool_mapping(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_or_drop_wm_trigger_to_pool_mapping", msg_type, seqid) + result.write(oprot) + oprot.writeMessageEnd() + oprot.trans.flush() + # HELPER FUNCTIONS AND STRUCTURES @@ -35005,20 +35385,670 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class add_master_key_args: - """ - Attributes: - - key - """ +class add_master_key_args: + """ + Attributes: + - key + """ + + thrift_spec = ( + None, # 0 + (1, TType.STRING, 'key', None, None, ), # 1 + ) + + def __init__(self, key=None,): + self.key = key + + 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.key = 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('add_master_key_args') + if self.key is not None: + oprot.writeFieldBegin('key', TType.STRING, 1) + oprot.writeString(self.key) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.key) + 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 add_master_key_result: + """ + Attributes: + - success + - o1 + """ + + thrift_spec = ( + (0, TType.I32, 'success', None, 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.I32: + self.success = iprot.readI32() + 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('add_master_key_result') + if self.success is not None: + oprot.writeFieldBegin('success', TType.I32, 0) + oprot.writeI32(self.success) + 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 update_master_key_args: + """ + Attributes: + - seq_number + - key + """ + + thrift_spec = ( + None, # 0 + (1, TType.I32, 'seq_number', None, None, ), # 1 + (2, TType.STRING, 'key', None, None, ), # 2 + ) + + def __init__(self, seq_number=None, key=None,): + self.seq_number = seq_number + self.key = key + + 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.I32: + self.seq_number = iprot.readI32() + else: + iprot.skip(ftype) + elif fid == 2: + if ftype == TType.STRING: + self.key = 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('update_master_key_args') + if self.seq_number is not None: + oprot.writeFieldBegin('seq_number', TType.I32, 1) + oprot.writeI32(self.seq_number) + oprot.writeFieldEnd() + if self.key is not None: + oprot.writeFieldBegin('key', TType.STRING, 2) + oprot.writeString(self.key) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.seq_number) + value = (value * 31) ^ hash(self.key) + 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 update_master_key_result: + """ + Attributes: + - o1 + - o2 + """ + + 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, o1=None, o2=None,): + 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 == 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('update_master_key_result') + if self.o1 is not None: + oprot.writeFieldBegin('o1', TType.STRUCT, 1) + self.o1.write(oprot) + oprot.writeFieldEnd() + if self.o2 is not None: + oprot.writeFieldBegin('o2', TType.STRUCT, 2) + self.o2.write(oprot) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + 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 remove_master_key_args: + """ + Attributes: + - key_seq + """ + + thrift_spec = ( + None, # 0 + (1, TType.I32, 'key_seq', None, None, ), # 1 + ) + + def __init__(self, key_seq=None,): + self.key_seq = key_seq + + 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.I32: + self.key_seq = iprot.readI32() + 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('remove_master_key_args') + if self.key_seq is not None: + oprot.writeFieldBegin('key_seq', TType.I32, 1) + oprot.writeI32(self.key_seq) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.key_seq) + 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 remove_master_key_result: + """ + Attributes: + - success + """ + + thrift_spec = ( + (0, TType.BOOL, 'success', None, None, ), # 0 + ) + + def __init__(self, success=None,): + self.success = success + + 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) + 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('remove_master_key_result') + if self.success is not None: + oprot.writeFieldBegin('success', TType.BOOL, 0) + oprot.writeBool(self.success) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.success) + 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_master_keys_args: + + thrift_spec = ( + ) + + def read(self, iprot): + if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: + fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) + return + iprot.readStructBegin() + while True: + (fname, ftype, fid) = iprot.readFieldBegin() + if ftype == TType.STOP: + break + else: + iprot.skip(ftype) + iprot.readFieldEnd() + iprot.readStructEnd() + + def write(self, oprot): + if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: + oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) + return + oprot.writeStructBegin('get_master_keys_args') + 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 get_master_keys_result: + """ + Attributes: + - success + """ + + thrift_spec = ( + (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0 + ) + + def __init__(self, success=None,): + self.success = success + + 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 = [] + (_etype1141, _size1138) = iprot.readListBegin() + for _i1142 in xrange(_size1138): + _elem1143 = iprot.readString() + self.success.append(_elem1143) + 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('get_master_keys_result') + if self.success is not None: + oprot.writeFieldBegin('success', TType.LIST, 0) + oprot.writeListBegin(TType.STRING, len(self.success)) + for iter1144 in self.success: + oprot.writeString(iter1144) + oprot.writeListEnd() + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.success) + 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_open_txns_args: + + thrift_spec = ( + ) + + def read(self, iprot): + if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: + fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) + return + iprot.readStructBegin() + while True: + (fname, ftype, fid) = iprot.readFieldBegin() + if ftype == TType.STOP: + break + else: + iprot.skip(ftype) + iprot.readFieldEnd() + iprot.readStructEnd() + + def write(self, oprot): + if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: + oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) + return + oprot.writeStructBegin('get_open_txns_args') + 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 get_open_txns_result: + """ + Attributes: + - success + """ + + thrift_spec = ( + (0, TType.STRUCT, 'success', (GetOpenTxnsResponse, GetOpenTxnsResponse.thrift_spec), None, ), # 0 + ) + + def __init__(self, success=None,): + self.success = success + + 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 = GetOpenTxnsResponse() + self.success.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_open_txns_result') + if self.success is not None: + oprot.writeFieldBegin('success', TType.STRUCT, 0) + self.success.write(oprot) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.success) + 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_open_txns_info_args: thrift_spec = ( - None, # 0 - (1, TType.STRING, 'key', None, None, ), # 1 ) - def __init__(self, key=None,): - self.key = key - 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)) @@ -35028,11 +36058,6 @@ def read(self, iprot): (fname, ftype, fid) = iprot.readFieldBegin() if ftype == TType.STOP: break - if fid == 1: - if ftype == TType.STRING: - self.key = iprot.readString() - else: - iprot.skip(ftype) else: iprot.skip(ftype) iprot.readFieldEnd() @@ -35042,11 +36067,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('add_master_key_args') - if self.key is not None: - oprot.writeFieldBegin('key', TType.STRING, 1) - oprot.writeString(self.key) - oprot.writeFieldEnd() + oprot.writeStructBegin('get_open_txns_info_args') oprot.writeFieldStop() oprot.writeStructEnd() @@ -35056,7 +36077,6 @@ def validate(self): def __hash__(self): value = 17 - value = (value * 31) ^ hash(self.key) return value def __repr__(self): @@ -35070,21 +36090,18 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class add_master_key_result: +class get_open_txns_info_result: """ Attributes: - success - - o1 """ thrift_spec = ( - (0, TType.I32, 'success', None, None, ), # 0 - (1, TType.STRUCT, 'o1', (MetaException, MetaException.thrift_spec), None, ), # 1 + (0, TType.STRUCT, 'success', (GetOpenTxnsInfoResponse, GetOpenTxnsInfoResponse.thrift_spec), None, ), # 0 ) - def __init__(self, success=None, o1=None,): + def __init__(self, success=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: @@ -35096,14 +36113,9 @@ def read(self, iprot): if ftype == TType.STOP: break if fid == 0: - if ftype == TType.I32: - self.success = iprot.readI32() - else: - iprot.skip(ftype) - elif fid == 1: if ftype == TType.STRUCT: - self.o1 = MetaException() - self.o1.read(iprot) + self.success = GetOpenTxnsInfoResponse() + self.success.read(iprot) else: iprot.skip(ftype) else: @@ -35115,14 +36127,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('add_master_key_result') + oprot.writeStructBegin('get_open_txns_info_result') if self.success is not None: - oprot.writeFieldBegin('success', TType.I32, 0) - oprot.writeI32(self.success) - oprot.writeFieldEnd() - if self.o1 is not None: - oprot.writeFieldBegin('o1', TType.STRUCT, 1) - self.o1.write(oprot) + oprot.writeFieldBegin('success', TType.STRUCT, 0) + self.success.write(oprot) oprot.writeFieldEnd() oprot.writeFieldStop() oprot.writeStructEnd() @@ -35134,7 +36142,6 @@ def validate(self): def __hash__(self): value = 17 value = (value * 31) ^ hash(self.success) - value = (value * 31) ^ hash(self.o1) return value def __repr__(self): @@ -35148,22 +36155,19 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class update_master_key_args: +class open_txns_args: """ Attributes: - - seq_number - - key + - rqst """ thrift_spec = ( None, # 0 - (1, TType.I32, 'seq_number', None, None, ), # 1 - (2, TType.STRING, 'key', None, None, ), # 2 + (1, TType.STRUCT, 'rqst', (OpenTxnRequest, OpenTxnRequest.thrift_spec), None, ), # 1 ) - def __init__(self, seq_number=None, key=None,): - self.seq_number = seq_number - self.key = key + def __init__(self, rqst=None,): + self.rqst = rqst 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: @@ -35175,13 +36179,9 @@ def read(self, iprot): if ftype == TType.STOP: break if fid == 1: - if ftype == TType.I32: - self.seq_number = iprot.readI32() - else: - iprot.skip(ftype) - elif fid == 2: - if ftype == TType.STRING: - self.key = iprot.readString() + if ftype == TType.STRUCT: + self.rqst = OpenTxnRequest() + self.rqst.read(iprot) else: iprot.skip(ftype) else: @@ -35193,14 +36193,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_master_key_args') - if self.seq_number is not None: - oprot.writeFieldBegin('seq_number', TType.I32, 1) - oprot.writeI32(self.seq_number) - oprot.writeFieldEnd() - if self.key is not None: - oprot.writeFieldBegin('key', TType.STRING, 2) - oprot.writeString(self.key) + oprot.writeStructBegin('open_txns_args') + if self.rqst is not None: + oprot.writeFieldBegin('rqst', TType.STRUCT, 1) + self.rqst.write(oprot) oprot.writeFieldEnd() oprot.writeFieldStop() oprot.writeStructEnd() @@ -35211,8 +36207,7 @@ def validate(self): def __hash__(self): value = 17 - value = (value * 31) ^ hash(self.seq_number) - value = (value * 31) ^ hash(self.key) + value = (value * 31) ^ hash(self.rqst) return value def __repr__(self): @@ -35226,22 +36221,18 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class update_master_key_result: +class open_txns_result: """ Attributes: - - o1 - - o2 + - success """ 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', (OpenTxnsResponse, OpenTxnsResponse.thrift_spec), None, ), # 0 ) - def __init__(self, o1=None, o2=None,): - self.o1 = o1 - self.o2 = o2 + def __init__(self, success=None,): + self.success = success 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: @@ -35252,16 +36243,10 @@ def read(self, iprot): (fname, ftype, fid) = iprot.readFieldBegin() if ftype == TType.STOP: break - if fid == 1: - if ftype == TType.STRUCT: - self.o1 = NoSuchObjectException() - self.o1.read(iprot) - else: - iprot.skip(ftype) - elif fid == 2: + if fid == 0: if ftype == TType.STRUCT: - self.o2 = MetaException() - self.o2.read(iprot) + self.success = OpenTxnsResponse() + self.success.read(iprot) else: iprot.skip(ftype) else: @@ -35273,14 +36258,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_master_key_result') - if self.o1 is not None: - oprot.writeFieldBegin('o1', TType.STRUCT, 1) - self.o1.write(oprot) - oprot.writeFieldEnd() - if self.o2 is not None: - oprot.writeFieldBegin('o2', TType.STRUCT, 2) - self.o2.write(oprot) + oprot.writeStructBegin('open_txns_result') + if self.success is not None: + oprot.writeFieldBegin('success', TType.STRUCT, 0) + self.success.write(oprot) oprot.writeFieldEnd() oprot.writeFieldStop() oprot.writeStructEnd() @@ -35291,8 +36272,7 @@ def validate(self): def __hash__(self): value = 17 - value = (value * 31) ^ hash(self.o1) - value = (value * 31) ^ hash(self.o2) + value = (value * 31) ^ hash(self.success) return value def __repr__(self): @@ -35306,19 +36286,19 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class remove_master_key_args: +class abort_txn_args: """ Attributes: - - key_seq + - rqst """ thrift_spec = ( None, # 0 - (1, TType.I32, 'key_seq', None, None, ), # 1 + (1, TType.STRUCT, 'rqst', (AbortTxnRequest, AbortTxnRequest.thrift_spec), None, ), # 1 ) - def __init__(self, key_seq=None,): - self.key_seq = key_seq + def __init__(self, rqst=None,): + self.rqst = rqst 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: @@ -35330,8 +36310,9 @@ def read(self, iprot): if ftype == TType.STOP: break if fid == 1: - if ftype == TType.I32: - self.key_seq = iprot.readI32() + if ftype == TType.STRUCT: + self.rqst = AbortTxnRequest() + self.rqst.read(iprot) else: iprot.skip(ftype) else: @@ -35343,10 +36324,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('remove_master_key_args') - if self.key_seq is not None: - oprot.writeFieldBegin('key_seq', TType.I32, 1) - oprot.writeI32(self.key_seq) + oprot.writeStructBegin('abort_txn_args') + if self.rqst is not None: + oprot.writeFieldBegin('rqst', TType.STRUCT, 1) + self.rqst.write(oprot) oprot.writeFieldEnd() oprot.writeFieldStop() oprot.writeStructEnd() @@ -35357,7 +36338,7 @@ def validate(self): def __hash__(self): value = 17 - value = (value * 31) ^ hash(self.key_seq) + value = (value * 31) ^ hash(self.rqst) return value def __repr__(self): @@ -35371,18 +36352,19 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class remove_master_key_result: +class abort_txn_result: """ Attributes: - - success + - o1 """ thrift_spec = ( - (0, TType.BOOL, 'success', None, None, ), # 0 + None, # 0 + (1, TType.STRUCT, 'o1', (NoSuchTxnException, NoSuchTxnException.thrift_spec), None, ), # 1 ) - def __init__(self, success=None,): - self.success = success + def __init__(self, o1=None,): + 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: @@ -35393,9 +36375,10 @@ def read(self, iprot): (fname, ftype, fid) = iprot.readFieldBegin() if ftype == TType.STOP: break - if fid == 0: - if ftype == TType.BOOL: - self.success = iprot.readBool() + if fid == 1: + if ftype == TType.STRUCT: + self.o1 = NoSuchTxnException() + self.o1.read(iprot) else: iprot.skip(ftype) else: @@ -35407,10 +36390,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('remove_master_key_result') - if self.success is not None: - oprot.writeFieldBegin('success', TType.BOOL, 0) - oprot.writeBool(self.success) + oprot.writeStructBegin('abort_txn_result') + if self.o1 is not None: + oprot.writeFieldBegin('o1', TType.STRUCT, 1) + self.o1.write(oprot) oprot.writeFieldEnd() oprot.writeFieldStop() oprot.writeStructEnd() @@ -35421,7 +36404,7 @@ def validate(self): def __hash__(self): value = 17 - value = (value * 31) ^ hash(self.success) + value = (value * 31) ^ hash(self.o1) return value def __repr__(self): @@ -35435,11 +36418,20 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class get_master_keys_args: +class abort_txns_args: + """ + Attributes: + - rqst + """ thrift_spec = ( + None, # 0 + (1, TType.STRUCT, 'rqst', (AbortTxnsRequest, AbortTxnsRequest.thrift_spec), None, ), # 1 ) + def __init__(self, rqst=None,): + self.rqst = rqst + 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)) @@ -35449,6 +36441,12 @@ def read(self, iprot): (fname, ftype, fid) = iprot.readFieldBegin() if ftype == TType.STOP: break + if fid == 1: + if ftype == TType.STRUCT: + self.rqst = AbortTxnsRequest() + self.rqst.read(iprot) + else: + iprot.skip(ftype) else: iprot.skip(ftype) iprot.readFieldEnd() @@ -35458,7 +36456,11 @@ 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_master_keys_args') + oprot.writeStructBegin('abort_txns_args') + if self.rqst is not None: + oprot.writeFieldBegin('rqst', TType.STRUCT, 1) + self.rqst.write(oprot) + oprot.writeFieldEnd() oprot.writeFieldStop() oprot.writeStructEnd() @@ -35468,6 +36470,7 @@ def validate(self): def __hash__(self): value = 17 + value = (value * 31) ^ hash(self.rqst) return value def __repr__(self): @@ -35481,18 +36484,19 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class get_master_keys_result: +class abort_txns_result: """ Attributes: - - success + - o1 """ thrift_spec = ( - (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0 + None, # 0 + (1, TType.STRUCT, 'o1', (NoSuchTxnException, NoSuchTxnException.thrift_spec), None, ), # 1 ) - def __init__(self, success=None,): - self.success = success + def __init__(self, o1=None,): + 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: @@ -35503,14 +36507,10 @@ def read(self, iprot): (fname, ftype, fid) = iprot.readFieldBegin() if ftype == TType.STOP: break - if fid == 0: - if ftype == TType.LIST: - self.success = [] - (_etype1141, _size1138) = iprot.readListBegin() - for _i1142 in xrange(_size1138): - _elem1143 = iprot.readString() - self.success.append(_elem1143) - iprot.readListEnd() + if fid == 1: + if ftype == TType.STRUCT: + self.o1 = NoSuchTxnException() + self.o1.read(iprot) else: iprot.skip(ftype) else: @@ -35522,13 +36522,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_master_keys_result') - if self.success is not None: - oprot.writeFieldBegin('success', TType.LIST, 0) - oprot.writeListBegin(TType.STRING, len(self.success)) - for iter1144 in self.success: - oprot.writeString(iter1144) - oprot.writeListEnd() + oprot.writeStructBegin('abort_txns_result') + if self.o1 is not None: + oprot.writeFieldBegin('o1', TType.STRUCT, 1) + self.o1.write(oprot) oprot.writeFieldEnd() oprot.writeFieldStop() oprot.writeStructEnd() @@ -35539,7 +36536,7 @@ def validate(self): def __hash__(self): value = 17 - value = (value * 31) ^ hash(self.success) + value = (value * 31) ^ hash(self.o1) return value def __repr__(self): @@ -35553,11 +36550,20 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class get_open_txns_args: +class commit_txn_args: + """ + Attributes: + - rqst + """ thrift_spec = ( + None, # 0 + (1, TType.STRUCT, 'rqst', (CommitTxnRequest, CommitTxnRequest.thrift_spec), None, ), # 1 ) + def __init__(self, rqst=None,): + self.rqst = rqst + 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)) @@ -35567,6 +36573,12 @@ def read(self, iprot): (fname, ftype, fid) = iprot.readFieldBegin() if ftype == TType.STOP: break + if fid == 1: + if ftype == TType.STRUCT: + self.rqst = CommitTxnRequest() + self.rqst.read(iprot) + else: + iprot.skip(ftype) else: iprot.skip(ftype) iprot.readFieldEnd() @@ -35576,7 +36588,11 @@ 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_open_txns_args') + oprot.writeStructBegin('commit_txn_args') + if self.rqst is not None: + oprot.writeFieldBegin('rqst', TType.STRUCT, 1) + self.rqst.write(oprot) + oprot.writeFieldEnd() oprot.writeFieldStop() oprot.writeStructEnd() @@ -35586,6 +36602,7 @@ def validate(self): def __hash__(self): value = 17 + value = (value * 31) ^ hash(self.rqst) return value def __repr__(self): @@ -35599,18 +36616,22 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class get_open_txns_result: +class commit_txn_result: """ Attributes: - - success + - o1 + - o2 """ thrift_spec = ( - (0, TType.STRUCT, 'success', (GetOpenTxnsResponse, GetOpenTxnsResponse.thrift_spec), None, ), # 0 + None, # 0 + (1, TType.STRUCT, 'o1', (NoSuchTxnException, NoSuchTxnException.thrift_spec), None, ), # 1 + (2, TType.STRUCT, 'o2', (TxnAbortedException, TxnAbortedException.thrift_spec), None, ), # 2 ) - def __init__(self, success=None,): - self.success = success + def __init__(self, o1=None, o2=None,): + 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: @@ -35621,10 +36642,16 @@ def read(self, iprot): (fname, ftype, fid) = iprot.readFieldBegin() if ftype == TType.STOP: break - if fid == 0: + if fid == 1: if ftype == TType.STRUCT: - self.success = GetOpenTxnsResponse() - self.success.read(iprot) + self.o1 = NoSuchTxnException() + self.o1.read(iprot) + else: + iprot.skip(ftype) + elif fid == 2: + if ftype == TType.STRUCT: + self.o2 = TxnAbortedException() + self.o2.read(iprot) else: iprot.skip(ftype) else: @@ -35636,10 +36663,14 @@ 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_open_txns_result') - if self.success is not None: - oprot.writeFieldBegin('success', TType.STRUCT, 0) - self.success.write(oprot) + oprot.writeStructBegin('commit_txn_result') + if self.o1 is not None: + oprot.writeFieldBegin('o1', TType.STRUCT, 1) + self.o1.write(oprot) + oprot.writeFieldEnd() + if self.o2 is not None: + oprot.writeFieldBegin('o2', TType.STRUCT, 2) + self.o2.write(oprot) oprot.writeFieldEnd() oprot.writeFieldStop() oprot.writeStructEnd() @@ -35650,7 +36681,8 @@ def validate(self): 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): @@ -35664,11 +36696,20 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class get_open_txns_info_args: +class lock_args: + """ + Attributes: + - rqst + """ thrift_spec = ( + None, # 0 + (1, TType.STRUCT, 'rqst', (LockRequest, LockRequest.thrift_spec), None, ), # 1 ) + def __init__(self, rqst=None,): + self.rqst = rqst + 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)) @@ -35678,6 +36719,12 @@ def read(self, iprot): (fname, ftype, fid) = iprot.readFieldBegin() if ftype == TType.STOP: break + if fid == 1: + if ftype == TType.STRUCT: + self.rqst = LockRequest() + self.rqst.read(iprot) + else: + iprot.skip(ftype) else: iprot.skip(ftype) iprot.readFieldEnd() @@ -35687,7 +36734,11 @@ 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_open_txns_info_args') + oprot.writeStructBegin('lock_args') + if self.rqst is not None: + oprot.writeFieldBegin('rqst', TType.STRUCT, 1) + self.rqst.write(oprot) + oprot.writeFieldEnd() oprot.writeFieldStop() oprot.writeStructEnd() @@ -35697,6 +36748,7 @@ def validate(self): def __hash__(self): value = 17 + value = (value * 31) ^ hash(self.rqst) return value def __repr__(self): @@ -35710,18 +36762,24 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class get_open_txns_info_result: +class lock_result: """ Attributes: - success + - o1 + - o2 """ thrift_spec = ( - (0, TType.STRUCT, 'success', (GetOpenTxnsInfoResponse, GetOpenTxnsInfoResponse.thrift_spec), None, ), # 0 + (0, TType.STRUCT, 'success', (LockResponse, LockResponse.thrift_spec), None, ), # 0 + (1, TType.STRUCT, 'o1', (NoSuchTxnException, NoSuchTxnException.thrift_spec), None, ), # 1 + (2, TType.STRUCT, 'o2', (TxnAbortedException, TxnAbortedException.thrift_spec), None, ), # 2 ) - def __init__(self, success=None,): + 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: @@ -35734,10 +36792,22 @@ def read(self, iprot): break if fid == 0: if ftype == TType.STRUCT: - self.success = GetOpenTxnsInfoResponse() + self.success = LockResponse() self.success.read(iprot) else: iprot.skip(ftype) + elif fid == 1: + if ftype == TType.STRUCT: + self.o1 = NoSuchTxnException() + self.o1.read(iprot) + else: + iprot.skip(ftype) + elif fid == 2: + if ftype == TType.STRUCT: + self.o2 = TxnAbortedException() + self.o2.read(iprot) + else: + iprot.skip(ftype) else: iprot.skip(ftype) iprot.readFieldEnd() @@ -35747,11 +36817,19 @@ 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_open_txns_info_result') + oprot.writeStructBegin('lock_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() @@ -35762,6 +36840,8 @@ def validate(self): 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): @@ -35775,7 +36855,7 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class open_txns_args: +class check_lock_args: """ Attributes: - rqst @@ -35783,7 +36863,7 @@ class open_txns_args: thrift_spec = ( None, # 0 - (1, TType.STRUCT, 'rqst', (OpenTxnRequest, OpenTxnRequest.thrift_spec), None, ), # 1 + (1, TType.STRUCT, 'rqst', (CheckLockRequest, CheckLockRequest.thrift_spec), None, ), # 1 ) def __init__(self, rqst=None,): @@ -35800,7 +36880,7 @@ def read(self, iprot): break if fid == 1: if ftype == TType.STRUCT: - self.rqst = OpenTxnRequest() + self.rqst = CheckLockRequest() self.rqst.read(iprot) else: iprot.skip(ftype) @@ -35813,7 +36893,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('open_txns_args') + oprot.writeStructBegin('check_lock_args') if self.rqst is not None: oprot.writeFieldBegin('rqst', TType.STRUCT, 1) self.rqst.write(oprot) @@ -35841,18 +36921,27 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class open_txns_result: +class check_lock_result: """ Attributes: - success + - o1 + - o2 + - o3 """ thrift_spec = ( - (0, TType.STRUCT, 'success', (OpenTxnsResponse, OpenTxnsResponse.thrift_spec), None, ), # 0 + (0, TType.STRUCT, 'success', (LockResponse, LockResponse.thrift_spec), None, ), # 0 + (1, TType.STRUCT, 'o1', (NoSuchTxnException, NoSuchTxnException.thrift_spec), None, ), # 1 + (2, TType.STRUCT, 'o2', (TxnAbortedException, TxnAbortedException.thrift_spec), None, ), # 2 + (3, TType.STRUCT, 'o3', (NoSuchLockException, NoSuchLockException.thrift_spec), None, ), # 3 ) - def __init__(self, success=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: @@ -35865,10 +36954,28 @@ def read(self, iprot): break if fid == 0: if ftype == TType.STRUCT: - self.success = OpenTxnsResponse() + self.success = LockResponse() self.success.read(iprot) else: iprot.skip(ftype) + elif fid == 1: + if ftype == TType.STRUCT: + self.o1 = NoSuchTxnException() + self.o1.read(iprot) + else: + iprot.skip(ftype) + elif fid == 2: + if ftype == TType.STRUCT: + self.o2 = TxnAbortedException() + self.o2.read(iprot) + else: + iprot.skip(ftype) + elif fid == 3: + if ftype == TType.STRUCT: + self.o3 = NoSuchLockException() + self.o3.read(iprot) + else: + iprot.skip(ftype) else: iprot.skip(ftype) iprot.readFieldEnd() @@ -35878,11 +36985,23 @@ 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('open_txns_result') + oprot.writeStructBegin('check_lock_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() @@ -35893,6 +37012,9 @@ def validate(self): 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): @@ -35906,7 +37028,7 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class abort_txn_args: +class unlock_args: """ Attributes: - rqst @@ -35914,7 +37036,7 @@ class abort_txn_args: thrift_spec = ( None, # 0 - (1, TType.STRUCT, 'rqst', (AbortTxnRequest, AbortTxnRequest.thrift_spec), None, ), # 1 + (1, TType.STRUCT, 'rqst', (UnlockRequest, UnlockRequest.thrift_spec), None, ), # 1 ) def __init__(self, rqst=None,): @@ -35931,7 +37053,7 @@ def read(self, iprot): break if fid == 1: if ftype == TType.STRUCT: - self.rqst = AbortTxnRequest() + self.rqst = UnlockRequest() self.rqst.read(iprot) else: iprot.skip(ftype) @@ -35944,7 +37066,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('abort_txn_args') + oprot.writeStructBegin('unlock_args') if self.rqst is not None: oprot.writeFieldBegin('rqst', TType.STRUCT, 1) self.rqst.write(oprot) @@ -35972,19 +37094,22 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class abort_txn_result: +class unlock_result: """ Attributes: - o1 + - o2 """ thrift_spec = ( None, # 0 - (1, TType.STRUCT, 'o1', (NoSuchTxnException, NoSuchTxnException.thrift_spec), None, ), # 1 + (1, TType.STRUCT, 'o1', (NoSuchLockException, NoSuchLockException.thrift_spec), None, ), # 1 + (2, TType.STRUCT, 'o2', (TxnOpenException, TxnOpenException.thrift_spec), None, ), # 2 ) - def __init__(self, o1=None,): + def __init__(self, o1=None, o2=None,): 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: @@ -35997,10 +37122,16 @@ def read(self, iprot): break if fid == 1: if ftype == TType.STRUCT: - self.o1 = NoSuchTxnException() + self.o1 = NoSuchLockException() self.o1.read(iprot) else: iprot.skip(ftype) + elif fid == 2: + if ftype == TType.STRUCT: + self.o2 = TxnOpenException() + self.o2.read(iprot) + else: + iprot.skip(ftype) else: iprot.skip(ftype) iprot.readFieldEnd() @@ -36010,11 +37141,15 @@ 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('abort_txn_result') + oprot.writeStructBegin('unlock_result') if self.o1 is not None: oprot.writeFieldBegin('o1', TType.STRUCT, 1) self.o1.write(oprot) oprot.writeFieldEnd() + if self.o2 is not None: + oprot.writeFieldBegin('o2', TType.STRUCT, 2) + self.o2.write(oprot) + oprot.writeFieldEnd() oprot.writeFieldStop() oprot.writeStructEnd() @@ -36025,6 +37160,7 @@ def validate(self): def __hash__(self): value = 17 value = (value * 31) ^ hash(self.o1) + value = (value * 31) ^ hash(self.o2) return value def __repr__(self): @@ -36038,7 +37174,7 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class abort_txns_args: +class show_locks_args: """ Attributes: - rqst @@ -36046,7 +37182,7 @@ class abort_txns_args: thrift_spec = ( None, # 0 - (1, TType.STRUCT, 'rqst', (AbortTxnsRequest, AbortTxnsRequest.thrift_spec), None, ), # 1 + (1, TType.STRUCT, 'rqst', (ShowLocksRequest, ShowLocksRequest.thrift_spec), None, ), # 1 ) def __init__(self, rqst=None,): @@ -36063,7 +37199,7 @@ def read(self, iprot): break if fid == 1: if ftype == TType.STRUCT: - self.rqst = AbortTxnsRequest() + self.rqst = ShowLocksRequest() self.rqst.read(iprot) else: iprot.skip(ftype) @@ -36076,7 +37212,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('abort_txns_args') + oprot.writeStructBegin('show_locks_args') if self.rqst is not None: oprot.writeFieldBegin('rqst', TType.STRUCT, 1) self.rqst.write(oprot) @@ -36104,19 +37240,18 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class abort_txns_result: +class show_locks_result: """ Attributes: - - o1 + - success """ thrift_spec = ( - None, # 0 - (1, TType.STRUCT, 'o1', (NoSuchTxnException, NoSuchTxnException.thrift_spec), None, ), # 1 + (0, TType.STRUCT, 'success', (ShowLocksResponse, ShowLocksResponse.thrift_spec), None, ), # 0 ) - def __init__(self, o1=None,): - self.o1 = o1 + def __init__(self, success=None,): + self.success = success 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: @@ -36127,10 +37262,10 @@ def read(self, iprot): (fname, ftype, fid) = iprot.readFieldBegin() if ftype == TType.STOP: break - if fid == 1: + if fid == 0: if ftype == TType.STRUCT: - self.o1 = NoSuchTxnException() - self.o1.read(iprot) + self.success = ShowLocksResponse() + self.success.read(iprot) else: iprot.skip(ftype) else: @@ -36142,10 +37277,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('abort_txns_result') - if self.o1 is not None: - oprot.writeFieldBegin('o1', TType.STRUCT, 1) - self.o1.write(oprot) + oprot.writeStructBegin('show_locks_result') + if self.success is not None: + oprot.writeFieldBegin('success', TType.STRUCT, 0) + self.success.write(oprot) oprot.writeFieldEnd() oprot.writeFieldStop() oprot.writeStructEnd() @@ -36156,7 +37291,7 @@ def validate(self): def __hash__(self): value = 17 - value = (value * 31) ^ hash(self.o1) + value = (value * 31) ^ hash(self.success) return value def __repr__(self): @@ -36170,19 +37305,19 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class commit_txn_args: +class heartbeat_args: """ Attributes: - - rqst + - ids """ thrift_spec = ( None, # 0 - (1, TType.STRUCT, 'rqst', (CommitTxnRequest, CommitTxnRequest.thrift_spec), None, ), # 1 + (1, TType.STRUCT, 'ids', (HeartbeatRequest, HeartbeatRequest.thrift_spec), None, ), # 1 ) - def __init__(self, rqst=None,): - self.rqst = rqst + def __init__(self, ids=None,): + self.ids = ids 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: @@ -36195,8 +37330,8 @@ def read(self, iprot): break if fid == 1: if ftype == TType.STRUCT: - self.rqst = CommitTxnRequest() - self.rqst.read(iprot) + self.ids = HeartbeatRequest() + self.ids.read(iprot) else: iprot.skip(ftype) else: @@ -36208,10 +37343,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('commit_txn_args') - if self.rqst is not None: - oprot.writeFieldBegin('rqst', TType.STRUCT, 1) - self.rqst.write(oprot) + oprot.writeStructBegin('heartbeat_args') + if self.ids is not None: + oprot.writeFieldBegin('ids', TType.STRUCT, 1) + self.ids.write(oprot) oprot.writeFieldEnd() oprot.writeFieldStop() oprot.writeStructEnd() @@ -36222,7 +37357,7 @@ def validate(self): def __hash__(self): value = 17 - value = (value * 31) ^ hash(self.rqst) + value = (value * 31) ^ hash(self.ids) return value def __repr__(self): @@ -36236,22 +37371,25 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class commit_txn_result: +class heartbeat_result: """ Attributes: - o1 - o2 + - o3 """ thrift_spec = ( None, # 0 - (1, TType.STRUCT, 'o1', (NoSuchTxnException, NoSuchTxnException.thrift_spec), None, ), # 1 - (2, TType.STRUCT, 'o2', (TxnAbortedException, TxnAbortedException.thrift_spec), None, ), # 2 + (1, TType.STRUCT, 'o1', (NoSuchLockException, NoSuchLockException.thrift_spec), None, ), # 1 + (2, TType.STRUCT, 'o2', (NoSuchTxnException, NoSuchTxnException.thrift_spec), None, ), # 2 + (3, TType.STRUCT, 'o3', (TxnAbortedException, TxnAbortedException.thrift_spec), None, ), # 3 ) - def __init__(self, o1=None, o2=None,): + def __init__(self, o1=None, o2=None, o3=None,): self.o1 = o1 self.o2 = o2 + self.o3 = o3 def read(self, iprot): if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: @@ -36264,16 +37402,22 @@ def read(self, iprot): break if fid == 1: if ftype == TType.STRUCT: - self.o1 = NoSuchTxnException() + self.o1 = NoSuchLockException() self.o1.read(iprot) else: iprot.skip(ftype) elif fid == 2: if ftype == TType.STRUCT: - self.o2 = TxnAbortedException() + self.o2 = NoSuchTxnException() self.o2.read(iprot) else: iprot.skip(ftype) + elif fid == 3: + if ftype == TType.STRUCT: + self.o3 = TxnAbortedException() + self.o3.read(iprot) + else: + iprot.skip(ftype) else: iprot.skip(ftype) iprot.readFieldEnd() @@ -36283,7 +37427,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('commit_txn_result') + oprot.writeStructBegin('heartbeat_result') if self.o1 is not None: oprot.writeFieldBegin('o1', TType.STRUCT, 1) self.o1.write(oprot) @@ -36292,6 +37436,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() @@ -36303,6 +37451,7 @@ def __hash__(self): value = 17 value = (value * 31) ^ hash(self.o1) value = (value * 31) ^ hash(self.o2) + value = (value * 31) ^ hash(self.o3) return value def __repr__(self): @@ -36316,19 +37465,19 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class lock_args: +class heartbeat_txn_range_args: """ Attributes: - - rqst + - txns """ thrift_spec = ( None, # 0 - (1, TType.STRUCT, 'rqst', (LockRequest, LockRequest.thrift_spec), None, ), # 1 + (1, TType.STRUCT, 'txns', (HeartbeatTxnRangeRequest, HeartbeatTxnRangeRequest.thrift_spec), None, ), # 1 ) - def __init__(self, rqst=None,): - self.rqst = rqst + def __init__(self, txns=None,): + self.txns = txns 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: @@ -36341,8 +37490,8 @@ def read(self, iprot): break if fid == 1: if ftype == TType.STRUCT: - self.rqst = LockRequest() - self.rqst.read(iprot) + self.txns = HeartbeatTxnRangeRequest() + self.txns.read(iprot) else: iprot.skip(ftype) else: @@ -36354,10 +37503,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('lock_args') - if self.rqst is not None: - oprot.writeFieldBegin('rqst', TType.STRUCT, 1) - self.rqst.write(oprot) + oprot.writeStructBegin('heartbeat_txn_range_args') + if self.txns is not None: + oprot.writeFieldBegin('txns', TType.STRUCT, 1) + self.txns.write(oprot) oprot.writeFieldEnd() oprot.writeFieldStop() oprot.writeStructEnd() @@ -36368,7 +37517,7 @@ def validate(self): def __hash__(self): value = 17 - value = (value * 31) ^ hash(self.rqst) + value = (value * 31) ^ hash(self.txns) return value def __repr__(self): @@ -36382,24 +37531,18 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class lock_result: +class heartbeat_txn_range_result: """ Attributes: - success - - o1 - - o2 """ thrift_spec = ( - (0, TType.STRUCT, 'success', (LockResponse, LockResponse.thrift_spec), None, ), # 0 - (1, TType.STRUCT, 'o1', (NoSuchTxnException, NoSuchTxnException.thrift_spec), None, ), # 1 - (2, TType.STRUCT, 'o2', (TxnAbortedException, TxnAbortedException.thrift_spec), None, ), # 2 + (0, TType.STRUCT, 'success', (HeartbeatTxnRangeResponse, HeartbeatTxnRangeResponse.thrift_spec), None, ), # 0 ) - def __init__(self, success=None, o1=None, o2=None,): + def __init__(self, success=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: @@ -36412,22 +37555,10 @@ def read(self, iprot): break if fid == 0: if ftype == TType.STRUCT: - self.success = LockResponse() + self.success = HeartbeatTxnRangeResponse() self.success.read(iprot) else: iprot.skip(ftype) - elif fid == 1: - if ftype == TType.STRUCT: - self.o1 = NoSuchTxnException() - self.o1.read(iprot) - else: - iprot.skip(ftype) - elif fid == 2: - if ftype == TType.STRUCT: - self.o2 = TxnAbortedException() - self.o2.read(iprot) - else: - iprot.skip(ftype) else: iprot.skip(ftype) iprot.readFieldEnd() @@ -36437,19 +37568,11 @@ 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('lock_result') + oprot.writeStructBegin('heartbeat_txn_range_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() @@ -36460,8 +37583,6 @@ def validate(self): 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): @@ -36475,7 +37596,7 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class check_lock_args: +class compact_args: """ Attributes: - rqst @@ -36483,7 +37604,7 @@ class check_lock_args: thrift_spec = ( None, # 0 - (1, TType.STRUCT, 'rqst', (CheckLockRequest, CheckLockRequest.thrift_spec), None, ), # 1 + (1, TType.STRUCT, 'rqst', (CompactionRequest, CompactionRequest.thrift_spec), None, ), # 1 ) def __init__(self, rqst=None,): @@ -36500,7 +37621,7 @@ def read(self, iprot): break if fid == 1: if ftype == TType.STRUCT: - self.rqst = CheckLockRequest() + self.rqst = CompactionRequest() self.rqst.read(iprot) else: iprot.skip(ftype) @@ -36513,7 +37634,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('check_lock_args') + oprot.writeStructBegin('compact_args') if self.rqst is not None: oprot.writeFieldBegin('rqst', TType.STRUCT, 1) self.rqst.write(oprot) @@ -36541,28 +37662,11 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class check_lock_result: - """ - Attributes: - - success - - o1 - - o2 - - o3 - """ +class compact_result: thrift_spec = ( - (0, TType.STRUCT, 'success', (LockResponse, LockResponse.thrift_spec), None, ), # 0 - (1, TType.STRUCT, 'o1', (NoSuchTxnException, NoSuchTxnException.thrift_spec), None, ), # 1 - (2, TType.STRUCT, 'o2', (TxnAbortedException, TxnAbortedException.thrift_spec), None, ), # 2 - (3, TType.STRUCT, 'o3', (NoSuchLockException, NoSuchLockException.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)) @@ -36572,30 +37676,6 @@ def read(self, iprot): (fname, ftype, fid) = iprot.readFieldBegin() if ftype == TType.STOP: break - if fid == 0: - if ftype == TType.STRUCT: - self.success = LockResponse() - self.success.read(iprot) - else: - iprot.skip(ftype) - elif fid == 1: - if ftype == TType.STRUCT: - self.o1 = NoSuchTxnException() - self.o1.read(iprot) - else: - iprot.skip(ftype) - elif fid == 2: - if ftype == TType.STRUCT: - self.o2 = TxnAbortedException() - self.o2.read(iprot) - else: - iprot.skip(ftype) - elif fid == 3: - if ftype == TType.STRUCT: - self.o3 = NoSuchLockException() - self.o3.read(iprot) - else: - iprot.skip(ftype) else: iprot.skip(ftype) iprot.readFieldEnd() @@ -36605,23 +37685,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('check_lock_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.writeStructBegin('compact_result') oprot.writeFieldStop() oprot.writeStructEnd() @@ -36631,10 +37695,6 @@ def validate(self): 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): @@ -36648,7 +37708,7 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class unlock_args: +class compact2_args: """ Attributes: - rqst @@ -36656,7 +37716,7 @@ class unlock_args: thrift_spec = ( None, # 0 - (1, TType.STRUCT, 'rqst', (UnlockRequest, UnlockRequest.thrift_spec), None, ), # 1 + (1, TType.STRUCT, 'rqst', (CompactionRequest, CompactionRequest.thrift_spec), None, ), # 1 ) def __init__(self, rqst=None,): @@ -36673,7 +37733,7 @@ def read(self, iprot): break if fid == 1: if ftype == TType.STRUCT: - self.rqst = UnlockRequest() + self.rqst = CompactionRequest() self.rqst.read(iprot) else: iprot.skip(ftype) @@ -36686,7 +37746,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('unlock_args') + oprot.writeStructBegin('compact2_args') if self.rqst is not None: oprot.writeFieldBegin('rqst', TType.STRUCT, 1) self.rqst.write(oprot) @@ -36714,22 +37774,18 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class unlock_result: +class compact2_result: """ Attributes: - - o1 - - o2 + - success """ thrift_spec = ( - None, # 0 - (1, TType.STRUCT, 'o1', (NoSuchLockException, NoSuchLockException.thrift_spec), None, ), # 1 - (2, TType.STRUCT, 'o2', (TxnOpenException, TxnOpenException.thrift_spec), None, ), # 2 + (0, TType.STRUCT, 'success', (CompactionResponse, CompactionResponse.thrift_spec), None, ), # 0 ) - def __init__(self, o1=None, o2=None,): - self.o1 = o1 - self.o2 = o2 + def __init__(self, success=None,): + self.success = success 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: @@ -36740,16 +37796,10 @@ def read(self, iprot): (fname, ftype, fid) = iprot.readFieldBegin() if ftype == TType.STOP: break - if fid == 1: - if ftype == TType.STRUCT: - self.o1 = NoSuchLockException() - self.o1.read(iprot) - else: - iprot.skip(ftype) - elif fid == 2: + if fid == 0: if ftype == TType.STRUCT: - self.o2 = TxnOpenException() - self.o2.read(iprot) + self.success = CompactionResponse() + self.success.read(iprot) else: iprot.skip(ftype) else: @@ -36761,14 +37811,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('unlock_result') - if self.o1 is not None: - oprot.writeFieldBegin('o1', TType.STRUCT, 1) - self.o1.write(oprot) - oprot.writeFieldEnd() - if self.o2 is not None: - oprot.writeFieldBegin('o2', TType.STRUCT, 2) - self.o2.write(oprot) + oprot.writeStructBegin('compact2_result') + if self.success is not None: + oprot.writeFieldBegin('success', TType.STRUCT, 0) + self.success.write(oprot) oprot.writeFieldEnd() oprot.writeFieldStop() oprot.writeStructEnd() @@ -36779,8 +37825,7 @@ def validate(self): def __hash__(self): value = 17 - value = (value * 31) ^ hash(self.o1) - value = (value * 31) ^ hash(self.o2) + value = (value * 31) ^ hash(self.success) return value def __repr__(self): @@ -36794,7 +37839,7 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class show_locks_args: +class show_compact_args: """ Attributes: - rqst @@ -36802,7 +37847,7 @@ class show_locks_args: thrift_spec = ( None, # 0 - (1, TType.STRUCT, 'rqst', (ShowLocksRequest, ShowLocksRequest.thrift_spec), None, ), # 1 + (1, TType.STRUCT, 'rqst', (ShowCompactRequest, ShowCompactRequest.thrift_spec), None, ), # 1 ) def __init__(self, rqst=None,): @@ -36819,7 +37864,7 @@ def read(self, iprot): break if fid == 1: if ftype == TType.STRUCT: - self.rqst = ShowLocksRequest() + self.rqst = ShowCompactRequest() self.rqst.read(iprot) else: iprot.skip(ftype) @@ -36832,7 +37877,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('show_locks_args') + oprot.writeStructBegin('show_compact_args') if self.rqst is not None: oprot.writeFieldBegin('rqst', TType.STRUCT, 1) self.rqst.write(oprot) @@ -36860,14 +37905,14 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class show_locks_result: +class show_compact_result: """ Attributes: - success """ thrift_spec = ( - (0, TType.STRUCT, 'success', (ShowLocksResponse, ShowLocksResponse.thrift_spec), None, ), # 0 + (0, TType.STRUCT, 'success', (ShowCompactResponse, ShowCompactResponse.thrift_spec), None, ), # 0 ) def __init__(self, success=None,): @@ -36884,7 +37929,7 @@ def read(self, iprot): break if fid == 0: if ftype == TType.STRUCT: - self.success = ShowLocksResponse() + self.success = ShowCompactResponse() self.success.read(iprot) else: iprot.skip(ftype) @@ -36897,7 +37942,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('show_locks_result') + oprot.writeStructBegin('show_compact_result') if self.success is not None: oprot.writeFieldBegin('success', TType.STRUCT, 0) self.success.write(oprot) @@ -36925,19 +37970,19 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class heartbeat_args: +class add_dynamic_partitions_args: """ Attributes: - - ids + - rqst """ thrift_spec = ( None, # 0 - (1, TType.STRUCT, 'ids', (HeartbeatRequest, HeartbeatRequest.thrift_spec), None, ), # 1 + (1, TType.STRUCT, 'rqst', (AddDynamicPartitions, AddDynamicPartitions.thrift_spec), None, ), # 1 ) - def __init__(self, ids=None,): - self.ids = ids + def __init__(self, rqst=None,): + self.rqst = rqst 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: @@ -36950,8 +37995,8 @@ def read(self, iprot): break if fid == 1: if ftype == TType.STRUCT: - self.ids = HeartbeatRequest() - self.ids.read(iprot) + self.rqst = AddDynamicPartitions() + self.rqst.read(iprot) else: iprot.skip(ftype) else: @@ -36963,10 +38008,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('heartbeat_args') - if self.ids is not None: - oprot.writeFieldBegin('ids', TType.STRUCT, 1) - self.ids.write(oprot) + oprot.writeStructBegin('add_dynamic_partitions_args') + if self.rqst is not None: + oprot.writeFieldBegin('rqst', TType.STRUCT, 1) + self.rqst.write(oprot) oprot.writeFieldEnd() oprot.writeFieldStop() oprot.writeStructEnd() @@ -36977,7 +38022,7 @@ def validate(self): def __hash__(self): value = 17 - value = (value * 31) ^ hash(self.ids) + value = (value * 31) ^ hash(self.rqst) return value def __repr__(self): @@ -36991,25 +38036,22 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class heartbeat_result: +class add_dynamic_partitions_result: """ Attributes: - o1 - o2 - - o3 """ thrift_spec = ( None, # 0 - (1, TType.STRUCT, 'o1', (NoSuchLockException, NoSuchLockException.thrift_spec), None, ), # 1 - (2, TType.STRUCT, 'o2', (NoSuchTxnException, NoSuchTxnException.thrift_spec), None, ), # 2 - (3, TType.STRUCT, 'o3', (TxnAbortedException, TxnAbortedException.thrift_spec), None, ), # 3 + (1, TType.STRUCT, 'o1', (NoSuchTxnException, NoSuchTxnException.thrift_spec), None, ), # 1 + (2, TType.STRUCT, 'o2', (TxnAbortedException, TxnAbortedException.thrift_spec), None, ), # 2 ) - def __init__(self, o1=None, o2=None, o3=None,): + def __init__(self, o1=None, o2=None,): self.o1 = o1 self.o2 = o2 - self.o3 = o3 def read(self, iprot): if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: @@ -37022,22 +38064,16 @@ def read(self, iprot): break if fid == 1: if ftype == TType.STRUCT: - self.o1 = NoSuchLockException() + self.o1 = NoSuchTxnException() self.o1.read(iprot) else: iprot.skip(ftype) elif fid == 2: if ftype == TType.STRUCT: - self.o2 = NoSuchTxnException() + self.o2 = TxnAbortedException() self.o2.read(iprot) else: iprot.skip(ftype) - elif fid == 3: - if ftype == TType.STRUCT: - self.o3 = TxnAbortedException() - self.o3.read(iprot) - else: - iprot.skip(ftype) else: iprot.skip(ftype) iprot.readFieldEnd() @@ -37047,7 +38083,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('heartbeat_result') + oprot.writeStructBegin('add_dynamic_partitions_result') if self.o1 is not None: oprot.writeFieldBegin('o1', TType.STRUCT, 1) self.o1.write(oprot) @@ -37056,10 +38092,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() @@ -37071,7 +38103,6 @@ def __hash__(self): value = 17 value = (value * 31) ^ hash(self.o1) value = (value * 31) ^ hash(self.o2) - value = (value * 31) ^ hash(self.o3) return value def __repr__(self): @@ -37085,19 +38116,19 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class heartbeat_txn_range_args: +class get_next_notification_args: """ Attributes: - - txns + - rqst """ thrift_spec = ( None, # 0 - (1, TType.STRUCT, 'txns', (HeartbeatTxnRangeRequest, HeartbeatTxnRangeRequest.thrift_spec), None, ), # 1 + (1, TType.STRUCT, 'rqst', (NotificationEventRequest, NotificationEventRequest.thrift_spec), None, ), # 1 ) - def __init__(self, txns=None,): - self.txns = txns + def __init__(self, rqst=None,): + self.rqst = rqst 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: @@ -37110,8 +38141,8 @@ def read(self, iprot): break if fid == 1: if ftype == TType.STRUCT: - self.txns = HeartbeatTxnRangeRequest() - self.txns.read(iprot) + self.rqst = NotificationEventRequest() + self.rqst.read(iprot) else: iprot.skip(ftype) else: @@ -37123,10 +38154,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('heartbeat_txn_range_args') - if self.txns is not None: - oprot.writeFieldBegin('txns', TType.STRUCT, 1) - self.txns.write(oprot) + oprot.writeStructBegin('get_next_notification_args') + if self.rqst is not None: + oprot.writeFieldBegin('rqst', TType.STRUCT, 1) + self.rqst.write(oprot) oprot.writeFieldEnd() oprot.writeFieldStop() oprot.writeStructEnd() @@ -37137,7 +38168,7 @@ def validate(self): def __hash__(self): value = 17 - value = (value * 31) ^ hash(self.txns) + value = (value * 31) ^ hash(self.rqst) return value def __repr__(self): @@ -37151,14 +38182,14 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class heartbeat_txn_range_result: +class get_next_notification_result: """ Attributes: - success """ thrift_spec = ( - (0, TType.STRUCT, 'success', (HeartbeatTxnRangeResponse, HeartbeatTxnRangeResponse.thrift_spec), None, ), # 0 + (0, TType.STRUCT, 'success', (NotificationEventResponse, NotificationEventResponse.thrift_spec), None, ), # 0 ) def __init__(self, success=None,): @@ -37175,7 +38206,7 @@ def read(self, iprot): break if fid == 0: if ftype == TType.STRUCT: - self.success = HeartbeatTxnRangeResponse() + self.success = NotificationEventResponse() self.success.read(iprot) else: iprot.skip(ftype) @@ -37188,7 +38219,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('heartbeat_txn_range_result') + oprot.writeStructBegin('get_next_notification_result') if self.success is not None: oprot.writeFieldBegin('success', TType.STRUCT, 0) self.success.write(oprot) @@ -37216,132 +38247,11 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class compact_args: - """ - Attributes: - - rqst - """ - - thrift_spec = ( - None, # 0 - (1, TType.STRUCT, 'rqst', (CompactionRequest, CompactionRequest.thrift_spec), None, ), # 1 - ) - - def __init__(self, rqst=None,): - self.rqst = rqst - - 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.rqst = CompactionRequest() - self.rqst.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('compact_args') - if self.rqst is not None: - oprot.writeFieldBegin('rqst', TType.STRUCT, 1) - self.rqst.write(oprot) - oprot.writeFieldEnd() - oprot.writeFieldStop() - oprot.writeStructEnd() - - def validate(self): - return - - - def __hash__(self): - value = 17 - value = (value * 31) ^ hash(self.rqst) - 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 compact_result: - - 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('compact_result') - 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 compact2_args: - """ - Attributes: - - rqst - """ +class get_current_notificationEventId_args: thrift_spec = ( - None, # 0 - (1, TType.STRUCT, 'rqst', (CompactionRequest, CompactionRequest.thrift_spec), None, ), # 1 ) - def __init__(self, rqst=None,): - self.rqst = rqst - 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)) @@ -37351,12 +38261,6 @@ def read(self, iprot): (fname, ftype, fid) = iprot.readFieldBegin() if ftype == TType.STOP: break - if fid == 1: - if ftype == TType.STRUCT: - self.rqst = CompactionRequest() - self.rqst.read(iprot) - else: - iprot.skip(ftype) else: iprot.skip(ftype) iprot.readFieldEnd() @@ -37366,11 +38270,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('compact2_args') - if self.rqst is not None: - oprot.writeFieldBegin('rqst', TType.STRUCT, 1) - self.rqst.write(oprot) - oprot.writeFieldEnd() + oprot.writeStructBegin('get_current_notificationEventId_args') oprot.writeFieldStop() oprot.writeStructEnd() @@ -37380,7 +38280,6 @@ def validate(self): def __hash__(self): value = 17 - value = (value * 31) ^ hash(self.rqst) return value def __repr__(self): @@ -37394,14 +38293,14 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class compact2_result: +class get_current_notificationEventId_result: """ Attributes: - success """ thrift_spec = ( - (0, TType.STRUCT, 'success', (CompactionResponse, CompactionResponse.thrift_spec), None, ), # 0 + (0, TType.STRUCT, 'success', (CurrentNotificationEventId, CurrentNotificationEventId.thrift_spec), None, ), # 0 ) def __init__(self, success=None,): @@ -37418,7 +38317,7 @@ def read(self, iprot): break if fid == 0: if ftype == TType.STRUCT: - self.success = CompactionResponse() + self.success = CurrentNotificationEventId() self.success.read(iprot) else: iprot.skip(ftype) @@ -37431,7 +38330,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('compact2_result') + oprot.writeStructBegin('get_current_notificationEventId_result') if self.success is not None: oprot.writeFieldBegin('success', TType.STRUCT, 0) self.success.write(oprot) @@ -37459,17 +38358,13 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class show_compact_args: +class get_notification_events_count_args: """ Attributes: - rqst """ - thrift_spec = ( - None, # 0 - (1, TType.STRUCT, 'rqst', (ShowCompactRequest, ShowCompactRequest.thrift_spec), None, ), # 1 - ) - + thrift_spec = None def __init__(self, rqst=None,): self.rqst = rqst @@ -37482,9 +38377,9 @@ def read(self, iprot): (fname, ftype, fid) = iprot.readFieldBegin() if ftype == TType.STOP: break - if fid == 1: + if fid == -1: if ftype == TType.STRUCT: - self.rqst = ShowCompactRequest() + self.rqst = NotificationEventsCountRequest() self.rqst.read(iprot) else: iprot.skip(ftype) @@ -37497,9 +38392,9 @@ 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('show_compact_args') + oprot.writeStructBegin('get_notification_events_count_args') if self.rqst is not None: - oprot.writeFieldBegin('rqst', TType.STRUCT, 1) + oprot.writeFieldBegin('rqst', TType.STRUCT, -1) self.rqst.write(oprot) oprot.writeFieldEnd() oprot.writeFieldStop() @@ -37525,14 +38420,14 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class show_compact_result: +class get_notification_events_count_result: """ Attributes: - success """ thrift_spec = ( - (0, TType.STRUCT, 'success', (ShowCompactResponse, ShowCompactResponse.thrift_spec), None, ), # 0 + (0, TType.STRUCT, 'success', (NotificationEventsCountResponse, NotificationEventsCountResponse.thrift_spec), None, ), # 0 ) def __init__(self, success=None,): @@ -37549,7 +38444,7 @@ def read(self, iprot): break if fid == 0: if ftype == TType.STRUCT: - self.success = ShowCompactResponse() + self.success = NotificationEventsCountResponse() self.success.read(iprot) else: iprot.skip(ftype) @@ -37562,7 +38457,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('show_compact_result') + oprot.writeStructBegin('get_notification_events_count_result') if self.success is not None: oprot.writeFieldBegin('success', TType.STRUCT, 0) self.success.write(oprot) @@ -37590,7 +38485,7 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class add_dynamic_partitions_args: +class fire_listener_event_args: """ Attributes: - rqst @@ -37598,7 +38493,7 @@ class add_dynamic_partitions_args: thrift_spec = ( None, # 0 - (1, TType.STRUCT, 'rqst', (AddDynamicPartitions, AddDynamicPartitions.thrift_spec), None, ), # 1 + (1, TType.STRUCT, 'rqst', (FireEventRequest, FireEventRequest.thrift_spec), None, ), # 1 ) def __init__(self, rqst=None,): @@ -37615,7 +38510,7 @@ def read(self, iprot): break if fid == 1: if ftype == TType.STRUCT: - self.rqst = AddDynamicPartitions() + self.rqst = FireEventRequest() self.rqst.read(iprot) else: iprot.skip(ftype) @@ -37628,7 +38523,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('add_dynamic_partitions_args') + oprot.writeStructBegin('fire_listener_event_args') if self.rqst is not None: oprot.writeFieldBegin('rqst', TType.STRUCT, 1) self.rqst.write(oprot) @@ -37656,22 +38551,18 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class add_dynamic_partitions_result: +class fire_listener_event_result: """ Attributes: - - o1 - - o2 + - success """ thrift_spec = ( - None, # 0 - (1, TType.STRUCT, 'o1', (NoSuchTxnException, NoSuchTxnException.thrift_spec), None, ), # 1 - (2, TType.STRUCT, 'o2', (TxnAbortedException, TxnAbortedException.thrift_spec), None, ), # 2 + (0, TType.STRUCT, 'success', (FireEventResponse, FireEventResponse.thrift_spec), None, ), # 0 ) - def __init__(self, o1=None, o2=None,): - self.o1 = o1 - self.o2 = o2 + def __init__(self, success=None,): + self.success = success 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: @@ -37682,16 +38573,10 @@ def read(self, iprot): (fname, ftype, fid) = iprot.readFieldBegin() if ftype == TType.STOP: break - if fid == 1: - if ftype == TType.STRUCT: - self.o1 = NoSuchTxnException() - self.o1.read(iprot) - else: - iprot.skip(ftype) - elif fid == 2: + if fid == 0: if ftype == TType.STRUCT: - self.o2 = TxnAbortedException() - self.o2.read(iprot) + self.success = FireEventResponse() + self.success.read(iprot) else: iprot.skip(ftype) else: @@ -37703,14 +38588,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('add_dynamic_partitions_result') - if self.o1 is not None: - oprot.writeFieldBegin('o1', TType.STRUCT, 1) - self.o1.write(oprot) - oprot.writeFieldEnd() - if self.o2 is not None: - oprot.writeFieldBegin('o2', TType.STRUCT, 2) - self.o2.write(oprot) + oprot.writeStructBegin('fire_listener_event_result') + if self.success is not None: + oprot.writeFieldBegin('success', TType.STRUCT, 0) + self.success.write(oprot) oprot.writeFieldEnd() oprot.writeFieldStop() oprot.writeStructEnd() @@ -37721,8 +38602,7 @@ def validate(self): def __hash__(self): value = 17 - value = (value * 31) ^ hash(self.o1) - value = (value * 31) ^ hash(self.o2) + value = (value * 31) ^ hash(self.success) return value def __repr__(self): @@ -37736,19 +38616,111 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class get_next_notification_args: +class flushCache_args: + + thrift_spec = ( + ) + + def read(self, iprot): + if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: + fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) + return + iprot.readStructBegin() + while True: + (fname, ftype, fid) = iprot.readFieldBegin() + if ftype == TType.STOP: + break + else: + iprot.skip(ftype) + iprot.readFieldEnd() + iprot.readStructEnd() + + def write(self, oprot): + if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: + oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) + return + oprot.writeStructBegin('flushCache_args') + 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 flushCache_result: + + 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('flushCache_result') + 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 cm_recycle_args: """ Attributes: - - rqst + - request """ thrift_spec = ( None, # 0 - (1, TType.STRUCT, 'rqst', (NotificationEventRequest, NotificationEventRequest.thrift_spec), None, ), # 1 + (1, TType.STRUCT, 'request', (CmRecycleRequest, CmRecycleRequest.thrift_spec), None, ), # 1 ) - def __init__(self, rqst=None,): - self.rqst = rqst + 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: @@ -37761,8 +38733,8 @@ def read(self, iprot): break if fid == 1: if ftype == TType.STRUCT: - self.rqst = NotificationEventRequest() - self.rqst.read(iprot) + self.request = CmRecycleRequest() + self.request.read(iprot) else: iprot.skip(ftype) else: @@ -37774,10 +38746,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_next_notification_args') - if self.rqst is not None: - oprot.writeFieldBegin('rqst', TType.STRUCT, 1) - self.rqst.write(oprot) + oprot.writeStructBegin('cm_recycle_args') + if self.request is not None: + oprot.writeFieldBegin('request', TType.STRUCT, 1) + self.request.write(oprot) oprot.writeFieldEnd() oprot.writeFieldStop() oprot.writeStructEnd() @@ -37788,7 +38760,7 @@ def validate(self): def __hash__(self): value = 17 - value = (value * 31) ^ hash(self.rqst) + value = (value * 31) ^ hash(self.request) return value def __repr__(self): @@ -37802,18 +38774,21 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class get_next_notification_result: +class cm_recycle_result: """ Attributes: - success + - o1 """ thrift_spec = ( - (0, TType.STRUCT, 'success', (NotificationEventResponse, NotificationEventResponse.thrift_spec), None, ), # 0 + (0, TType.STRUCT, 'success', (CmRecycleResponse, CmRecycleResponse.thrift_spec), None, ), # 0 + (1, TType.STRUCT, 'o1', (MetaException, MetaException.thrift_spec), None, ), # 1 ) - def __init__(self, success=None,): + 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: @@ -37826,10 +38801,16 @@ def read(self, iprot): break if fid == 0: if ftype == TType.STRUCT: - self.success = NotificationEventResponse() + self.success = CmRecycleResponse() 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() @@ -37839,11 +38820,15 @@ 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_next_notification_result') + oprot.writeStructBegin('cm_recycle_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() @@ -37854,6 +38839,7 @@ def validate(self): def __hash__(self): value = 17 value = (value * 31) ^ hash(self.success) + value = (value * 31) ^ hash(self.o1) return value def __repr__(self): @@ -37867,11 +38853,20 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class get_current_notificationEventId_args: +class get_file_metadata_by_expr_args: + """ + Attributes: + - req + """ thrift_spec = ( + None, # 0 + (1, TType.STRUCT, 'req', (GetFileMetadataByExprRequest, GetFileMetadataByExprRequest.thrift_spec), None, ), # 1 ) + def __init__(self, req=None,): + self.req = req + 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)) @@ -37881,6 +38876,12 @@ def read(self, iprot): (fname, ftype, fid) = iprot.readFieldBegin() if ftype == TType.STOP: break + if fid == 1: + if ftype == TType.STRUCT: + self.req = GetFileMetadataByExprRequest() + self.req.read(iprot) + else: + iprot.skip(ftype) else: iprot.skip(ftype) iprot.readFieldEnd() @@ -37890,7 +38891,11 @@ 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_current_notificationEventId_args') + oprot.writeStructBegin('get_file_metadata_by_expr_args') + if self.req is not None: + oprot.writeFieldBegin('req', TType.STRUCT, 1) + self.req.write(oprot) + oprot.writeFieldEnd() oprot.writeFieldStop() oprot.writeStructEnd() @@ -37900,6 +38905,7 @@ def validate(self): def __hash__(self): value = 17 + value = (value * 31) ^ hash(self.req) return value def __repr__(self): @@ -37913,14 +38919,14 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class get_current_notificationEventId_result: +class get_file_metadata_by_expr_result: """ Attributes: - success """ thrift_spec = ( - (0, TType.STRUCT, 'success', (CurrentNotificationEventId, CurrentNotificationEventId.thrift_spec), None, ), # 0 + (0, TType.STRUCT, 'success', (GetFileMetadataByExprResult, GetFileMetadataByExprResult.thrift_spec), None, ), # 0 ) def __init__(self, success=None,): @@ -37937,7 +38943,7 @@ def read(self, iprot): break if fid == 0: if ftype == TType.STRUCT: - self.success = CurrentNotificationEventId() + self.success = GetFileMetadataByExprResult() self.success.read(iprot) else: iprot.skip(ftype) @@ -37950,7 +38956,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_current_notificationEventId_result') + oprot.writeStructBegin('get_file_metadata_by_expr_result') if self.success is not None: oprot.writeFieldBegin('success', TType.STRUCT, 0) self.success.write(oprot) @@ -37978,15 +38984,19 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class get_notification_events_count_args: +class get_file_metadata_args: """ Attributes: - - rqst + - req """ - thrift_spec = None - def __init__(self, rqst=None,): - self.rqst = rqst + thrift_spec = ( + None, # 0 + (1, TType.STRUCT, 'req', (GetFileMetadataRequest, GetFileMetadataRequest.thrift_spec), None, ), # 1 + ) + + def __init__(self, req=None,): + self.req = req 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: @@ -37997,10 +39007,10 @@ def read(self, iprot): (fname, ftype, fid) = iprot.readFieldBegin() if ftype == TType.STOP: break - if fid == -1: + if fid == 1: if ftype == TType.STRUCT: - self.rqst = NotificationEventsCountRequest() - self.rqst.read(iprot) + self.req = GetFileMetadataRequest() + self.req.read(iprot) else: iprot.skip(ftype) else: @@ -38012,10 +39022,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_notification_events_count_args') - if self.rqst is not None: - oprot.writeFieldBegin('rqst', TType.STRUCT, -1) - self.rqst.write(oprot) + oprot.writeStructBegin('get_file_metadata_args') + if self.req is not None: + oprot.writeFieldBegin('req', TType.STRUCT, 1) + self.req.write(oprot) oprot.writeFieldEnd() oprot.writeFieldStop() oprot.writeStructEnd() @@ -38026,7 +39036,7 @@ def validate(self): def __hash__(self): value = 17 - value = (value * 31) ^ hash(self.rqst) + value = (value * 31) ^ hash(self.req) return value def __repr__(self): @@ -38040,14 +39050,14 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class get_notification_events_count_result: +class get_file_metadata_result: """ Attributes: - success """ thrift_spec = ( - (0, TType.STRUCT, 'success', (NotificationEventsCountResponse, NotificationEventsCountResponse.thrift_spec), None, ), # 0 + (0, TType.STRUCT, 'success', (GetFileMetadataResult, GetFileMetadataResult.thrift_spec), None, ), # 0 ) def __init__(self, success=None,): @@ -38064,7 +39074,7 @@ def read(self, iprot): break if fid == 0: if ftype == TType.STRUCT: - self.success = NotificationEventsCountResponse() + self.success = GetFileMetadataResult() self.success.read(iprot) else: iprot.skip(ftype) @@ -38077,7 +39087,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_notification_events_count_result') + oprot.writeStructBegin('get_file_metadata_result') if self.success is not None: oprot.writeFieldBegin('success', TType.STRUCT, 0) self.success.write(oprot) @@ -38105,19 +39115,19 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class fire_listener_event_args: +class put_file_metadata_args: """ Attributes: - - rqst + - req """ thrift_spec = ( None, # 0 - (1, TType.STRUCT, 'rqst', (FireEventRequest, FireEventRequest.thrift_spec), None, ), # 1 + (1, TType.STRUCT, 'req', (PutFileMetadataRequest, PutFileMetadataRequest.thrift_spec), None, ), # 1 ) - def __init__(self, rqst=None,): - self.rqst = rqst + def __init__(self, req=None,): + self.req = req 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: @@ -38130,8 +39140,8 @@ def read(self, iprot): break if fid == 1: if ftype == TType.STRUCT: - self.rqst = FireEventRequest() - self.rqst.read(iprot) + self.req = PutFileMetadataRequest() + self.req.read(iprot) else: iprot.skip(ftype) else: @@ -38143,10 +39153,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('fire_listener_event_args') - if self.rqst is not None: - oprot.writeFieldBegin('rqst', TType.STRUCT, 1) - self.rqst.write(oprot) + oprot.writeStructBegin('put_file_metadata_args') + if self.req is not None: + oprot.writeFieldBegin('req', TType.STRUCT, 1) + self.req.write(oprot) oprot.writeFieldEnd() oprot.writeFieldStop() oprot.writeStructEnd() @@ -38157,7 +39167,7 @@ def validate(self): def __hash__(self): value = 17 - value = (value * 31) ^ hash(self.rqst) + value = (value * 31) ^ hash(self.req) return value def __repr__(self): @@ -38171,14 +39181,14 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class fire_listener_event_result: +class put_file_metadata_result: """ Attributes: - success """ thrift_spec = ( - (0, TType.STRUCT, 'success', (FireEventResponse, FireEventResponse.thrift_spec), None, ), # 0 + (0, TType.STRUCT, 'success', (PutFileMetadataResult, PutFileMetadataResult.thrift_spec), None, ), # 0 ) def __init__(self, success=None,): @@ -38195,7 +39205,7 @@ def read(self, iprot): break if fid == 0: if ftype == TType.STRUCT: - self.success = FireEventResponse() + self.success = PutFileMetadataResult() self.success.read(iprot) else: iprot.skip(ftype) @@ -38208,7 +39218,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('fire_listener_event_result') + oprot.writeStructBegin('put_file_metadata_result') if self.success is not None: oprot.writeFieldBegin('success', TType.STRUCT, 0) self.success.write(oprot) @@ -38236,11 +39246,20 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class flushCache_args: +class clear_file_metadata_args: + """ + Attributes: + - req + """ thrift_spec = ( + None, # 0 + (1, TType.STRUCT, 'req', (ClearFileMetadataRequest, ClearFileMetadataRequest.thrift_spec), None, ), # 1 ) + def __init__(self, req=None,): + self.req = req + 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)) @@ -38250,6 +39269,12 @@ def read(self, iprot): (fname, ftype, fid) = iprot.readFieldBegin() if ftype == TType.STOP: break + if fid == 1: + if ftype == TType.STRUCT: + self.req = ClearFileMetadataRequest() + self.req.read(iprot) + else: + iprot.skip(ftype) else: iprot.skip(ftype) iprot.readFieldEnd() @@ -38259,7 +39284,11 @@ 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('flushCache_args') + oprot.writeStructBegin('clear_file_metadata_args') + if self.req is not None: + oprot.writeFieldBegin('req', TType.STRUCT, 1) + self.req.write(oprot) + oprot.writeFieldEnd() oprot.writeFieldStop() oprot.writeStructEnd() @@ -38269,6 +39298,7 @@ def validate(self): def __hash__(self): value = 17 + value = (value * 31) ^ hash(self.req) return value def __repr__(self): @@ -38282,11 +39312,19 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class flushCache_result: +class clear_file_metadata_result: + """ + Attributes: + - success + """ thrift_spec = ( + (0, TType.STRUCT, 'success', (ClearFileMetadataResult, ClearFileMetadataResult.thrift_spec), None, ), # 0 ) + def __init__(self, success=None,): + self.success = success + 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)) @@ -38296,6 +39334,12 @@ def read(self, iprot): (fname, ftype, fid) = iprot.readFieldBegin() if ftype == TType.STOP: break + if fid == 0: + if ftype == TType.STRUCT: + self.success = ClearFileMetadataResult() + self.success.read(iprot) + else: + iprot.skip(ftype) else: iprot.skip(ftype) iprot.readFieldEnd() @@ -38305,7 +39349,11 @@ 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('flushCache_result') + oprot.writeStructBegin('clear_file_metadata_result') + if self.success is not None: + oprot.writeFieldBegin('success', TType.STRUCT, 0) + self.success.write(oprot) + oprot.writeFieldEnd() oprot.writeFieldStop() oprot.writeStructEnd() @@ -38315,6 +39363,7 @@ def validate(self): def __hash__(self): value = 17 + value = (value * 31) ^ hash(self.success) return value def __repr__(self): @@ -38328,19 +39377,19 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class cm_recycle_args: +class cache_file_metadata_args: """ Attributes: - - request + - req """ thrift_spec = ( None, # 0 - (1, TType.STRUCT, 'request', (CmRecycleRequest, CmRecycleRequest.thrift_spec), None, ), # 1 + (1, TType.STRUCT, 'req', (CacheFileMetadataRequest, CacheFileMetadataRequest.thrift_spec), None, ), # 1 ) - def __init__(self, request=None,): - self.request = request + def __init__(self, req=None,): + self.req = req 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: @@ -38353,8 +39402,8 @@ def read(self, iprot): break if fid == 1: if ftype == TType.STRUCT: - self.request = CmRecycleRequest() - self.request.read(iprot) + self.req = CacheFileMetadataRequest() + self.req.read(iprot) else: iprot.skip(ftype) else: @@ -38366,10 +39415,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('cm_recycle_args') - if self.request is not None: - oprot.writeFieldBegin('request', TType.STRUCT, 1) - self.request.write(oprot) + oprot.writeStructBegin('cache_file_metadata_args') + if self.req is not None: + oprot.writeFieldBegin('req', TType.STRUCT, 1) + self.req.write(oprot) oprot.writeFieldEnd() oprot.writeFieldStop() oprot.writeStructEnd() @@ -38380,7 +39429,7 @@ def validate(self): def __hash__(self): value = 17 - value = (value * 31) ^ hash(self.request) + value = (value * 31) ^ hash(self.req) return value def __repr__(self): @@ -38394,21 +39443,18 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class cm_recycle_result: +class cache_file_metadata_result: """ Attributes: - success - - o1 """ thrift_spec = ( - (0, TType.STRUCT, 'success', (CmRecycleResponse, CmRecycleResponse.thrift_spec), None, ), # 0 - (1, TType.STRUCT, 'o1', (MetaException, MetaException.thrift_spec), None, ), # 1 + (0, TType.STRUCT, 'success', (CacheFileMetadataResult, CacheFileMetadataResult.thrift_spec), None, ), # 0 ) - def __init__(self, success=None, o1=None,): + def __init__(self, success=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: @@ -38421,16 +39467,10 @@ def read(self, iprot): break if fid == 0: if ftype == TType.STRUCT: - self.success = CmRecycleResponse() + self.success = CacheFileMetadataResult() 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() @@ -38440,15 +39480,11 @@ 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('cm_recycle_result') + oprot.writeStructBegin('cache_file_metadata_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() @@ -38459,7 +39495,6 @@ def validate(self): def __hash__(self): value = 17 value = (value * 31) ^ hash(self.success) - value = (value * 31) ^ hash(self.o1) return value def __repr__(self): @@ -38473,20 +39508,11 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class get_file_metadata_by_expr_args: - """ - Attributes: - - req - """ +class get_metastore_db_uuid_args: thrift_spec = ( - None, # 0 - (1, TType.STRUCT, 'req', (GetFileMetadataByExprRequest, GetFileMetadataByExprRequest.thrift_spec), None, ), # 1 ) - def __init__(self, req=None,): - self.req = req - 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)) @@ -38496,12 +39522,6 @@ def read(self, iprot): (fname, ftype, fid) = iprot.readFieldBegin() if ftype == TType.STOP: break - if fid == 1: - if ftype == TType.STRUCT: - self.req = GetFileMetadataByExprRequest() - self.req.read(iprot) - else: - iprot.skip(ftype) else: iprot.skip(ftype) iprot.readFieldEnd() @@ -38511,11 +39531,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_file_metadata_by_expr_args') - if self.req is not None: - oprot.writeFieldBegin('req', TType.STRUCT, 1) - self.req.write(oprot) - oprot.writeFieldEnd() + oprot.writeStructBegin('get_metastore_db_uuid_args') oprot.writeFieldStop() oprot.writeStructEnd() @@ -38525,7 +39541,6 @@ def validate(self): def __hash__(self): value = 17 - value = (value * 31) ^ hash(self.req) return value def __repr__(self): @@ -38539,18 +39554,21 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class get_file_metadata_by_expr_result: +class get_metastore_db_uuid_result: """ Attributes: - success + - o1 """ thrift_spec = ( - (0, TType.STRUCT, 'success', (GetFileMetadataByExprResult, GetFileMetadataByExprResult.thrift_spec), None, ), # 0 + (0, TType.STRING, 'success', None, None, ), # 0 + (1, TType.STRUCT, 'o1', (MetaException, MetaException.thrift_spec), None, ), # 1 ) - def __init__(self, success=None,): + 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: @@ -38562,9 +39580,14 @@ def read(self, iprot): if ftype == TType.STOP: break if fid == 0: + if ftype == TType.STRING: + self.success = iprot.readString() + else: + iprot.skip(ftype) + elif fid == 1: if ftype == TType.STRUCT: - self.success = GetFileMetadataByExprResult() - self.success.read(iprot) + self.o1 = MetaException() + self.o1.read(iprot) else: iprot.skip(ftype) else: @@ -38576,10 +39599,14 @@ 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_file_metadata_by_expr_result') + oprot.writeStructBegin('get_metastore_db_uuid_result') if self.success is not None: - oprot.writeFieldBegin('success', TType.STRUCT, 0) - self.success.write(oprot) + oprot.writeFieldBegin('success', TType.STRING, 0) + oprot.writeString(self.success) + oprot.writeFieldEnd() + if self.o1 is not None: + oprot.writeFieldBegin('o1', TType.STRUCT, 1) + self.o1.write(oprot) oprot.writeFieldEnd() oprot.writeFieldStop() oprot.writeStructEnd() @@ -38591,6 +39618,7 @@ def validate(self): def __hash__(self): value = 17 value = (value * 31) ^ hash(self.success) + value = (value * 31) ^ hash(self.o1) return value def __repr__(self): @@ -38604,19 +39632,19 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class get_file_metadata_args: +class create_resource_plan_args: """ Attributes: - - req + - request """ thrift_spec = ( None, # 0 - (1, TType.STRUCT, 'req', (GetFileMetadataRequest, GetFileMetadataRequest.thrift_spec), None, ), # 1 + (1, TType.STRUCT, 'request', (WMCreateResourcePlanRequest, WMCreateResourcePlanRequest.thrift_spec), None, ), # 1 ) - def __init__(self, req=None,): - self.req = req + 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: @@ -38629,8 +39657,8 @@ def read(self, iprot): break if fid == 1: if ftype == TType.STRUCT: - self.req = GetFileMetadataRequest() - self.req.read(iprot) + self.request = WMCreateResourcePlanRequest() + self.request.read(iprot) else: iprot.skip(ftype) else: @@ -38642,10 +39670,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_file_metadata_args') - if self.req is not None: - oprot.writeFieldBegin('req', TType.STRUCT, 1) - self.req.write(oprot) + oprot.writeStructBegin('create_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() @@ -38656,7 +39684,7 @@ def validate(self): def __hash__(self): value = 17 - value = (value * 31) ^ hash(self.req) + value = (value * 31) ^ hash(self.request) return value def __repr__(self): @@ -38670,18 +39698,27 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class get_file_metadata_result: +class create_resource_plan_result: """ Attributes: - success + - o1 + - o2 + - o3 """ thrift_spec = ( - (0, TType.STRUCT, 'success', (GetFileMetadataResult, GetFileMetadataResult.thrift_spec), None, ), # 0 + (0, TType.STRUCT, 'success', (WMCreateResourcePlanResponse, WMCreateResourcePlanResponse.thrift_spec), None, ), # 0 + (1, TType.STRUCT, 'o1', (AlreadyExistsException, AlreadyExistsException.thrift_spec), None, ), # 1 + (2, TType.STRUCT, 'o2', (InvalidObjectException, InvalidObjectException.thrift_spec), None, ), # 2 + (3, TType.STRUCT, 'o3', (MetaException, MetaException.thrift_spec), None, ), # 3 ) - def __init__(self, success=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: @@ -38694,10 +39731,28 @@ def read(self, iprot): break if fid == 0: if ftype == TType.STRUCT: - self.success = GetFileMetadataResult() + 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() @@ -38707,11 +39762,23 @@ 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_file_metadata_result') + 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() @@ -38722,6 +39789,9 @@ def validate(self): 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): @@ -38735,19 +39805,19 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class put_file_metadata_args: +class get_resource_plan_args: """ Attributes: - - req + - request """ thrift_spec = ( None, # 0 - (1, TType.STRUCT, 'req', (PutFileMetadataRequest, PutFileMetadataRequest.thrift_spec), None, ), # 1 + (1, TType.STRUCT, 'request', (WMGetResourcePlanRequest, WMGetResourcePlanRequest.thrift_spec), None, ), # 1 ) - def __init__(self, req=None,): - self.req = req + 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: @@ -38760,8 +39830,8 @@ def read(self, iprot): break if fid == 1: if ftype == TType.STRUCT: - self.req = PutFileMetadataRequest() - self.req.read(iprot) + self.request = WMGetResourcePlanRequest() + self.request.read(iprot) else: iprot.skip(ftype) else: @@ -38773,10 +39843,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('put_file_metadata_args') - if self.req is not None: - oprot.writeFieldBegin('req', TType.STRUCT, 1) - self.req.write(oprot) + 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() @@ -38787,7 +39857,7 @@ def validate(self): def __hash__(self): value = 17 - value = (value * 31) ^ hash(self.req) + value = (value * 31) ^ hash(self.request) return value def __repr__(self): @@ -38801,18 +39871,24 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class put_file_metadata_result: +class get_resource_plan_result: """ Attributes: - success + - o1 + - o2 """ thrift_spec = ( - (0, TType.STRUCT, 'success', (PutFileMetadataResult, PutFileMetadataResult.thrift_spec), None, ), # 0 + (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,): + 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: @@ -38825,10 +39901,22 @@ def read(self, iprot): break if fid == 0: if ftype == TType.STRUCT: - self.success = PutFileMetadataResult() + 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() @@ -38838,11 +39926,19 @@ 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('put_file_metadata_result') + 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() @@ -38853,6 +39949,8 @@ def validate(self): 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): @@ -38866,19 +39964,19 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class clear_file_metadata_args: +class get_all_resource_plans_args: """ Attributes: - - req + - request """ thrift_spec = ( None, # 0 - (1, TType.STRUCT, 'req', (ClearFileMetadataRequest, ClearFileMetadataRequest.thrift_spec), None, ), # 1 + (1, TType.STRUCT, 'request', (WMGetAllResourcePlanRequest, WMGetAllResourcePlanRequest.thrift_spec), None, ), # 1 ) - def __init__(self, req=None,): - self.req = req + 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: @@ -38891,8 +39989,8 @@ def read(self, iprot): break if fid == 1: if ftype == TType.STRUCT: - self.req = ClearFileMetadataRequest() - self.req.read(iprot) + self.request = WMGetAllResourcePlanRequest() + self.request.read(iprot) else: iprot.skip(ftype) else: @@ -38904,10 +40002,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('clear_file_metadata_args') - if self.req is not None: - oprot.writeFieldBegin('req', TType.STRUCT, 1) - self.req.write(oprot) + 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() @@ -38918,7 +40016,7 @@ def validate(self): def __hash__(self): value = 17 - value = (value * 31) ^ hash(self.req) + value = (value * 31) ^ hash(self.request) return value def __repr__(self): @@ -38932,18 +40030,21 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class clear_file_metadata_result: +class get_all_resource_plans_result: """ Attributes: - success + - o1 """ thrift_spec = ( - (0, TType.STRUCT, 'success', (ClearFileMetadataResult, ClearFileMetadataResult.thrift_spec), None, ), # 0 + (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,): + 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: @@ -38956,10 +40057,16 @@ def read(self, iprot): break if fid == 0: if ftype == TType.STRUCT: - self.success = ClearFileMetadataResult() + 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() @@ -38969,11 +40076,15 @@ 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('clear_file_metadata_result') + 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() @@ -38984,6 +40095,7 @@ def validate(self): def __hash__(self): value = 17 value = (value * 31) ^ hash(self.success) + value = (value * 31) ^ hash(self.o1) return value def __repr__(self): @@ -38997,19 +40109,19 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class cache_file_metadata_args: +class alter_resource_plan_args: """ Attributes: - - req + - request """ thrift_spec = ( None, # 0 - (1, TType.STRUCT, 'req', (CacheFileMetadataRequest, CacheFileMetadataRequest.thrift_spec), None, ), # 1 + (1, TType.STRUCT, 'request', (WMAlterResourcePlanRequest, WMAlterResourcePlanRequest.thrift_spec), None, ), # 1 ) - def __init__(self, req=None,): - self.req = req + 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: @@ -39022,8 +40134,8 @@ def read(self, iprot): break if fid == 1: if ftype == TType.STRUCT: - self.req = CacheFileMetadataRequest() - self.req.read(iprot) + self.request = WMAlterResourcePlanRequest() + self.request.read(iprot) else: iprot.skip(ftype) else: @@ -39035,10 +40147,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('cache_file_metadata_args') - if self.req is not None: - oprot.writeFieldBegin('req', TType.STRUCT, 1) - self.req.write(oprot) + 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() @@ -39049,7 +40161,7 @@ def validate(self): def __hash__(self): value = 17 - value = (value * 31) ^ hash(self.req) + value = (value * 31) ^ hash(self.request) return value def __repr__(self): @@ -39063,18 +40175,27 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class cache_file_metadata_result: +class alter_resource_plan_result: """ Attributes: - success + - o1 + - o2 + - o3 """ thrift_spec = ( - (0, TType.STRUCT, 'success', (CacheFileMetadataResult, CacheFileMetadataResult.thrift_spec), None, ), # 0 + (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,): + 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: @@ -39087,10 +40208,28 @@ def read(self, iprot): break if fid == 0: if ftype == TType.STRUCT: - self.success = CacheFileMetadataResult() + 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() @@ -39100,11 +40239,23 @@ 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('cache_file_metadata_result') + 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() @@ -39115,6 +40266,9 @@ def validate(self): 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): @@ -39128,11 +40282,20 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class get_metastore_db_uuid_args: +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)) @@ -39142,6 +40305,12 @@ def read(self, iprot): (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() @@ -39151,7 +40320,11 @@ 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_metastore_db_uuid_args') + 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() @@ -39161,6 +40334,7 @@ def validate(self): def __hash__(self): value = 17 + value = (value * 31) ^ hash(self.request) return value def __repr__(self): @@ -39174,21 +40348,24 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class get_metastore_db_uuid_result: +class validate_resource_plan_result: """ Attributes: - success - o1 + - o2 """ thrift_spec = ( - (0, TType.STRING, 'success', None, None, ), # 0 - (1, TType.STRUCT, 'o1', (MetaException, MetaException.thrift_spec), None, ), # 1 + (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,): + 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: @@ -39200,16 +40377,23 @@ def read(self, iprot): if ftype == TType.STOP: break if fid == 0: - if ftype == TType.STRING: - self.success = iprot.readString() + if ftype == TType.STRUCT: + self.success = WMValidateResourcePlanResponse() + self.success.read(iprot) else: iprot.skip(ftype) elif fid == 1: if ftype == TType.STRUCT: - self.o1 = MetaException() + 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() @@ -39219,15 +40403,19 @@ 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_metastore_db_uuid_result') + oprot.writeStructBegin('validate_resource_plan_result') if self.success is not None: - oprot.writeFieldBegin('success', TType.STRING, 0) - oprot.writeString(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) 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() @@ -39239,6 +40427,7 @@ 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): @@ -39252,7 +40441,7 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class create_resource_plan_args: +class drop_resource_plan_args: """ Attributes: - request @@ -39260,7 +40449,7 @@ class create_resource_plan_args: thrift_spec = ( None, # 0 - (1, TType.STRUCT, 'request', (WMCreateResourcePlanRequest, WMCreateResourcePlanRequest.thrift_spec), None, ), # 1 + (1, TType.STRUCT, 'request', (WMDropResourcePlanRequest, WMDropResourcePlanRequest.thrift_spec), None, ), # 1 ) def __init__(self, request=None,): @@ -39277,7 +40466,7 @@ def read(self, iprot): break if fid == 1: if ftype == TType.STRUCT: - self.request = WMCreateResourcePlanRequest() + self.request = WMDropResourcePlanRequest() self.request.read(iprot) else: iprot.skip(ftype) @@ -39290,7 +40479,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_args') + oprot.writeStructBegin('drop_resource_plan_args') if self.request is not None: oprot.writeFieldBegin('request', TType.STRUCT, 1) self.request.write(oprot) @@ -39318,7 +40507,7 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class create_resource_plan_result: +class drop_resource_plan_result: """ Attributes: - success @@ -39328,9 +40517,9 @@ class create_resource_plan_result: """ thrift_spec = ( - (0, TType.STRUCT, 'success', (WMCreateResourcePlanResponse, WMCreateResourcePlanResponse.thrift_spec), None, ), # 0 - (1, TType.STRUCT, 'o1', (AlreadyExistsException, AlreadyExistsException.thrift_spec), None, ), # 1 - (2, TType.STRUCT, 'o2', (InvalidObjectException, InvalidObjectException.thrift_spec), None, ), # 2 + (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 ) @@ -39351,19 +40540,19 @@ def read(self, iprot): break if fid == 0: if ftype == TType.STRUCT: - self.success = WMCreateResourcePlanResponse() + 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) @@ -39382,7 +40571,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) @@ -39425,7 +40614,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 @@ -39433,7 +40622,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,): @@ -39450,7 +40639,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) @@ -39463,7 +40652,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) @@ -39491,24 +40680,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: @@ -39521,22 +40716,34 @@ 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) + 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 = MetaException() + self.o4.read(iprot) + else: + iprot.skip(ftype) else: iprot.skip(ftype) iprot.readFieldEnd() @@ -39546,7 +40753,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_result') + oprot.writeStructBegin('create_wm_trigger_result') if self.success is not None: oprot.writeFieldBegin('success', TType.STRUCT, 0) self.success.write(oprot) @@ -39559,6 +40766,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() @@ -39571,6 +40786,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): @@ -39584,7 +40801,7 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class get_all_resource_plans_args: +class alter_wm_trigger_args: """ Attributes: - request @@ -39592,7 +40809,7 @@ class get_all_resource_plans_args: thrift_spec = ( None, # 0 - (1, TType.STRUCT, 'request', (WMGetAllResourcePlanRequest, WMGetAllResourcePlanRequest.thrift_spec), None, ), # 1 + (1, TType.STRUCT, 'request', (WMAlterTriggerRequest, WMAlterTriggerRequest.thrift_spec), None, ), # 1 ) def __init__(self, request=None,): @@ -39609,7 +40826,7 @@ def read(self, iprot): break if fid == 1: if ftype == TType.STRUCT: - self.request = WMGetAllResourcePlanRequest() + self.request = WMAlterTriggerRequest() self.request.read(iprot) else: iprot.skip(ftype) @@ -39622,7 +40839,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_args') + oprot.writeStructBegin('alter_wm_trigger_args') if self.request is not None: oprot.writeFieldBegin('request', TType.STRUCT, 1) self.request.write(oprot) @@ -39650,21 +40867,27 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class get_all_resource_plans_result: +class alter_wm_trigger_result: """ Attributes: - success - o1 + - o2 + - o3 """ thrift_spec = ( - (0, TType.STRUCT, 'success', (WMGetAllResourcePlanResponse, WMGetAllResourcePlanResponse.thrift_spec), None, ), # 0 - (1, TType.STRUCT, 'o1', (MetaException, MetaException.thrift_spec), None, ), # 1 + (0, TType.STRUCT, 'success', (WMAlterTriggerResponse, WMAlterTriggerResponse.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 ) - def __init__(self, success=None, o1=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: @@ -39677,16 +40900,28 @@ def read(self, iprot): break if fid == 0: if ftype == TType.STRUCT: - self.success = WMGetAllResourcePlanResponse() + self.success = WMAlterTriggerResponse() self.success.read(iprot) else: iprot.skip(ftype) elif fid == 1: if ftype == TType.STRUCT: - self.o1 = MetaException() + self.o1 = NoSuchObjectException() 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() @@ -39696,7 +40931,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('alter_wm_trigger_result') if self.success is not None: oprot.writeFieldBegin('success', TType.STRUCT, 0) self.success.write(oprot) @@ -39705,6 +40940,14 @@ 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() oprot.writeFieldStop() oprot.writeStructEnd() @@ -39716,6 +40959,8 @@ 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): @@ -39729,7 +40974,7 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class alter_resource_plan_args: +class drop_wm_trigger_args: """ Attributes: - request @@ -39737,7 +40982,7 @@ class alter_resource_plan_args: thrift_spec = ( None, # 0 - (1, TType.STRUCT, 'request', (WMAlterResourcePlanRequest, WMAlterResourcePlanRequest.thrift_spec), None, ), # 1 + (1, TType.STRUCT, 'request', (WMDropTriggerRequest, WMDropTriggerRequest.thrift_spec), None, ), # 1 ) def __init__(self, request=None,): @@ -39754,7 +40999,7 @@ def read(self, iprot): break if fid == 1: if ftype == TType.STRUCT: - self.request = WMAlterResourcePlanRequest() + self.request = WMDropTriggerRequest() self.request.read(iprot) else: iprot.skip(ftype) @@ -39767,7 +41012,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('drop_wm_trigger_args') if self.request is not None: oprot.writeFieldBegin('request', TType.STRUCT, 1) self.request.write(oprot) @@ -39795,7 +41040,7 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class alter_resource_plan_result: +class drop_wm_trigger_result: """ Attributes: - success @@ -39805,7 +41050,7 @@ class alter_resource_plan_result: """ thrift_spec = ( - (0, TType.STRUCT, 'success', (WMAlterResourcePlanResponse, WMAlterResourcePlanResponse.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', (InvalidOperationException, InvalidOperationException.thrift_spec), None, ), # 2 (3, TType.STRUCT, 'o3', (MetaException, MetaException.thrift_spec), None, ), # 3 @@ -39828,7 +41073,7 @@ def read(self, iprot): break if fid == 0: if ftype == TType.STRUCT: - self.success = WMAlterResourcePlanResponse() + self.success = WMDropTriggerResponse() self.success.read(iprot) else: iprot.skip(ftype) @@ -39859,7 +41104,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('drop_wm_trigger_result') if self.success is not None: oprot.writeFieldBegin('success', TType.STRUCT, 0) self.success.write(oprot) @@ -39902,7 +41147,7 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class validate_resource_plan_args: +class get_triggers_for_resourceplan_args: """ Attributes: - request @@ -39910,7 +41155,7 @@ class validate_resource_plan_args: thrift_spec = ( None, # 0 - (1, TType.STRUCT, 'request', (WMValidateResourcePlanRequest, WMValidateResourcePlanRequest.thrift_spec), None, ), # 1 + (1, TType.STRUCT, 'request', (WMGetTriggersForResourePlanRequest, WMGetTriggersForResourePlanRequest.thrift_spec), None, ), # 1 ) def __init__(self, request=None,): @@ -39927,7 +41172,7 @@ def read(self, iprot): break if fid == 1: if ftype == TType.STRUCT: - self.request = WMValidateResourcePlanRequest() + self.request = WMGetTriggersForResourePlanRequest() self.request.read(iprot) else: iprot.skip(ftype) @@ -39940,7 +41185,166 @@ 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('get_triggers_for_resourceplan_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_triggers_for_resourceplan_result: + """ + Attributes: + - success + - o1 + - o2 + """ + + thrift_spec = ( + (0, TType.STRUCT, 'success', (WMGetTriggersForResourePlanResponse, WMGetTriggersForResourePlanResponse.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 = WMGetTriggersForResourePlanResponse() + 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_triggers_for_resourceplan_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 create_or_update_wm_pool_args: + """ + Attributes: + - request + """ + + thrift_spec = ( + None, # 0 + (1, TType.STRUCT, 'request', (WMCreateOrUpdatePoolRequest, WMCreateOrUpdatePoolRequest.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 = WMCreateOrUpdatePoolRequest() + 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('create_or_update_wm_pool_args') if self.request is not None: oprot.writeFieldBegin('request', TType.STRUCT, 1) self.request.write(oprot) @@ -39968,24 +41372,30 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class validate_resource_plan_result: +class create_or_update_wm_pool_result: """ Attributes: - success - o1 - o2 + - o3 + - o4 """ 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 + (0, TType.STRUCT, 'success', (WMCreateOrUpdatePoolResponse, WMCreateOrUpdatePoolResponse.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: @@ -39998,22 +41408,34 @@ def read(self, iprot): break if fid == 0: if ftype == TType.STRUCT: - self.success = WMValidateResourcePlanResponse() + self.success = WMCreateOrUpdatePoolResponse() 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) + 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 = MetaException() + self.o4.read(iprot) + else: + iprot.skip(ftype) else: iprot.skip(ftype) iprot.readFieldEnd() @@ -40023,7 +41445,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('create_or_update_wm_pool_result') if self.success is not None: oprot.writeFieldBegin('success', TType.STRUCT, 0) self.success.write(oprot) @@ -40036,6 +41458,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() @@ -40048,6 +41478,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): @@ -40061,7 +41493,7 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class drop_resource_plan_args: +class drop_wm_pool_args: """ Attributes: - request @@ -40069,7 +41501,7 @@ class drop_resource_plan_args: thrift_spec = ( None, # 0 - (1, TType.STRUCT, 'request', (WMDropResourcePlanRequest, WMDropResourcePlanRequest.thrift_spec), None, ), # 1 + (1, TType.STRUCT, 'request', (WMDropPoolRequest, WMDropPoolRequest.thrift_spec), None, ), # 1 ) def __init__(self, request=None,): @@ -40086,7 +41518,7 @@ def read(self, iprot): break if fid == 1: if ftype == TType.STRUCT: - self.request = WMDropResourcePlanRequest() + self.request = WMDropPoolRequest() self.request.read(iprot) else: iprot.skip(ftype) @@ -40099,7 +41531,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('drop_wm_pool_args') if self.request is not None: oprot.writeFieldBegin('request', TType.STRUCT, 1) self.request.write(oprot) @@ -40127,7 +41559,7 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class drop_resource_plan_result: +class drop_wm_pool_result: """ Attributes: - success @@ -40137,7 +41569,7 @@ class drop_resource_plan_result: """ thrift_spec = ( - (0, TType.STRUCT, 'success', (WMDropResourcePlanResponse, WMDropResourcePlanResponse.thrift_spec), None, ), # 0 + (0, TType.STRUCT, 'success', (WMDropPoolResponse, WMDropPoolResponse.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 @@ -40160,7 +41592,7 @@ def read(self, iprot): break if fid == 0: if ftype == TType.STRUCT: - self.success = WMDropResourcePlanResponse() + self.success = WMDropPoolResponse() self.success.read(iprot) else: iprot.skip(ftype) @@ -40191,7 +41623,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('drop_wm_pool_result') if self.success is not None: oprot.writeFieldBegin('success', TType.STRUCT, 0) self.success.write(oprot) @@ -40234,7 +41666,7 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class create_wm_trigger_args: +class create_or_update_wm_mapping_args: """ Attributes: - request @@ -40242,7 +41674,7 @@ class create_wm_trigger_args: thrift_spec = ( None, # 0 - (1, TType.STRUCT, 'request', (WMCreateTriggerRequest, WMCreateTriggerRequest.thrift_spec), None, ), # 1 + (1, TType.STRUCT, 'request', (WMCreateOrUpdateMappingRequest, WMCreateOrUpdateMappingRequest.thrift_spec), None, ), # 1 ) def __init__(self, request=None,): @@ -40259,7 +41691,7 @@ def read(self, iprot): break if fid == 1: if ftype == TType.STRUCT: - self.request = WMCreateTriggerRequest() + self.request = WMCreateOrUpdateMappingRequest() self.request.read(iprot) else: iprot.skip(ftype) @@ -40272,7 +41704,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_wm_trigger_args') + oprot.writeStructBegin('create_or_update_wm_mapping_args') if self.request is not None: oprot.writeFieldBegin('request', TType.STRUCT, 1) self.request.write(oprot) @@ -40300,7 +41732,7 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class create_wm_trigger_result: +class create_or_update_wm_mapping_result: """ Attributes: - success @@ -40311,7 +41743,7 @@ class create_wm_trigger_result: """ thrift_spec = ( - (0, TType.STRUCT, 'success', (WMCreateTriggerResponse, WMCreateTriggerResponse.thrift_spec), None, ), # 0 + (0, TType.STRUCT, 'success', (WMCreateOrUpdateMappingResponse, WMCreateOrUpdateMappingResponse.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 @@ -40336,7 +41768,7 @@ def read(self, iprot): break if fid == 0: if ftype == TType.STRUCT: - self.success = WMCreateTriggerResponse() + self.success = WMCreateOrUpdateMappingResponse() self.success.read(iprot) else: iprot.skip(ftype) @@ -40373,7 +41805,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_wm_trigger_result') + oprot.writeStructBegin('create_or_update_wm_mapping_result') if self.success is not None: oprot.writeFieldBegin('success', TType.STRUCT, 0) self.success.write(oprot) @@ -40421,7 +41853,7 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class alter_wm_trigger_args: +class drop_wm_mapping_args: """ Attributes: - request @@ -40429,7 +41861,7 @@ class alter_wm_trigger_args: thrift_spec = ( None, # 0 - (1, TType.STRUCT, 'request', (WMAlterTriggerRequest, WMAlterTriggerRequest.thrift_spec), None, ), # 1 + (1, TType.STRUCT, 'request', (WMDropMappingRequest, WMDropMappingRequest.thrift_spec), None, ), # 1 ) def __init__(self, request=None,): @@ -40446,7 +41878,7 @@ def read(self, iprot): break if fid == 1: if ftype == TType.STRUCT: - self.request = WMAlterTriggerRequest() + self.request = WMDropMappingRequest() self.request.read(iprot) else: iprot.skip(ftype) @@ -40459,7 +41891,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_wm_trigger_args') + oprot.writeStructBegin('drop_wm_mapping_args') if self.request is not None: oprot.writeFieldBegin('request', TType.STRUCT, 1) self.request.write(oprot) @@ -40487,7 +41919,7 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class alter_wm_trigger_result: +class drop_wm_mapping_result: """ Attributes: - success @@ -40497,9 +41929,9 @@ class alter_wm_trigger_result: """ thrift_spec = ( - (0, TType.STRUCT, 'success', (WMAlterTriggerResponse, WMAlterTriggerResponse.thrift_spec), None, ), # 0 + (0, TType.STRUCT, 'success', (WMDropMappingResponse, WMDropMappingResponse.thrift_spec), None, ), # 0 (1, TType.STRUCT, 'o1', (NoSuchObjectException, NoSuchObjectException.thrift_spec), None, ), # 1 - (2, TType.STRUCT, 'o2', (InvalidObjectException, InvalidObjectException.thrift_spec), None, ), # 2 + (2, TType.STRUCT, 'o2', (InvalidOperationException, InvalidOperationException.thrift_spec), None, ), # 2 (3, TType.STRUCT, 'o3', (MetaException, MetaException.thrift_spec), None, ), # 3 ) @@ -40520,7 +41952,7 @@ def read(self, iprot): break if fid == 0: if ftype == TType.STRUCT: - self.success = WMAlterTriggerResponse() + self.success = WMDropMappingResponse() self.success.read(iprot) else: iprot.skip(ftype) @@ -40532,7 +41964,7 @@ def read(self, iprot): iprot.skip(ftype) elif fid == 2: if ftype == TType.STRUCT: - self.o2 = InvalidObjectException() + self.o2 = InvalidOperationException() self.o2.read(iprot) else: iprot.skip(ftype) @@ -40551,7 +41983,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_wm_trigger_result') + oprot.writeStructBegin('drop_wm_mapping_result') if self.success is not None: oprot.writeFieldBegin('success', TType.STRUCT, 0) self.success.write(oprot) @@ -40594,7 +42026,7 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class drop_wm_trigger_args: +class create_or_drop_wm_trigger_to_pool_mapping_args: """ Attributes: - request @@ -40602,7 +42034,7 @@ class drop_wm_trigger_args: thrift_spec = ( None, # 0 - (1, TType.STRUCT, 'request', (WMDropTriggerRequest, WMDropTriggerRequest.thrift_spec), None, ), # 1 + (1, TType.STRUCT, 'request', (WMCreateOrDropTriggerToPoolMappingRequest, WMCreateOrDropTriggerToPoolMappingRequest.thrift_spec), None, ), # 1 ) def __init__(self, request=None,): @@ -40619,7 +42051,7 @@ def read(self, iprot): break if fid == 1: if ftype == TType.STRUCT: - self.request = WMDropTriggerRequest() + self.request = WMCreateOrDropTriggerToPoolMappingRequest() self.request.read(iprot) else: iprot.skip(ftype) @@ -40632,7 +42064,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_wm_trigger_args') + oprot.writeStructBegin('create_or_drop_wm_trigger_to_pool_mapping_args') if self.request is not None: oprot.writeFieldBegin('request', TType.STRUCT, 1) self.request.write(oprot) @@ -40660,27 +42092,30 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class drop_wm_trigger_result: +class create_or_drop_wm_trigger_to_pool_mapping_result: """ Attributes: - success - o1 - o2 - o3 + - o4 """ thrift_spec = ( - (0, TType.STRUCT, 'success', (WMDropTriggerResponse, WMDropTriggerResponse.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 + (0, TType.STRUCT, 'success', (WMCreateOrDropTriggerToPoolMappingResponse, WMCreateOrDropTriggerToPoolMappingResponse.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, o3=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: @@ -40693,28 +42128,34 @@ def read(self, iprot): break if fid == 0: if ftype == TType.STRUCT: - self.success = WMDropTriggerResponse() + self.success = WMCreateOrDropTriggerToPoolMappingResponse() 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 = InvalidOperationException() + self.o2 = NoSuchObjectException() self.o2.read(iprot) else: iprot.skip(ftype) elif fid == 3: if ftype == TType.STRUCT: - self.o3 = MetaException() + self.o3 = InvalidObjectException() self.o3.read(iprot) else: iprot.skip(ftype) + elif fid == 4: + if ftype == TType.STRUCT: + self.o4 = MetaException() + self.o4.read(iprot) + else: + iprot.skip(ftype) else: iprot.skip(ftype) iprot.readFieldEnd() @@ -40724,7 +42165,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_wm_trigger_result') + oprot.writeStructBegin('create_or_drop_wm_trigger_to_pool_mapping_result') if self.success is not None: oprot.writeFieldBegin('success', TType.STRUCT, 0) self.success.write(oprot) @@ -40741,165 +42182,9 @@ def write(self, oprot): 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_triggers_for_resourceplan_args: - """ - Attributes: - - request - """ - - thrift_spec = ( - None, # 0 - (1, TType.STRUCT, 'request', (WMGetTriggersForResourePlanRequest, WMGetTriggersForResourePlanRequest.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 = WMGetTriggersForResourePlanRequest() - 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_triggers_for_resourceplan_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_triggers_for_resourceplan_result: - """ - Attributes: - - success - - o1 - - o2 - """ - - thrift_spec = ( - (0, TType.STRUCT, 'success', (WMGetTriggersForResourePlanResponse, WMGetTriggersForResourePlanResponse.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 = WMGetTriggersForResourePlanResponse() - 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_triggers_for_resourceplan_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) + if self.o4 is not None: + oprot.writeFieldBegin('o4', TType.STRUCT, 4) + self.o4.write(oprot) oprot.writeFieldEnd() oprot.writeFieldStop() oprot.writeStructEnd() @@ -40913,6 +42198,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): 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 b97b78ae0c..1e3cc316dd 100644 --- standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py +++ standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py @@ -14519,8 +14519,7 @@ class WMPool: """ Attributes: - resourcePlanName - - poolName - - parentPoolName + - path - allocFraction - queryParallelism - schedulingPolicy @@ -14529,17 +14528,15 @@ class WMPool: thrift_spec = ( None, # 0 (1, TType.STRING, 'resourcePlanName', None, None, ), # 1 - (2, TType.STRING, 'poolName', None, None, ), # 2 - (3, TType.STRING, 'parentPoolName', None, None, ), # 3 - (4, TType.DOUBLE, 'allocFraction', None, None, ), # 4 - (5, TType.I32, 'queryParallelism', None, None, ), # 5 - (6, TType.STRING, 'schedulingPolicy', None, None, ), # 6 + (2, TType.STRING, 'path', None, None, ), # 2 + (3, TType.DOUBLE, 'allocFraction', None, None, ), # 3 + (4, TType.I32, 'queryParallelism', None, None, ), # 4 + (5, TType.STRING, 'schedulingPolicy', None, None, ), # 5 ) - def __init__(self, resourcePlanName=None, poolName=None, parentPoolName=None, allocFraction=None, queryParallelism=None, schedulingPolicy=None,): + def __init__(self, resourcePlanName=None, path=None, allocFraction=None, queryParallelism=None, schedulingPolicy=None,): self.resourcePlanName = resourcePlanName - self.poolName = poolName - self.parentPoolName = parentPoolName + self.path = path self.allocFraction = allocFraction self.queryParallelism = queryParallelism self.schedulingPolicy = schedulingPolicy @@ -14560,25 +14557,20 @@ def read(self, iprot): iprot.skip(ftype) elif fid == 2: if ftype == TType.STRING: - self.poolName = iprot.readString() + self.path = iprot.readString() else: iprot.skip(ftype) elif fid == 3: - if ftype == TType.STRING: - self.parentPoolName = iprot.readString() - else: - iprot.skip(ftype) - elif fid == 4: if ftype == TType.DOUBLE: self.allocFraction = iprot.readDouble() else: iprot.skip(ftype) - elif fid == 5: + elif fid == 4: if ftype == TType.I32: self.queryParallelism = iprot.readI32() else: iprot.skip(ftype) - elif fid == 6: + elif fid == 5: if ftype == TType.STRING: self.schedulingPolicy = iprot.readString() else: @@ -14597,24 +14589,20 @@ 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) - oprot.writeFieldEnd() - if self.parentPoolName is not None: - oprot.writeFieldBegin('parentPoolName', TType.STRING, 3) - oprot.writeString(self.parentPoolName) + if self.path is not None: + oprot.writeFieldBegin('path', TType.STRING, 2) + oprot.writeString(self.path) oprot.writeFieldEnd() if self.allocFraction is not None: - oprot.writeFieldBegin('allocFraction', TType.DOUBLE, 4) + oprot.writeFieldBegin('allocFraction', TType.DOUBLE, 3) oprot.writeDouble(self.allocFraction) oprot.writeFieldEnd() if self.queryParallelism is not None: - oprot.writeFieldBegin('queryParallelism', TType.I32, 5) + oprot.writeFieldBegin('queryParallelism', TType.I32, 4) oprot.writeI32(self.queryParallelism) oprot.writeFieldEnd() if self.schedulingPolicy is not None: - oprot.writeFieldBegin('schedulingPolicy', TType.STRING, 6) + oprot.writeFieldBegin('schedulingPolicy', TType.STRING, 5) oprot.writeString(self.schedulingPolicy) oprot.writeFieldEnd() oprot.writeFieldStop() @@ -14623,16 +14611,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.path is None: + raise TProtocol.TProtocolException(message='Required field path 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.parentPoolName) + value = (value * 31) ^ hash(self.path) value = (value * 31) ^ hash(self.allocFraction) value = (value * 31) ^ hash(self.queryParallelism) value = (value * 31) ^ hash(self.schedulingPolicy) @@ -14763,7 +14750,7 @@ class WMMapping: - resourcePlanName - entityType - entityName - - poolName + - poolPath - ordering """ @@ -14772,15 +14759,15 @@ class WMMapping: (1, TType.STRING, 'resourcePlanName', None, None, ), # 1 (2, TType.STRING, 'entityType', None, None, ), # 2 (3, TType.STRING, 'entityName', None, None, ), # 3 - (4, TType.STRING, 'poolName', None, None, ), # 4 + (4, TType.STRING, 'poolPath', None, None, ), # 4 (5, TType.I32, 'ordering', None, None, ), # 5 ) - def __init__(self, resourcePlanName=None, entityType=None, entityName=None, poolName=None, ordering=None,): + def __init__(self, resourcePlanName=None, entityType=None, entityName=None, poolPath=None, ordering=None,): self.resourcePlanName = resourcePlanName self.entityType = entityType self.entityName = entityName - self.poolName = poolName + self.poolPath = poolPath self.ordering = ordering def read(self, iprot): @@ -14809,7 +14796,7 @@ def read(self, iprot): iprot.skip(ftype) elif fid == 4: if ftype == TType.STRING: - self.poolName = iprot.readString() + self.poolPath = iprot.readString() else: iprot.skip(ftype) elif fid == 5: @@ -14839,9 +14826,9 @@ def write(self, oprot): oprot.writeFieldBegin('entityName', TType.STRING, 3) oprot.writeString(self.entityName) oprot.writeFieldEnd() - if self.poolName is not None: - oprot.writeFieldBegin('poolName', TType.STRING, 4) - oprot.writeString(self.poolName) + if self.poolPath is not None: + oprot.writeFieldBegin('poolPath', TType.STRING, 4) + oprot.writeString(self.poolPath) oprot.writeFieldEnd() if self.ordering is not None: oprot.writeFieldBegin('ordering', TType.I32, 5) @@ -14865,7 +14852,7 @@ def __hash__(self): value = (value * 31) ^ hash(self.resourcePlanName) value = (value * 31) ^ hash(self.entityType) value = (value * 31) ^ hash(self.entityName) - value = (value * 31) ^ hash(self.poolName) + value = (value * 31) ^ hash(self.poolPath) value = (value * 31) ^ hash(self.ordering) return value @@ -16096,6 +16083,655 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) +class WMCreateOrUpdatePoolRequest: + """ + Attributes: + - pool + - newPoolPath + - update + """ + + thrift_spec = ( + None, # 0 + (1, TType.STRUCT, 'pool', (WMPool, WMPool.thrift_spec), None, ), # 1 + (2, TType.STRING, 'newPoolPath', None, None, ), # 2 + (3, TType.BOOL, 'update', None, None, ), # 3 + ) + + def __init__(self, pool=None, newPoolPath=None, update=None,): + self.pool = pool + self.newPoolPath = newPoolPath + self.update = update + + 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.pool = WMPool() + self.pool.read(iprot) + else: + iprot.skip(ftype) + elif fid == 2: + if ftype == TType.STRING: + self.newPoolPath = iprot.readString() + else: + iprot.skip(ftype) + elif fid == 3: + if ftype == TType.BOOL: + self.update = iprot.readBool() + else: + iprot.skip(ftype) + else: + iprot.skip(ftype) + iprot.readFieldEnd() + iprot.readStructEnd() + + def write(self, oprot): + if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: + oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) + return + oprot.writeStructBegin('WMCreateOrUpdatePoolRequest') + if self.pool is not None: + oprot.writeFieldBegin('pool', TType.STRUCT, 1) + self.pool.write(oprot) + oprot.writeFieldEnd() + if self.newPoolPath is not None: + oprot.writeFieldBegin('newPoolPath', TType.STRING, 2) + oprot.writeString(self.newPoolPath) + oprot.writeFieldEnd() + if self.update is not None: + oprot.writeFieldBegin('update', TType.BOOL, 3) + oprot.writeBool(self.update) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.pool) + value = (value * 31) ^ hash(self.newPoolPath) + value = (value * 31) ^ hash(self.update) + 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 WMCreateOrUpdatePoolResponse: + + 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('WMCreateOrUpdatePoolResponse') + 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 WMDropPoolRequest: + """ + Attributes: + - resourcePlanName + - poolPath + """ + + thrift_spec = ( + None, # 0 + (1, TType.STRING, 'resourcePlanName', None, None, ), # 1 + (2, TType.STRING, 'poolPath', None, None, ), # 2 + ) + + def __init__(self, resourcePlanName=None, poolPath=None,): + self.resourcePlanName = resourcePlanName + self.poolPath = poolPath + + 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.poolPath = 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('WMDropPoolRequest') + if self.resourcePlanName is not None: + oprot.writeFieldBegin('resourcePlanName', TType.STRING, 1) + oprot.writeString(self.resourcePlanName) + oprot.writeFieldEnd() + if self.poolPath is not None: + oprot.writeFieldBegin('poolPath', TType.STRING, 2) + oprot.writeString(self.poolPath) + 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.poolPath) + 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 WMDropPoolResponse: + + 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('WMDropPoolResponse') + 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 WMCreateOrUpdateMappingRequest: + """ + Attributes: + - mapping + - update + """ + + thrift_spec = ( + None, # 0 + (1, TType.STRUCT, 'mapping', (WMMapping, WMMapping.thrift_spec), None, ), # 1 + (2, TType.BOOL, 'update', None, None, ), # 2 + ) + + def __init__(self, mapping=None, update=None,): + self.mapping = mapping + self.update = update + + 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.mapping = WMMapping() + self.mapping.read(iprot) + else: + iprot.skip(ftype) + elif fid == 2: + if ftype == TType.BOOL: + self.update = iprot.readBool() + else: + iprot.skip(ftype) + else: + iprot.skip(ftype) + iprot.readFieldEnd() + iprot.readStructEnd() + + def write(self, oprot): + if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: + oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) + return + oprot.writeStructBegin('WMCreateOrUpdateMappingRequest') + if self.mapping is not None: + oprot.writeFieldBegin('mapping', TType.STRUCT, 1) + self.mapping.write(oprot) + oprot.writeFieldEnd() + if self.update is not None: + oprot.writeFieldBegin('update', TType.BOOL, 2) + oprot.writeBool(self.update) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.mapping) + value = (value * 31) ^ hash(self.update) + 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 WMCreateOrUpdateMappingResponse: + + 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('WMCreateOrUpdateMappingResponse') + 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 WMDropMappingRequest: + """ + Attributes: + - mapping + """ + + thrift_spec = ( + None, # 0 + (1, TType.STRUCT, 'mapping', (WMMapping, WMMapping.thrift_spec), None, ), # 1 + ) + + def __init__(self, mapping=None,): + self.mapping = mapping + + 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.mapping = WMMapping() + self.mapping.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('WMDropMappingRequest') + if self.mapping is not None: + oprot.writeFieldBegin('mapping', TType.STRUCT, 1) + self.mapping.write(oprot) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.mapping) + 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 WMDropMappingResponse: + + 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('WMDropMappingResponse') + 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 WMCreateOrDropTriggerToPoolMappingRequest: + """ + Attributes: + - resourcePlanName + - triggerName + - poolPath + - drop + """ + + thrift_spec = ( + None, # 0 + (1, TType.STRING, 'resourcePlanName', None, None, ), # 1 + (2, TType.STRING, 'triggerName', None, None, ), # 2 + (3, TType.STRING, 'poolPath', None, None, ), # 3 + (4, TType.BOOL, 'drop', None, None, ), # 4 + ) + + def __init__(self, resourcePlanName=None, triggerName=None, poolPath=None, drop=None,): + self.resourcePlanName = resourcePlanName + self.triggerName = triggerName + self.poolPath = poolPath + self.drop = drop + + 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) + elif fid == 3: + if ftype == TType.STRING: + self.poolPath = iprot.readString() + else: + iprot.skip(ftype) + elif fid == 4: + if ftype == TType.BOOL: + self.drop = iprot.readBool() + else: + iprot.skip(ftype) + else: + iprot.skip(ftype) + iprot.readFieldEnd() + iprot.readStructEnd() + + def write(self, oprot): + if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: + oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) + return + oprot.writeStructBegin('WMCreateOrDropTriggerToPoolMappingRequest') + 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() + if self.poolPath is not None: + oprot.writeFieldBegin('poolPath', TType.STRING, 3) + oprot.writeString(self.poolPath) + oprot.writeFieldEnd() + if self.drop is not None: + oprot.writeFieldBegin('drop', TType.BOOL, 4) + oprot.writeBool(self.drop) + 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) + value = (value * 31) ^ hash(self.poolPath) + value = (value * 31) ^ hash(self.drop) + 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 WMCreateOrDropTriggerToPoolMappingResponse: + + 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('WMCreateOrDropTriggerToPoolMappingResponse') + 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 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 31516d6f5d..a4b55baf6c 100644 --- standalone-metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb +++ standalone-metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb @@ -3280,16 +3280,14 @@ end class WMPool include ::Thrift::Struct, ::Thrift::Struct_Union RESOURCEPLANNAME = 1 - POOLNAME = 2 - PARENTPOOLNAME = 3 - ALLOCFRACTION = 4 - QUERYPARALLELISM = 5 - SCHEDULINGPOLICY = 6 + PATH = 2 + ALLOCFRACTION = 3 + QUERYPARALLELISM = 4 + SCHEDULINGPOLICY = 5 FIELDS = { RESOURCEPLANNAME => {:type => ::Thrift::Types::STRING, :name => 'resourcePlanName'}, - POOLNAME => {:type => ::Thrift::Types::STRING, :name => 'poolName'}, - PARENTPOOLNAME => {:type => ::Thrift::Types::STRING, :name => 'parentPoolName', :optional => true}, + PATH => {:type => ::Thrift::Types::STRING, :name => 'path'}, ALLOCFRACTION => {:type => ::Thrift::Types::DOUBLE, :name => 'allocFraction', :optional => true}, QUERYPARALLELISM => {:type => ::Thrift::Types::I32, :name => 'queryParallelism', :optional => true}, SCHEDULINGPOLICY => {:type => ::Thrift::Types::STRING, :name => 'schedulingPolicy', :optional => true} @@ -3299,7 +3297,7 @@ class WMPool 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 path is unset!') unless @path end ::Thrift::Struct.generate_accessors self @@ -3334,14 +3332,14 @@ class WMMapping RESOURCEPLANNAME = 1 ENTITYTYPE = 2 ENTITYNAME = 3 - POOLNAME = 4 + POOLPATH = 4 ORDERING = 5 FIELDS = { RESOURCEPLANNAME => {:type => ::Thrift::Types::STRING, :name => 'resourcePlanName'}, ENTITYTYPE => {:type => ::Thrift::Types::STRING, :name => 'entityType'}, ENTITYNAME => {:type => ::Thrift::Types::STRING, :name => 'entityName'}, - POOLNAME => {:type => ::Thrift::Types::STRING, :name => 'poolName', :optional => true}, + POOLPATH => {:type => ::Thrift::Types::STRING, :name => 'poolPath', :optional => true}, ORDERING => {:type => ::Thrift::Types::I32, :name => 'ordering', :optional => true} } @@ -3673,6 +3671,175 @@ class WMGetTriggersForResourePlanResponse ::Thrift::Struct.generate_accessors self end +class WMCreateOrUpdatePoolRequest + include ::Thrift::Struct, ::Thrift::Struct_Union + POOL = 1 + NEWPOOLPATH = 2 + UPDATE = 3 + + FIELDS = { + POOL => {:type => ::Thrift::Types::STRUCT, :name => 'pool', :class => ::WMPool, :optional => true}, + NEWPOOLPATH => {:type => ::Thrift::Types::STRING, :name => 'newPoolPath', :optional => true}, + UPDATE => {:type => ::Thrift::Types::BOOL, :name => 'update', :optional => true} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self +end + +class WMCreateOrUpdatePoolResponse + include ::Thrift::Struct, ::Thrift::Struct_Union + + FIELDS = { + + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self +end + +class WMDropPoolRequest + include ::Thrift::Struct, ::Thrift::Struct_Union + RESOURCEPLANNAME = 1 + POOLPATH = 2 + + FIELDS = { + RESOURCEPLANNAME => {:type => ::Thrift::Types::STRING, :name => 'resourcePlanName', :optional => true}, + POOLPATH => {:type => ::Thrift::Types::STRING, :name => 'poolPath', :optional => true} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self +end + +class WMDropPoolResponse + include ::Thrift::Struct, ::Thrift::Struct_Union + + FIELDS = { + + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self +end + +class WMCreateOrUpdateMappingRequest + include ::Thrift::Struct, ::Thrift::Struct_Union + MAPPING = 1 + UPDATE = 2 + + FIELDS = { + MAPPING => {:type => ::Thrift::Types::STRUCT, :name => 'mapping', :class => ::WMMapping, :optional => true}, + UPDATE => {:type => ::Thrift::Types::BOOL, :name => 'update', :optional => true} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self +end + +class WMCreateOrUpdateMappingResponse + include ::Thrift::Struct, ::Thrift::Struct_Union + + FIELDS = { + + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self +end + +class WMDropMappingRequest + include ::Thrift::Struct, ::Thrift::Struct_Union + MAPPING = 1 + + FIELDS = { + MAPPING => {:type => ::Thrift::Types::STRUCT, :name => 'mapping', :class => ::WMMapping, :optional => true} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self +end + +class WMDropMappingResponse + include ::Thrift::Struct, ::Thrift::Struct_Union + + FIELDS = { + + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self +end + +class WMCreateOrDropTriggerToPoolMappingRequest + include ::Thrift::Struct, ::Thrift::Struct_Union + RESOURCEPLANNAME = 1 + TRIGGERNAME = 2 + POOLPATH = 3 + DROP = 4 + + FIELDS = { + RESOURCEPLANNAME => {:type => ::Thrift::Types::STRING, :name => 'resourcePlanName', :optional => true}, + TRIGGERNAME => {:type => ::Thrift::Types::STRING, :name => 'triggerName', :optional => true}, + POOLPATH => {:type => ::Thrift::Types::STRING, :name => 'poolPath', :optional => true}, + DROP => {:type => ::Thrift::Types::BOOL, :name => 'drop', :optional => true} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self +end + +class WMCreateOrDropTriggerToPoolMappingResponse + include ::Thrift::Struct, ::Thrift::Struct_Union + + FIELDS = { + + } + + 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 cf4c40c55f..84c5671dff 100644 --- standalone-metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb +++ standalone-metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb @@ -2869,6 +2869,99 @@ module ThriftHiveMetastore raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'get_triggers_for_resourceplan failed: unknown result') end + def create_or_update_wm_pool(request) + send_create_or_update_wm_pool(request) + return recv_create_or_update_wm_pool() + end + + def send_create_or_update_wm_pool(request) + send_message('create_or_update_wm_pool', Create_or_update_wm_pool_args, :request => request) + end + + def recv_create_or_update_wm_pool() + result = receive_message(Create_or_update_wm_pool_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_or_update_wm_pool failed: unknown result') + end + + def drop_wm_pool(request) + send_drop_wm_pool(request) + return recv_drop_wm_pool() + end + + def send_drop_wm_pool(request) + send_message('drop_wm_pool', Drop_wm_pool_args, :request => request) + end + + def recv_drop_wm_pool() + result = receive_message(Drop_wm_pool_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_pool failed: unknown result') + end + + def create_or_update_wm_mapping(request) + send_create_or_update_wm_mapping(request) + return recv_create_or_update_wm_mapping() + end + + def send_create_or_update_wm_mapping(request) + send_message('create_or_update_wm_mapping', Create_or_update_wm_mapping_args, :request => request) + end + + def recv_create_or_update_wm_mapping() + result = receive_message(Create_or_update_wm_mapping_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_or_update_wm_mapping failed: unknown result') + end + + def drop_wm_mapping(request) + send_drop_wm_mapping(request) + return recv_drop_wm_mapping() + end + + def send_drop_wm_mapping(request) + send_message('drop_wm_mapping', Drop_wm_mapping_args, :request => request) + end + + def recv_drop_wm_mapping() + result = receive_message(Drop_wm_mapping_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_mapping failed: unknown result') + end + + def create_or_drop_wm_trigger_to_pool_mapping(request) + send_create_or_drop_wm_trigger_to_pool_mapping(request) + return recv_create_or_drop_wm_trigger_to_pool_mapping() + end + + def send_create_or_drop_wm_trigger_to_pool_mapping(request) + send_message('create_or_drop_wm_trigger_to_pool_mapping', Create_or_drop_wm_trigger_to_pool_mapping_args, :request => request) + end + + def recv_create_or_drop_wm_trigger_to_pool_mapping() + result = receive_message(Create_or_drop_wm_trigger_to_pool_mapping_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_or_drop_wm_trigger_to_pool_mapping failed: unknown result') + end + end class Processor < ::FacebookService::Processor @@ -5002,6 +5095,87 @@ module ThriftHiveMetastore write_result(result, oprot, 'get_triggers_for_resourceplan', seqid) end + def process_create_or_update_wm_pool(seqid, iprot, oprot) + args = read_args(iprot, Create_or_update_wm_pool_args) + result = Create_or_update_wm_pool_result.new() + begin + result.success = @handler.create_or_update_wm_pool(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_or_update_wm_pool', seqid) + end + + def process_drop_wm_pool(seqid, iprot, oprot) + args = read_args(iprot, Drop_wm_pool_args) + result = Drop_wm_pool_result.new() + begin + result.success = @handler.drop_wm_pool(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_pool', seqid) + end + + def process_create_or_update_wm_mapping(seqid, iprot, oprot) + args = read_args(iprot, Create_or_update_wm_mapping_args) + result = Create_or_update_wm_mapping_result.new() + begin + result.success = @handler.create_or_update_wm_mapping(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_or_update_wm_mapping', seqid) + end + + def process_drop_wm_mapping(seqid, iprot, oprot) + args = read_args(iprot, Drop_wm_mapping_args) + result = Drop_wm_mapping_result.new() + begin + result.success = @handler.drop_wm_mapping(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_mapping', seqid) + end + + def process_create_or_drop_wm_trigger_to_pool_mapping(seqid, iprot, oprot) + args = read_args(iprot, Create_or_drop_wm_trigger_to_pool_mapping_args) + result = Create_or_drop_wm_trigger_to_pool_mapping_result.new() + begin + result.success = @handler.create_or_drop_wm_trigger_to_pool_mapping(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_or_drop_wm_trigger_to_pool_mapping', seqid) + end + end # HELPER FUNCTIONS AND STRUCTURES @@ -11429,5 +11603,201 @@ module ThriftHiveMetastore ::Thrift::Struct.generate_accessors self end + class Create_or_update_wm_pool_args + include ::Thrift::Struct, ::Thrift::Struct_Union + REQUEST = 1 + + FIELDS = { + REQUEST => {:type => ::Thrift::Types::STRUCT, :name => 'request', :class => ::WMCreateOrUpdatePoolRequest} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Create_or_update_wm_pool_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 => ::WMCreateOrUpdatePoolResponse}, + 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 Drop_wm_pool_args + include ::Thrift::Struct, ::Thrift::Struct_Union + REQUEST = 1 + + FIELDS = { + REQUEST => {:type => ::Thrift::Types::STRUCT, :name => 'request', :class => ::WMDropPoolRequest} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Drop_wm_pool_result + include ::Thrift::Struct, ::Thrift::Struct_Union + SUCCESS = 0 + O1 = 1 + O2 = 2 + O3 = 3 + + FIELDS = { + SUCCESS => {:type => ::Thrift::Types::STRUCT, :name => 'success', :class => ::WMDropPoolResponse}, + 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 Create_or_update_wm_mapping_args + include ::Thrift::Struct, ::Thrift::Struct_Union + REQUEST = 1 + + FIELDS = { + REQUEST => {:type => ::Thrift::Types::STRUCT, :name => 'request', :class => ::WMCreateOrUpdateMappingRequest} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Create_or_update_wm_mapping_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 => ::WMCreateOrUpdateMappingResponse}, + 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 Drop_wm_mapping_args + include ::Thrift::Struct, ::Thrift::Struct_Union + REQUEST = 1 + + FIELDS = { + REQUEST => {:type => ::Thrift::Types::STRUCT, :name => 'request', :class => ::WMDropMappingRequest} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Drop_wm_mapping_result + include ::Thrift::Struct, ::Thrift::Struct_Union + SUCCESS = 0 + O1 = 1 + O2 = 2 + O3 = 3 + + FIELDS = { + SUCCESS => {:type => ::Thrift::Types::STRUCT, :name => 'success', :class => ::WMDropMappingResponse}, + 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 Create_or_drop_wm_trigger_to_pool_mapping_args + include ::Thrift::Struct, ::Thrift::Struct_Union + REQUEST = 1 + + FIELDS = { + REQUEST => {:type => ::Thrift::Types::STRUCT, :name => 'request', :class => ::WMCreateOrDropTriggerToPoolMappingRequest} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Create_or_drop_wm_trigger_to_pool_mapping_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 => ::WMCreateOrDropTriggerToPoolMappingResponse}, + 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 + end diff --git standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/MetaStoreDirectSql.java standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/MetaStoreDirectSql.java index fc7235be17..d74ac09a94 100644 --- standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/MetaStoreDirectSql.java +++ standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/MetaStoreDirectSql.java @@ -73,6 +73,7 @@ import org.apache.hadoop.hive.metastore.model.MNotificationNextId; import org.apache.hadoop.hive.metastore.model.MPartitionColumnStatistics; import org.apache.hadoop.hive.metastore.model.MTableColumnStatistics; +import org.apache.hadoop.hive.metastore.model.MWMPool; import org.apache.hadoop.hive.metastore.model.MWMResourcePlan; import org.apache.hadoop.hive.metastore.parser.ExpressionTree; import org.apache.hadoop.hive.metastore.parser.ExpressionTree.FilterBuilder; @@ -226,6 +227,7 @@ private boolean ensureDbInit() { initQueries.add(pm.newQuery(MNotificationLog.class, "dbName == ''")); initQueries.add(pm.newQuery(MNotificationNextId.class, "nextEventId < -1")); initQueries.add(pm.newQuery(MWMResourcePlan.class, "name == ''")); + initQueries.add(pm.newQuery(MWMPool.class, "path == ''")); Query q; while ((q = initQueries.peekFirst()) != null) { q.execute(); 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 62801c5385..3168594d3b 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 @@ -132,6 +132,8 @@ import org.apache.hadoop.hive.metastore.api.UnknownDBException; import org.apache.hadoop.hive.metastore.api.UnknownPartitionException; import org.apache.hadoop.hive.metastore.api.UnknownTableException; +import org.apache.hadoop.hive.metastore.api.WMMapping; +import org.apache.hadoop.hive.metastore.api.WMPool; import org.apache.hadoop.hive.metastore.conf.MetastoreConf; import org.apache.hadoop.hive.metastore.datasource.DataSourceProvider; import org.apache.hadoop.hive.metastore.datasource.DataSourceProviderFactory; @@ -171,6 +173,7 @@ import org.apache.hadoop.hive.metastore.model.MTablePrivilege; import org.apache.hadoop.hive.metastore.model.MType; import org.apache.hadoop.hive.metastore.model.MVersionTable; +import org.apache.hadoop.hive.metastore.model.MWMPool; import org.apache.hadoop.hive.metastore.model.MMetastoreDBProperties; import org.apache.hadoop.hive.metastore.parser.ExpressionTree; import org.apache.hadoop.hive.metastore.parser.ExpressionTree.FilterBuilder; @@ -9659,7 +9662,7 @@ public void dropResourcePlan(String name) throws NoSuchObjectException, MetaExce openTransaction(); query = pm.newQuery(MWMResourcePlan.class, "name == resourcePlanName && status != \"ACTIVE\""); query.declareParameters("java.lang.String resourcePlanName"); - if (query.deletePersistentAll(name) == 0) { + if (query.deletePersistentAll(name) != 1) { throw new NoSuchObjectException("Cannot find resourcePlan: " + name + " or its active"); } commited = commitTransaction(); @@ -9738,7 +9741,7 @@ public void dropWMTrigger(String resourcePlanName, String triggerName) } query = pm.newQuery(MWMTrigger.class, "resourcePlan == rp && name == triggerName"); query.declareParameters("MWMResourcePlan rp, java.lang.String triggerName"); - if (query.deletePersistentAll(resourcePlan, triggerName) == 0) { + if (query.deletePersistentAll(resourcePlan, triggerName) != 1) { throw new NoSuchObjectException("Cannot delete trigger: " + triggerName); } commited = commitTransaction(); @@ -9780,4 +9783,200 @@ private WMTrigger fromMWMTrigger(MWMTrigger mTrigger, String resourcePlanName) { trigger.setActionExpression(mTrigger.getActionExpression()); return trigger; } + + @Override + public void createOrUpdatePool(WMPool pool, String newPoolPath, boolean update) + throws AlreadyExistsException, NoSuchObjectException, InvalidOperationException, + MetaException { + if (!update && newPoolPath != null) { + throw new InvalidOperationException("Unexpected move while creating pool."); + } + boolean commited = false; + Query query = null; + try { + openTransaction(); + MWMResourcePlan resourcePlan = getMWMResourcePlan( + normalizeIdentifier(pool.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(MWMPool.class, "resourcePlan == rp && path == poolPath"); + query.declareParameters("MWMResourcePlan rp, java.lang.String poolPath"); + query.setUnique(true); + MWMPool mPool = (MWMPool) query.execute(resourcePlan, pool.getPath()); + + if (!update) { + if (mPool != null) { + throw new AlreadyExistsException("Pool with path: " + pool.getPath() + + " already exists in resource plan: " + pool.getResourcePlanName()); + } + if (!poolParentExists(resourcePlan, pool.getPath())) { + throw new NoSuchObjectException("Pool path is invalid, the parent does not exist"); + } + mPool = new MWMPool(resourcePlan, pool.getPath(), pool.getAllocFraction(), + pool.getQueryParallelism(), pool.getSchedulingPolicy()); + pm.makePersistent(mPool); + } else { + if (mPool == null) { + throw new NoSuchObjectException("Cannot find pool with path: " + pool.getPath() + + " in resource plan: " + pool.getResourcePlanName()); + } + pm.retrieve(mPool); + if (pool.isSetAllocFraction()) { + mPool.setAllocFraction(pool.getAllocFraction()); + } + if (pool.isSetQueryParallelism()) { + mPool.setQueryParallelism(pool.getQueryParallelism()); + } + if (pool.isSetSchedulingPolicy()) { + mPool.setSchedulingPolicy(pool.getSchedulingPolicy()); + } + if (newPoolPath != null && !pool.getPath().equals(newPoolPath)) { + moveDescendents(resourcePlan, mPool.getPath(), newPoolPath); + mPool.setPath(newPoolPath); + } + } + commited = commitTransaction(); + } finally { + rollbackAndCleanup(commited, query); + } + } + + private MWMPool getPool(MWMResourcePlan resourcePlan, WMPool pool) { + boolean commited = false; + Query query = null; + try { + openTransaction(); + query = pm.newQuery(MWMPool.class, "resourcePlan == rp && path == poolPath"); + query.declareParameters("MWMResourcePlan rp, java.lang.String poolPath"); + query.setUnique(true); + MWMPool mPool = (MWMPool) query.execute(resourcePlan, pool.getPath()); + commited = commitTransaction(); + return mPool; + } finally { + rollbackAndCleanup(commited, query); + } + } + + private void moveDescendents(MWMResourcePlan resourcePlan, String path, String newPoolPath) + throws NoSuchObjectException { + if (!poolParentExists(resourcePlan, newPoolPath)) { + throw new NoSuchObjectException("Pool path is invalid, the parent does not exist"); + } + boolean commited = false; + Query query = null; + openTransaction(); + try { + query = pm.newQuery(MWMPool.class, "resourcePlan == rp && path.startsWith(poolPath)"); + query.declareParameters("MWMResourcePlan rp, java.lang.String poolPath"); + List descPools = (List) query.execute(resourcePlan, path + "."); + pm.retrieveAll(descPools); + for (MWMPool pool : descPools) { + pool.setPath(newPoolPath + pool.getPath().substring(path.length())); + } + commited = commitTransaction(); + } finally { + rollbackAndCleanup(commited, query); + } + } + + private boolean poolParentExists(MWMResourcePlan resourcePlan, String poolPath) { + int idx = poolPath.lastIndexOf('.'); + if (idx == -1) { + return true; + } + String parent = poolPath.substring(0, idx); + boolean commited = false; + Query query = null; + openTransaction(); + try { + query = pm.newQuery(MWMPool.class, "resourcePlan == rp && path == poolPath"); + query.declareParameters("MWMResourcePlan rp, java.lang.String poolPath"); + query.setUnique(true); + MWMPool pool = (MWMPool) query.execute(resourcePlan, parent); + pm.retrieve(pool); + commited = commitTransaction(); + return pool != null; + } finally { + rollbackAndCleanup(commited, query); + } + } + + @Override + public void dropWMPool(String resourcePlanName, String poolPath) + throws NoSuchObjectException, InvalidOperationException, MetaException { + resourcePlanName = normalizeIdentifier(resourcePlanName); + poolPath = normalizeIdentifier(poolPath); + + 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."); + } + if (poolHasChildren(resourcePlan, poolPath)) { + throw new InvalidOperationException("Pool has children cannot drop."); + } + query = pm.newQuery(MWMPool.class, "resourcePlan == rp && path.startsWith(poolPath)"); + query.declareParameters("MWMResourcePlan rp, java.lang.String poolPath"); + query.execute(resourcePlan, poolPath); + if (query.deletePersistentAll(resourcePlan, poolPath) != 1) { + throw new NoSuchObjectException("Cannot delete pool: " + poolPath); + } + commited = commitTransaction(); + } finally { + rollbackAndCleanup(commited, query); + } + } + + private boolean poolHasChildren(MWMResourcePlan resourcePlan, String poolPath) { + boolean commited = false; + Query query = null; + try { + openTransaction(); + query = pm.newQuery(MWMPool.class, "resourcePlan == rp && path.startsWith(poolPath)"); + query.declareParameters("MWMResourcePlan rp, java.lang.String poolPath"); + query.setResult("count(*)"); + query.setUnique(true); + Integer count = (Integer) query.execute(resourcePlan, poolPath + "."); + commited = commitTransaction(); + return count != null && count > 0; + } finally { + rollbackAndCleanup(commited, query); + } + } + + @Override + public void createOrUpdateWMMapping(WMMapping mapping, boolean update) + throws AlreadyExistsException, NoSuchObjectException, InvalidOperationException, + MetaException { + // TODO Auto-generated method stub + + } + + @Override + public void dropWMMapping(WMMapping mapping) + throws NoSuchObjectException, InvalidOperationException, MetaException { + // TODO Auto-generated method stub + + } + + @Override + public void createWMTriggerToPoolMapping(String resourcePlanName, String triggerName, + String poolPath) throws AlreadyExistsException, NoSuchObjectException, + InvalidOperationException, MetaException { + // TODO Auto-generated method stub + + } + + @Override + public void dropWMTriggerToPoolMapping(String resourcePlanName, String triggerName, + String poolPath) throws NoSuchObjectException, InvalidOperationException, MetaException { + // TODO Auto-generated method stub + + } } 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 a99b8e123e..655839c3a2 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 @@ -70,6 +70,8 @@ import org.apache.hadoop.hive.metastore.api.UnknownDBException; import org.apache.hadoop.hive.metastore.api.UnknownPartitionException; import org.apache.hadoop.hive.metastore.api.UnknownTableException; +import org.apache.hadoop.hive.metastore.api.WMMapping; +import org.apache.hadoop.hive.metastore.api.WMPool; import org.apache.hadoop.hive.metastore.partition.spec.PartitionSpecProxy; import org.apache.thrift.TException; @@ -777,4 +779,25 @@ void dropWMTrigger(String resourcePlanName, String triggerName) List getTriggersForResourcePlan(String resourcePlanName) throws NoSuchObjectException, MetaException; + + void createOrUpdatePool(WMPool pool, String newPoolPath, boolean update) + throws AlreadyExistsException, NoSuchObjectException, InvalidOperationException, + MetaException; + + void dropWMPool(String resourcePlanName, String poolPath) + throws NoSuchObjectException, InvalidOperationException, MetaException; + + void createOrUpdateWMMapping(WMMapping mapping, boolean update) + throws AlreadyExistsException, NoSuchObjectException, InvalidOperationException, + MetaException; + + void dropWMMapping(WMMapping mapping) + throws NoSuchObjectException, InvalidOperationException, MetaException; + + void createWMTriggerToPoolMapping(String resourcePlanName, String triggerName, String poolPath) + throws AlreadyExistsException, NoSuchObjectException, InvalidOperationException, + MetaException; + + void dropWMTriggerToPoolMapping(String resourcePlanName, String triggerName, String poolPath) + throws NoSuchObjectException, InvalidOperationException, 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 e13dcd20a3..5bb2ef7e26 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 @@ -85,6 +85,8 @@ import org.apache.hadoop.hive.metastore.api.UnknownDBException; import org.apache.hadoop.hive.metastore.api.UnknownPartitionException; import org.apache.hadoop.hive.metastore.api.UnknownTableException; +import org.apache.hadoop.hive.metastore.api.WMMapping; +import org.apache.hadoop.hive.metastore.api.WMPool; import org.apache.hadoop.hive.metastore.conf.MetastoreConf; import org.apache.hadoop.hive.metastore.conf.MetastoreConf.ConfVars; import org.apache.hadoop.hive.metastore.partition.spec.PartitionSpecProxy; @@ -2297,4 +2299,43 @@ public void dropWMTrigger(String resourcePlanName, String triggerName) throws NoSuchObjectException, MetaException { return rawStore.getTriggersForResourcePlan(resourcePlanName); } + + @Override + public void createOrUpdatePool(WMPool pool, String newPoolPath, boolean update) + throws AlreadyExistsException, NoSuchObjectException, InvalidOperationException, + MetaException { + rawStore.createOrUpdatePool(pool, newPoolPath, update); + } + + @Override + public void dropWMPool(String resourcePlanName, String poolPath) + throws NoSuchObjectException, InvalidOperationException, MetaException { + rawStore.dropWMPool(resourcePlanName, poolPath); + } + + @Override + public void createOrUpdateWMMapping(WMMapping mapping, boolean update) + throws AlreadyExistsException, NoSuchObjectException, InvalidOperationException, + MetaException { + rawStore.createOrUpdateWMMapping(mapping, update); + } + + @Override + public void dropWMMapping(WMMapping mapping) + throws NoSuchObjectException, InvalidOperationException, MetaException { + rawStore.dropWMMapping(mapping); + } + + @Override + public void createWMTriggerToPoolMapping(String resourcePlanName, String triggerName, + String poolPath) throws AlreadyExistsException, NoSuchObjectException, + InvalidOperationException, MetaException { + rawStore.createWMTriggerToPoolMapping(resourcePlanName, triggerName, poolPath); + } + + @Override + public void dropWMTriggerToPoolMapping(String resourcePlanName, String triggerName, + String poolPath) throws NoSuchObjectException, InvalidOperationException, MetaException { + rawStore.dropWMTriggerToPoolMapping(resourcePlanName, triggerName, poolPath); + } } diff --git standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/model/MWMPool.java standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/model/MWMPool.java index c7cd983709..01f2fe30ad 100644 --- standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/model/MWMPool.java +++ standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/model/MWMPool.java @@ -23,20 +23,20 @@ public class MWMPool { private MWMResourcePlan resourcePlan; private String path; - private MWMPool parentPool; private Double allocFraction; private Integer queryParallelism; + private String schedulingPolicy; private Set triggers; public MWMPool() {} - public MWMPool(MWMResourcePlan resourcePlan, String path, MWMPool parentPool, - Double allocFraction, Integer queryParallelism) { + public MWMPool(MWMResourcePlan resourcePlan, String path, Double allocFraction, + Integer queryParallelism, String schedulingPolicy) { this.resourcePlan = resourcePlan; this.path = path; - this.parentPool = parentPool; this.allocFraction = allocFraction; this.queryParallelism = queryParallelism; + this.schedulingPolicy = schedulingPolicy; } public MWMResourcePlan getResourcePlan() { @@ -55,14 +55,6 @@ public void setPath(String path) { this.path = path; } - public MWMPool getParentPool() { - return parentPool; - } - - public void setParentPool(MWMPool parentPool) { - this.parentPool = parentPool; - } - public Double getAllocFraction() { return allocFraction; } @@ -79,6 +71,14 @@ public void setQueryParallelism(Integer queryParallelism) { this.queryParallelism = queryParallelism; } + public String getSchedulingPolicy() { + return schedulingPolicy; + } + + public void setSchedulingPolicy(String schedulingPolicy) { + this.schedulingPolicy = schedulingPolicy; + } + public Set getTriggers() { return triggers; } diff --git standalone-metastore/src/main/resources/package.jdo standalone-metastore/src/main/resources/package.jdo index 296e273ec8..16907ccba8 100644 --- standalone-metastore/src/main/resources/package.jdo +++ standalone-metastore/src/main/resources/package.jdo @@ -1120,15 +1120,15 @@ - - - + + + diff --git standalone-metastore/src/main/thrift/hive_metastore.thrift standalone-metastore/src/main/thrift/hive_metastore.thrift index 60531457b7..12c5d83f80 100644 --- standalone-metastore/src/main/thrift/hive_metastore.thrift +++ standalone-metastore/src/main/thrift/hive_metastore.thrift @@ -1047,11 +1047,10 @@ struct WMResourcePlan { struct WMPool { 1: required string resourcePlanName; - 2: required string poolName; - 3: optional string parentPoolName; - 4: optional double allocFraction; - 5: optional i32 queryParallelism; - 6: optional string schedulingPolicy; + 2: required string path; + 3: optional double allocFraction; + 4: optional i32 queryParallelism; + 5: optional string schedulingPolicy; } struct WMTrigger { @@ -1065,7 +1064,7 @@ struct WMMapping { 1: required string resourcePlanName; 2: required string entityType; 3: required string entityName; - 4: optional string poolName; + 4: optional string poolPath; 5: optional i32 ordering; } @@ -1146,6 +1145,47 @@ struct WMGetTriggersForResourePlanResponse { 1: optional list triggers; } +struct WMCreateOrUpdatePoolRequest { + 1: optional WMPool pool; + 2: optional string newPoolPath; + 3: optional bool update; +} + +struct WMCreateOrUpdatePoolResponse { +} + +struct WMDropPoolRequest { + 1: optional string resourcePlanName; + 2: optional string poolPath; +} + +struct WMDropPoolResponse { +} + +struct WMCreateOrUpdateMappingRequest { + 1: optional WMMapping mapping; + 2: optional bool update; +} + +struct WMCreateOrUpdateMappingResponse { +} + +struct WMDropMappingRequest { + 1: optional WMMapping mapping; +} + +struct WMDropMappingResponse { +} + +struct WMCreateOrDropTriggerToPoolMappingRequest { + 1: optional string resourcePlanName; + 2: optional string triggerName; + 3: optional string poolPath; + 4: optional bool drop; +} + +struct WMCreateOrDropTriggerToPoolMappingResponse { +} // Exceptions. @@ -1742,6 +1782,21 @@ service ThriftHiveMetastore extends fb303.FacebookService WMGetTriggersForResourePlanResponse get_triggers_for_resourceplan(1:WMGetTriggersForResourePlanRequest request) throws(1:NoSuchObjectException o1, 2:MetaException o2) + + WMCreateOrUpdatePoolResponse create_or_update_wm_pool(1:WMCreateOrUpdatePoolRequest request) + throws(1:AlreadyExistsException o1, 2:NoSuchObjectException o2, 3:InvalidObjectException o3, 4:MetaException o4) + + WMDropPoolResponse drop_wm_pool(1:WMDropPoolRequest request) + throws(1:NoSuchObjectException o1, 2:InvalidOperationException o2, 3:MetaException o3) + + WMCreateOrUpdateMappingResponse create_or_update_wm_mapping(1:WMCreateOrUpdateMappingRequest request) + throws(1:AlreadyExistsException o1, 2:NoSuchObjectException o2, 3:InvalidObjectException o3, 4:MetaException o4) + + WMDropMappingResponse drop_wm_mapping(1:WMDropMappingRequest request) + throws(1:NoSuchObjectException o1, 2:InvalidOperationException o2, 3:MetaException o3) + + WMCreateOrDropTriggerToPoolMappingResponse create_or_drop_wm_trigger_to_pool_mapping(1:WMCreateOrDropTriggerToPoolMappingRequest request) + throws(1:AlreadyExistsException o1, 2:NoSuchObjectException o2, 3:InvalidObjectException o3, 4:MetaException o4) } // * Note about the DDL_TIME: When creating or altering a table or a partition,