diff --git a/HIVE-13509.2.patch b/HIVE-13509.2.patch index 930b1f7..08e7dce 100644 --- a/HIVE-13509.2.patch +++ b/HIVE-13509.2.patch @@ -1,478 +1,12821 @@ -diff --git a/hcatalog/core/src/main/java/org/apache/hive/hcatalog/common/HCatConstants.java b/hcatalog/core/src/main/java/org/apache/hive/hcatalog/common/HCatConstants.java -index 6b03fcb..d165e7e 100644 ---- a/hcatalog/core/src/main/java/org/apache/hive/hcatalog/common/HCatConstants.java -+++ b/hcatalog/core/src/main/java/org/apache/hive/hcatalog/common/HCatConstants.java -@@ -208,4 +208,7 @@ private HCatConstants() { // restrict instantiation - */ - public static final String HCAT_INPUT_BAD_RECORD_MIN_KEY = "hcat.input.bad.record.min"; - public static final int HCAT_INPUT_BAD_RECORD_MIN_DEFAULT = 2; -+ -+ public static final String HCAT_INPUT_IGNORE_INVALID_PATH_KEY = "hcat.input.ignore.invalid.path"; -+ public static final boolean HCAT_INPUT_IGNORE_INVALID_PATH_DEFAULT = false; - } -diff --git a/hcatalog/core/src/main/java/org/apache/hive/hcatalog/mapreduce/HCatBaseInputFormat.java b/hcatalog/core/src/main/java/org/apache/hive/hcatalog/mapreduce/HCatBaseInputFormat.java -index adfaf4e..dbbdd61 100644 ---- a/hcatalog/core/src/main/java/org/apache/hive/hcatalog/mapreduce/HCatBaseInputFormat.java -+++ b/hcatalog/core/src/main/java/org/apache/hive/hcatalog/mapreduce/HCatBaseInputFormat.java -@@ -21,11 +21,11 @@ - - import java.io.IOException; - import java.util.ArrayList; -+import java.util.Iterator; - import java.util.LinkedList; - import java.util.Map; - import java.util.HashMap; - import java.util.List; -- - import org.apache.hadoop.conf.Configuration; - import org.apache.hadoop.fs.FileSystem; - import org.apache.hadoop.fs.Path; -@@ -127,7 +127,10 @@ public static void setOutputSchema(Job job, HCatSchema hcatSchema) - //For each matching partition, call getSplits on the underlying InputFormat - for (PartInfo partitionInfo : partitionInfoList) { - jobConf = HCatUtil.getJobConfFromContext(jobContext); -- setInputPath(jobConf, partitionInfo.getLocation()); -+ List setInputPath = setInputPath(jobConf, partitionInfo.getLocation()); -+ if (setInputPath.isEmpty()) { -+ continue; -+ } - Map jobProperties = partitionInfo.getJobProperties(); - - HCatUtil.copyJobPropertiesToJobConf(jobProperties, jobConf); -@@ -281,7 +284,7 @@ private static InputJobInfo getJobInfo(Configuration conf) - return (InputJobInfo) HCatUtil.deserialize(jobString); - } - -- private void setInputPath(JobConf jobConf, String location) -+ private List setInputPath(JobConf jobConf, String location) - throws IOException { - - // ideally we should just call FileInputFormat.setInputPaths() here - but -@@ -322,19 +325,33 @@ private void setInputPath(JobConf jobConf, String location) - } - pathStrings.add(location.substring(pathStart, length)); - -- Path[] paths = StringUtils.stringToPath(pathStrings.toArray(new String[0])); - String separator = ""; - StringBuilder str = new StringBuilder(); - -- for (Path path : paths) { -+ boolean ignoreInvalidPath =jobConf.getBoolean(HCatConstants.HCAT_INPUT_IGNORE_INVALID_PATH_KEY, -+ HCatConstants.HCAT_INPUT_IGNORE_INVALID_PATH_DEFAULT); -+ Iterator pathIterator = pathStrings.iterator(); -+ while (pathIterator.hasNext()) { -+ String pathString = pathIterator.next(); -+ if (ignoreInvalidPath && org.apache.commons.lang.StringUtils.isBlank(pathString)) { -+ continue; -+ } -+ Path path = new Path(pathString); - FileSystem fs = path.getFileSystem(jobConf); -+ if (ignoreInvalidPath && !fs.exists(path)) { -+ pathIterator.remove(); -+ continue; -+ } - final String qualifiedPath = fs.makeQualified(path).toString(); - str.append(separator) - .append(StringUtils.escapeString(qualifiedPath)); - separator = StringUtils.COMMA_STR; - } - -- jobConf.set("mapred.input.dir", str.toString()); -+ if (!ignoreInvalidPath || !pathStrings.isEmpty()) { -+ jobConf.set("mapred.input.dir", str.toString()); -+ } -+ return pathStrings; - } - - } -diff --git a/hcatalog/hcatalog-pig-adapter/src/test/java/org/apache/hive/hcatalog/pig/TestHCatLoader.java b/hcatalog/hcatalog-pig-adapter/src/test/java/org/apache/hive/hcatalog/pig/TestHCatLoader.java -index 2440cb5..4e23fa2 100644 ---- a/hcatalog/hcatalog-pig-adapter/src/test/java/org/apache/hive/hcatalog/pig/TestHCatLoader.java -+++ b/hcatalog/hcatalog-pig-adapter/src/test/java/org/apache/hive/hcatalog/pig/TestHCatLoader.java -@@ -66,6 +66,7 @@ - import org.apache.pig.data.Tuple; - import org.apache.pig.impl.logicalLayer.schema.Schema; - import org.apache.pig.impl.logicalLayer.schema.Schema.FieldSchema; -+import org.apache.pig.impl.util.PropertiesUtil; - import org.joda.time.DateTime; - import org.junit.After; - import org.junit.Before; -@@ -102,6 +103,7 @@ - add("testReadPartitionedBasic"); - add("testProjectionsBasic"); - add("testColumnarStorePushdown2"); -+ add("testReadMissingPartitionBasicNeg"); - }}); - }}; - -@@ -438,6 +440,59 @@ public void testReadPartitionedBasic() throws IOException, CommandNeedRetryExcep - } - - @Test -+ public void testReadMissingPartitionBasicNeg() throws IOException, CommandNeedRetryException { -+ assumeTrue(!TestUtil.shouldSkip(storageFormat, DISABLED_STORAGE_FORMATS)); -+ PigServer server = new PigServer(ExecType.LOCAL); -+ -+ File removedPartitionDir = new File(TEST_WAREHOUSE_DIR + "/" + PARTITIONED_TABLE + "/bkt=0"); -+ if (!removeDirectory(removedPartitionDir)) { -+ System.out.println("Test did not run because its environment could not be set."); +diff --git a/HIVE-13509.2.patch b/HIVE-13509.2.patch +index 930b1f7..e69de29 100644 +--- a/HIVE-13509.2.patch ++++ b/HIVE-13509.2.patch +@@ -1,478 +0,0 @@ +-diff --git a/hcatalog/core/src/main/java/org/apache/hive/hcatalog/common/HCatConstants.java b/hcatalog/core/src/main/java/org/apache/hive/hcatalog/common/HCatConstants.java +-index 6b03fcb..d165e7e 100644 +---- a/hcatalog/core/src/main/java/org/apache/hive/hcatalog/common/HCatConstants.java +-+++ b/hcatalog/core/src/main/java/org/apache/hive/hcatalog/common/HCatConstants.java +-@@ -208,4 +208,7 @@ private HCatConstants() { // restrict instantiation +- */ +- public static final String HCAT_INPUT_BAD_RECORD_MIN_KEY = "hcat.input.bad.record.min"; +- public static final int HCAT_INPUT_BAD_RECORD_MIN_DEFAULT = 2; +-+ +-+ public static final String HCAT_INPUT_IGNORE_INVALID_PATH_KEY = "hcat.input.ignore.invalid.path"; +-+ public static final boolean HCAT_INPUT_IGNORE_INVALID_PATH_DEFAULT = false; +- } +-diff --git a/hcatalog/core/src/main/java/org/apache/hive/hcatalog/mapreduce/HCatBaseInputFormat.java b/hcatalog/core/src/main/java/org/apache/hive/hcatalog/mapreduce/HCatBaseInputFormat.java +-index adfaf4e..dbbdd61 100644 +---- a/hcatalog/core/src/main/java/org/apache/hive/hcatalog/mapreduce/HCatBaseInputFormat.java +-+++ b/hcatalog/core/src/main/java/org/apache/hive/hcatalog/mapreduce/HCatBaseInputFormat.java +-@@ -21,11 +21,11 @@ +- +- import java.io.IOException; +- import java.util.ArrayList; +-+import java.util.Iterator; +- import java.util.LinkedList; +- import java.util.Map; +- import java.util.HashMap; +- import java.util.List; +-- +- import org.apache.hadoop.conf.Configuration; +- import org.apache.hadoop.fs.FileSystem; +- import org.apache.hadoop.fs.Path; +-@@ -127,7 +127,10 @@ public static void setOutputSchema(Job job, HCatSchema hcatSchema) +- //For each matching partition, call getSplits on the underlying InputFormat +- for (PartInfo partitionInfo : partitionInfoList) { +- jobConf = HCatUtil.getJobConfFromContext(jobContext); +-- setInputPath(jobConf, partitionInfo.getLocation()); +-+ List setInputPath = setInputPath(jobConf, partitionInfo.getLocation()); +-+ if (setInputPath.isEmpty()) { +-+ continue; +-+ } +- Map jobProperties = partitionInfo.getJobProperties(); +- +- HCatUtil.copyJobPropertiesToJobConf(jobProperties, jobConf); +-@@ -281,7 +284,7 @@ private static InputJobInfo getJobInfo(Configuration conf) +- return (InputJobInfo) HCatUtil.deserialize(jobString); +- } +- +-- private void setInputPath(JobConf jobConf, String location) +-+ private List setInputPath(JobConf jobConf, String location) +- throws IOException { +- +- // ideally we should just call FileInputFormat.setInputPaths() here - but +-@@ -322,19 +325,33 @@ private void setInputPath(JobConf jobConf, String location) +- } +- pathStrings.add(location.substring(pathStart, length)); +- +-- Path[] paths = StringUtils.stringToPath(pathStrings.toArray(new String[0])); +- String separator = ""; +- StringBuilder str = new StringBuilder(); +- +-- for (Path path : paths) { +-+ boolean ignoreInvalidPath =jobConf.getBoolean(HCatConstants.HCAT_INPUT_IGNORE_INVALID_PATH_KEY, +-+ HCatConstants.HCAT_INPUT_IGNORE_INVALID_PATH_DEFAULT); +-+ Iterator pathIterator = pathStrings.iterator(); +-+ while (pathIterator.hasNext()) { +-+ String pathString = pathIterator.next(); +-+ if (ignoreInvalidPath && org.apache.commons.lang.StringUtils.isBlank(pathString)) { +-+ continue; +-+ } +-+ Path path = new Path(pathString); +- FileSystem fs = path.getFileSystem(jobConf); +-+ if (ignoreInvalidPath && !fs.exists(path)) { +-+ pathIterator.remove(); +-+ continue; +-+ } +- final String qualifiedPath = fs.makeQualified(path).toString(); +- str.append(separator) +- .append(StringUtils.escapeString(qualifiedPath)); +- separator = StringUtils.COMMA_STR; +- } +- +-- jobConf.set("mapred.input.dir", str.toString()); +-+ if (!ignoreInvalidPath || !pathStrings.isEmpty()) { +-+ jobConf.set("mapred.input.dir", str.toString()); +-+ } +-+ return pathStrings; +- } +- +- } +-diff --git a/hcatalog/hcatalog-pig-adapter/src/test/java/org/apache/hive/hcatalog/pig/TestHCatLoader.java b/hcatalog/hcatalog-pig-adapter/src/test/java/org/apache/hive/hcatalog/pig/TestHCatLoader.java +-index 2440cb5..4e23fa2 100644 +---- a/hcatalog/hcatalog-pig-adapter/src/test/java/org/apache/hive/hcatalog/pig/TestHCatLoader.java +-+++ b/hcatalog/hcatalog-pig-adapter/src/test/java/org/apache/hive/hcatalog/pig/TestHCatLoader.java +-@@ -66,6 +66,7 @@ +- import org.apache.pig.data.Tuple; +- import org.apache.pig.impl.logicalLayer.schema.Schema; +- import org.apache.pig.impl.logicalLayer.schema.Schema.FieldSchema; +-+import org.apache.pig.impl.util.PropertiesUtil; +- import org.joda.time.DateTime; +- import org.junit.After; +- import org.junit.Before; +-@@ -102,6 +103,7 @@ +- add("testReadPartitionedBasic"); +- add("testProjectionsBasic"); +- add("testColumnarStorePushdown2"); +-+ add("testReadMissingPartitionBasicNeg"); +- }}); +- }}; +- +-@@ -438,6 +440,59 @@ public void testReadPartitionedBasic() throws IOException, CommandNeedRetryExcep +- } +- +- @Test +-+ public void testReadMissingPartitionBasicNeg() throws IOException, CommandNeedRetryException { +-+ assumeTrue(!TestUtil.shouldSkip(storageFormat, DISABLED_STORAGE_FORMATS)); +-+ PigServer server = new PigServer(ExecType.LOCAL); +-+ +-+ File removedPartitionDir = new File(TEST_WAREHOUSE_DIR + "/" + PARTITIONED_TABLE + "/bkt=0"); +-+ if (!removeDirectory(removedPartitionDir)) { +-+ System.out.println("Test did not run because its environment could not be set."); +-+ return; +-+ } +-+ driver.run("select * from " + PARTITIONED_TABLE); +-+ ArrayList valuesReadFromHiveDriver = new ArrayList(); +-+ driver.getResults(valuesReadFromHiveDriver); +-+ assertTrue(valuesReadFromHiveDriver.size() == 6); +-+ +-+ server.registerQuery("W = load '" + PARTITIONED_TABLE + "' using org.apache.hive.hcatalog.pig.HCatLoader();"); +-+ Schema dumpedWSchema = server.dumpSchema("W"); +-+ List Wfields = dumpedWSchema.getFields(); +-+ assertEquals(3, Wfields.size()); +-+ assertTrue(Wfields.get(0).alias.equalsIgnoreCase("a")); +-+ assertTrue(Wfields.get(0).type == DataType.INTEGER); +-+ assertTrue(Wfields.get(1).alias.equalsIgnoreCase("b")); +-+ assertTrue(Wfields.get(1).type == DataType.CHARARRAY); +-+ assertTrue(Wfields.get(2).alias.equalsIgnoreCase("bkt")); +-+ assertTrue(Wfields.get(2).type == DataType.CHARARRAY); +-+ +-+ try { +-+ Iterator WIter = server.openIterator("W"); +-+ fail("Should failed in retriving an invalid partition"); +-+ } catch (IOException ioe) { +-+ // expected +-+ } +-+ } +-+ +-+ private static boolean removeDirectory(File dir) { +-+ boolean success = false; +-+ if (dir.isDirectory()) { +-+ File[] files = dir.listFiles(); +-+ if (files != null && files.length > 0) { +-+ for (File file : files) { +-+ success = removeDirectory(file); +-+ if (!success) { +-+ return false; +-+ } +-+ } +-+ } +-+ success = dir.delete(); +-+ } else { +-+ success = dir.delete(); +-+ } +-+ return success; +-+ } +-+ +-+ @Test +- public void testProjectionsBasic() throws IOException { +- assumeTrue(!TestUtil.shouldSkip(storageFormat, DISABLED_STORAGE_FORMATS)); +- +-diff --git a/hcatalog/hcatalog-pig-adapter/src/test/java/org/apache/hive/hcatalog/pig/TestHCatLoaderWithProps.java b/hcatalog/hcatalog-pig-adapter/src/test/java/org/apache/hive/hcatalog/pig/TestHCatLoaderWithProps.java +-new file mode 100644 +-index 0000000..41fe79b +---- /dev/null +-+++ b/hcatalog/hcatalog-pig-adapter/src/test/java/org/apache/hive/hcatalog/pig/TestHCatLoaderWithProps.java +-@@ -0,0 +1,305 @@ +-+/** +-+ * Licensed to the Apache Software Foundation (ASF) under one +-+ * or more contributor license agreements. See the NOTICE file +-+ * distributed with this work for additional information +-+ * regarding copyright ownership. The ASF licenses this file +-+ * to you under the Apache License, Version 2.0 (the +-+ * "License"); you may not use this file except in compliance +-+ * with the License. You may obtain a copy of the License at +-+ * +-+ * http://www.apache.org/licenses/LICENSE-2.0 +-+ * +-+ * Unless required by applicable law or agreed to in writing, +-+ * software distributed under the License is distributed on an +-+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +-+ * KIND, either express or implied. See the License for the +-+ * specific language governing permissions and limitations +-+ * under the License. +-+ */ +-+package org.apache.hive.hcatalog.pig; +-+ +-+import java.io.File; +-+import java.io.FileWriter; +-+import java.io.IOException; +-+import java.io.PrintWriter; +-+import java.io.RandomAccessFile; +-+import java.sql.Date; +-+import java.sql.Timestamp; +-+import java.util.ArrayList; +-+import java.util.Collection; +-+import java.util.HashMap; +-+import java.util.HashSet; +-+import java.util.Iterator; +-+import java.util.List; +-+import java.util.Map; +-+import java.util.Properties; +-+import java.util.Set; +-+ +-+import org.apache.commons.io.FileUtils; +-+import org.apache.hadoop.fs.FileSystem; +-+import org.apache.hadoop.fs.FileUtil; +-+import org.apache.hadoop.fs.Path; +-+import org.apache.hadoop.hive.cli.CliSessionState; +-+import org.apache.hadoop.hive.conf.HiveConf; +-+import org.apache.hadoop.hive.ql.CommandNeedRetryException; +-+import org.apache.hadoop.hive.ql.Driver; +-+import org.apache.hadoop.hive.ql.WindowsPathUtil; +-+import org.apache.hadoop.hive.ql.io.IOConstants; +-+import org.apache.hadoop.hive.ql.io.StorageFormats; +-+import org.apache.hadoop.hive.ql.processors.CommandProcessorResponse; +-+import org.apache.hadoop.hive.ql.session.SessionState; +-+import org.apache.hadoop.hive.serde2.ColumnProjectionUtils; +-+import org.apache.hadoop.mapreduce.Job; +-+import org.apache.hadoop.util.Shell; +-+import org.apache.hive.hcatalog.HcatTestUtils; +-+import org.apache.hive.hcatalog.common.HCatUtil; +-+import org.apache.hive.hcatalog.common.HCatConstants; +-+import org.apache.hive.hcatalog.data.Pair; +-+import org.apache.hive.hcatalog.data.schema.HCatFieldSchema; +-+import org.apache.pig.ExecType; +-+import org.apache.pig.PigRunner; +-+import org.apache.pig.PigServer; +-+import org.apache.pig.ResourceStatistics; +-+import org.apache.pig.tools.pigstats.OutputStats; +-+import org.apache.pig.tools.pigstats.PigStats; +-+import org.apache.pig.data.DataType; +-+import org.apache.pig.data.Tuple; +-+import org.apache.pig.impl.logicalLayer.schema.Schema; +-+import org.apache.pig.impl.logicalLayer.schema.Schema.FieldSchema; +-+import org.apache.pig.impl.util.PropertiesUtil; +-+import org.joda.time.DateTime; +-+import org.junit.After; +-+import org.junit.Before; +-+import org.junit.Test; +-+import org.junit.runner.RunWith; +-+import org.junit.runners.Parameterized; +-+import org.slf4j.Logger; +-+import org.slf4j.LoggerFactory; +-+ +-+import static org.junit.Assert.*; +-+import static org.junit.Assume.assumeTrue; +-+ +-+@RunWith(Parameterized.class) +-+public class TestHCatLoaderWithProps { +-+ private static final Logger LOG = LoggerFactory.getLogger(TestHCatLoaderWithProps.class); +-+ private static final String TEST_DATA_DIR = HCatUtil.makePathASafeFileName(System.getProperty("java.io.tmpdir") + +-+ File.separator + TestHCatLoaderWithProps.class.getCanonicalName() + "-" + System.currentTimeMillis()); +-+ private static final String TEST_WAREHOUSE_DIR = TEST_DATA_DIR + "/warehouse"; +-+ private static final String BASIC_FILE_NAME = TEST_DATA_DIR + "/basic.input.data"; +-+ +-+ private static final String BASIC_TABLE = "junit_unparted_basic"; +-+ private static final String PARTITIONED_TABLE = "junit_parted_basic"; +-+ +-+ private Driver driver; +-+ private Map> basicInputData; +-+ +-+ private static final Map> DISABLED_STORAGE_FORMATS = +-+ new HashMap>() {{ +-+ put(IOConstants.PARQUETFILE, new HashSet() {{ +-+ add("testReadMissingPartitionBasic"); +-+ }}); +-+ }}; +-+ +-+ private final String storageFormat; +-+ +-+ @Parameterized.Parameters +-+ public static Collection generateParameters() { +-+ return StorageFormats.names(); +-+ } +-+ +-+ public TestHCatLoaderWithProps(String storageFormat) { +-+ this.storageFormat = storageFormat; +-+ } +-+ +-+ private void dropTable(String tablename) throws IOException, CommandNeedRetryException { +-+ dropTable(tablename, driver); +-+ } +-+ +-+ static void dropTable(String tablename, Driver driver) throws IOException, CommandNeedRetryException { +-+ driver.run("drop table if exists " + tablename); +-+ } +-+ +-+ private void createTable(String tablename, String schema, String partitionedBy) throws IOException, CommandNeedRetryException { +-+ createTable(tablename, schema, partitionedBy, driver, storageFormat); +-+ } +-+ +-+ static void createTable(String tablename, String schema, String partitionedBy, Driver driver, String storageFormat) +-+ throws IOException, CommandNeedRetryException { +-+ String createTable; +-+ createTable = "create table " + tablename + "(" + schema + ") "; +-+ if ((partitionedBy != null) && (!partitionedBy.trim().isEmpty())) { +-+ createTable = createTable + "partitioned by (" + partitionedBy + ") "; +-+ } +-+ createTable = createTable + "stored as " +storageFormat; +-+ executeStatementOnDriver(createTable, driver); +-+ } +-+ +-+ private void createTable(String tablename, String schema) throws IOException, CommandNeedRetryException { +-+ createTable(tablename, schema, null); +-+ } +-+ +-+ /** +-+ * Execute Hive CLI statement +-+ * @param cmd arbitrary statement to execute +-+ */ +-+ static void executeStatementOnDriver(String cmd, Driver driver) throws IOException, CommandNeedRetryException { +-+ LOG.debug("Executing: " + cmd); +-+ CommandProcessorResponse cpr = driver.run(cmd); +-+ if(cpr.getResponseCode() != 0) { +-+ throw new IOException("Failed to execute \"" + cmd + "\". Driver returned " + cpr.getResponseCode() + " Error: " + cpr.getErrorMessage()); +-+ } +-+ } +-+ +-+ @Before +-+ public void setup() throws Exception { +-+ File f = new File(TEST_WAREHOUSE_DIR); +-+ if (f.exists()) { +-+ FileUtil.fullyDelete(f); +-+ } +-+ if (!(new File(TEST_WAREHOUSE_DIR).mkdirs())) { +-+ throw new RuntimeException("Could not create " + TEST_WAREHOUSE_DIR); +-+ } +-+ +-+ HiveConf hiveConf = new HiveConf(this.getClass()); +-+ hiveConf.set(HiveConf.ConfVars.PREEXECHOOKS.varname, ""); +-+ hiveConf.set(HiveConf.ConfVars.POSTEXECHOOKS.varname, ""); +-+ hiveConf.set(HiveConf.ConfVars.HIVE_SUPPORT_CONCURRENCY.varname, "false"); +-+ hiveConf.set(HiveConf.ConfVars.METASTOREWAREHOUSE.varname, TEST_WAREHOUSE_DIR); +-+ hiveConf.setVar(HiveConf.ConfVars.HIVEMAPREDMODE, "nonstrict"); +-+ +-+ if (Shell.WINDOWS) { +-+ WindowsPathUtil.convertPathsFromWindowsToHdfs(hiveConf); +-+ } +-+ +-+ driver = new Driver(hiveConf); +-+ SessionState.start(new CliSessionState(hiveConf)); +-+ +-+ createTable(BASIC_TABLE, "a int, b string"); +-+ createTable(PARTITIONED_TABLE, "a int, b string", "bkt string"); +-+ +-+ int LOOP_SIZE = 3; +-+ String[] input = new String[LOOP_SIZE * LOOP_SIZE]; +-+ basicInputData = new HashMap>(); +-+ int k = 0; +-+ for (int i = 1; i <= LOOP_SIZE; i++) { +-+ String si = i + ""; +-+ for (int j = 1; j <= LOOP_SIZE; j++) { +-+ String sj = "S" + j + "S"; +-+ input[k] = si + "\t" + sj; +-+ basicInputData.put(k, new Pair(i, sj)); +-+ k++; +-+ } +-+ } +-+ HcatTestUtils.createTestDataFile(BASIC_FILE_NAME, input); +-+ +-+ PigServer server = new PigServer(ExecType.LOCAL); +-+ server.setBatchOn(); +-+ int i = 0; +-+ server.registerQuery("A = load '" + BASIC_FILE_NAME + "' as (a:int, b:chararray);", ++i); +-+ +-+ server.registerQuery("store A into '" + BASIC_TABLE + "' using org.apache.hive.hcatalog.pig.HCatStorer();", ++i); +-+ server.registerQuery("B = foreach A generate a,b;", ++i); +-+ server.registerQuery("B2 = filter B by a < 2;", ++i); +-+ server.registerQuery("store B2 into '" + PARTITIONED_TABLE + "' using org.apache.hive.hcatalog.pig.HCatStorer('bkt=0');", ++i); +-+ +-+ server.registerQuery("C = foreach A generate a,b;", ++i); +-+ server.registerQuery("C2 = filter C by a >= 2;", ++i); +-+ server.registerQuery("store C2 into '" + PARTITIONED_TABLE + "' using org.apache.hive.hcatalog.pig.HCatStorer('bkt=1');", ++i); +-+ +-+ server.executeBatch(); +-+ } +-+ +-+ @After +-+ public void tearDown() throws Exception { +-+ try { +-+ if (driver != null) { +-+ dropTable(BASIC_TABLE); +-+ dropTable(PARTITIONED_TABLE); +-+ } +-+ } finally { +-+ FileUtils.deleteDirectory(new File(TEST_DATA_DIR)); +-+ } +-+ } +-+ +-+ @Test +-+ public void testReadMissingPartitionBasic() throws IOException, CommandNeedRetryException { +-+ assumeTrue(!TestUtil.shouldSkip(storageFormat, DISABLED_STORAGE_FORMATS)); +-+ Properties pigProperties = PropertiesUtil.loadDefaultProperties(); +-+ pigProperties.setProperty("hcat.input.ignore.invalid.path", "true"); +-+ PigServer server = new PigServer(ExecType.LOCAL, pigProperties); +-+ +-+ File removedPartitionDir = new File(TEST_WAREHOUSE_DIR + "/" + PARTITIONED_TABLE + "/bkt=0"); +-+ if (!removeDirectory(removedPartitionDir)) { +-+ System.out.println("Test did not run because its environment could not be set."); +-+ return; +-+ } +-+ driver.run("select * from " + PARTITIONED_TABLE); +-+ ArrayList valuesReadFromHiveDriver = new ArrayList(); +-+ driver.getResults(valuesReadFromHiveDriver); +-+ assertTrue(valuesReadFromHiveDriver.size() == 6); +-+ +-+ server.registerQuery("W = load '" + PARTITIONED_TABLE + "' using org.apache.hive.hcatalog.pig.HCatLoader();"); +-+ Schema dumpedWSchema = server.dumpSchema("W"); +-+ List Wfields = dumpedWSchema.getFields(); +-+ assertEquals(3, Wfields.size()); +-+ assertTrue(Wfields.get(0).alias.equalsIgnoreCase("a")); +-+ assertTrue(Wfields.get(0).type == DataType.INTEGER); +-+ assertTrue(Wfields.get(1).alias.equalsIgnoreCase("b")); +-+ assertTrue(Wfields.get(1).type == DataType.CHARARRAY); +-+ assertTrue(Wfields.get(2).alias.equalsIgnoreCase("bkt")); +-+ assertTrue(Wfields.get(2).type == DataType.CHARARRAY); +-+ +-+ Iterator WIter = server.openIterator("W"); +-+ Collection> valuesRead = new ArrayList>(); +-+ while (WIter.hasNext()) { +-+ Tuple t = WIter.next(); +-+ assertTrue(t.size() == 3); +-+ assertNotNull(t.get(0)); +-+ assertNotNull(t.get(1)); +-+ assertNotNull(t.get(2)); +-+ assertTrue(t.get(0).getClass() == Integer.class); +-+ assertTrue(t.get(1).getClass() == String.class); +-+ assertTrue(t.get(2).getClass() == String.class); +-+ valuesRead.add(new Pair((Integer) t.get(0), (String) t.get(1))); +-+ // the returned partition value is always 1 +-+ assertEquals("1", t.get(2)); +-+ } +-+ assertEquals(valuesReadFromHiveDriver.size(), valuesRead.size()); +-+ +-+ server.registerQuery("P1 = load '" + PARTITIONED_TABLE + "' using org.apache.hive.hcatalog.pig.HCatLoader();"); +-+ server.registerQuery("P1filter = filter P1 by bkt == '0';"); +-+ Iterator P1Iter = server.openIterator("P1filter"); +-+ assertFalse(P1Iter.hasNext()); +-+ +-+ server.registerQuery("P2 = load '" + PARTITIONED_TABLE + "' using org.apache.hive.hcatalog.pig.HCatLoader();"); +-+ server.registerQuery("P2filter = filter P2 by bkt == '1';"); +-+ Iterator P2Iter = server.openIterator("P2filter"); +-+ int count2 = 0; +-+ while (P2Iter.hasNext()) { +-+ Tuple t = P2Iter.next(); +-+ assertEquals("1", t.get(2)); +-+ assertTrue(((Integer) t.get(0)) > 1); +-+ count2++; +-+ } +-+ assertEquals(6, count2); +-+ } +-+ +-+ private static boolean removeDirectory(File dir) { +-+ boolean success = false; +-+ if (dir.isDirectory()) { +-+ File[] files = dir.listFiles(); +-+ if (files != null && files.length > 0) { +-+ for (File file : files) { +-+ success = removeDirectory(file); +-+ if (!success) { +-+ return false; +-+ } +-+ } +-+ } +-+ success = dir.delete(); +-+ } else { +-+ success = dir.delete(); +-+ } +-+ return success; +-+ } +-+} +diff --git a/metastore/if/hive_metastore.thrift b/metastore/if/hive_metastore.thrift +index acebf7a..c8d78b6 100755 +--- a/metastore/if/hive_metastore.thrift ++++ b/metastore/if/hive_metastore.thrift +@@ -487,6 +487,11 @@ struct ForeignKeysResponse { + 1: required list foreignKeys + } + ++struct DropConstraintRequest { ++ 1: required string dbname, ++ 2: required string tablename, ++ 3: required string constraintname ++} + + // Return type for get_partitions_by_expr + struct PartitionsByExprResult { +@@ -993,6 +998,9 @@ service ThriftHiveMetastore extends fb303.FacebookService + throws (1:AlreadyExistsException o1, + 2:InvalidObjectException o2, 3:MetaException o3, + 4:NoSuchObjectException o4) ++ void drop_constraint(1:DropConstraintRequest req) ++ throws(1:NoSuchObjectException o1, 2:MetaException o3) ++ + // drops the table and all the partitions associated with it if the table has partitions + // delete data (including partitions) if deleteData is set to true + void drop_table(1:string dbname, 2:string name, 3:bool deleteData) +diff --git a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp +index 690c895..2734a1c 100644 +--- a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp ++++ b/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 _size749; +- ::apache::thrift::protocol::TType _etype752; +- xfer += iprot->readListBegin(_etype752, _size749); +- this->success.resize(_size749); +- uint32_t _i753; +- for (_i753 = 0; _i753 < _size749; ++_i753) ++ uint32_t _size751; ++ ::apache::thrift::protocol::TType _etype754; ++ xfer += iprot->readListBegin(_etype754, _size751); ++ this->success.resize(_size751); ++ uint32_t _i755; ++ for (_i755 = 0; _i755 < _size751; ++_i755) + { +- xfer += iprot->readString(this->success[_i753]); ++ xfer += iprot->readString(this->success[_i755]); + } + 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 _iter754; +- for (_iter754 = this->success.begin(); _iter754 != this->success.end(); ++_iter754) ++ std::vector ::const_iterator _iter756; ++ for (_iter756 = this->success.begin(); _iter756 != this->success.end(); ++_iter756) + { +- xfer += oprot->writeString((*_iter754)); ++ xfer += oprot->writeString((*_iter756)); + } + 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 _size755; +- ::apache::thrift::protocol::TType _etype758; +- xfer += iprot->readListBegin(_etype758, _size755); +- (*(this->success)).resize(_size755); +- uint32_t _i759; +- for (_i759 = 0; _i759 < _size755; ++_i759) ++ uint32_t _size757; ++ ::apache::thrift::protocol::TType _etype760; ++ xfer += iprot->readListBegin(_etype760, _size757); ++ (*(this->success)).resize(_size757); ++ uint32_t _i761; ++ for (_i761 = 0; _i761 < _size757; ++_i761) + { +- xfer += iprot->readString((*(this->success))[_i759]); ++ xfer += iprot->readString((*(this->success))[_i761]); + } + 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 _size760; +- ::apache::thrift::protocol::TType _etype763; +- xfer += iprot->readListBegin(_etype763, _size760); +- this->success.resize(_size760); +- uint32_t _i764; +- for (_i764 = 0; _i764 < _size760; ++_i764) ++ uint32_t _size762; ++ ::apache::thrift::protocol::TType _etype765; ++ xfer += iprot->readListBegin(_etype765, _size762); ++ this->success.resize(_size762); ++ uint32_t _i766; ++ for (_i766 = 0; _i766 < _size762; ++_i766) + { +- xfer += iprot->readString(this->success[_i764]); ++ xfer += iprot->readString(this->success[_i766]); + } + 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 _iter765; +- for (_iter765 = this->success.begin(); _iter765 != this->success.end(); ++_iter765) ++ std::vector ::const_iterator _iter767; ++ for (_iter767 = this->success.begin(); _iter767 != this->success.end(); ++_iter767) + { +- xfer += oprot->writeString((*_iter765)); ++ xfer += oprot->writeString((*_iter767)); + } + 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 _size766; +- ::apache::thrift::protocol::TType _etype769; +- xfer += iprot->readListBegin(_etype769, _size766); +- (*(this->success)).resize(_size766); +- uint32_t _i770; +- for (_i770 = 0; _i770 < _size766; ++_i770) ++ uint32_t _size768; ++ ::apache::thrift::protocol::TType _etype771; ++ xfer += iprot->readListBegin(_etype771, _size768); ++ (*(this->success)).resize(_size768); ++ uint32_t _i772; ++ for (_i772 = 0; _i772 < _size768; ++_i772) + { +- xfer += iprot->readString((*(this->success))[_i770]); ++ xfer += iprot->readString((*(this->success))[_i772]); + } + 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 _size771; +- ::apache::thrift::protocol::TType _ktype772; +- ::apache::thrift::protocol::TType _vtype773; +- xfer += iprot->readMapBegin(_ktype772, _vtype773, _size771); +- uint32_t _i775; +- for (_i775 = 0; _i775 < _size771; ++_i775) ++ uint32_t _size773; ++ ::apache::thrift::protocol::TType _ktype774; ++ ::apache::thrift::protocol::TType _vtype775; ++ xfer += iprot->readMapBegin(_ktype774, _vtype775, _size773); ++ uint32_t _i777; ++ for (_i777 = 0; _i777 < _size773; ++_i777) + { +- std::string _key776; +- xfer += iprot->readString(_key776); +- Type& _val777 = this->success[_key776]; +- xfer += _val777.read(iprot); ++ std::string _key778; ++ xfer += iprot->readString(_key778); ++ Type& _val779 = this->success[_key778]; ++ xfer += _val779.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 _iter778; +- for (_iter778 = this->success.begin(); _iter778 != this->success.end(); ++_iter778) ++ std::map ::const_iterator _iter780; ++ for (_iter780 = this->success.begin(); _iter780 != this->success.end(); ++_iter780) + { +- xfer += oprot->writeString(_iter778->first); +- xfer += _iter778->second.write(oprot); ++ xfer += oprot->writeString(_iter780->first); ++ xfer += _iter780->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 _size779; +- ::apache::thrift::protocol::TType _ktype780; +- ::apache::thrift::protocol::TType _vtype781; +- xfer += iprot->readMapBegin(_ktype780, _vtype781, _size779); +- uint32_t _i783; +- for (_i783 = 0; _i783 < _size779; ++_i783) ++ uint32_t _size781; ++ ::apache::thrift::protocol::TType _ktype782; ++ ::apache::thrift::protocol::TType _vtype783; ++ xfer += iprot->readMapBegin(_ktype782, _vtype783, _size781); ++ uint32_t _i785; ++ for (_i785 = 0; _i785 < _size781; ++_i785) + { +- std::string _key784; +- xfer += iprot->readString(_key784); +- Type& _val785 = (*(this->success))[_key784]; +- xfer += _val785.read(iprot); ++ std::string _key786; ++ xfer += iprot->readString(_key786); ++ Type& _val787 = (*(this->success))[_key786]; ++ xfer += _val787.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 _size786; +- ::apache::thrift::protocol::TType _etype789; +- xfer += iprot->readListBegin(_etype789, _size786); +- this->success.resize(_size786); +- uint32_t _i790; +- for (_i790 = 0; _i790 < _size786; ++_i790) ++ uint32_t _size788; ++ ::apache::thrift::protocol::TType _etype791; ++ xfer += iprot->readListBegin(_etype791, _size788); ++ this->success.resize(_size788); ++ uint32_t _i792; ++ for (_i792 = 0; _i792 < _size788; ++_i792) + { +- xfer += this->success[_i790].read(iprot); ++ xfer += this->success[_i792].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 _iter791; +- for (_iter791 = this->success.begin(); _iter791 != this->success.end(); ++_iter791) ++ std::vector ::const_iterator _iter793; ++ for (_iter793 = this->success.begin(); _iter793 != this->success.end(); ++_iter793) + { +- xfer += (*_iter791).write(oprot); ++ xfer += (*_iter793).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 _size792; +- ::apache::thrift::protocol::TType _etype795; +- xfer += iprot->readListBegin(_etype795, _size792); +- (*(this->success)).resize(_size792); +- uint32_t _i796; +- for (_i796 = 0; _i796 < _size792; ++_i796) ++ uint32_t _size794; ++ ::apache::thrift::protocol::TType _etype797; ++ xfer += iprot->readListBegin(_etype797, _size794); ++ (*(this->success)).resize(_size794); ++ uint32_t _i798; ++ for (_i798 = 0; _i798 < _size794; ++_i798) + { +- xfer += (*(this->success))[_i796].read(iprot); ++ xfer += (*(this->success))[_i798].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 _size797; +- ::apache::thrift::protocol::TType _etype800; +- xfer += iprot->readListBegin(_etype800, _size797); +- this->success.resize(_size797); +- uint32_t _i801; +- for (_i801 = 0; _i801 < _size797; ++_i801) ++ uint32_t _size799; ++ ::apache::thrift::protocol::TType _etype802; ++ xfer += iprot->readListBegin(_etype802, _size799); ++ this->success.resize(_size799); ++ uint32_t _i803; ++ for (_i803 = 0; _i803 < _size799; ++_i803) + { +- xfer += this->success[_i801].read(iprot); ++ xfer += this->success[_i803].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 _iter802; +- for (_iter802 = this->success.begin(); _iter802 != this->success.end(); ++_iter802) ++ std::vector ::const_iterator _iter804; ++ for (_iter804 = this->success.begin(); _iter804 != this->success.end(); ++_iter804) + { +- xfer += (*_iter802).write(oprot); ++ xfer += (*_iter804).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 _size803; +- ::apache::thrift::protocol::TType _etype806; +- xfer += iprot->readListBegin(_etype806, _size803); +- (*(this->success)).resize(_size803); +- uint32_t _i807; +- for (_i807 = 0; _i807 < _size803; ++_i807) ++ uint32_t _size805; ++ ::apache::thrift::protocol::TType _etype808; ++ xfer += iprot->readListBegin(_etype808, _size805); ++ (*(this->success)).resize(_size805); ++ uint32_t _i809; ++ for (_i809 = 0; _i809 < _size805; ++_i809) + { +- xfer += (*(this->success))[_i807].read(iprot); ++ xfer += (*(this->success))[_i809].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 _size808; +- ::apache::thrift::protocol::TType _etype811; +- xfer += iprot->readListBegin(_etype811, _size808); +- this->success.resize(_size808); +- uint32_t _i812; +- for (_i812 = 0; _i812 < _size808; ++_i812) ++ uint32_t _size810; ++ ::apache::thrift::protocol::TType _etype813; ++ xfer += iprot->readListBegin(_etype813, _size810); ++ this->success.resize(_size810); ++ uint32_t _i814; ++ for (_i814 = 0; _i814 < _size810; ++_i814) + { +- xfer += this->success[_i812].read(iprot); ++ xfer += this->success[_i814].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 _iter813; +- for (_iter813 = this->success.begin(); _iter813 != this->success.end(); ++_iter813) ++ std::vector ::const_iterator _iter815; ++ for (_iter815 = this->success.begin(); _iter815 != this->success.end(); ++_iter815) + { +- xfer += (*_iter813).write(oprot); ++ xfer += (*_iter815).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 _size814; +- ::apache::thrift::protocol::TType _etype817; +- xfer += iprot->readListBegin(_etype817, _size814); +- (*(this->success)).resize(_size814); +- uint32_t _i818; +- for (_i818 = 0; _i818 < _size814; ++_i818) ++ uint32_t _size816; ++ ::apache::thrift::protocol::TType _etype819; ++ xfer += iprot->readListBegin(_etype819, _size816); ++ (*(this->success)).resize(_size816); ++ uint32_t _i820; ++ for (_i820 = 0; _i820 < _size816; ++_i820) + { +- xfer += (*(this->success))[_i818].read(iprot); ++ xfer += (*(this->success))[_i820].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 _size819; +- ::apache::thrift::protocol::TType _etype822; +- xfer += iprot->readListBegin(_etype822, _size819); +- this->success.resize(_size819); +- uint32_t _i823; +- for (_i823 = 0; _i823 < _size819; ++_i823) ++ uint32_t _size821; ++ ::apache::thrift::protocol::TType _etype824; ++ xfer += iprot->readListBegin(_etype824, _size821); ++ this->success.resize(_size821); ++ uint32_t _i825; ++ for (_i825 = 0; _i825 < _size821; ++_i825) + { +- xfer += this->success[_i823].read(iprot); ++ xfer += this->success[_i825].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 _iter824; +- for (_iter824 = this->success.begin(); _iter824 != this->success.end(); ++_iter824) ++ std::vector ::const_iterator _iter826; ++ for (_iter826 = this->success.begin(); _iter826 != this->success.end(); ++_iter826) + { +- xfer += (*_iter824).write(oprot); ++ xfer += (*_iter826).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 _size825; +- ::apache::thrift::protocol::TType _etype828; +- xfer += iprot->readListBegin(_etype828, _size825); +- (*(this->success)).resize(_size825); +- uint32_t _i829; +- for (_i829 = 0; _i829 < _size825; ++_i829) ++ uint32_t _size827; ++ ::apache::thrift::protocol::TType _etype830; ++ xfer += iprot->readListBegin(_etype830, _size827); ++ (*(this->success)).resize(_size827); ++ uint32_t _i831; ++ for (_i831 = 0; _i831 < _size827; ++_i831) + { +- xfer += (*(this->success))[_i829].read(iprot); ++ xfer += (*(this->success))[_i831].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 _size830; +- ::apache::thrift::protocol::TType _etype833; +- xfer += iprot->readListBegin(_etype833, _size830); +- this->primaryKeys.resize(_size830); +- uint32_t _i834; +- for (_i834 = 0; _i834 < _size830; ++_i834) ++ uint32_t _size832; ++ ::apache::thrift::protocol::TType _etype835; ++ xfer += iprot->readListBegin(_etype835, _size832); ++ this->primaryKeys.resize(_size832); ++ uint32_t _i836; ++ for (_i836 = 0; _i836 < _size832; ++_i836) + { +- xfer += this->primaryKeys[_i834].read(iprot); ++ xfer += this->primaryKeys[_i836].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 _size835; +- ::apache::thrift::protocol::TType _etype838; +- xfer += iprot->readListBegin(_etype838, _size835); +- this->foreignKeys.resize(_size835); +- uint32_t _i839; +- for (_i839 = 0; _i839 < _size835; ++_i839) ++ uint32_t _size837; ++ ::apache::thrift::protocol::TType _etype840; ++ xfer += iprot->readListBegin(_etype840, _size837); ++ this->foreignKeys.resize(_size837); ++ uint32_t _i841; ++ for (_i841 = 0; _i841 < _size837; ++_i841) + { +- xfer += this->foreignKeys[_i839].read(iprot); ++ xfer += this->foreignKeys[_i841].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -4578,10 +4578,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 _iter840; +- for (_iter840 = this->primaryKeys.begin(); _iter840 != this->primaryKeys.end(); ++_iter840) ++ std::vector ::const_iterator _iter842; ++ for (_iter842 = this->primaryKeys.begin(); _iter842 != this->primaryKeys.end(); ++_iter842) + { +- xfer += (*_iter840).write(oprot); ++ xfer += (*_iter842).write(oprot); + } + xfer += oprot->writeListEnd(); + } +@@ -4590,10 +4590,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 _iter841; +- for (_iter841 = this->foreignKeys.begin(); _iter841 != this->foreignKeys.end(); ++_iter841) ++ std::vector ::const_iterator _iter843; ++ for (_iter843 = this->foreignKeys.begin(); _iter843 != this->foreignKeys.end(); ++_iter843) + { +- xfer += (*_iter841).write(oprot); ++ xfer += (*_iter843).write(oprot); + } + xfer += oprot->writeListEnd(); + } +@@ -4621,10 +4621,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 _iter842; +- for (_iter842 = (*(this->primaryKeys)).begin(); _iter842 != (*(this->primaryKeys)).end(); ++_iter842) ++ std::vector ::const_iterator _iter844; ++ for (_iter844 = (*(this->primaryKeys)).begin(); _iter844 != (*(this->primaryKeys)).end(); ++_iter844) + { +- xfer += (*_iter842).write(oprot); ++ xfer += (*_iter844).write(oprot); + } + xfer += oprot->writeListEnd(); + } +@@ -4633,10 +4633,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 _iter843; +- for (_iter843 = (*(this->foreignKeys)).begin(); _iter843 != (*(this->foreignKeys)).end(); ++_iter843) ++ std::vector ::const_iterator _iter845; ++ for (_iter845 = (*(this->foreignKeys)).begin(); _iter845 != (*(this->foreignKeys)).end(); ++_iter845) + { +- xfer += (*_iter843).write(oprot); ++ xfer += (*_iter845).write(oprot); + } + xfer += oprot->writeListEnd(); + } +@@ -4816,6 +4816,213 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_presult::read(::apach + } + + ++ThriftHiveMetastore_drop_constraint_args::~ThriftHiveMetastore_drop_constraint_args() throw() { ++} ++ ++ ++uint32_t ThriftHiveMetastore_drop_constraint_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->req.read(iprot); ++ this->__isset.req = 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_constraint_args::write(::apache::thrift::protocol::TProtocol* oprot) const { ++ uint32_t xfer = 0; ++ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); ++ xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_constraint_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(); ++ return xfer; ++} ++ ++ ++ThriftHiveMetastore_drop_constraint_pargs::~ThriftHiveMetastore_drop_constraint_pargs() throw() { ++} ++ ++ ++uint32_t ThriftHiveMetastore_drop_constraint_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { ++ uint32_t xfer = 0; ++ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); ++ xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_constraint_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(); ++ return xfer; ++} ++ ++ ++ThriftHiveMetastore_drop_constraint_result::~ThriftHiveMetastore_drop_constraint_result() throw() { ++} ++ ++ ++uint32_t ThriftHiveMetastore_drop_constraint_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->o3.read(iprot); ++ this->__isset.o3 = true; ++ } else { ++ xfer += iprot->skip(ftype); ++ } ++ break; ++ default: ++ xfer += iprot->skip(ftype); ++ break; ++ } ++ xfer += iprot->readFieldEnd(); ++ } ++ ++ xfer += iprot->readStructEnd(); ++ ++ return xfer; ++} ++ ++uint32_t ThriftHiveMetastore_drop_constraint_result::write(::apache::thrift::protocol::TProtocol* oprot) const { ++ ++ uint32_t xfer = 0; ++ ++ xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_constraint_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.o3) { ++ xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 2); ++ xfer += this->o3.write(oprot); ++ xfer += oprot->writeFieldEnd(); ++ } ++ xfer += oprot->writeFieldStop(); ++ xfer += oprot->writeStructEnd(); ++ return xfer; ++} ++ ++ ++ThriftHiveMetastore_drop_constraint_presult::~ThriftHiveMetastore_drop_constraint_presult() throw() { ++} ++ ++ ++uint32_t ThriftHiveMetastore_drop_constraint_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 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->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_drop_table_args::~ThriftHiveMetastore_drop_table_args() throw() { + } + +@@ -5434,14 +5641,14 @@ uint32_t ThriftHiveMetastore_get_tables_result::read(::apache::thrift::protocol: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); +- uint32_t _size844; +- ::apache::thrift::protocol::TType _etype847; +- xfer += iprot->readListBegin(_etype847, _size844); +- this->success.resize(_size844); +- uint32_t _i848; +- for (_i848 = 0; _i848 < _size844; ++_i848) ++ uint32_t _size846; ++ ::apache::thrift::protocol::TType _etype849; ++ xfer += iprot->readListBegin(_etype849, _size846); ++ this->success.resize(_size846); ++ uint32_t _i850; ++ for (_i850 = 0; _i850 < _size846; ++_i850) + { +- xfer += iprot->readString(this->success[_i848]); ++ xfer += iprot->readString(this->success[_i850]); + } + xfer += iprot->readListEnd(); + } +@@ -5480,10 +5687,10 @@ uint32_t ThriftHiveMetastore_get_tables_result::write(::apache::thrift::protocol + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); +- std::vector ::const_iterator _iter849; +- for (_iter849 = this->success.begin(); _iter849 != this->success.end(); ++_iter849) ++ std::vector ::const_iterator _iter851; ++ for (_iter851 = this->success.begin(); _iter851 != this->success.end(); ++_iter851) + { +- xfer += oprot->writeString((*_iter849)); ++ xfer += oprot->writeString((*_iter851)); + } + xfer += oprot->writeListEnd(); + } +@@ -5528,14 +5735,14 @@ uint32_t ThriftHiveMetastore_get_tables_presult::read(::apache::thrift::protocol + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); +- uint32_t _size850; +- ::apache::thrift::protocol::TType _etype853; +- xfer += iprot->readListBegin(_etype853, _size850); +- (*(this->success)).resize(_size850); +- uint32_t _i854; +- for (_i854 = 0; _i854 < _size850; ++_i854) ++ uint32_t _size852; ++ ::apache::thrift::protocol::TType _etype855; ++ xfer += iprot->readListBegin(_etype855, _size852); ++ (*(this->success)).resize(_size852); ++ uint32_t _i856; ++ for (_i856 = 0; _i856 < _size852; ++_i856) + { +- xfer += iprot->readString((*(this->success))[_i854]); ++ xfer += iprot->readString((*(this->success))[_i856]); + } + xfer += iprot->readListEnd(); + } +@@ -5610,14 +5817,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 _size855; +- ::apache::thrift::protocol::TType _etype858; +- xfer += iprot->readListBegin(_etype858, _size855); +- this->tbl_types.resize(_size855); +- uint32_t _i859; +- for (_i859 = 0; _i859 < _size855; ++_i859) ++ uint32_t _size857; ++ ::apache::thrift::protocol::TType _etype860; ++ xfer += iprot->readListBegin(_etype860, _size857); ++ this->tbl_types.resize(_size857); ++ uint32_t _i861; ++ for (_i861 = 0; _i861 < _size857; ++_i861) + { +- xfer += iprot->readString(this->tbl_types[_i859]); ++ xfer += iprot->readString(this->tbl_types[_i861]); + } + xfer += iprot->readListEnd(); + } +@@ -5654,10 +5861,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 _iter860; +- for (_iter860 = this->tbl_types.begin(); _iter860 != this->tbl_types.end(); ++_iter860) ++ std::vector ::const_iterator _iter862; ++ for (_iter862 = this->tbl_types.begin(); _iter862 != this->tbl_types.end(); ++_iter862) + { +- xfer += oprot->writeString((*_iter860)); ++ xfer += oprot->writeString((*_iter862)); + } + xfer += oprot->writeListEnd(); + } +@@ -5689,10 +5896,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 _iter861; +- for (_iter861 = (*(this->tbl_types)).begin(); _iter861 != (*(this->tbl_types)).end(); ++_iter861) ++ std::vector ::const_iterator _iter863; ++ for (_iter863 = (*(this->tbl_types)).begin(); _iter863 != (*(this->tbl_types)).end(); ++_iter863) + { +- xfer += oprot->writeString((*_iter861)); ++ xfer += oprot->writeString((*_iter863)); + } + xfer += oprot->writeListEnd(); + } +@@ -5733,14 +5940,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_result::read(::apache::thrift::proto + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); +- uint32_t _size862; +- ::apache::thrift::protocol::TType _etype865; +- xfer += iprot->readListBegin(_etype865, _size862); +- this->success.resize(_size862); +- uint32_t _i866; +- for (_i866 = 0; _i866 < _size862; ++_i866) ++ uint32_t _size864; ++ ::apache::thrift::protocol::TType _etype867; ++ xfer += iprot->readListBegin(_etype867, _size864); ++ this->success.resize(_size864); ++ uint32_t _i868; ++ for (_i868 = 0; _i868 < _size864; ++_i868) + { +- xfer += this->success[_i866].read(iprot); ++ xfer += this->success[_i868].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -5779,10 +5986,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 _iter867; +- for (_iter867 = this->success.begin(); _iter867 != this->success.end(); ++_iter867) ++ std::vector ::const_iterator _iter869; ++ for (_iter869 = this->success.begin(); _iter869 != this->success.end(); ++_iter869) + { +- xfer += (*_iter867).write(oprot); ++ xfer += (*_iter869).write(oprot); + } + xfer += oprot->writeListEnd(); + } +@@ -5827,14 +6034,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_presult::read(::apache::thrift::prot + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); +- uint32_t _size868; +- ::apache::thrift::protocol::TType _etype871; +- xfer += iprot->readListBegin(_etype871, _size868); +- (*(this->success)).resize(_size868); +- uint32_t _i872; +- for (_i872 = 0; _i872 < _size868; ++_i872) ++ uint32_t _size870; ++ ::apache::thrift::protocol::TType _etype873; ++ xfer += iprot->readListBegin(_etype873, _size870); ++ (*(this->success)).resize(_size870); ++ uint32_t _i874; ++ for (_i874 = 0; _i874 < _size870; ++_i874) + { +- xfer += (*(this->success))[_i872].read(iprot); ++ xfer += (*(this->success))[_i874].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -5972,14 +6179,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_result::read(::apache::thrift::proto + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); +- uint32_t _size873; +- ::apache::thrift::protocol::TType _etype876; +- xfer += iprot->readListBegin(_etype876, _size873); +- this->success.resize(_size873); +- uint32_t _i877; +- for (_i877 = 0; _i877 < _size873; ++_i877) ++ uint32_t _size875; ++ ::apache::thrift::protocol::TType _etype878; ++ xfer += iprot->readListBegin(_etype878, _size875); ++ this->success.resize(_size875); ++ uint32_t _i879; ++ for (_i879 = 0; _i879 < _size875; ++_i879) + { +- xfer += iprot->readString(this->success[_i877]); ++ xfer += iprot->readString(this->success[_i879]); + } + xfer += iprot->readListEnd(); + } +@@ -6018,10 +6225,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 _iter878; +- for (_iter878 = this->success.begin(); _iter878 != this->success.end(); ++_iter878) ++ std::vector ::const_iterator _iter880; ++ for (_iter880 = this->success.begin(); _iter880 != this->success.end(); ++_iter880) + { +- xfer += oprot->writeString((*_iter878)); ++ xfer += oprot->writeString((*_iter880)); + } + xfer += oprot->writeListEnd(); + } +@@ -6066,14 +6273,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_presult::read(::apache::thrift::prot + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); +- uint32_t _size879; +- ::apache::thrift::protocol::TType _etype882; +- xfer += iprot->readListBegin(_etype882, _size879); +- (*(this->success)).resize(_size879); +- uint32_t _i883; +- for (_i883 = 0; _i883 < _size879; ++_i883) ++ uint32_t _size881; ++ ::apache::thrift::protocol::TType _etype884; ++ xfer += iprot->readListBegin(_etype884, _size881); ++ (*(this->success)).resize(_size881); ++ uint32_t _i885; ++ for (_i885 = 0; _i885 < _size881; ++_i885) + { +- xfer += iprot->readString((*(this->success))[_i883]); ++ xfer += iprot->readString((*(this->success))[_i885]); + } + xfer += iprot->readListEnd(); + } +@@ -6383,14 +6590,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 _size884; +- ::apache::thrift::protocol::TType _etype887; +- xfer += iprot->readListBegin(_etype887, _size884); +- this->tbl_names.resize(_size884); +- uint32_t _i888; +- for (_i888 = 0; _i888 < _size884; ++_i888) ++ uint32_t _size886; ++ ::apache::thrift::protocol::TType _etype889; ++ xfer += iprot->readListBegin(_etype889, _size886); ++ this->tbl_names.resize(_size886); ++ uint32_t _i890; ++ for (_i890 = 0; _i890 < _size886; ++_i890) + { +- xfer += iprot->readString(this->tbl_names[_i888]); ++ xfer += iprot->readString(this->tbl_names[_i890]); + } + xfer += iprot->readListEnd(); + } +@@ -6423,10 +6630,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 _iter889; +- for (_iter889 = this->tbl_names.begin(); _iter889 != this->tbl_names.end(); ++_iter889) ++ std::vector ::const_iterator _iter891; ++ for (_iter891 = this->tbl_names.begin(); _iter891 != this->tbl_names.end(); ++_iter891) + { +- xfer += oprot->writeString((*_iter889)); ++ xfer += oprot->writeString((*_iter891)); + } + xfer += oprot->writeListEnd(); + } +@@ -6454,10 +6661,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 _iter890; +- for (_iter890 = (*(this->tbl_names)).begin(); _iter890 != (*(this->tbl_names)).end(); ++_iter890) ++ std::vector ::const_iterator _iter892; ++ for (_iter892 = (*(this->tbl_names)).begin(); _iter892 != (*(this->tbl_names)).end(); ++_iter892) + { +- xfer += oprot->writeString((*_iter890)); ++ xfer += oprot->writeString((*_iter892)); + } + xfer += oprot->writeListEnd(); + } +@@ -6498,14 +6705,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 _size891; +- ::apache::thrift::protocol::TType _etype894; +- xfer += iprot->readListBegin(_etype894, _size891); +- this->success.resize(_size891); +- uint32_t _i895; +- for (_i895 = 0; _i895 < _size891; ++_i895) ++ uint32_t _size893; ++ ::apache::thrift::protocol::TType _etype896; ++ xfer += iprot->readListBegin(_etype896, _size893); ++ this->success.resize(_size893); ++ uint32_t _i897; ++ for (_i897 = 0; _i897 < _size893; ++_i897) + { +- xfer += this->success[_i895].read(iprot); ++ xfer += this->success[_i897].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -6560,10 +6767,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 _iter896; +- for (_iter896 = this->success.begin(); _iter896 != this->success.end(); ++_iter896) ++ std::vector
::const_iterator _iter898; ++ for (_iter898 = this->success.begin(); _iter898 != this->success.end(); ++_iter898) + { +- xfer += (*_iter896).write(oprot); ++ xfer += (*_iter898).write(oprot); + } + xfer += oprot->writeListEnd(); + } +@@ -6616,14 +6823,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 _size897; +- ::apache::thrift::protocol::TType _etype900; +- xfer += iprot->readListBegin(_etype900, _size897); +- (*(this->success)).resize(_size897); +- uint32_t _i901; +- for (_i901 = 0; _i901 < _size897; ++_i901) ++ uint32_t _size899; ++ ::apache::thrift::protocol::TType _etype902; ++ xfer += iprot->readListBegin(_etype902, _size899); ++ (*(this->success)).resize(_size899); ++ uint32_t _i903; ++ for (_i903 = 0; _i903 < _size899; ++_i903) + { +- xfer += (*(this->success))[_i901].read(iprot); ++ xfer += (*(this->success))[_i903].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -6809,14 +7016,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 _size902; +- ::apache::thrift::protocol::TType _etype905; +- xfer += iprot->readListBegin(_etype905, _size902); +- this->success.resize(_size902); +- uint32_t _i906; +- for (_i906 = 0; _i906 < _size902; ++_i906) ++ uint32_t _size904; ++ ::apache::thrift::protocol::TType _etype907; ++ xfer += iprot->readListBegin(_etype907, _size904); ++ this->success.resize(_size904); ++ uint32_t _i908; ++ for (_i908 = 0; _i908 < _size904; ++_i908) + { +- xfer += iprot->readString(this->success[_i906]); ++ xfer += iprot->readString(this->success[_i908]); + } + xfer += iprot->readListEnd(); + } +@@ -6871,10 +7078,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 _iter907; +- for (_iter907 = this->success.begin(); _iter907 != this->success.end(); ++_iter907) ++ std::vector ::const_iterator _iter909; ++ for (_iter909 = this->success.begin(); _iter909 != this->success.end(); ++_iter909) + { +- xfer += oprot->writeString((*_iter907)); ++ xfer += oprot->writeString((*_iter909)); + } + xfer += oprot->writeListEnd(); + } +@@ -6927,14 +7134,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 _size908; +- ::apache::thrift::protocol::TType _etype911; +- xfer += iprot->readListBegin(_etype911, _size908); +- (*(this->success)).resize(_size908); +- uint32_t _i912; +- for (_i912 = 0; _i912 < _size908; ++_i912) ++ uint32_t _size910; ++ ::apache::thrift::protocol::TType _etype913; ++ xfer += iprot->readListBegin(_etype913, _size910); ++ (*(this->success)).resize(_size910); ++ uint32_t _i914; ++ for (_i914 = 0; _i914 < _size910; ++_i914) + { +- xfer += iprot->readString((*(this->success))[_i912]); ++ xfer += iprot->readString((*(this->success))[_i914]); + } + xfer += iprot->readListEnd(); + } +@@ -8268,14 +8475,14 @@ uint32_t ThriftHiveMetastore_add_partitions_args::read(::apache::thrift::protoco + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->new_parts.clear(); +- uint32_t _size913; +- ::apache::thrift::protocol::TType _etype916; +- xfer += iprot->readListBegin(_etype916, _size913); +- this->new_parts.resize(_size913); +- uint32_t _i917; +- for (_i917 = 0; _i917 < _size913; ++_i917) ++ uint32_t _size915; ++ ::apache::thrift::protocol::TType _etype918; ++ xfer += iprot->readListBegin(_etype918, _size915); ++ this->new_parts.resize(_size915); ++ uint32_t _i919; ++ for (_i919 = 0; _i919 < _size915; ++_i919) + { +- xfer += this->new_parts[_i917].read(iprot); ++ xfer += this->new_parts[_i919].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -8304,10 +8511,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 _iter918; +- for (_iter918 = this->new_parts.begin(); _iter918 != this->new_parts.end(); ++_iter918) ++ std::vector ::const_iterator _iter920; ++ for (_iter920 = this->new_parts.begin(); _iter920 != this->new_parts.end(); ++_iter920) + { +- xfer += (*_iter918).write(oprot); ++ xfer += (*_iter920).write(oprot); + } + xfer += oprot->writeListEnd(); + } +@@ -8331,10 +8538,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 _iter919; +- for (_iter919 = (*(this->new_parts)).begin(); _iter919 != (*(this->new_parts)).end(); ++_iter919) ++ std::vector ::const_iterator _iter921; ++ for (_iter921 = (*(this->new_parts)).begin(); _iter921 != (*(this->new_parts)).end(); ++_iter921) + { +- xfer += (*_iter919).write(oprot); ++ xfer += (*_iter921).write(oprot); + } + xfer += oprot->writeListEnd(); + } +@@ -8543,14 +8750,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 _size920; +- ::apache::thrift::protocol::TType _etype923; +- xfer += iprot->readListBegin(_etype923, _size920); +- this->new_parts.resize(_size920); +- uint32_t _i924; +- for (_i924 = 0; _i924 < _size920; ++_i924) ++ uint32_t _size922; ++ ::apache::thrift::protocol::TType _etype925; ++ xfer += iprot->readListBegin(_etype925, _size922); ++ this->new_parts.resize(_size922); ++ uint32_t _i926; ++ for (_i926 = 0; _i926 < _size922; ++_i926) + { +- xfer += this->new_parts[_i924].read(iprot); ++ xfer += this->new_parts[_i926].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -8579,10 +8786,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 _iter925; +- for (_iter925 = this->new_parts.begin(); _iter925 != this->new_parts.end(); ++_iter925) ++ std::vector ::const_iterator _iter927; ++ for (_iter927 = this->new_parts.begin(); _iter927 != this->new_parts.end(); ++_iter927) + { +- xfer += (*_iter925).write(oprot); ++ xfer += (*_iter927).write(oprot); + } + xfer += oprot->writeListEnd(); + } +@@ -8606,10 +8813,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 _iter926; +- for (_iter926 = (*(this->new_parts)).begin(); _iter926 != (*(this->new_parts)).end(); ++_iter926) ++ std::vector ::const_iterator _iter928; ++ for (_iter928 = (*(this->new_parts)).begin(); _iter928 != (*(this->new_parts)).end(); ++_iter928) + { +- xfer += (*_iter926).write(oprot); ++ xfer += (*_iter928).write(oprot); + } + xfer += oprot->writeListEnd(); + } +@@ -8834,14 +9041,14 @@ uint32_t ThriftHiveMetastore_append_partition_args::read(::apache::thrift::proto + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->part_vals.clear(); +- uint32_t _size927; +- ::apache::thrift::protocol::TType _etype930; +- xfer += iprot->readListBegin(_etype930, _size927); +- this->part_vals.resize(_size927); +- uint32_t _i931; +- for (_i931 = 0; _i931 < _size927; ++_i931) ++ uint32_t _size929; ++ ::apache::thrift::protocol::TType _etype932; ++ xfer += iprot->readListBegin(_etype932, _size929); ++ this->part_vals.resize(_size929); ++ uint32_t _i933; ++ for (_i933 = 0; _i933 < _size929; ++_i933) + { +- xfer += iprot->readString(this->part_vals[_i931]); ++ xfer += iprot->readString(this->part_vals[_i933]); + } + xfer += iprot->readListEnd(); + } +@@ -8878,10 +9085,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 _iter932; +- for (_iter932 = this->part_vals.begin(); _iter932 != this->part_vals.end(); ++_iter932) ++ std::vector ::const_iterator _iter934; ++ for (_iter934 = this->part_vals.begin(); _iter934 != this->part_vals.end(); ++_iter934) + { +- xfer += oprot->writeString((*_iter932)); ++ xfer += oprot->writeString((*_iter934)); + } + xfer += oprot->writeListEnd(); + } +@@ -8913,10 +9120,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 _iter933; +- for (_iter933 = (*(this->part_vals)).begin(); _iter933 != (*(this->part_vals)).end(); ++_iter933) ++ std::vector ::const_iterator _iter935; ++ for (_iter935 = (*(this->part_vals)).begin(); _iter935 != (*(this->part_vals)).end(); ++_iter935) + { +- xfer += oprot->writeString((*_iter933)); ++ xfer += oprot->writeString((*_iter935)); + } + xfer += oprot->writeListEnd(); + } +@@ -9388,14 +9595,14 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::rea + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->part_vals.clear(); +- uint32_t _size934; +- ::apache::thrift::protocol::TType _etype937; +- xfer += iprot->readListBegin(_etype937, _size934); +- this->part_vals.resize(_size934); +- uint32_t _i938; +- for (_i938 = 0; _i938 < _size934; ++_i938) ++ uint32_t _size936; ++ ::apache::thrift::protocol::TType _etype939; ++ xfer += iprot->readListBegin(_etype939, _size936); ++ this->part_vals.resize(_size936); ++ uint32_t _i940; ++ for (_i940 = 0; _i940 < _size936; ++_i940) + { +- xfer += iprot->readString(this->part_vals[_i938]); ++ xfer += iprot->readString(this->part_vals[_i940]); + } + xfer += iprot->readListEnd(); + } +@@ -9440,10 +9647,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 _iter939; +- for (_iter939 = this->part_vals.begin(); _iter939 != this->part_vals.end(); ++_iter939) ++ std::vector ::const_iterator _iter941; ++ for (_iter941 = this->part_vals.begin(); _iter941 != this->part_vals.end(); ++_iter941) + { +- xfer += oprot->writeString((*_iter939)); ++ xfer += oprot->writeString((*_iter941)); + } + xfer += oprot->writeListEnd(); + } +@@ -9479,10 +9686,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 _iter940; +- for (_iter940 = (*(this->part_vals)).begin(); _iter940 != (*(this->part_vals)).end(); ++_iter940) ++ std::vector ::const_iterator _iter942; ++ for (_iter942 = (*(this->part_vals)).begin(); _iter942 != (*(this->part_vals)).end(); ++_iter942) + { +- xfer += oprot->writeString((*_iter940)); ++ xfer += oprot->writeString((*_iter942)); + } + xfer += oprot->writeListEnd(); + } +@@ -10285,14 +10492,14 @@ uint32_t ThriftHiveMetastore_drop_partition_args::read(::apache::thrift::protoco + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->part_vals.clear(); +- uint32_t _size941; +- ::apache::thrift::protocol::TType _etype944; +- xfer += iprot->readListBegin(_etype944, _size941); +- this->part_vals.resize(_size941); +- uint32_t _i945; +- for (_i945 = 0; _i945 < _size941; ++_i945) ++ uint32_t _size943; ++ ::apache::thrift::protocol::TType _etype946; ++ xfer += iprot->readListBegin(_etype946, _size943); ++ this->part_vals.resize(_size943); ++ uint32_t _i947; ++ for (_i947 = 0; _i947 < _size943; ++_i947) + { +- xfer += iprot->readString(this->part_vals[_i945]); ++ xfer += iprot->readString(this->part_vals[_i947]); + } + xfer += iprot->readListEnd(); + } +@@ -10337,10 +10544,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 _iter946; +- for (_iter946 = this->part_vals.begin(); _iter946 != this->part_vals.end(); ++_iter946) ++ std::vector ::const_iterator _iter948; ++ for (_iter948 = this->part_vals.begin(); _iter948 != this->part_vals.end(); ++_iter948) + { +- xfer += oprot->writeString((*_iter946)); ++ xfer += oprot->writeString((*_iter948)); + } + xfer += oprot->writeListEnd(); + } +@@ -10376,10 +10583,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 _iter947; +- for (_iter947 = (*(this->part_vals)).begin(); _iter947 != (*(this->part_vals)).end(); ++_iter947) ++ std::vector ::const_iterator _iter949; ++ for (_iter949 = (*(this->part_vals)).begin(); _iter949 != (*(this->part_vals)).end(); ++_iter949) + { +- xfer += oprot->writeString((*_iter947)); ++ xfer += oprot->writeString((*_iter949)); + } + xfer += oprot->writeListEnd(); + } +@@ -10588,14 +10795,14 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::read( + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->part_vals.clear(); +- uint32_t _size948; +- ::apache::thrift::protocol::TType _etype951; +- xfer += iprot->readListBegin(_etype951, _size948); +- this->part_vals.resize(_size948); +- uint32_t _i952; +- for (_i952 = 0; _i952 < _size948; ++_i952) ++ uint32_t _size950; ++ ::apache::thrift::protocol::TType _etype953; ++ xfer += iprot->readListBegin(_etype953, _size950); ++ this->part_vals.resize(_size950); ++ uint32_t _i954; ++ for (_i954 = 0; _i954 < _size950; ++_i954) + { +- xfer += iprot->readString(this->part_vals[_i952]); ++ xfer += iprot->readString(this->part_vals[_i954]); + } + xfer += iprot->readListEnd(); + } +@@ -10648,10 +10855,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 _iter953; +- for (_iter953 = this->part_vals.begin(); _iter953 != this->part_vals.end(); ++_iter953) ++ std::vector ::const_iterator _iter955; ++ for (_iter955 = this->part_vals.begin(); _iter955 != this->part_vals.end(); ++_iter955) + { +- xfer += oprot->writeString((*_iter953)); ++ xfer += oprot->writeString((*_iter955)); + } + xfer += oprot->writeListEnd(); + } +@@ -10691,10 +10898,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 _iter954; +- for (_iter954 = (*(this->part_vals)).begin(); _iter954 != (*(this->part_vals)).end(); ++_iter954) ++ std::vector ::const_iterator _iter956; ++ for (_iter956 = (*(this->part_vals)).begin(); _iter956 != (*(this->part_vals)).end(); ++_iter956) + { +- xfer += oprot->writeString((*_iter954)); ++ xfer += oprot->writeString((*_iter956)); + } + xfer += oprot->writeListEnd(); + } +@@ -11700,14 +11907,14 @@ uint32_t ThriftHiveMetastore_get_partition_args::read(::apache::thrift::protocol + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->part_vals.clear(); +- uint32_t _size955; +- ::apache::thrift::protocol::TType _etype958; +- xfer += iprot->readListBegin(_etype958, _size955); +- this->part_vals.resize(_size955); +- uint32_t _i959; +- for (_i959 = 0; _i959 < _size955; ++_i959) ++ uint32_t _size957; ++ ::apache::thrift::protocol::TType _etype960; ++ xfer += iprot->readListBegin(_etype960, _size957); ++ this->part_vals.resize(_size957); ++ uint32_t _i961; ++ for (_i961 = 0; _i961 < _size957; ++_i961) + { +- xfer += iprot->readString(this->part_vals[_i959]); ++ xfer += iprot->readString(this->part_vals[_i961]); + } + xfer += iprot->readListEnd(); + } +@@ -11744,10 +11951,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 _iter960; +- for (_iter960 = this->part_vals.begin(); _iter960 != this->part_vals.end(); ++_iter960) ++ std::vector ::const_iterator _iter962; ++ for (_iter962 = this->part_vals.begin(); _iter962 != this->part_vals.end(); ++_iter962) + { +- xfer += oprot->writeString((*_iter960)); ++ xfer += oprot->writeString((*_iter962)); + } + xfer += oprot->writeListEnd(); + } +@@ -11779,10 +11986,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 _iter961; +- for (_iter961 = (*(this->part_vals)).begin(); _iter961 != (*(this->part_vals)).end(); ++_iter961) ++ std::vector ::const_iterator _iter963; ++ for (_iter963 = (*(this->part_vals)).begin(); _iter963 != (*(this->part_vals)).end(); ++_iter963) + { +- xfer += oprot->writeString((*_iter961)); ++ xfer += oprot->writeString((*_iter963)); + } + xfer += oprot->writeListEnd(); + } +@@ -11971,17 +12178,17 @@ uint32_t ThriftHiveMetastore_exchange_partition_args::read(::apache::thrift::pro + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + this->partitionSpecs.clear(); +- uint32_t _size962; +- ::apache::thrift::protocol::TType _ktype963; +- ::apache::thrift::protocol::TType _vtype964; +- xfer += iprot->readMapBegin(_ktype963, _vtype964, _size962); +- uint32_t _i966; +- for (_i966 = 0; _i966 < _size962; ++_i966) ++ uint32_t _size964; ++ ::apache::thrift::protocol::TType _ktype965; ++ ::apache::thrift::protocol::TType _vtype966; ++ xfer += iprot->readMapBegin(_ktype965, _vtype966, _size964); ++ uint32_t _i968; ++ for (_i968 = 0; _i968 < _size964; ++_i968) + { +- std::string _key967; +- xfer += iprot->readString(_key967); +- std::string& _val968 = this->partitionSpecs[_key967]; +- xfer += iprot->readString(_val968); ++ std::string _key969; ++ xfer += iprot->readString(_key969); ++ std::string& _val970 = this->partitionSpecs[_key969]; ++ xfer += iprot->readString(_val970); + } + xfer += iprot->readMapEnd(); + } +@@ -12042,11 +12249,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 _iter969; +- for (_iter969 = this->partitionSpecs.begin(); _iter969 != this->partitionSpecs.end(); ++_iter969) ++ std::map ::const_iterator _iter971; ++ for (_iter971 = this->partitionSpecs.begin(); _iter971 != this->partitionSpecs.end(); ++_iter971) + { +- xfer += oprot->writeString(_iter969->first); +- xfer += oprot->writeString(_iter969->second); ++ xfer += oprot->writeString(_iter971->first); ++ xfer += oprot->writeString(_iter971->second); + } + xfer += oprot->writeMapEnd(); + } +@@ -12086,11 +12293,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 _iter970; +- for (_iter970 = (*(this->partitionSpecs)).begin(); _iter970 != (*(this->partitionSpecs)).end(); ++_iter970) ++ std::map ::const_iterator _iter972; ++ for (_iter972 = (*(this->partitionSpecs)).begin(); _iter972 != (*(this->partitionSpecs)).end(); ++_iter972) + { +- xfer += oprot->writeString(_iter970->first); +- xfer += oprot->writeString(_iter970->second); ++ xfer += oprot->writeString(_iter972->first); ++ xfer += oprot->writeString(_iter972->second); + } + xfer += oprot->writeMapEnd(); + } +@@ -12335,17 +12542,17 @@ uint32_t ThriftHiveMetastore_exchange_partitions_args::read(::apache::thrift::pr + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + this->partitionSpecs.clear(); +- uint32_t _size971; +- ::apache::thrift::protocol::TType _ktype972; +- ::apache::thrift::protocol::TType _vtype973; +- xfer += iprot->readMapBegin(_ktype972, _vtype973, _size971); +- uint32_t _i975; +- for (_i975 = 0; _i975 < _size971; ++_i975) ++ uint32_t _size973; ++ ::apache::thrift::protocol::TType _ktype974; ++ ::apache::thrift::protocol::TType _vtype975; ++ xfer += iprot->readMapBegin(_ktype974, _vtype975, _size973); ++ uint32_t _i977; ++ for (_i977 = 0; _i977 < _size973; ++_i977) + { +- std::string _key976; +- xfer += iprot->readString(_key976); +- std::string& _val977 = this->partitionSpecs[_key976]; +- xfer += iprot->readString(_val977); ++ std::string _key978; ++ xfer += iprot->readString(_key978); ++ std::string& _val979 = this->partitionSpecs[_key978]; ++ xfer += iprot->readString(_val979); + } + xfer += iprot->readMapEnd(); + } +@@ -12406,11 +12613,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 _iter978; +- for (_iter978 = this->partitionSpecs.begin(); _iter978 != this->partitionSpecs.end(); ++_iter978) ++ std::map ::const_iterator _iter980; ++ for (_iter980 = this->partitionSpecs.begin(); _iter980 != this->partitionSpecs.end(); ++_iter980) + { +- xfer += oprot->writeString(_iter978->first); +- xfer += oprot->writeString(_iter978->second); ++ xfer += oprot->writeString(_iter980->first); ++ xfer += oprot->writeString(_iter980->second); + } + xfer += oprot->writeMapEnd(); + } +@@ -12450,11 +12657,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 _iter979; +- for (_iter979 = (*(this->partitionSpecs)).begin(); _iter979 != (*(this->partitionSpecs)).end(); ++_iter979) ++ std::map ::const_iterator _iter981; ++ for (_iter981 = (*(this->partitionSpecs)).begin(); _iter981 != (*(this->partitionSpecs)).end(); ++_iter981) + { +- xfer += oprot->writeString(_iter979->first); +- xfer += oprot->writeString(_iter979->second); ++ xfer += oprot->writeString(_iter981->first); ++ xfer += oprot->writeString(_iter981->second); + } + xfer += oprot->writeMapEnd(); + } +@@ -12511,14 +12718,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_result::read(::apache::thrift:: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); +- uint32_t _size980; +- ::apache::thrift::protocol::TType _etype983; +- xfer += iprot->readListBegin(_etype983, _size980); +- this->success.resize(_size980); +- uint32_t _i984; +- for (_i984 = 0; _i984 < _size980; ++_i984) ++ 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 += this->success[_i984].read(iprot); ++ xfer += this->success[_i986].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -12581,10 +12788,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 _iter985; +- for (_iter985 = this->success.begin(); _iter985 != this->success.end(); ++_iter985) ++ std::vector ::const_iterator _iter987; ++ for (_iter987 = this->success.begin(); _iter987 != this->success.end(); ++_iter987) + { +- xfer += (*_iter985).write(oprot); ++ xfer += (*_iter987).write(oprot); + } + xfer += oprot->writeListEnd(); + } +@@ -12641,14 +12848,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_presult::read(::apache::thrift: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); +- uint32_t _size986; +- ::apache::thrift::protocol::TType _etype989; +- xfer += iprot->readListBegin(_etype989, _size986); +- (*(this->success)).resize(_size986); +- uint32_t _i990; +- for (_i990 = 0; _i990 < _size986; ++_i990) ++ uint32_t _size988; ++ ::apache::thrift::protocol::TType _etype991; ++ xfer += iprot->readListBegin(_etype991, _size988); ++ (*(this->success)).resize(_size988); ++ uint32_t _i992; ++ for (_i992 = 0; _i992 < _size988; ++_i992) + { +- xfer += (*(this->success))[_i990].read(iprot); ++ xfer += (*(this->success))[_i992].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -12747,14 +12954,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 _size991; +- ::apache::thrift::protocol::TType _etype994; +- xfer += iprot->readListBegin(_etype994, _size991); +- this->part_vals.resize(_size991); +- uint32_t _i995; +- for (_i995 = 0; _i995 < _size991; ++_i995) ++ uint32_t _size993; ++ ::apache::thrift::protocol::TType _etype996; ++ xfer += iprot->readListBegin(_etype996, _size993); ++ this->part_vals.resize(_size993); ++ uint32_t _i997; ++ for (_i997 = 0; _i997 < _size993; ++_i997) + { +- xfer += iprot->readString(this->part_vals[_i995]); ++ xfer += iprot->readString(this->part_vals[_i997]); + } + xfer += iprot->readListEnd(); + } +@@ -12775,14 +12982,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 _size996; +- ::apache::thrift::protocol::TType _etype999; +- xfer += iprot->readListBegin(_etype999, _size996); +- this->group_names.resize(_size996); +- uint32_t _i1000; +- for (_i1000 = 0; _i1000 < _size996; ++_i1000) ++ uint32_t _size998; ++ ::apache::thrift::protocol::TType _etype1001; ++ xfer += iprot->readListBegin(_etype1001, _size998); ++ this->group_names.resize(_size998); ++ uint32_t _i1002; ++ for (_i1002 = 0; _i1002 < _size998; ++_i1002) + { +- xfer += iprot->readString(this->group_names[_i1000]); ++ xfer += iprot->readString(this->group_names[_i1002]); + } + xfer += iprot->readListEnd(); + } +@@ -12819,10 +13026,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 _iter1001; +- for (_iter1001 = this->part_vals.begin(); _iter1001 != this->part_vals.end(); ++_iter1001) ++ std::vector ::const_iterator _iter1003; ++ for (_iter1003 = this->part_vals.begin(); _iter1003 != this->part_vals.end(); ++_iter1003) + { +- xfer += oprot->writeString((*_iter1001)); ++ xfer += oprot->writeString((*_iter1003)); + } + xfer += oprot->writeListEnd(); + } +@@ -12835,10 +13042,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 _iter1002; +- for (_iter1002 = this->group_names.begin(); _iter1002 != this->group_names.end(); ++_iter1002) ++ std::vector ::const_iterator _iter1004; ++ for (_iter1004 = this->group_names.begin(); _iter1004 != this->group_names.end(); ++_iter1004) + { +- xfer += oprot->writeString((*_iter1002)); ++ xfer += oprot->writeString((*_iter1004)); + } + xfer += oprot->writeListEnd(); + } +@@ -12870,10 +13077,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 _iter1003; +- for (_iter1003 = (*(this->part_vals)).begin(); _iter1003 != (*(this->part_vals)).end(); ++_iter1003) ++ std::vector ::const_iterator _iter1005; ++ for (_iter1005 = (*(this->part_vals)).begin(); _iter1005 != (*(this->part_vals)).end(); ++_iter1005) + { +- xfer += oprot->writeString((*_iter1003)); ++ xfer += oprot->writeString((*_iter1005)); + } + xfer += oprot->writeListEnd(); + } +@@ -12886,10 +13093,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 _iter1004; +- for (_iter1004 = (*(this->group_names)).begin(); _iter1004 != (*(this->group_names)).end(); ++_iter1004) ++ std::vector ::const_iterator _iter1006; ++ for (_iter1006 = (*(this->group_names)).begin(); _iter1006 != (*(this->group_names)).end(); ++_iter1006) + { +- xfer += oprot->writeString((*_iter1004)); ++ xfer += oprot->writeString((*_iter1006)); + } + xfer += oprot->writeListEnd(); + } +@@ -13448,14 +13655,14 @@ uint32_t ThriftHiveMetastore_get_partitions_result::read(::apache::thrift::proto + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); +- uint32_t _size1005; +- ::apache::thrift::protocol::TType _etype1008; +- xfer += iprot->readListBegin(_etype1008, _size1005); +- this->success.resize(_size1005); +- uint32_t _i1009; +- for (_i1009 = 0; _i1009 < _size1005; ++_i1009) ++ uint32_t _size1007; ++ ::apache::thrift::protocol::TType _etype1010; ++ xfer += iprot->readListBegin(_etype1010, _size1007); ++ this->success.resize(_size1007); ++ uint32_t _i1011; ++ for (_i1011 = 0; _i1011 < _size1007; ++_i1011) + { +- xfer += this->success[_i1009].read(iprot); ++ xfer += this->success[_i1011].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -13502,10 +13709,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 _iter1010; +- for (_iter1010 = this->success.begin(); _iter1010 != this->success.end(); ++_iter1010) ++ std::vector ::const_iterator _iter1012; ++ for (_iter1012 = this->success.begin(); _iter1012 != this->success.end(); ++_iter1012) + { +- xfer += (*_iter1010).write(oprot); ++ xfer += (*_iter1012).write(oprot); + } + xfer += oprot->writeListEnd(); + } +@@ -13554,14 +13761,14 @@ uint32_t ThriftHiveMetastore_get_partitions_presult::read(::apache::thrift::prot + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); +- uint32_t _size1011; +- ::apache::thrift::protocol::TType _etype1014; +- xfer += iprot->readListBegin(_etype1014, _size1011); +- (*(this->success)).resize(_size1011); +- uint32_t _i1015; +- for (_i1015 = 0; _i1015 < _size1011; ++_i1015) ++ 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))[_i1015].read(iprot); ++ xfer += (*(this->success))[_i1017].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -13660,14 +13867,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 _size1016; +- ::apache::thrift::protocol::TType _etype1019; +- xfer += iprot->readListBegin(_etype1019, _size1016); +- this->group_names.resize(_size1016); +- uint32_t _i1020; +- for (_i1020 = 0; _i1020 < _size1016; ++_i1020) ++ uint32_t _size1018; ++ ::apache::thrift::protocol::TType _etype1021; ++ xfer += iprot->readListBegin(_etype1021, _size1018); ++ this->group_names.resize(_size1018); ++ uint32_t _i1022; ++ for (_i1022 = 0; _i1022 < _size1018; ++_i1022) + { +- xfer += iprot->readString(this->group_names[_i1020]); ++ xfer += iprot->readString(this->group_names[_i1022]); + } + xfer += iprot->readListEnd(); + } +@@ -13712,10 +13919,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 _iter1021; +- for (_iter1021 = this->group_names.begin(); _iter1021 != this->group_names.end(); ++_iter1021) ++ std::vector ::const_iterator _iter1023; ++ for (_iter1023 = this->group_names.begin(); _iter1023 != this->group_names.end(); ++_iter1023) + { +- xfer += oprot->writeString((*_iter1021)); ++ xfer += oprot->writeString((*_iter1023)); + } + xfer += oprot->writeListEnd(); + } +@@ -13755,10 +13962,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 _iter1022; +- for (_iter1022 = (*(this->group_names)).begin(); _iter1022 != (*(this->group_names)).end(); ++_iter1022) ++ std::vector ::const_iterator _iter1024; ++ for (_iter1024 = (*(this->group_names)).begin(); _iter1024 != (*(this->group_names)).end(); ++_iter1024) + { +- xfer += oprot->writeString((*_iter1022)); ++ xfer += oprot->writeString((*_iter1024)); + } + xfer += oprot->writeListEnd(); + } +@@ -13799,14 +14006,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_result::read(::apache::thr + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); +- uint32_t _size1023; +- ::apache::thrift::protocol::TType _etype1026; +- xfer += iprot->readListBegin(_etype1026, _size1023); +- this->success.resize(_size1023); +- uint32_t _i1027; +- for (_i1027 = 0; _i1027 < _size1023; ++_i1027) ++ uint32_t _size1025; ++ ::apache::thrift::protocol::TType _etype1028; ++ xfer += iprot->readListBegin(_etype1028, _size1025); ++ this->success.resize(_size1025); ++ uint32_t _i1029; ++ for (_i1029 = 0; _i1029 < _size1025; ++_i1029) + { +- xfer += this->success[_i1027].read(iprot); ++ xfer += this->success[_i1029].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -13853,10 +14060,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 _iter1028; +- for (_iter1028 = this->success.begin(); _iter1028 != this->success.end(); ++_iter1028) ++ std::vector ::const_iterator _iter1030; ++ for (_iter1030 = this->success.begin(); _iter1030 != this->success.end(); ++_iter1030) + { +- xfer += (*_iter1028).write(oprot); ++ xfer += (*_iter1030).write(oprot); + } + xfer += oprot->writeListEnd(); + } +@@ -13905,14 +14112,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_presult::read(::apache::th + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); +- uint32_t _size1029; +- ::apache::thrift::protocol::TType _etype1032; +- xfer += iprot->readListBegin(_etype1032, _size1029); +- (*(this->success)).resize(_size1029); +- uint32_t _i1033; +- for (_i1033 = 0; _i1033 < _size1029; ++_i1033) ++ uint32_t _size1031; ++ ::apache::thrift::protocol::TType _etype1034; ++ xfer += iprot->readListBegin(_etype1034, _size1031); ++ (*(this->success)).resize(_size1031); ++ uint32_t _i1035; ++ for (_i1035 = 0; _i1035 < _size1031; ++_i1035) + { +- xfer += (*(this->success))[_i1033].read(iprot); ++ xfer += (*(this->success))[_i1035].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -14090,14 +14297,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_result::read(::apache::thrift: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); +- uint32_t _size1034; +- ::apache::thrift::protocol::TType _etype1037; +- xfer += iprot->readListBegin(_etype1037, _size1034); +- this->success.resize(_size1034); +- uint32_t _i1038; +- for (_i1038 = 0; _i1038 < _size1034; ++_i1038) ++ uint32_t _size1036; ++ ::apache::thrift::protocol::TType _etype1039; ++ xfer += iprot->readListBegin(_etype1039, _size1036); ++ this->success.resize(_size1036); ++ uint32_t _i1040; ++ for (_i1040 = 0; _i1040 < _size1036; ++_i1040) + { +- xfer += this->success[_i1038].read(iprot); ++ xfer += this->success[_i1040].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -14144,10 +14351,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 _iter1039; +- for (_iter1039 = this->success.begin(); _iter1039 != this->success.end(); ++_iter1039) ++ std::vector ::const_iterator _iter1041; ++ for (_iter1041 = this->success.begin(); _iter1041 != this->success.end(); ++_iter1041) + { +- xfer += (*_iter1039).write(oprot); ++ xfer += (*_iter1041).write(oprot); + } + xfer += oprot->writeListEnd(); + } +@@ -14196,14 +14403,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_presult::read(::apache::thrift + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); +- uint32_t _size1040; +- ::apache::thrift::protocol::TType _etype1043; +- xfer += iprot->readListBegin(_etype1043, _size1040); +- (*(this->success)).resize(_size1040); +- uint32_t _i1044; +- for (_i1044 = 0; _i1044 < _size1040; ++_i1044) ++ uint32_t _size1042; ++ ::apache::thrift::protocol::TType _etype1045; ++ xfer += iprot->readListBegin(_etype1045, _size1042); ++ (*(this->success)).resize(_size1042); ++ uint32_t _i1046; ++ for (_i1046 = 0; _i1046 < _size1042; ++_i1046) + { +- xfer += (*(this->success))[_i1044].read(iprot); ++ xfer += (*(this->success))[_i1046].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -14381,14 +14588,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_result::read(::apache::thrift:: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); +- uint32_t _size1045; +- ::apache::thrift::protocol::TType _etype1048; +- xfer += iprot->readListBegin(_etype1048, _size1045); +- this->success.resize(_size1045); +- uint32_t _i1049; +- for (_i1049 = 0; _i1049 < _size1045; ++_i1049) ++ uint32_t _size1047; ++ ::apache::thrift::protocol::TType _etype1050; ++ xfer += iprot->readListBegin(_etype1050, _size1047); ++ this->success.resize(_size1047); ++ uint32_t _i1051; ++ for (_i1051 = 0; _i1051 < _size1047; ++_i1051) + { +- xfer += iprot->readString(this->success[_i1049]); ++ xfer += iprot->readString(this->success[_i1051]); + } + xfer += iprot->readListEnd(); + } +@@ -14427,10 +14634,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 _iter1050; +- for (_iter1050 = this->success.begin(); _iter1050 != this->success.end(); ++_iter1050) ++ std::vector ::const_iterator _iter1052; ++ for (_iter1052 = this->success.begin(); _iter1052 != this->success.end(); ++_iter1052) + { +- xfer += oprot->writeString((*_iter1050)); ++ xfer += oprot->writeString((*_iter1052)); + } + xfer += oprot->writeListEnd(); + } +@@ -14475,14 +14682,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_presult::read(::apache::thrift: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); +- uint32_t _size1051; +- ::apache::thrift::protocol::TType _etype1054; +- xfer += iprot->readListBegin(_etype1054, _size1051); +- (*(this->success)).resize(_size1051); +- uint32_t _i1055; +- for (_i1055 = 0; _i1055 < _size1051; ++_i1055) ++ uint32_t _size1053; ++ ::apache::thrift::protocol::TType _etype1056; ++ xfer += iprot->readListBegin(_etype1056, _size1053); ++ (*(this->success)).resize(_size1053); ++ uint32_t _i1057; ++ for (_i1057 = 0; _i1057 < _size1053; ++_i1057) + { +- xfer += iprot->readString((*(this->success))[_i1055]); ++ xfer += iprot->readString((*(this->success))[_i1057]); + } + xfer += iprot->readListEnd(); + } +@@ -14557,14 +14764,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 _size1056; +- ::apache::thrift::protocol::TType _etype1059; +- xfer += iprot->readListBegin(_etype1059, _size1056); +- this->part_vals.resize(_size1056); +- uint32_t _i1060; +- for (_i1060 = 0; _i1060 < _size1056; ++_i1060) ++ uint32_t _size1058; ++ ::apache::thrift::protocol::TType _etype1061; ++ xfer += iprot->readListBegin(_etype1061, _size1058); ++ this->part_vals.resize(_size1058); ++ uint32_t _i1062; ++ for (_i1062 = 0; _i1062 < _size1058; ++_i1062) + { +- xfer += iprot->readString(this->part_vals[_i1060]); ++ xfer += iprot->readString(this->part_vals[_i1062]); + } + xfer += iprot->readListEnd(); + } +@@ -14609,10 +14816,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 _iter1061; +- for (_iter1061 = this->part_vals.begin(); _iter1061 != this->part_vals.end(); ++_iter1061) ++ std::vector ::const_iterator _iter1063; ++ for (_iter1063 = this->part_vals.begin(); _iter1063 != this->part_vals.end(); ++_iter1063) + { +- xfer += oprot->writeString((*_iter1061)); ++ xfer += oprot->writeString((*_iter1063)); + } + xfer += oprot->writeListEnd(); + } +@@ -14648,10 +14855,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 _iter1062; +- for (_iter1062 = (*(this->part_vals)).begin(); _iter1062 != (*(this->part_vals)).end(); ++_iter1062) ++ std::vector ::const_iterator _iter1064; ++ for (_iter1064 = (*(this->part_vals)).begin(); _iter1064 != (*(this->part_vals)).end(); ++_iter1064) + { +- xfer += oprot->writeString((*_iter1062)); ++ xfer += oprot->writeString((*_iter1064)); + } + xfer += oprot->writeListEnd(); + } +@@ -14696,14 +14903,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_result::read(::apache::thrift::pr + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); +- uint32_t _size1063; +- ::apache::thrift::protocol::TType _etype1066; +- xfer += iprot->readListBegin(_etype1066, _size1063); +- this->success.resize(_size1063); +- uint32_t _i1067; +- for (_i1067 = 0; _i1067 < _size1063; ++_i1067) ++ uint32_t _size1065; ++ ::apache::thrift::protocol::TType _etype1068; ++ xfer += iprot->readListBegin(_etype1068, _size1065); ++ this->success.resize(_size1065); ++ uint32_t _i1069; ++ for (_i1069 = 0; _i1069 < _size1065; ++_i1069) + { +- xfer += this->success[_i1067].read(iprot); ++ xfer += this->success[_i1069].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -14750,10 +14957,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 _iter1068; +- for (_iter1068 = this->success.begin(); _iter1068 != this->success.end(); ++_iter1068) ++ std::vector ::const_iterator _iter1070; ++ for (_iter1070 = this->success.begin(); _iter1070 != this->success.end(); ++_iter1070) + { +- xfer += (*_iter1068).write(oprot); ++ xfer += (*_iter1070).write(oprot); + } + xfer += oprot->writeListEnd(); + } +@@ -14802,14 +15009,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_presult::read(::apache::thrift::p + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); +- uint32_t _size1069; +- ::apache::thrift::protocol::TType _etype1072; +- xfer += iprot->readListBegin(_etype1072, _size1069); +- (*(this->success)).resize(_size1069); +- uint32_t _i1073; +- for (_i1073 = 0; _i1073 < _size1069; ++_i1073) ++ uint32_t _size1071; ++ ::apache::thrift::protocol::TType _etype1074; ++ xfer += iprot->readListBegin(_etype1074, _size1071); ++ (*(this->success)).resize(_size1071); ++ uint32_t _i1075; ++ for (_i1075 = 0; _i1075 < _size1071; ++_i1075) + { +- xfer += (*(this->success))[_i1073].read(iprot); ++ xfer += (*(this->success))[_i1075].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -14892,14 +15099,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 _size1074; +- ::apache::thrift::protocol::TType _etype1077; +- xfer += iprot->readListBegin(_etype1077, _size1074); +- this->part_vals.resize(_size1074); +- uint32_t _i1078; +- for (_i1078 = 0; _i1078 < _size1074; ++_i1078) ++ uint32_t _size1076; ++ ::apache::thrift::protocol::TType _etype1079; ++ xfer += iprot->readListBegin(_etype1079, _size1076); ++ this->part_vals.resize(_size1076); ++ uint32_t _i1080; ++ for (_i1080 = 0; _i1080 < _size1076; ++_i1080) + { +- xfer += iprot->readString(this->part_vals[_i1078]); ++ xfer += iprot->readString(this->part_vals[_i1080]); + } + xfer += iprot->readListEnd(); + } +@@ -14928,14 +15135,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::read(::apache::th + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->group_names.clear(); +- uint32_t _size1079; +- ::apache::thrift::protocol::TType _etype1082; +- xfer += iprot->readListBegin(_etype1082, _size1079); +- this->group_names.resize(_size1079); +- uint32_t _i1083; +- for (_i1083 = 0; _i1083 < _size1079; ++_i1083) ++ uint32_t _size1081; ++ ::apache::thrift::protocol::TType _etype1084; ++ xfer += iprot->readListBegin(_etype1084, _size1081); ++ this->group_names.resize(_size1081); ++ uint32_t _i1085; ++ for (_i1085 = 0; _i1085 < _size1081; ++_i1085) + { +- xfer += iprot->readString(this->group_names[_i1083]); ++ xfer += iprot->readString(this->group_names[_i1085]); + } + xfer += iprot->readListEnd(); + } +@@ -14972,10 +15179,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::write(::apache::t + xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); +- std::vector ::const_iterator _iter1084; +- for (_iter1084 = this->part_vals.begin(); _iter1084 != this->part_vals.end(); ++_iter1084) ++ std::vector ::const_iterator _iter1086; ++ for (_iter1086 = this->part_vals.begin(); _iter1086 != this->part_vals.end(); ++_iter1086) + { +- xfer += oprot->writeString((*_iter1084)); ++ xfer += oprot->writeString((*_iter1086)); + } + xfer += oprot->writeListEnd(); + } +@@ -14992,10 +15199,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::write(::apache::t + xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 6); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->group_names.size())); +- std::vector ::const_iterator _iter1085; +- for (_iter1085 = this->group_names.begin(); _iter1085 != this->group_names.end(); ++_iter1085) ++ std::vector ::const_iterator _iter1087; ++ for (_iter1087 = this->group_names.begin(); _iter1087 != this->group_names.end(); ++_iter1087) + { +- xfer += oprot->writeString((*_iter1085)); ++ xfer += oprot->writeString((*_iter1087)); + } + xfer += oprot->writeListEnd(); + } +@@ -15027,10 +15234,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_pargs::write(::apache:: + xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); +- std::vector ::const_iterator _iter1086; +- for (_iter1086 = (*(this->part_vals)).begin(); _iter1086 != (*(this->part_vals)).end(); ++_iter1086) ++ std::vector ::const_iterator _iter1088; ++ for (_iter1088 = (*(this->part_vals)).begin(); _iter1088 != (*(this->part_vals)).end(); ++_iter1088) + { +- xfer += oprot->writeString((*_iter1086)); ++ xfer += oprot->writeString((*_iter1088)); + } + xfer += oprot->writeListEnd(); + } +@@ -15047,10 +15254,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_pargs::write(::apache:: + xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 6); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->group_names)).size())); +- std::vector ::const_iterator _iter1087; +- for (_iter1087 = (*(this->group_names)).begin(); _iter1087 != (*(this->group_names)).end(); ++_iter1087) ++ std::vector ::const_iterator _iter1089; ++ for (_iter1089 = (*(this->group_names)).begin(); _iter1089 != (*(this->group_names)).end(); ++_iter1089) + { +- xfer += oprot->writeString((*_iter1087)); ++ xfer += oprot->writeString((*_iter1089)); + } + xfer += oprot->writeListEnd(); + } +@@ -15091,14 +15298,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_result::read(::apache:: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); +- uint32_t _size1088; +- ::apache::thrift::protocol::TType _etype1091; +- xfer += iprot->readListBegin(_etype1091, _size1088); +- this->success.resize(_size1088); +- uint32_t _i1092; +- for (_i1092 = 0; _i1092 < _size1088; ++_i1092) ++ uint32_t _size1090; ++ ::apache::thrift::protocol::TType _etype1093; ++ xfer += iprot->readListBegin(_etype1093, _size1090); ++ this->success.resize(_size1090); ++ uint32_t _i1094; ++ for (_i1094 = 0; _i1094 < _size1090; ++_i1094) + { +- xfer += this->success[_i1092].read(iprot); ++ xfer += this->success[_i1094].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -15145,10 +15352,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_result::write(::apache: + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); +- std::vector ::const_iterator _iter1093; +- for (_iter1093 = this->success.begin(); _iter1093 != this->success.end(); ++_iter1093) ++ std::vector ::const_iterator _iter1095; ++ for (_iter1095 = this->success.begin(); _iter1095 != this->success.end(); ++_iter1095) + { +- xfer += (*_iter1093).write(oprot); ++ xfer += (*_iter1095).write(oprot); + } + xfer += oprot->writeListEnd(); + } +@@ -15197,14 +15404,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_presult::read(::apache: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); +- uint32_t _size1094; +- ::apache::thrift::protocol::TType _etype1097; +- xfer += iprot->readListBegin(_etype1097, _size1094); +- (*(this->success)).resize(_size1094); +- uint32_t _i1098; +- for (_i1098 = 0; _i1098 < _size1094; ++_i1098) ++ uint32_t _size1096; ++ ::apache::thrift::protocol::TType _etype1099; ++ xfer += iprot->readListBegin(_etype1099, _size1096); ++ (*(this->success)).resize(_size1096); ++ uint32_t _i1100; ++ for (_i1100 = 0; _i1100 < _size1096; ++_i1100) + { +- xfer += (*(this->success))[_i1098].read(iprot); ++ xfer += (*(this->success))[_i1100].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -15287,14 +15494,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_args::read(::apache::thrift: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->part_vals.clear(); +- uint32_t _size1099; +- ::apache::thrift::protocol::TType _etype1102; +- xfer += iprot->readListBegin(_etype1102, _size1099); +- this->part_vals.resize(_size1099); +- uint32_t _i1103; +- for (_i1103 = 0; _i1103 < _size1099; ++_i1103) ++ uint32_t _size1101; ++ ::apache::thrift::protocol::TType _etype1104; ++ xfer += iprot->readListBegin(_etype1104, _size1101); ++ this->part_vals.resize(_size1101); ++ uint32_t _i1105; ++ for (_i1105 = 0; _i1105 < _size1101; ++_i1105) + { +- xfer += iprot->readString(this->part_vals[_i1103]); ++ xfer += iprot->readString(this->part_vals[_i1105]); + } + xfer += iprot->readListEnd(); + } +@@ -15339,10 +15546,10 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_args::write(::apache::thrift + xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); +- std::vector ::const_iterator _iter1104; +- for (_iter1104 = this->part_vals.begin(); _iter1104 != this->part_vals.end(); ++_iter1104) ++ std::vector ::const_iterator _iter1106; ++ for (_iter1106 = this->part_vals.begin(); _iter1106 != this->part_vals.end(); ++_iter1106) + { +- xfer += oprot->writeString((*_iter1104)); ++ xfer += oprot->writeString((*_iter1106)); + } + xfer += oprot->writeListEnd(); + } +@@ -15378,10 +15585,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 _iter1105; +- for (_iter1105 = (*(this->part_vals)).begin(); _iter1105 != (*(this->part_vals)).end(); ++_iter1105) ++ std::vector ::const_iterator _iter1107; ++ for (_iter1107 = (*(this->part_vals)).begin(); _iter1107 != (*(this->part_vals)).end(); ++_iter1107) + { +- xfer += oprot->writeString((*_iter1105)); ++ xfer += oprot->writeString((*_iter1107)); + } + xfer += oprot->writeListEnd(); + } +@@ -15426,14 +15633,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_result::read(::apache::thrif + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); +- uint32_t _size1106; +- ::apache::thrift::protocol::TType _etype1109; +- xfer += iprot->readListBegin(_etype1109, _size1106); +- this->success.resize(_size1106); +- uint32_t _i1110; +- for (_i1110 = 0; _i1110 < _size1106; ++_i1110) ++ uint32_t _size1108; ++ ::apache::thrift::protocol::TType _etype1111; ++ xfer += iprot->readListBegin(_etype1111, _size1108); ++ this->success.resize(_size1108); ++ uint32_t _i1112; ++ for (_i1112 = 0; _i1112 < _size1108; ++_i1112) + { +- xfer += iprot->readString(this->success[_i1110]); ++ xfer += iprot->readString(this->success[_i1112]); + } + xfer += iprot->readListEnd(); + } +@@ -15480,10 +15687,10 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_result::write(::apache::thri + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); +- std::vector ::const_iterator _iter1111; +- for (_iter1111 = this->success.begin(); _iter1111 != this->success.end(); ++_iter1111) ++ std::vector ::const_iterator _iter1113; ++ for (_iter1113 = this->success.begin(); _iter1113 != this->success.end(); ++_iter1113) + { +- xfer += oprot->writeString((*_iter1111)); ++ xfer += oprot->writeString((*_iter1113)); + } + xfer += oprot->writeListEnd(); + } +@@ -15532,14 +15739,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_presult::read(::apache::thri + 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 _size1114; ++ ::apache::thrift::protocol::TType _etype1117; ++ xfer += iprot->readListBegin(_etype1117, _size1114); ++ (*(this->success)).resize(_size1114); ++ uint32_t _i1118; ++ for (_i1118 = 0; _i1118 < _size1114; ++_i1118) + { +- xfer += iprot->readString((*(this->success))[_i1116]); ++ xfer += iprot->readString((*(this->success))[_i1118]); + } + xfer += iprot->readListEnd(); + } +@@ -15733,14 +15940,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_result::read(::apache::thr + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); +- uint32_t _size1117; +- ::apache::thrift::protocol::TType _etype1120; +- xfer += iprot->readListBegin(_etype1120, _size1117); +- this->success.resize(_size1117); +- uint32_t _i1121; +- for (_i1121 = 0; _i1121 < _size1117; ++_i1121) ++ uint32_t _size1119; ++ ::apache::thrift::protocol::TType _etype1122; ++ xfer += iprot->readListBegin(_etype1122, _size1119); ++ this->success.resize(_size1119); ++ uint32_t _i1123; ++ for (_i1123 = 0; _i1123 < _size1119; ++_i1123) + { +- xfer += this->success[_i1121].read(iprot); ++ xfer += this->success[_i1123].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -15787,10 +15994,10 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_result::write(::apache::th + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); +- std::vector ::const_iterator _iter1122; +- for (_iter1122 = this->success.begin(); _iter1122 != this->success.end(); ++_iter1122) ++ std::vector ::const_iterator _iter1124; ++ for (_iter1124 = this->success.begin(); _iter1124 != this->success.end(); ++_iter1124) + { +- xfer += (*_iter1122).write(oprot); ++ xfer += (*_iter1124).write(oprot); + } + xfer += oprot->writeListEnd(); + } +@@ -15839,14 +16046,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_presult::read(::apache::th + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); +- uint32_t _size1123; +- ::apache::thrift::protocol::TType _etype1126; +- xfer += iprot->readListBegin(_etype1126, _size1123); +- (*(this->success)).resize(_size1123); +- uint32_t _i1127; +- for (_i1127 = 0; _i1127 < _size1123; ++_i1127) ++ uint32_t _size1125; ++ ::apache::thrift::protocol::TType _etype1128; ++ xfer += iprot->readListBegin(_etype1128, _size1125); ++ (*(this->success)).resize(_size1125); ++ uint32_t _i1129; ++ for (_i1129 = 0; _i1129 < _size1125; ++_i1129) + { +- xfer += (*(this->success))[_i1127].read(iprot); ++ xfer += (*(this->success))[_i1129].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -16040,14 +16247,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 _size1128; +- ::apache::thrift::protocol::TType _etype1131; +- xfer += iprot->readListBegin(_etype1131, _size1128); +- this->success.resize(_size1128); +- uint32_t _i1132; +- for (_i1132 = 0; _i1132 < _size1128; ++_i1132) ++ uint32_t _size1130; ++ ::apache::thrift::protocol::TType _etype1133; ++ xfer += iprot->readListBegin(_etype1133, _size1130); ++ this->success.resize(_size1130); ++ uint32_t _i1134; ++ for (_i1134 = 0; _i1134 < _size1130; ++_i1134) + { +- xfer += this->success[_i1132].read(iprot); ++ xfer += this->success[_i1134].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -16094,10 +16301,10 @@ uint32_t ThriftHiveMetastore_get_part_specs_by_filter_result::write(::apache::th + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); +- std::vector ::const_iterator _iter1133; +- for (_iter1133 = this->success.begin(); _iter1133 != this->success.end(); ++_iter1133) ++ std::vector ::const_iterator _iter1135; ++ for (_iter1135 = this->success.begin(); _iter1135 != this->success.end(); ++_iter1135) + { +- xfer += (*_iter1133).write(oprot); ++ xfer += (*_iter1135).write(oprot); + } + xfer += oprot->writeListEnd(); + } +@@ -16146,14 +16353,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 _size1134; +- ::apache::thrift::protocol::TType _etype1137; +- xfer += iprot->readListBegin(_etype1137, _size1134); +- (*(this->success)).resize(_size1134); +- uint32_t _i1138; +- for (_i1138 = 0; _i1138 < _size1134; ++_i1138) ++ uint32_t _size1136; ++ ::apache::thrift::protocol::TType _etype1139; ++ xfer += iprot->readListBegin(_etype1139, _size1136); ++ (*(this->success)).resize(_size1136); ++ uint32_t _i1140; ++ for (_i1140 = 0; _i1140 < _size1136; ++_i1140) + { +- xfer += (*(this->success))[_i1138].read(iprot); ++ xfer += (*(this->success))[_i1140].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -16722,14 +16929,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_args::read(::apache::thrift + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->names.clear(); +- uint32_t _size1139; +- ::apache::thrift::protocol::TType _etype1142; +- xfer += iprot->readListBegin(_etype1142, _size1139); +- this->names.resize(_size1139); +- uint32_t _i1143; +- for (_i1143 = 0; _i1143 < _size1139; ++_i1143) ++ uint32_t _size1141; ++ ::apache::thrift::protocol::TType _etype1144; ++ xfer += iprot->readListBegin(_etype1144, _size1141); ++ this->names.resize(_size1141); ++ uint32_t _i1145; ++ for (_i1145 = 0; _i1145 < _size1141; ++_i1145) + { +- xfer += iprot->readString(this->names[_i1143]); ++ xfer += iprot->readString(this->names[_i1145]); + } + xfer += iprot->readListEnd(); + } +@@ -16766,10 +16973,10 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_args::write(::apache::thrif + xfer += oprot->writeFieldBegin("names", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->names.size())); +- std::vector ::const_iterator _iter1144; +- for (_iter1144 = this->names.begin(); _iter1144 != this->names.end(); ++_iter1144) ++ std::vector ::const_iterator _iter1146; ++ for (_iter1146 = this->names.begin(); _iter1146 != this->names.end(); ++_iter1146) + { +- xfer += oprot->writeString((*_iter1144)); ++ xfer += oprot->writeString((*_iter1146)); + } + xfer += oprot->writeListEnd(); + } +@@ -16801,10 +17008,10 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_pargs::write(::apache::thri + xfer += oprot->writeFieldBegin("names", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->names)).size())); +- std::vector ::const_iterator _iter1145; +- for (_iter1145 = (*(this->names)).begin(); _iter1145 != (*(this->names)).end(); ++_iter1145) ++ std::vector ::const_iterator _iter1147; ++ for (_iter1147 = (*(this->names)).begin(); _iter1147 != (*(this->names)).end(); ++_iter1147) + { +- xfer += oprot->writeString((*_iter1145)); ++ xfer += oprot->writeString((*_iter1147)); + } + xfer += oprot->writeListEnd(); + } +@@ -16845,14 +17052,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_result::read(::apache::thri + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); +- uint32_t _size1146; +- ::apache::thrift::protocol::TType _etype1149; +- xfer += iprot->readListBegin(_etype1149, _size1146); +- this->success.resize(_size1146); +- uint32_t _i1150; +- for (_i1150 = 0; _i1150 < _size1146; ++_i1150) ++ uint32_t _size1148; ++ ::apache::thrift::protocol::TType _etype1151; ++ xfer += iprot->readListBegin(_etype1151, _size1148); ++ this->success.resize(_size1148); ++ uint32_t _i1152; ++ for (_i1152 = 0; _i1152 < _size1148; ++_i1152) + { +- xfer += this->success[_i1150].read(iprot); ++ xfer += this->success[_i1152].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -16899,10 +17106,10 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_result::write(::apache::thr + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); +- std::vector ::const_iterator _iter1151; +- for (_iter1151 = this->success.begin(); _iter1151 != this->success.end(); ++_iter1151) ++ std::vector ::const_iterator _iter1153; ++ for (_iter1153 = this->success.begin(); _iter1153 != this->success.end(); ++_iter1153) + { +- xfer += (*_iter1151).write(oprot); ++ xfer += (*_iter1153).write(oprot); + } + xfer += oprot->writeListEnd(); + } +@@ -16951,14 +17158,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_presult::read(::apache::thr + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); +- uint32_t _size1152; +- ::apache::thrift::protocol::TType _etype1155; +- xfer += iprot->readListBegin(_etype1155, _size1152); +- (*(this->success)).resize(_size1152); +- uint32_t _i1156; +- for (_i1156 = 0; _i1156 < _size1152; ++_i1156) ++ uint32_t _size1154; ++ ::apache::thrift::protocol::TType _etype1157; ++ xfer += iprot->readListBegin(_etype1157, _size1154); ++ (*(this->success)).resize(_size1154); ++ uint32_t _i1158; ++ for (_i1158 = 0; _i1158 < _size1154; ++_i1158) + { +- xfer += (*(this->success))[_i1156].read(iprot); ++ xfer += (*(this->success))[_i1158].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -17280,14 +17487,14 @@ uint32_t ThriftHiveMetastore_alter_partitions_args::read(::apache::thrift::proto + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->new_parts.clear(); +- uint32_t _size1157; +- ::apache::thrift::protocol::TType _etype1160; +- xfer += iprot->readListBegin(_etype1160, _size1157); +- this->new_parts.resize(_size1157); +- uint32_t _i1161; +- for (_i1161 = 0; _i1161 < _size1157; ++_i1161) ++ uint32_t _size1159; ++ ::apache::thrift::protocol::TType _etype1162; ++ xfer += iprot->readListBegin(_etype1162, _size1159); ++ this->new_parts.resize(_size1159); ++ uint32_t _i1163; ++ for (_i1163 = 0; _i1163 < _size1159; ++_i1163) + { +- xfer += this->new_parts[_i1161].read(iprot); ++ xfer += this->new_parts[_i1163].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -17324,10 +17531,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 _iter1162; +- for (_iter1162 = this->new_parts.begin(); _iter1162 != this->new_parts.end(); ++_iter1162) ++ std::vector ::const_iterator _iter1164; ++ for (_iter1164 = this->new_parts.begin(); _iter1164 != this->new_parts.end(); ++_iter1164) + { +- xfer += (*_iter1162).write(oprot); ++ xfer += (*_iter1164).write(oprot); + } + xfer += oprot->writeListEnd(); + } +@@ -17359,10 +17566,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 _iter1163; +- for (_iter1163 = (*(this->new_parts)).begin(); _iter1163 != (*(this->new_parts)).end(); ++_iter1163) ++ std::vector ::const_iterator _iter1165; ++ for (_iter1165 = (*(this->new_parts)).begin(); _iter1165 != (*(this->new_parts)).end(); ++_iter1165) + { +- xfer += (*_iter1163).write(oprot); ++ xfer += (*_iter1165).write(oprot); + } + xfer += oprot->writeListEnd(); + } +@@ -17547,14 +17754,14 @@ uint32_t ThriftHiveMetastore_alter_partitions_with_environment_context_args::rea + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->new_parts.clear(); +- uint32_t _size1164; +- ::apache::thrift::protocol::TType _etype1167; +- xfer += iprot->readListBegin(_etype1167, _size1164); +- this->new_parts.resize(_size1164); +- uint32_t _i1168; +- for (_i1168 = 0; _i1168 < _size1164; ++_i1168) ++ uint32_t _size1166; ++ ::apache::thrift::protocol::TType _etype1169; ++ xfer += iprot->readListBegin(_etype1169, _size1166); ++ this->new_parts.resize(_size1166); ++ uint32_t _i1170; ++ for (_i1170 = 0; _i1170 < _size1166; ++_i1170) + { +- xfer += this->new_parts[_i1168].read(iprot); ++ xfer += this->new_parts[_i1170].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -17599,10 +17806,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 _iter1169; +- for (_iter1169 = this->new_parts.begin(); _iter1169 != this->new_parts.end(); ++_iter1169) ++ std::vector ::const_iterator _iter1171; ++ for (_iter1171 = this->new_parts.begin(); _iter1171 != this->new_parts.end(); ++_iter1171) + { +- xfer += (*_iter1169).write(oprot); ++ xfer += (*_iter1171).write(oprot); + } + xfer += oprot->writeListEnd(); + } +@@ -17638,10 +17845,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 _iter1170; +- for (_iter1170 = (*(this->new_parts)).begin(); _iter1170 != (*(this->new_parts)).end(); ++_iter1170) ++ std::vector ::const_iterator _iter1172; ++ for (_iter1172 = (*(this->new_parts)).begin(); _iter1172 != (*(this->new_parts)).end(); ++_iter1172) + { +- xfer += (*_iter1170).write(oprot); ++ xfer += (*_iter1172).write(oprot); + } + xfer += oprot->writeListEnd(); + } +@@ -18085,14 +18292,14 @@ uint32_t ThriftHiveMetastore_rename_partition_args::read(::apache::thrift::proto + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->part_vals.clear(); +- uint32_t _size1171; +- ::apache::thrift::protocol::TType _etype1174; +- xfer += iprot->readListBegin(_etype1174, _size1171); +- this->part_vals.resize(_size1171); +- uint32_t _i1175; +- for (_i1175 = 0; _i1175 < _size1171; ++_i1175) ++ uint32_t _size1173; ++ ::apache::thrift::protocol::TType _etype1176; ++ xfer += iprot->readListBegin(_etype1176, _size1173); ++ this->part_vals.resize(_size1173); ++ uint32_t _i1177; ++ for (_i1177 = 0; _i1177 < _size1173; ++_i1177) + { +- xfer += iprot->readString(this->part_vals[_i1175]); ++ xfer += iprot->readString(this->part_vals[_i1177]); + } + xfer += iprot->readListEnd(); + } +@@ -18137,10 +18344,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 _iter1176; +- for (_iter1176 = this->part_vals.begin(); _iter1176 != this->part_vals.end(); ++_iter1176) ++ std::vector ::const_iterator _iter1178; ++ for (_iter1178 = this->part_vals.begin(); _iter1178 != this->part_vals.end(); ++_iter1178) + { +- xfer += oprot->writeString((*_iter1176)); ++ xfer += oprot->writeString((*_iter1178)); + } + xfer += oprot->writeListEnd(); + } +@@ -18176,10 +18383,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 _iter1177; +- for (_iter1177 = (*(this->part_vals)).begin(); _iter1177 != (*(this->part_vals)).end(); ++_iter1177) ++ std::vector ::const_iterator _iter1179; ++ for (_iter1179 = (*(this->part_vals)).begin(); _iter1179 != (*(this->part_vals)).end(); ++_iter1179) + { +- xfer += oprot->writeString((*_iter1177)); ++ xfer += oprot->writeString((*_iter1179)); + } + xfer += oprot->writeListEnd(); + } +@@ -18352,14 +18559,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 _size1178; +- ::apache::thrift::protocol::TType _etype1181; +- xfer += iprot->readListBegin(_etype1181, _size1178); +- this->part_vals.resize(_size1178); +- uint32_t _i1182; +- for (_i1182 = 0; _i1182 < _size1178; ++_i1182) ++ uint32_t _size1180; ++ ::apache::thrift::protocol::TType _etype1183; ++ xfer += iprot->readListBegin(_etype1183, _size1180); ++ this->part_vals.resize(_size1180); ++ uint32_t _i1184; ++ for (_i1184 = 0; _i1184 < _size1180; ++_i1184) + { +- xfer += iprot->readString(this->part_vals[_i1182]); ++ xfer += iprot->readString(this->part_vals[_i1184]); + } + xfer += iprot->readListEnd(); + } +@@ -18396,10 +18603,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 _iter1183; +- for (_iter1183 = this->part_vals.begin(); _iter1183 != this->part_vals.end(); ++_iter1183) ++ std::vector ::const_iterator _iter1185; ++ for (_iter1185 = this->part_vals.begin(); _iter1185 != this->part_vals.end(); ++_iter1185) + { +- xfer += oprot->writeString((*_iter1183)); ++ xfer += oprot->writeString((*_iter1185)); + } + xfer += oprot->writeListEnd(); + } +@@ -18427,10 +18634,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 _iter1184; +- for (_iter1184 = (*(this->part_vals)).begin(); _iter1184 != (*(this->part_vals)).end(); ++_iter1184) ++ std::vector ::const_iterator _iter1186; ++ for (_iter1186 = (*(this->part_vals)).begin(); _iter1186 != (*(this->part_vals)).end(); ++_iter1186) + { +- xfer += oprot->writeString((*_iter1184)); ++ xfer += oprot->writeString((*_iter1186)); + } + xfer += oprot->writeListEnd(); + } +@@ -18905,14 +19112,14 @@ uint32_t ThriftHiveMetastore_partition_name_to_vals_result::read(::apache::thrif + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); +- uint32_t _size1185; +- ::apache::thrift::protocol::TType _etype1188; +- xfer += iprot->readListBegin(_etype1188, _size1185); +- this->success.resize(_size1185); +- uint32_t _i1189; +- for (_i1189 = 0; _i1189 < _size1185; ++_i1189) ++ uint32_t _size1187; ++ ::apache::thrift::protocol::TType _etype1190; ++ xfer += iprot->readListBegin(_etype1190, _size1187); ++ this->success.resize(_size1187); ++ uint32_t _i1191; ++ for (_i1191 = 0; _i1191 < _size1187; ++_i1191) + { +- xfer += iprot->readString(this->success[_i1189]); ++ xfer += iprot->readString(this->success[_i1191]); + } + xfer += iprot->readListEnd(); + } +@@ -18951,10 +19158,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 _iter1190; +- for (_iter1190 = this->success.begin(); _iter1190 != this->success.end(); ++_iter1190) ++ std::vector ::const_iterator _iter1192; ++ for (_iter1192 = this->success.begin(); _iter1192 != this->success.end(); ++_iter1192) + { +- xfer += oprot->writeString((*_iter1190)); ++ xfer += oprot->writeString((*_iter1192)); + } + xfer += oprot->writeListEnd(); + } +@@ -18999,14 +19206,14 @@ uint32_t ThriftHiveMetastore_partition_name_to_vals_presult::read(::apache::thri + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); +- uint32_t _size1191; +- ::apache::thrift::protocol::TType _etype1194; +- xfer += iprot->readListBegin(_etype1194, _size1191); +- (*(this->success)).resize(_size1191); +- uint32_t _i1195; +- for (_i1195 = 0; _i1195 < _size1191; ++_i1195) ++ uint32_t _size1193; ++ ::apache::thrift::protocol::TType _etype1196; ++ xfer += iprot->readListBegin(_etype1196, _size1193); ++ (*(this->success)).resize(_size1193); ++ uint32_t _i1197; ++ for (_i1197 = 0; _i1197 < _size1193; ++_i1197) + { +- xfer += iprot->readString((*(this->success))[_i1195]); ++ xfer += iprot->readString((*(this->success))[_i1197]); + } + xfer += iprot->readListEnd(); + } +@@ -19144,17 +19351,17 @@ uint32_t ThriftHiveMetastore_partition_name_to_spec_result::read(::apache::thrif + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + this->success.clear(); +- uint32_t _size1196; +- ::apache::thrift::protocol::TType _ktype1197; +- ::apache::thrift::protocol::TType _vtype1198; +- xfer += iprot->readMapBegin(_ktype1197, _vtype1198, _size1196); +- uint32_t _i1200; +- for (_i1200 = 0; _i1200 < _size1196; ++_i1200) ++ uint32_t _size1198; ++ ::apache::thrift::protocol::TType _ktype1199; ++ ::apache::thrift::protocol::TType _vtype1200; ++ xfer += iprot->readMapBegin(_ktype1199, _vtype1200, _size1198); ++ uint32_t _i1202; ++ for (_i1202 = 0; _i1202 < _size1198; ++_i1202) + { +- std::string _key1201; +- xfer += iprot->readString(_key1201); +- std::string& _val1202 = this->success[_key1201]; +- xfer += iprot->readString(_val1202); ++ std::string _key1203; ++ xfer += iprot->readString(_key1203); ++ std::string& _val1204 = this->success[_key1203]; ++ xfer += iprot->readString(_val1204); + } + xfer += iprot->readMapEnd(); + } +@@ -19193,11 +19400,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 _iter1203; +- for (_iter1203 = this->success.begin(); _iter1203 != this->success.end(); ++_iter1203) ++ std::map ::const_iterator _iter1205; ++ for (_iter1205 = this->success.begin(); _iter1205 != this->success.end(); ++_iter1205) + { +- xfer += oprot->writeString(_iter1203->first); +- xfer += oprot->writeString(_iter1203->second); ++ xfer += oprot->writeString(_iter1205->first); ++ xfer += oprot->writeString(_iter1205->second); + } + xfer += oprot->writeMapEnd(); + } +@@ -19242,17 +19449,17 @@ uint32_t ThriftHiveMetastore_partition_name_to_spec_presult::read(::apache::thri + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + (*(this->success)).clear(); +- uint32_t _size1204; +- ::apache::thrift::protocol::TType _ktype1205; +- ::apache::thrift::protocol::TType _vtype1206; +- xfer += iprot->readMapBegin(_ktype1205, _vtype1206, _size1204); +- uint32_t _i1208; +- for (_i1208 = 0; _i1208 < _size1204; ++_i1208) ++ uint32_t _size1206; ++ ::apache::thrift::protocol::TType _ktype1207; ++ ::apache::thrift::protocol::TType _vtype1208; ++ xfer += iprot->readMapBegin(_ktype1207, _vtype1208, _size1206); ++ uint32_t _i1210; ++ for (_i1210 = 0; _i1210 < _size1206; ++_i1210) + { +- std::string _key1209; +- xfer += iprot->readString(_key1209); +- std::string& _val1210 = (*(this->success))[_key1209]; +- xfer += iprot->readString(_val1210); ++ std::string _key1211; ++ xfer += iprot->readString(_key1211); ++ std::string& _val1212 = (*(this->success))[_key1211]; ++ xfer += iprot->readString(_val1212); + } + xfer += iprot->readMapEnd(); + } +@@ -19327,17 +19534,17 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_args::read(::apache::thrift:: + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + this->part_vals.clear(); +- uint32_t _size1211; +- ::apache::thrift::protocol::TType _ktype1212; +- ::apache::thrift::protocol::TType _vtype1213; +- xfer += iprot->readMapBegin(_ktype1212, _vtype1213, _size1211); +- uint32_t _i1215; +- for (_i1215 = 0; _i1215 < _size1211; ++_i1215) ++ uint32_t _size1213; ++ ::apache::thrift::protocol::TType _ktype1214; ++ ::apache::thrift::protocol::TType _vtype1215; ++ xfer += iprot->readMapBegin(_ktype1214, _vtype1215, _size1213); ++ uint32_t _i1217; ++ for (_i1217 = 0; _i1217 < _size1213; ++_i1217) + { +- std::string _key1216; +- xfer += iprot->readString(_key1216); +- std::string& _val1217 = this->part_vals[_key1216]; +- xfer += iprot->readString(_val1217); ++ std::string _key1218; ++ xfer += iprot->readString(_key1218); ++ std::string& _val1219 = this->part_vals[_key1218]; ++ xfer += iprot->readString(_val1219); + } + xfer += iprot->readMapEnd(); + } +@@ -19348,9 +19555,9 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_args::read(::apache::thrift:: + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I32) { +- int32_t ecast1218; +- xfer += iprot->readI32(ecast1218); +- this->eventType = (PartitionEventType::type)ecast1218; ++ int32_t ecast1220; ++ xfer += iprot->readI32(ecast1220); ++ this->eventType = (PartitionEventType::type)ecast1220; + this->__isset.eventType = true; + } else { + xfer += iprot->skip(ftype); +@@ -19384,11 +19591,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 _iter1219; +- for (_iter1219 = this->part_vals.begin(); _iter1219 != this->part_vals.end(); ++_iter1219) ++ std::map ::const_iterator _iter1221; ++ for (_iter1221 = this->part_vals.begin(); _iter1221 != this->part_vals.end(); ++_iter1221) + { +- xfer += oprot->writeString(_iter1219->first); +- xfer += oprot->writeString(_iter1219->second); ++ xfer += oprot->writeString(_iter1221->first); ++ xfer += oprot->writeString(_iter1221->second); + } + xfer += oprot->writeMapEnd(); + } +@@ -19424,11 +19631,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 _iter1220; +- for (_iter1220 = (*(this->part_vals)).begin(); _iter1220 != (*(this->part_vals)).end(); ++_iter1220) ++ std::map ::const_iterator _iter1222; ++ for (_iter1222 = (*(this->part_vals)).begin(); _iter1222 != (*(this->part_vals)).end(); ++_iter1222) + { +- xfer += oprot->writeString(_iter1220->first); +- xfer += oprot->writeString(_iter1220->second); ++ xfer += oprot->writeString(_iter1222->first); ++ xfer += oprot->writeString(_iter1222->second); + } + xfer += oprot->writeMapEnd(); + } +@@ -19697,17 +19904,17 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::read(::apache::thri + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + this->part_vals.clear(); +- 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) ++ uint32_t _size1223; ++ ::apache::thrift::protocol::TType _ktype1224; ++ ::apache::thrift::protocol::TType _vtype1225; ++ xfer += iprot->readMapBegin(_ktype1224, _vtype1225, _size1223); ++ uint32_t _i1227; ++ for (_i1227 = 0; _i1227 < _size1223; ++_i1227) + { +- std::string _key1226; +- xfer += iprot->readString(_key1226); +- std::string& _val1227 = this->part_vals[_key1226]; +- xfer += iprot->readString(_val1227); ++ std::string _key1228; ++ xfer += iprot->readString(_key1228); ++ std::string& _val1229 = this->part_vals[_key1228]; ++ xfer += iprot->readString(_val1229); + } + xfer += iprot->readMapEnd(); + } +@@ -19718,9 +19925,9 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::read(::apache::thri + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I32) { +- int32_t ecast1228; +- xfer += iprot->readI32(ecast1228); +- this->eventType = (PartitionEventType::type)ecast1228; ++ int32_t ecast1230; ++ xfer += iprot->readI32(ecast1230); ++ this->eventType = (PartitionEventType::type)ecast1230; + this->__isset.eventType = true; + } else { + xfer += iprot->skip(ftype); +@@ -19754,11 +19961,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 _iter1229; +- for (_iter1229 = this->part_vals.begin(); _iter1229 != this->part_vals.end(); ++_iter1229) ++ std::map ::const_iterator _iter1231; ++ for (_iter1231 = this->part_vals.begin(); _iter1231 != this->part_vals.end(); ++_iter1231) + { +- xfer += oprot->writeString(_iter1229->first); +- xfer += oprot->writeString(_iter1229->second); ++ xfer += oprot->writeString(_iter1231->first); ++ xfer += oprot->writeString(_iter1231->second); + } + xfer += oprot->writeMapEnd(); + } +@@ -19794,11 +20001,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 _iter1230; +- for (_iter1230 = (*(this->part_vals)).begin(); _iter1230 != (*(this->part_vals)).end(); ++_iter1230) ++ std::map ::const_iterator _iter1232; ++ for (_iter1232 = (*(this->part_vals)).begin(); _iter1232 != (*(this->part_vals)).end(); ++_iter1232) + { +- xfer += oprot->writeString(_iter1230->first); +- xfer += oprot->writeString(_iter1230->second); ++ xfer += oprot->writeString(_iter1232->first); ++ xfer += oprot->writeString(_iter1232->second); + } + xfer += oprot->writeMapEnd(); + } +@@ -21234,14 +21441,14 @@ uint32_t ThriftHiveMetastore_get_indexes_result::read(::apache::thrift::protocol + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); +- uint32_t _size1231; +- ::apache::thrift::protocol::TType _etype1234; +- xfer += iprot->readListBegin(_etype1234, _size1231); +- this->success.resize(_size1231); +- uint32_t _i1235; +- for (_i1235 = 0; _i1235 < _size1231; ++_i1235) ++ uint32_t _size1233; ++ ::apache::thrift::protocol::TType _etype1236; ++ xfer += iprot->readListBegin(_etype1236, _size1233); ++ this->success.resize(_size1233); ++ uint32_t _i1237; ++ for (_i1237 = 0; _i1237 < _size1233; ++_i1237) + { +- xfer += this->success[_i1235].read(iprot); ++ xfer += this->success[_i1237].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -21288,10 +21495,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 _iter1236; +- for (_iter1236 = this->success.begin(); _iter1236 != this->success.end(); ++_iter1236) ++ std::vector ::const_iterator _iter1238; ++ for (_iter1238 = this->success.begin(); _iter1238 != this->success.end(); ++_iter1238) + { +- xfer += (*_iter1236).write(oprot); ++ xfer += (*_iter1238).write(oprot); + } + xfer += oprot->writeListEnd(); + } +@@ -21340,14 +21547,14 @@ uint32_t ThriftHiveMetastore_get_indexes_presult::read(::apache::thrift::protoco + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); +- uint32_t _size1237; +- ::apache::thrift::protocol::TType _etype1240; +- xfer += iprot->readListBegin(_etype1240, _size1237); +- (*(this->success)).resize(_size1237); +- uint32_t _i1241; +- for (_i1241 = 0; _i1241 < _size1237; ++_i1241) ++ 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))[_i1241].read(iprot); ++ xfer += (*(this->success))[_i1243].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -21525,14 +21732,14 @@ uint32_t ThriftHiveMetastore_get_index_names_result::read(::apache::thrift::prot + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); +- uint32_t _size1242; +- ::apache::thrift::protocol::TType _etype1245; +- xfer += iprot->readListBegin(_etype1245, _size1242); +- this->success.resize(_size1242); +- uint32_t _i1246; +- for (_i1246 = 0; _i1246 < _size1242; ++_i1246) ++ uint32_t _size1244; ++ ::apache::thrift::protocol::TType _etype1247; ++ xfer += iprot->readListBegin(_etype1247, _size1244); ++ this->success.resize(_size1244); ++ uint32_t _i1248; ++ for (_i1248 = 0; _i1248 < _size1244; ++_i1248) + { +- xfer += iprot->readString(this->success[_i1246]); ++ xfer += iprot->readString(this->success[_i1248]); + } + xfer += iprot->readListEnd(); + } +@@ -21571,10 +21778,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 _iter1247; +- for (_iter1247 = this->success.begin(); _iter1247 != this->success.end(); ++_iter1247) ++ std::vector ::const_iterator _iter1249; ++ for (_iter1249 = this->success.begin(); _iter1249 != this->success.end(); ++_iter1249) + { +- xfer += oprot->writeString((*_iter1247)); ++ xfer += oprot->writeString((*_iter1249)); + } + xfer += oprot->writeListEnd(); + } +@@ -21619,14 +21826,14 @@ uint32_t ThriftHiveMetastore_get_index_names_presult::read(::apache::thrift::pro + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); +- uint32_t _size1248; +- ::apache::thrift::protocol::TType _etype1251; +- xfer += iprot->readListBegin(_etype1251, _size1248); +- (*(this->success)).resize(_size1248); +- uint32_t _i1252; +- for (_i1252 = 0; _i1252 < _size1248; ++_i1252) ++ uint32_t _size1250; ++ ::apache::thrift::protocol::TType _etype1253; ++ xfer += iprot->readListBegin(_etype1253, _size1250); ++ (*(this->success)).resize(_size1250); ++ uint32_t _i1254; ++ for (_i1254 = 0; _i1254 < _size1250; ++_i1254) + { +- xfer += iprot->readString((*(this->success))[_i1252]); ++ xfer += iprot->readString((*(this->success))[_i1254]); + } + xfer += iprot->readListEnd(); + } +@@ -25653,14 +25860,14 @@ uint32_t ThriftHiveMetastore_get_functions_result::read(::apache::thrift::protoc + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); +- uint32_t _size1253; +- ::apache::thrift::protocol::TType _etype1256; +- xfer += iprot->readListBegin(_etype1256, _size1253); +- this->success.resize(_size1253); +- uint32_t _i1257; +- for (_i1257 = 0; _i1257 < _size1253; ++_i1257) ++ uint32_t _size1255; ++ ::apache::thrift::protocol::TType _etype1258; ++ xfer += iprot->readListBegin(_etype1258, _size1255); ++ this->success.resize(_size1255); ++ uint32_t _i1259; ++ for (_i1259 = 0; _i1259 < _size1255; ++_i1259) + { +- xfer += iprot->readString(this->success[_i1257]); ++ xfer += iprot->readString(this->success[_i1259]); + } + xfer += iprot->readListEnd(); + } +@@ -25699,10 +25906,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 _iter1258; +- for (_iter1258 = this->success.begin(); _iter1258 != this->success.end(); ++_iter1258) ++ std::vector ::const_iterator _iter1260; ++ for (_iter1260 = this->success.begin(); _iter1260 != this->success.end(); ++_iter1260) + { +- xfer += oprot->writeString((*_iter1258)); ++ xfer += oprot->writeString((*_iter1260)); + } + xfer += oprot->writeListEnd(); + } +@@ -25747,14 +25954,14 @@ uint32_t ThriftHiveMetastore_get_functions_presult::read(::apache::thrift::proto + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); +- uint32_t _size1259; +- ::apache::thrift::protocol::TType _etype1262; +- xfer += iprot->readListBegin(_etype1262, _size1259); +- (*(this->success)).resize(_size1259); +- uint32_t _i1263; +- for (_i1263 = 0; _i1263 < _size1259; ++_i1263) ++ uint32_t _size1261; ++ ::apache::thrift::protocol::TType _etype1264; ++ xfer += iprot->readListBegin(_etype1264, _size1261); ++ (*(this->success)).resize(_size1261); ++ uint32_t _i1265; ++ for (_i1265 = 0; _i1265 < _size1261; ++_i1265) + { +- xfer += iprot->readString((*(this->success))[_i1263]); ++ xfer += iprot->readString((*(this->success))[_i1265]); + } + xfer += iprot->readListEnd(); + } +@@ -26714,14 +26921,14 @@ uint32_t ThriftHiveMetastore_get_role_names_result::read(::apache::thrift::proto + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); +- uint32_t _size1264; +- ::apache::thrift::protocol::TType _etype1267; +- xfer += iprot->readListBegin(_etype1267, _size1264); +- this->success.resize(_size1264); +- uint32_t _i1268; +- for (_i1268 = 0; _i1268 < _size1264; ++_i1268) ++ uint32_t _size1266; ++ ::apache::thrift::protocol::TType _etype1269; ++ xfer += iprot->readListBegin(_etype1269, _size1266); ++ this->success.resize(_size1266); ++ uint32_t _i1270; ++ for (_i1270 = 0; _i1270 < _size1266; ++_i1270) + { +- xfer += iprot->readString(this->success[_i1268]); ++ xfer += iprot->readString(this->success[_i1270]); + } + xfer += iprot->readListEnd(); + } +@@ -26760,10 +26967,10 @@ uint32_t ThriftHiveMetastore_get_role_names_result::write(::apache::thrift::prot + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); +- std::vector ::const_iterator _iter1269; +- for (_iter1269 = this->success.begin(); _iter1269 != this->success.end(); ++_iter1269) ++ std::vector ::const_iterator _iter1271; ++ for (_iter1271 = this->success.begin(); _iter1271 != this->success.end(); ++_iter1271) + { +- xfer += oprot->writeString((*_iter1269)); ++ xfer += oprot->writeString((*_iter1271)); + } + xfer += oprot->writeListEnd(); + } +@@ -26808,14 +27015,14 @@ uint32_t ThriftHiveMetastore_get_role_names_presult::read(::apache::thrift::prot + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); +- 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) ++ uint32_t _size1272; ++ ::apache::thrift::protocol::TType _etype1275; ++ xfer += iprot->readListBegin(_etype1275, _size1272); ++ (*(this->success)).resize(_size1272); ++ uint32_t _i1276; ++ for (_i1276 = 0; _i1276 < _size1272; ++_i1276) + { +- xfer += iprot->readString((*(this->success))[_i1274]); ++ xfer += iprot->readString((*(this->success))[_i1276]); + } + xfer += iprot->readListEnd(); + } +@@ -26888,9 +27095,9 @@ uint32_t ThriftHiveMetastore_grant_role_args::read(::apache::thrift::protocol::T + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I32) { +- int32_t ecast1275; +- xfer += iprot->readI32(ecast1275); +- this->principal_type = (PrincipalType::type)ecast1275; ++ int32_t ecast1277; ++ xfer += iprot->readI32(ecast1277); ++ this->principal_type = (PrincipalType::type)ecast1277; + this->__isset.principal_type = true; + } else { + xfer += iprot->skip(ftype); +@@ -26906,9 +27113,9 @@ uint32_t ThriftHiveMetastore_grant_role_args::read(::apache::thrift::protocol::T + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_I32) { +- int32_t ecast1276; +- xfer += iprot->readI32(ecast1276); +- this->grantorType = (PrincipalType::type)ecast1276; ++ int32_t ecast1278; ++ xfer += iprot->readI32(ecast1278); ++ this->grantorType = (PrincipalType::type)ecast1278; + this->__isset.grantorType = true; + } else { + xfer += iprot->skip(ftype); +@@ -27179,9 +27386,9 @@ uint32_t ThriftHiveMetastore_revoke_role_args::read(::apache::thrift::protocol:: + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I32) { +- int32_t ecast1277; +- xfer += iprot->readI32(ecast1277); +- this->principal_type = (PrincipalType::type)ecast1277; ++ int32_t ecast1279; ++ xfer += iprot->readI32(ecast1279); ++ this->principal_type = (PrincipalType::type)ecast1279; + this->__isset.principal_type = true; + } else { + xfer += iprot->skip(ftype); +@@ -27412,9 +27619,9 @@ uint32_t ThriftHiveMetastore_list_roles_args::read(::apache::thrift::protocol::T + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I32) { +- int32_t ecast1278; +- xfer += iprot->readI32(ecast1278); +- this->principal_type = (PrincipalType::type)ecast1278; ++ int32_t ecast1280; ++ xfer += iprot->readI32(ecast1280); ++ this->principal_type = (PrincipalType::type)ecast1280; + this->__isset.principal_type = true; + } else { + xfer += iprot->skip(ftype); +@@ -27503,14 +27710,14 @@ uint32_t ThriftHiveMetastore_list_roles_result::read(::apache::thrift::protocol: + 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 _size1281; ++ ::apache::thrift::protocol::TType _etype1284; ++ xfer += iprot->readListBegin(_etype1284, _size1281); ++ this->success.resize(_size1281); ++ uint32_t _i1285; ++ for (_i1285 = 0; _i1285 < _size1281; ++_i1285) + { +- xfer += this->success[_i1283].read(iprot); ++ xfer += this->success[_i1285].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -27549,10 +27756,10 @@ uint32_t ThriftHiveMetastore_list_roles_result::write(::apache::thrift::protocol + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); +- std::vector ::const_iterator _iter1284; +- for (_iter1284 = this->success.begin(); _iter1284 != this->success.end(); ++_iter1284) ++ std::vector ::const_iterator _iter1286; ++ for (_iter1286 = this->success.begin(); _iter1286 != this->success.end(); ++_iter1286) + { +- xfer += (*_iter1284).write(oprot); ++ xfer += (*_iter1286).write(oprot); + } + xfer += oprot->writeListEnd(); + } +@@ -27597,14 +27804,14 @@ uint32_t ThriftHiveMetastore_list_roles_presult::read(::apache::thrift::protocol + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); +- uint32_t _size1285; +- ::apache::thrift::protocol::TType _etype1288; +- xfer += iprot->readListBegin(_etype1288, _size1285); +- (*(this->success)).resize(_size1285); +- uint32_t _i1289; +- for (_i1289 = 0; _i1289 < _size1285; ++_i1289) ++ uint32_t _size1287; ++ ::apache::thrift::protocol::TType _etype1290; ++ xfer += iprot->readListBegin(_etype1290, _size1287); ++ (*(this->success)).resize(_size1287); ++ uint32_t _i1291; ++ for (_i1291 = 0; _i1291 < _size1287; ++_i1291) + { +- xfer += (*(this->success))[_i1289].read(iprot); ++ xfer += (*(this->success))[_i1291].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -28300,14 +28507,14 @@ uint32_t ThriftHiveMetastore_get_privilege_set_args::read(::apache::thrift::prot + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->group_names.clear(); +- uint32_t _size1290; +- ::apache::thrift::protocol::TType _etype1293; +- xfer += iprot->readListBegin(_etype1293, _size1290); +- this->group_names.resize(_size1290); +- uint32_t _i1294; +- for (_i1294 = 0; _i1294 < _size1290; ++_i1294) ++ uint32_t _size1292; ++ ::apache::thrift::protocol::TType _etype1295; ++ xfer += iprot->readListBegin(_etype1295, _size1292); ++ this->group_names.resize(_size1292); ++ uint32_t _i1296; ++ for (_i1296 = 0; _i1296 < _size1292; ++_i1296) + { +- xfer += iprot->readString(this->group_names[_i1294]); ++ xfer += iprot->readString(this->group_names[_i1296]); + } + xfer += iprot->readListEnd(); + } +@@ -28344,10 +28551,10 @@ uint32_t ThriftHiveMetastore_get_privilege_set_args::write(::apache::thrift::pro + xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->group_names.size())); +- std::vector ::const_iterator _iter1295; +- for (_iter1295 = this->group_names.begin(); _iter1295 != this->group_names.end(); ++_iter1295) ++ std::vector ::const_iterator _iter1297; ++ for (_iter1297 = this->group_names.begin(); _iter1297 != this->group_names.end(); ++_iter1297) + { +- xfer += oprot->writeString((*_iter1295)); ++ xfer += oprot->writeString((*_iter1297)); + } + xfer += oprot->writeListEnd(); + } +@@ -28379,10 +28586,10 @@ uint32_t ThriftHiveMetastore_get_privilege_set_pargs::write(::apache::thrift::pr + xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->group_names)).size())); +- std::vector ::const_iterator _iter1296; +- for (_iter1296 = (*(this->group_names)).begin(); _iter1296 != (*(this->group_names)).end(); ++_iter1296) ++ std::vector ::const_iterator _iter1298; ++ for (_iter1298 = (*(this->group_names)).begin(); _iter1298 != (*(this->group_names)).end(); ++_iter1298) + { +- xfer += oprot->writeString((*_iter1296)); ++ xfer += oprot->writeString((*_iter1298)); + } + xfer += oprot->writeListEnd(); + } +@@ -28557,9 +28764,9 @@ uint32_t ThriftHiveMetastore_list_privileges_args::read(::apache::thrift::protoc + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I32) { +- int32_t ecast1297; +- xfer += iprot->readI32(ecast1297); +- this->principal_type = (PrincipalType::type)ecast1297; ++ int32_t ecast1299; ++ xfer += iprot->readI32(ecast1299); ++ this->principal_type = (PrincipalType::type)ecast1299; + this->__isset.principal_type = true; + } else { + xfer += iprot->skip(ftype); +@@ -28664,14 +28871,14 @@ uint32_t ThriftHiveMetastore_list_privileges_result::read(::apache::thrift::prot + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); +- uint32_t _size1298; +- ::apache::thrift::protocol::TType _etype1301; +- xfer += iprot->readListBegin(_etype1301, _size1298); +- this->success.resize(_size1298); +- uint32_t _i1302; +- for (_i1302 = 0; _i1302 < _size1298; ++_i1302) ++ uint32_t _size1300; ++ ::apache::thrift::protocol::TType _etype1303; ++ xfer += iprot->readListBegin(_etype1303, _size1300); ++ this->success.resize(_size1300); ++ uint32_t _i1304; ++ for (_i1304 = 0; _i1304 < _size1300; ++_i1304) + { +- xfer += this->success[_i1302].read(iprot); ++ xfer += this->success[_i1304].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -28710,10 +28917,10 @@ uint32_t ThriftHiveMetastore_list_privileges_result::write(::apache::thrift::pro + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); +- std::vector ::const_iterator _iter1303; +- for (_iter1303 = this->success.begin(); _iter1303 != this->success.end(); ++_iter1303) ++ std::vector ::const_iterator _iter1305; ++ for (_iter1305 = this->success.begin(); _iter1305 != this->success.end(); ++_iter1305) + { +- xfer += (*_iter1303).write(oprot); ++ xfer += (*_iter1305).write(oprot); + } + xfer += oprot->writeListEnd(); + } +@@ -28758,14 +28965,14 @@ uint32_t ThriftHiveMetastore_list_privileges_presult::read(::apache::thrift::pro + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); +- 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) ++ uint32_t _size1306; ++ ::apache::thrift::protocol::TType _etype1309; ++ xfer += iprot->readListBegin(_etype1309, _size1306); ++ (*(this->success)).resize(_size1306); ++ uint32_t _i1310; ++ for (_i1310 = 0; _i1310 < _size1306; ++_i1310) + { +- xfer += (*(this->success))[_i1308].read(iprot); ++ xfer += (*(this->success))[_i1310].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -29453,14 +29660,14 @@ uint32_t ThriftHiveMetastore_set_ugi_args::read(::apache::thrift::protocol::TPro + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->group_names.clear(); +- uint32_t _size1309; +- ::apache::thrift::protocol::TType _etype1312; +- xfer += iprot->readListBegin(_etype1312, _size1309); +- this->group_names.resize(_size1309); +- uint32_t _i1313; +- for (_i1313 = 0; _i1313 < _size1309; ++_i1313) ++ uint32_t _size1311; ++ ::apache::thrift::protocol::TType _etype1314; ++ xfer += iprot->readListBegin(_etype1314, _size1311); ++ this->group_names.resize(_size1311); ++ uint32_t _i1315; ++ for (_i1315 = 0; _i1315 < _size1311; ++_i1315) + { +- xfer += iprot->readString(this->group_names[_i1313]); ++ xfer += iprot->readString(this->group_names[_i1315]); + } + xfer += iprot->readListEnd(); + } +@@ -29493,10 +29700,10 @@ uint32_t ThriftHiveMetastore_set_ugi_args::write(::apache::thrift::protocol::TPr + xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 2); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->group_names.size())); +- std::vector ::const_iterator _iter1314; +- for (_iter1314 = this->group_names.begin(); _iter1314 != this->group_names.end(); ++_iter1314) ++ std::vector ::const_iterator _iter1316; ++ for (_iter1316 = this->group_names.begin(); _iter1316 != this->group_names.end(); ++_iter1316) + { +- xfer += oprot->writeString((*_iter1314)); ++ xfer += oprot->writeString((*_iter1316)); + } + xfer += oprot->writeListEnd(); + } +@@ -29524,10 +29731,10 @@ uint32_t ThriftHiveMetastore_set_ugi_pargs::write(::apache::thrift::protocol::TP + xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 2); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->group_names)).size())); +- std::vector ::const_iterator _iter1315; +- for (_iter1315 = (*(this->group_names)).begin(); _iter1315 != (*(this->group_names)).end(); ++_iter1315) ++ std::vector ::const_iterator _iter1317; ++ for (_iter1317 = (*(this->group_names)).begin(); _iter1317 != (*(this->group_names)).end(); ++_iter1317) + { +- xfer += oprot->writeString((*_iter1315)); ++ xfer += oprot->writeString((*_iter1317)); + } + xfer += oprot->writeListEnd(); + } +@@ -29568,14 +29775,14 @@ uint32_t ThriftHiveMetastore_set_ugi_result::read(::apache::thrift::protocol::TP + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); +- uint32_t _size1316; +- ::apache::thrift::protocol::TType _etype1319; +- xfer += iprot->readListBegin(_etype1319, _size1316); +- this->success.resize(_size1316); +- uint32_t _i1320; +- for (_i1320 = 0; _i1320 < _size1316; ++_i1320) ++ uint32_t _size1318; ++ ::apache::thrift::protocol::TType _etype1321; ++ xfer += iprot->readListBegin(_etype1321, _size1318); ++ this->success.resize(_size1318); ++ uint32_t _i1322; ++ for (_i1322 = 0; _i1322 < _size1318; ++_i1322) + { +- xfer += iprot->readString(this->success[_i1320]); ++ xfer += iprot->readString(this->success[_i1322]); + } + xfer += iprot->readListEnd(); + } +@@ -29614,10 +29821,10 @@ uint32_t ThriftHiveMetastore_set_ugi_result::write(::apache::thrift::protocol::T + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); +- std::vector ::const_iterator _iter1321; +- for (_iter1321 = this->success.begin(); _iter1321 != this->success.end(); ++_iter1321) ++ std::vector ::const_iterator _iter1323; ++ for (_iter1323 = this->success.begin(); _iter1323 != this->success.end(); ++_iter1323) + { +- xfer += oprot->writeString((*_iter1321)); ++ xfer += oprot->writeString((*_iter1323)); + } + xfer += oprot->writeListEnd(); + } +@@ -29662,14 +29869,14 @@ uint32_t ThriftHiveMetastore_set_ugi_presult::read(::apache::thrift::protocol::T + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); +- 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) ++ uint32_t _size1324; ++ ::apache::thrift::protocol::TType _etype1327; ++ xfer += iprot->readListBegin(_etype1327, _size1324); ++ (*(this->success)).resize(_size1324); ++ uint32_t _i1328; ++ for (_i1328 = 0; _i1328 < _size1324; ++_i1328) + { +- xfer += iprot->readString((*(this->success))[_i1326]); ++ xfer += iprot->readString((*(this->success))[_i1328]); + } + xfer += iprot->readListEnd(); + } +@@ -30980,14 +31187,14 @@ uint32_t ThriftHiveMetastore_get_all_token_identifiers_result::read(::apache::th + 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) ++ uint32_t _size1329; ++ ::apache::thrift::protocol::TType _etype1332; ++ xfer += iprot->readListBegin(_etype1332, _size1329); ++ this->success.resize(_size1329); ++ uint32_t _i1333; ++ for (_i1333 = 0; _i1333 < _size1329; ++_i1333) + { +- xfer += iprot->readString(this->success[_i1331]); ++ xfer += iprot->readString(this->success[_i1333]); + } + xfer += iprot->readListEnd(); + } +@@ -31018,10 +31225,10 @@ uint32_t ThriftHiveMetastore_get_all_token_identifiers_result::write(::apache::t + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); +- std::vector ::const_iterator _iter1332; +- for (_iter1332 = this->success.begin(); _iter1332 != this->success.end(); ++_iter1332) ++ std::vector ::const_iterator _iter1334; ++ for (_iter1334 = this->success.begin(); _iter1334 != this->success.end(); ++_iter1334) + { +- xfer += oprot->writeString((*_iter1332)); ++ xfer += oprot->writeString((*_iter1334)); + } + xfer += oprot->writeListEnd(); + } +@@ -31062,14 +31269,14 @@ uint32_t ThriftHiveMetastore_get_all_token_identifiers_presult::read(::apache::t + 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) ++ uint32_t _size1335; ++ ::apache::thrift::protocol::TType _etype1338; ++ xfer += iprot->readListBegin(_etype1338, _size1335); ++ (*(this->success)).resize(_size1335); ++ uint32_t _i1339; ++ for (_i1339 = 0; _i1339 < _size1335; ++_i1339) + { +- xfer += iprot->readString((*(this->success))[_i1337]); ++ xfer += iprot->readString((*(this->success))[_i1339]); + } + xfer += iprot->readListEnd(); + } +@@ -31795,14 +32002,14 @@ uint32_t ThriftHiveMetastore_get_master_keys_result::read(::apache::thrift::prot + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); +- uint32_t _size1338; +- ::apache::thrift::protocol::TType _etype1341; +- xfer += iprot->readListBegin(_etype1341, _size1338); +- this->success.resize(_size1338); +- uint32_t _i1342; +- for (_i1342 = 0; _i1342 < _size1338; ++_i1342) ++ uint32_t _size1340; ++ ::apache::thrift::protocol::TType _etype1343; ++ xfer += iprot->readListBegin(_etype1343, _size1340); ++ this->success.resize(_size1340); ++ uint32_t _i1344; ++ for (_i1344 = 0; _i1344 < _size1340; ++_i1344) + { +- xfer += iprot->readString(this->success[_i1342]); ++ xfer += iprot->readString(this->success[_i1344]); + } + xfer += iprot->readListEnd(); + } +@@ -31833,10 +32040,10 @@ uint32_t ThriftHiveMetastore_get_master_keys_result::write(::apache::thrift::pro + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); +- std::vector ::const_iterator _iter1343; +- for (_iter1343 = this->success.begin(); _iter1343 != this->success.end(); ++_iter1343) ++ std::vector ::const_iterator _iter1345; ++ for (_iter1345 = this->success.begin(); _iter1345 != this->success.end(); ++_iter1345) + { +- xfer += oprot->writeString((*_iter1343)); ++ xfer += oprot->writeString((*_iter1345)); + } + xfer += oprot->writeListEnd(); + } +@@ -31877,14 +32084,14 @@ uint32_t ThriftHiveMetastore_get_master_keys_presult::read(::apache::thrift::pro + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); +- uint32_t _size1344; +- ::apache::thrift::protocol::TType _etype1347; +- xfer += iprot->readListBegin(_etype1347, _size1344); +- (*(this->success)).resize(_size1344); +- uint32_t _i1348; +- for (_i1348 = 0; _i1348 < _size1344; ++_i1348) ++ uint32_t _size1346; ++ ::apache::thrift::protocol::TType _etype1349; ++ xfer += iprot->readListBegin(_etype1349, _size1346); ++ (*(this->success)).resize(_size1346); ++ uint32_t _i1350; ++ for (_i1350 = 0; _i1350 < _size1346; ++_i1350) + { +- xfer += iprot->readString((*(this->success))[_i1348]); ++ xfer += iprot->readString((*(this->success))[_i1350]); + } + xfer += iprot->readListEnd(); + } +@@ -37664,6 +37871,65 @@ void ThriftHiveMetastoreClient::recv_create_table_with_constraints() + return; + } + ++void ThriftHiveMetastoreClient::drop_constraint(const DropConstraintRequest& req) ++{ ++ send_drop_constraint(req); ++ recv_drop_constraint(); ++} ++ ++void ThriftHiveMetastoreClient::send_drop_constraint(const DropConstraintRequest& req) ++{ ++ int32_t cseqid = 0; ++ oprot_->writeMessageBegin("drop_constraint", ::apache::thrift::protocol::T_CALL, cseqid); ++ ++ ThriftHiveMetastore_drop_constraint_pargs args; ++ args.req = &req; ++ args.write(oprot_); ++ ++ oprot_->writeMessageEnd(); ++ oprot_->getTransport()->writeEnd(); ++ oprot_->getTransport()->flush(); ++} ++ ++void ThriftHiveMetastoreClient::recv_drop_constraint() ++{ ++ ++ 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_constraint") != 0) { ++ iprot_->skip(::apache::thrift::protocol::T_STRUCT); ++ iprot_->readMessageEnd(); ++ iprot_->getTransport()->readEnd(); ++ } ++ ThriftHiveMetastore_drop_constraint_presult result; ++ result.read(iprot_); ++ iprot_->readMessageEnd(); ++ iprot_->getTransport()->readEnd(); ++ ++ if (result.__isset.o1) { ++ throw result.o1; ++ } ++ if (result.__isset.o3) { ++ throw result.o3; ++ } ++ return; ++} ++ + void ThriftHiveMetastoreClient::drop_table(const std::string& dbname, const std::string& name, const bool deleteData) + { + send_drop_table(dbname, name, deleteData); +@@ -46883,6 +47149,65 @@ void ThriftHiveMetastoreProcessor::process_create_table_with_constraints(int32_t + } + } + ++void ThriftHiveMetastoreProcessor::process_drop_constraint(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_constraint", callContext); ++ } ++ ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.drop_constraint"); ++ ++ if (this->eventHandler_.get() != NULL) { ++ this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.drop_constraint"); ++ } ++ ++ ThriftHiveMetastore_drop_constraint_args args; ++ args.read(iprot); ++ iprot->readMessageEnd(); ++ uint32_t bytes = iprot->getTransport()->readEnd(); ++ ++ if (this->eventHandler_.get() != NULL) { ++ this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.drop_constraint", bytes); ++ } ++ ++ ThriftHiveMetastore_drop_constraint_result result; ++ try { ++ iface_->drop_constraint(args.req); ++ } catch (NoSuchObjectException &o1) { ++ result.o1 = o1; ++ result.__isset.o1 = 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_constraint"); ++ } ++ ++ ::apache::thrift::TApplicationException x(e.what()); ++ oprot->writeMessageBegin("drop_constraint", ::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_constraint"); ++ } ++ ++ oprot->writeMessageBegin("drop_constraint", ::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_constraint", bytes); ++ } ++} ++ + void ThriftHiveMetastoreProcessor::process_drop_table(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) + { + void* ctx = NULL; +@@ -56131,6 +56456,92 @@ void ThriftHiveMetastoreConcurrentClient::recv_create_table_with_constraints(con + } // end while(true) + } + ++void ThriftHiveMetastoreConcurrentClient::drop_constraint(const DropConstraintRequest& req) ++{ ++ int32_t seqid = send_drop_constraint(req); ++ recv_drop_constraint(seqid); ++} ++ ++int32_t ThriftHiveMetastoreConcurrentClient::send_drop_constraint(const DropConstraintRequest& req) ++{ ++ int32_t cseqid = this->sync_.generateSeqId(); ++ ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); ++ oprot_->writeMessageBegin("drop_constraint", ::apache::thrift::protocol::T_CALL, cseqid); ++ ++ ThriftHiveMetastore_drop_constraint_pargs args; ++ args.req = &req; ++ args.write(oprot_); ++ ++ oprot_->writeMessageEnd(); ++ oprot_->getTransport()->writeEnd(); ++ oprot_->getTransport()->flush(); ++ ++ sentry.commit(); ++ return cseqid; ++} ++ ++void ThriftHiveMetastoreConcurrentClient::recv_drop_constraint(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_constraint") != 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_drop_constraint_presult result; ++ result.read(iprot_); ++ iprot_->readMessageEnd(); ++ iprot_->getTransport()->readEnd(); ++ ++ if (result.__isset.o1) { ++ sentry.commit(); ++ throw result.o1; ++ } ++ if (result.__isset.o3) { ++ sentry.commit(); ++ throw result.o3; ++ } ++ sentry.commit(); ++ return; ++ } ++ // seqid != rseqid ++ this->sync_.updatePending(fname, mtype, rseqid); ++ ++ // this will temporarily unlock the readMutex, and let other clients get work done ++ this->sync_.waitForWork(seqid); ++ } // end while(true) ++} ++ + void ThriftHiveMetastoreConcurrentClient::drop_table(const std::string& dbname, const std::string& name, const bool deleteData) + { + int32_t seqid = send_drop_table(dbname, name, deleteData); +diff --git a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h +index 11d3322..990be15 100644 +--- a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h ++++ b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h +@@ -41,6 +41,7 @@ class ThriftHiveMetastoreIf : virtual public ::facebook::fb303::FacebookService + virtual void create_table(const Table& tbl) = 0; + virtual void create_table_with_environment_context(const Table& tbl, const EnvironmentContext& environment_context) = 0; + virtual void create_table_with_constraints(const Table& tbl, const std::vector & primaryKeys, const std::vector & foreignKeys) = 0; ++ virtual void drop_constraint(const DropConstraintRequest& req) = 0; + virtual void drop_table(const std::string& dbname, const std::string& name, const bool deleteData) = 0; + virtual void drop_table_with_environment_context(const std::string& dbname, const std::string& name, const bool deleteData, const EnvironmentContext& environment_context) = 0; + virtual void get_tables(std::vector & _return, const std::string& db_name, const std::string& pattern) = 0; +@@ -256,6 +257,9 @@ class ThriftHiveMetastoreNull : virtual public ThriftHiveMetastoreIf , virtual p + void create_table_with_constraints(const Table& /* tbl */, const std::vector & /* primaryKeys */, const std::vector & /* foreignKeys */) { + return; + } ++ void drop_constraint(const DropConstraintRequest& /* req */) { ++ return; ++ } + void drop_table(const std::string& /* dbname */, const std::string& /* name */, const bool /* deleteData */) { + return; + } +@@ -3032,6 +3036,118 @@ class ThriftHiveMetastore_create_table_with_constraints_presult { + + }; + ++typedef struct _ThriftHiveMetastore_drop_constraint_args__isset { ++ _ThriftHiveMetastore_drop_constraint_args__isset() : req(false) {} ++ bool req :1; ++} _ThriftHiveMetastore_drop_constraint_args__isset; ++ ++class ThriftHiveMetastore_drop_constraint_args { ++ public: ++ ++ ThriftHiveMetastore_drop_constraint_args(const ThriftHiveMetastore_drop_constraint_args&); ++ ThriftHiveMetastore_drop_constraint_args& operator=(const ThriftHiveMetastore_drop_constraint_args&); ++ ThriftHiveMetastore_drop_constraint_args() { ++ } ++ ++ virtual ~ThriftHiveMetastore_drop_constraint_args() throw(); ++ DropConstraintRequest req; ++ ++ _ThriftHiveMetastore_drop_constraint_args__isset __isset; ++ ++ void __set_req(const DropConstraintRequest& val); ++ ++ bool operator == (const ThriftHiveMetastore_drop_constraint_args & rhs) const ++ { ++ if (!(req == rhs.req)) ++ return false; ++ return true; ++ } ++ bool operator != (const ThriftHiveMetastore_drop_constraint_args &rhs) const { ++ return !(*this == rhs); ++ } ++ ++ bool operator < (const ThriftHiveMetastore_drop_constraint_args & ) const; ++ ++ uint32_t read(::apache::thrift::protocol::TProtocol* iprot); ++ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; ++ ++}; ++ ++ ++class ThriftHiveMetastore_drop_constraint_pargs { ++ public: ++ ++ ++ virtual ~ThriftHiveMetastore_drop_constraint_pargs() throw(); ++ const DropConstraintRequest* req; ++ ++ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; ++ ++}; ++ ++typedef struct _ThriftHiveMetastore_drop_constraint_result__isset { ++ _ThriftHiveMetastore_drop_constraint_result__isset() : o1(false), o3(false) {} ++ bool o1 :1; ++ bool o3 :1; ++} _ThriftHiveMetastore_drop_constraint_result__isset; ++ ++class ThriftHiveMetastore_drop_constraint_result { ++ public: ++ ++ ThriftHiveMetastore_drop_constraint_result(const ThriftHiveMetastore_drop_constraint_result&); ++ ThriftHiveMetastore_drop_constraint_result& operator=(const ThriftHiveMetastore_drop_constraint_result&); ++ ThriftHiveMetastore_drop_constraint_result() { ++ } ++ ++ virtual ~ThriftHiveMetastore_drop_constraint_result() throw(); ++ NoSuchObjectException o1; ++ MetaException o3; ++ ++ _ThriftHiveMetastore_drop_constraint_result__isset __isset; ++ ++ void __set_o1(const NoSuchObjectException& val); ++ ++ void __set_o3(const MetaException& val); ++ ++ bool operator == (const ThriftHiveMetastore_drop_constraint_result & rhs) const ++ { ++ if (!(o1 == rhs.o1)) ++ return false; ++ if (!(o3 == rhs.o3)) ++ return false; ++ return true; ++ } ++ bool operator != (const ThriftHiveMetastore_drop_constraint_result &rhs) const { ++ return !(*this == rhs); ++ } ++ ++ bool operator < (const ThriftHiveMetastore_drop_constraint_result & ) const; ++ ++ uint32_t read(::apache::thrift::protocol::TProtocol* iprot); ++ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; ++ ++}; ++ ++typedef struct _ThriftHiveMetastore_drop_constraint_presult__isset { ++ _ThriftHiveMetastore_drop_constraint_presult__isset() : o1(false), o3(false) {} ++ bool o1 :1; ++ bool o3 :1; ++} _ThriftHiveMetastore_drop_constraint_presult__isset; ++ ++class ThriftHiveMetastore_drop_constraint_presult { ++ public: ++ ++ ++ virtual ~ThriftHiveMetastore_drop_constraint_presult() throw(); ++ NoSuchObjectException o1; ++ MetaException o3; ++ ++ _ThriftHiveMetastore_drop_constraint_presult__isset __isset; ++ ++ uint32_t read(::apache::thrift::protocol::TProtocol* iprot); ++ ++}; ++ + typedef struct _ThriftHiveMetastore_drop_table_args__isset { + _ThriftHiveMetastore_drop_table_args__isset() : dbname(false), name(false), deleteData(false) {} + bool dbname :1; +@@ -18851,6 +18967,9 @@ class ThriftHiveMetastoreClient : virtual public ThriftHiveMetastoreIf, public + void create_table_with_constraints(const Table& tbl, const std::vector & primaryKeys, const std::vector & foreignKeys); + void send_create_table_with_constraints(const Table& tbl, const std::vector & primaryKeys, const std::vector & foreignKeys); + void recv_create_table_with_constraints(); ++ void drop_constraint(const DropConstraintRequest& req); ++ void send_drop_constraint(const DropConstraintRequest& req); ++ void recv_drop_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(); +@@ -19261,6 +19380,7 @@ class ThriftHiveMetastoreProcessor : public ::facebook::fb303::FacebookServiceP + void process_create_table(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_create_table_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_create_table_with_constraints(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); ++ void process_drop_constraint(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_drop_table(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_drop_table_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_tables(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); +@@ -19411,6 +19531,7 @@ class ThriftHiveMetastoreProcessor : public ::facebook::fb303::FacebookServiceP + processMap_["create_table"] = &ThriftHiveMetastoreProcessor::process_create_table; + processMap_["create_table_with_environment_context"] = &ThriftHiveMetastoreProcessor::process_create_table_with_environment_context; + processMap_["create_table_with_constraints"] = &ThriftHiveMetastoreProcessor::process_create_table_with_constraints; ++ processMap_["drop_constraint"] = &ThriftHiveMetastoreProcessor::process_drop_constraint; + processMap_["drop_table"] = &ThriftHiveMetastoreProcessor::process_drop_table; + processMap_["drop_table_with_environment_context"] = &ThriftHiveMetastoreProcessor::process_drop_table_with_environment_context; + processMap_["get_tables"] = &ThriftHiveMetastoreProcessor::process_get_tables; +@@ -19752,6 +19873,15 @@ class ThriftHiveMetastoreMultiface : virtual public ThriftHiveMetastoreIf, publi + ifaces_[i]->create_table_with_constraints(tbl, primaryKeys, foreignKeys); + } + ++ void drop_constraint(const DropConstraintRequest& req) { ++ size_t sz = ifaces_.size(); ++ size_t i = 0; ++ for (; i < (sz - 1); ++i) { ++ ifaces_[i]->drop_constraint(req); ++ } ++ ifaces_[i]->drop_constraint(req); ++ } ++ + void drop_table(const std::string& dbname, const std::string& name, const bool deleteData) { + size_t sz = ifaces_.size(); + size_t i = 0; +@@ -21045,6 +21175,9 @@ class ThriftHiveMetastoreConcurrentClient : virtual public ThriftHiveMetastoreIf + void create_table_with_constraints(const Table& tbl, const std::vector & primaryKeys, const std::vector & foreignKeys); + int32_t send_create_table_with_constraints(const Table& tbl, const std::vector & primaryKeys, const std::vector & foreignKeys); + void recv_create_table_with_constraints(const int32_t seqid); ++ void drop_constraint(const DropConstraintRequest& req); ++ int32_t send_drop_constraint(const DropConstraintRequest& req); ++ void recv_drop_constraint(const int32_t seqid); + void drop_table(const std::string& dbname, const std::string& name, const bool deleteData); + int32_t send_drop_table(const std::string& dbname, const std::string& name, const bool deleteData); + void recv_drop_table(const int32_t seqid); +diff --git a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp +index fa87e34..2d13e77 100644 +--- a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp ++++ b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp +@@ -117,6 +117,11 @@ class ThriftHiveMetastoreHandler : virtual public ThriftHiveMetastoreIf { + printf("create_table_with_constraints\n"); + } + ++ void drop_constraint(const DropConstraintRequest& req) { ++ // Your implementation goes here ++ printf("drop_constraint\n"); ++ } ++ + void drop_table(const std::string& dbname, const std::string& name, const bool deleteData) { + // Your implementation goes here + printf("drop_table\n"); +diff --git a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp +index 8da883d..36a0f96 100644 +--- a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp ++++ b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp +@@ -8999,6 +8999,138 @@ void ForeignKeysResponse::printTo(std::ostream& out) const { + } + + ++DropConstraintRequest::~DropConstraintRequest() throw() { ++} ++ ++ ++void DropConstraintRequest::__set_dbname(const std::string& val) { ++ this->dbname = val; ++} ++ ++void DropConstraintRequest::__set_tablename(const std::string& val) { ++ this->tablename = val; ++} ++ ++void DropConstraintRequest::__set_constraintname(const std::string& val) { ++ this->constraintname = val; ++} ++ ++uint32_t DropConstraintRequest::read(::apache::thrift::protocol::TProtocol* iprot) { ++ ++ apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); ++ uint32_t xfer = 0; ++ std::string fname; ++ ::apache::thrift::protocol::TType ftype; ++ int16_t fid; ++ ++ xfer += iprot->readStructBegin(fname); ++ ++ using ::apache::thrift::protocol::TProtocolException; ++ ++ bool isset_dbname = false; ++ bool isset_tablename = false; ++ bool isset_constraintname = false; ++ ++ while (true) ++ { ++ xfer += iprot->readFieldBegin(fname, ftype, fid); ++ if (ftype == ::apache::thrift::protocol::T_STOP) { ++ break; ++ } ++ switch (fid) ++ { ++ case 1: ++ if (ftype == ::apache::thrift::protocol::T_STRING) { ++ xfer += iprot->readString(this->dbname); ++ isset_dbname = true; ++ } else { ++ xfer += iprot->skip(ftype); ++ } ++ break; ++ case 2: ++ if (ftype == ::apache::thrift::protocol::T_STRING) { ++ xfer += iprot->readString(this->tablename); ++ isset_tablename = true; ++ } else { ++ xfer += iprot->skip(ftype); ++ } ++ break; ++ case 3: ++ if (ftype == ::apache::thrift::protocol::T_STRING) { ++ xfer += iprot->readString(this->constraintname); ++ isset_constraintname = true; ++ } else { ++ xfer += iprot->skip(ftype); ++ } ++ break; ++ default: ++ xfer += iprot->skip(ftype); ++ break; ++ } ++ xfer += iprot->readFieldEnd(); ++ } ++ ++ xfer += iprot->readStructEnd(); ++ ++ if (!isset_dbname) ++ throw TProtocolException(TProtocolException::INVALID_DATA); ++ if (!isset_tablename) ++ throw TProtocolException(TProtocolException::INVALID_DATA); ++ if (!isset_constraintname) ++ throw TProtocolException(TProtocolException::INVALID_DATA); ++ return xfer; ++} ++ ++uint32_t DropConstraintRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { ++ uint32_t xfer = 0; ++ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); ++ xfer += oprot->writeStructBegin("DropConstraintRequest"); ++ ++ xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 1); ++ xfer += oprot->writeString(this->dbname); ++ xfer += oprot->writeFieldEnd(); ++ ++ xfer += oprot->writeFieldBegin("tablename", ::apache::thrift::protocol::T_STRING, 2); ++ xfer += oprot->writeString(this->tablename); ++ xfer += oprot->writeFieldEnd(); ++ ++ xfer += oprot->writeFieldBegin("constraintname", ::apache::thrift::protocol::T_STRING, 3); ++ xfer += oprot->writeString(this->constraintname); ++ xfer += oprot->writeFieldEnd(); ++ ++ xfer += oprot->writeFieldStop(); ++ xfer += oprot->writeStructEnd(); ++ return xfer; ++} ++ ++void swap(DropConstraintRequest &a, DropConstraintRequest &b) { ++ using ::std::swap; ++ swap(a.dbname, b.dbname); ++ swap(a.tablename, b.tablename); ++ swap(a.constraintname, b.constraintname); ++} ++ ++DropConstraintRequest::DropConstraintRequest(const DropConstraintRequest& other377) { ++ dbname = other377.dbname; ++ tablename = other377.tablename; ++ constraintname = other377.constraintname; ++} ++DropConstraintRequest& DropConstraintRequest::operator=(const DropConstraintRequest& other378) { ++ dbname = other378.dbname; ++ tablename = other378.tablename; ++ constraintname = other378.constraintname; ++ return *this; ++} ++void DropConstraintRequest::printTo(std::ostream& out) const { ++ using ::apache::thrift::to_string; ++ out << "DropConstraintRequest("; ++ out << "dbname=" << to_string(dbname); ++ out << ", " << "tablename=" << to_string(tablename); ++ out << ", " << "constraintname=" << to_string(constraintname); ++ out << ")"; ++} ++ ++ + PartitionsByExprResult::~PartitionsByExprResult() throw() { + } + +@@ -9038,14 +9170,14 @@ uint32_t PartitionsByExprResult::read(::apache::thrift::protocol::TProtocol* ipr + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partitions.clear(); +- uint32_t _size377; +- ::apache::thrift::protocol::TType _etype380; +- xfer += iprot->readListBegin(_etype380, _size377); +- this->partitions.resize(_size377); +- uint32_t _i381; +- for (_i381 = 0; _i381 < _size377; ++_i381) ++ uint32_t _size379; ++ ::apache::thrift::protocol::TType _etype382; ++ xfer += iprot->readListBegin(_etype382, _size379); ++ this->partitions.resize(_size379); ++ uint32_t _i383; ++ for (_i383 = 0; _i383 < _size379; ++_i383) + { +- xfer += this->partitions[_i381].read(iprot); ++ xfer += this->partitions[_i383].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -9086,10 +9218,10 @@ uint32_t PartitionsByExprResult::write(::apache::thrift::protocol::TProtocol* op + xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitions.size())); +- std::vector ::const_iterator _iter382; +- for (_iter382 = this->partitions.begin(); _iter382 != this->partitions.end(); ++_iter382) ++ std::vector ::const_iterator _iter384; ++ for (_iter384 = this->partitions.begin(); _iter384 != this->partitions.end(); ++_iter384) + { +- xfer += (*_iter382).write(oprot); ++ xfer += (*_iter384).write(oprot); + } + xfer += oprot->writeListEnd(); + } +@@ -9110,13 +9242,13 @@ void swap(PartitionsByExprResult &a, PartitionsByExprResult &b) { + swap(a.hasUnknownPartitions, b.hasUnknownPartitions); + } + +-PartitionsByExprResult::PartitionsByExprResult(const PartitionsByExprResult& other383) { +- partitions = other383.partitions; +- hasUnknownPartitions = other383.hasUnknownPartitions; ++PartitionsByExprResult::PartitionsByExprResult(const PartitionsByExprResult& other385) { ++ partitions = other385.partitions; ++ hasUnknownPartitions = other385.hasUnknownPartitions; + } +-PartitionsByExprResult& PartitionsByExprResult::operator=(const PartitionsByExprResult& other384) { +- partitions = other384.partitions; +- hasUnknownPartitions = other384.hasUnknownPartitions; ++PartitionsByExprResult& PartitionsByExprResult::operator=(const PartitionsByExprResult& other386) { ++ partitions = other386.partitions; ++ hasUnknownPartitions = other386.hasUnknownPartitions; + return *this; + } + void PartitionsByExprResult::printTo(std::ostream& out) const { +@@ -9278,21 +9410,21 @@ void swap(PartitionsByExprRequest &a, PartitionsByExprRequest &b) { + swap(a.__isset, b.__isset); + } + +-PartitionsByExprRequest::PartitionsByExprRequest(const PartitionsByExprRequest& other385) { +- dbName = other385.dbName; +- tblName = other385.tblName; +- expr = other385.expr; +- defaultPartitionName = other385.defaultPartitionName; +- maxParts = other385.maxParts; +- __isset = other385.__isset; +-} +-PartitionsByExprRequest& PartitionsByExprRequest::operator=(const PartitionsByExprRequest& other386) { +- dbName = other386.dbName; +- tblName = other386.tblName; +- expr = other386.expr; +- defaultPartitionName = other386.defaultPartitionName; +- maxParts = other386.maxParts; +- __isset = other386.__isset; ++PartitionsByExprRequest::PartitionsByExprRequest(const PartitionsByExprRequest& other387) { ++ dbName = other387.dbName; ++ tblName = other387.tblName; ++ expr = other387.expr; ++ defaultPartitionName = other387.defaultPartitionName; ++ maxParts = other387.maxParts; ++ __isset = other387.__isset; ++} ++PartitionsByExprRequest& PartitionsByExprRequest::operator=(const PartitionsByExprRequest& other388) { ++ dbName = other388.dbName; ++ tblName = other388.tblName; ++ expr = other388.expr; ++ defaultPartitionName = other388.defaultPartitionName; ++ maxParts = other388.maxParts; ++ __isset = other388.__isset; + return *this; + } + void PartitionsByExprRequest::printTo(std::ostream& out) const { +@@ -9341,14 +9473,14 @@ uint32_t TableStatsResult::read(::apache::thrift::protocol::TProtocol* iprot) { + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->tableStats.clear(); +- uint32_t _size387; +- ::apache::thrift::protocol::TType _etype390; +- xfer += iprot->readListBegin(_etype390, _size387); +- this->tableStats.resize(_size387); +- uint32_t _i391; +- for (_i391 = 0; _i391 < _size387; ++_i391) ++ uint32_t _size389; ++ ::apache::thrift::protocol::TType _etype392; ++ xfer += iprot->readListBegin(_etype392, _size389); ++ this->tableStats.resize(_size389); ++ uint32_t _i393; ++ for (_i393 = 0; _i393 < _size389; ++_i393) + { +- xfer += this->tableStats[_i391].read(iprot); ++ xfer += this->tableStats[_i393].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -9379,10 +9511,10 @@ uint32_t TableStatsResult::write(::apache::thrift::protocol::TProtocol* oprot) c + xfer += oprot->writeFieldBegin("tableStats", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->tableStats.size())); +- std::vector ::const_iterator _iter392; +- for (_iter392 = this->tableStats.begin(); _iter392 != this->tableStats.end(); ++_iter392) ++ std::vector ::const_iterator _iter394; ++ for (_iter394 = this->tableStats.begin(); _iter394 != this->tableStats.end(); ++_iter394) + { +- xfer += (*_iter392).write(oprot); ++ xfer += (*_iter394).write(oprot); + } + xfer += oprot->writeListEnd(); + } +@@ -9398,11 +9530,11 @@ void swap(TableStatsResult &a, TableStatsResult &b) { + swap(a.tableStats, b.tableStats); + } + +-TableStatsResult::TableStatsResult(const TableStatsResult& other393) { +- tableStats = other393.tableStats; ++TableStatsResult::TableStatsResult(const TableStatsResult& other395) { ++ tableStats = other395.tableStats; + } +-TableStatsResult& TableStatsResult::operator=(const TableStatsResult& other394) { +- tableStats = other394.tableStats; ++TableStatsResult& TableStatsResult::operator=(const TableStatsResult& other396) { ++ tableStats = other396.tableStats; + return *this; + } + void TableStatsResult::printTo(std::ostream& out) const { +@@ -9447,26 +9579,26 @@ uint32_t PartitionsStatsResult::read(::apache::thrift::protocol::TProtocol* ipro + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + this->partStats.clear(); +- uint32_t _size395; +- ::apache::thrift::protocol::TType _ktype396; +- ::apache::thrift::protocol::TType _vtype397; +- xfer += iprot->readMapBegin(_ktype396, _vtype397, _size395); +- uint32_t _i399; +- for (_i399 = 0; _i399 < _size395; ++_i399) ++ uint32_t _size397; ++ ::apache::thrift::protocol::TType _ktype398; ++ ::apache::thrift::protocol::TType _vtype399; ++ xfer += iprot->readMapBegin(_ktype398, _vtype399, _size397); ++ uint32_t _i401; ++ for (_i401 = 0; _i401 < _size397; ++_i401) + { +- std::string _key400; +- xfer += iprot->readString(_key400); +- std::vector & _val401 = this->partStats[_key400]; ++ std::string _key402; ++ xfer += iprot->readString(_key402); ++ std::vector & _val403 = this->partStats[_key402]; + { +- _val401.clear(); +- uint32_t _size402; +- ::apache::thrift::protocol::TType _etype405; +- xfer += iprot->readListBegin(_etype405, _size402); +- _val401.resize(_size402); +- uint32_t _i406; +- for (_i406 = 0; _i406 < _size402; ++_i406) ++ _val403.clear(); ++ uint32_t _size404; ++ ::apache::thrift::protocol::TType _etype407; ++ xfer += iprot->readListBegin(_etype407, _size404); ++ _val403.resize(_size404); ++ uint32_t _i408; ++ for (_i408 = 0; _i408 < _size404; ++_i408) + { +- xfer += _val401[_i406].read(iprot); ++ xfer += _val403[_i408].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -9500,16 +9632,16 @@ uint32_t PartitionsStatsResult::write(::apache::thrift::protocol::TProtocol* opr + xfer += oprot->writeFieldBegin("partStats", ::apache::thrift::protocol::T_MAP, 1); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_LIST, static_cast(this->partStats.size())); +- std::map > ::const_iterator _iter407; +- for (_iter407 = this->partStats.begin(); _iter407 != this->partStats.end(); ++_iter407) ++ std::map > ::const_iterator _iter409; ++ for (_iter409 = this->partStats.begin(); _iter409 != this->partStats.end(); ++_iter409) + { +- xfer += oprot->writeString(_iter407->first); ++ xfer += oprot->writeString(_iter409->first); + { +- xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(_iter407->second.size())); +- std::vector ::const_iterator _iter408; +- for (_iter408 = _iter407->second.begin(); _iter408 != _iter407->second.end(); ++_iter408) ++ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(_iter409->second.size())); ++ std::vector ::const_iterator _iter410; ++ for (_iter410 = _iter409->second.begin(); _iter410 != _iter409->second.end(); ++_iter410) + { +- xfer += (*_iter408).write(oprot); ++ xfer += (*_iter410).write(oprot); + } + xfer += oprot->writeListEnd(); + } +@@ -9528,11 +9660,11 @@ void swap(PartitionsStatsResult &a, PartitionsStatsResult &b) { + swap(a.partStats, b.partStats); + } + +-PartitionsStatsResult::PartitionsStatsResult(const PartitionsStatsResult& other409) { +- partStats = other409.partStats; ++PartitionsStatsResult::PartitionsStatsResult(const PartitionsStatsResult& other411) { ++ partStats = other411.partStats; + } +-PartitionsStatsResult& PartitionsStatsResult::operator=(const PartitionsStatsResult& other410) { +- partStats = other410.partStats; ++PartitionsStatsResult& PartitionsStatsResult::operator=(const PartitionsStatsResult& other412) { ++ partStats = other412.partStats; + return *this; + } + void PartitionsStatsResult::printTo(std::ostream& out) const { +@@ -9603,14 +9735,14 @@ uint32_t TableStatsRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->colNames.clear(); +- uint32_t _size411; +- ::apache::thrift::protocol::TType _etype414; +- xfer += iprot->readListBegin(_etype414, _size411); +- this->colNames.resize(_size411); +- uint32_t _i415; +- for (_i415 = 0; _i415 < _size411; ++_i415) ++ uint32_t _size413; ++ ::apache::thrift::protocol::TType _etype416; ++ xfer += iprot->readListBegin(_etype416, _size413); ++ this->colNames.resize(_size413); ++ uint32_t _i417; ++ for (_i417 = 0; _i417 < _size413; ++_i417) + { +- xfer += iprot->readString(this->colNames[_i415]); ++ xfer += iprot->readString(this->colNames[_i417]); + } + xfer += iprot->readListEnd(); + } +@@ -9653,10 +9785,10 @@ uint32_t TableStatsRequest::write(::apache::thrift::protocol::TProtocol* oprot) + xfer += oprot->writeFieldBegin("colNames", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->colNames.size())); +- std::vector ::const_iterator _iter416; +- for (_iter416 = this->colNames.begin(); _iter416 != this->colNames.end(); ++_iter416) ++ std::vector ::const_iterator _iter418; ++ for (_iter418 = this->colNames.begin(); _iter418 != this->colNames.end(); ++_iter418) + { +- xfer += oprot->writeString((*_iter416)); ++ xfer += oprot->writeString((*_iter418)); + } + xfer += oprot->writeListEnd(); + } +@@ -9674,15 +9806,15 @@ void swap(TableStatsRequest &a, TableStatsRequest &b) { + swap(a.colNames, b.colNames); + } + +-TableStatsRequest::TableStatsRequest(const TableStatsRequest& other417) { +- dbName = other417.dbName; +- tblName = other417.tblName; +- colNames = other417.colNames; ++TableStatsRequest::TableStatsRequest(const TableStatsRequest& other419) { ++ dbName = other419.dbName; ++ tblName = other419.tblName; ++ colNames = other419.colNames; + } +-TableStatsRequest& TableStatsRequest::operator=(const TableStatsRequest& other418) { +- dbName = other418.dbName; +- tblName = other418.tblName; +- colNames = other418.colNames; ++TableStatsRequest& TableStatsRequest::operator=(const TableStatsRequest& other420) { ++ dbName = other420.dbName; ++ tblName = other420.tblName; ++ colNames = other420.colNames; + return *this; + } + void TableStatsRequest::printTo(std::ostream& out) const { +@@ -9760,14 +9892,14 @@ uint32_t PartitionsStatsRequest::read(::apache::thrift::protocol::TProtocol* ipr + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->colNames.clear(); +- uint32_t _size419; +- ::apache::thrift::protocol::TType _etype422; +- xfer += iprot->readListBegin(_etype422, _size419); +- this->colNames.resize(_size419); +- uint32_t _i423; +- for (_i423 = 0; _i423 < _size419; ++_i423) ++ uint32_t _size421; ++ ::apache::thrift::protocol::TType _etype424; ++ xfer += iprot->readListBegin(_etype424, _size421); ++ this->colNames.resize(_size421); ++ uint32_t _i425; ++ for (_i425 = 0; _i425 < _size421; ++_i425) + { +- xfer += iprot->readString(this->colNames[_i423]); ++ xfer += iprot->readString(this->colNames[_i425]); + } + xfer += iprot->readListEnd(); + } +@@ -9780,14 +9912,14 @@ uint32_t PartitionsStatsRequest::read(::apache::thrift::protocol::TProtocol* ipr + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partNames.clear(); +- uint32_t _size424; +- ::apache::thrift::protocol::TType _etype427; +- xfer += iprot->readListBegin(_etype427, _size424); +- this->partNames.resize(_size424); +- uint32_t _i428; +- for (_i428 = 0; _i428 < _size424; ++_i428) ++ uint32_t _size426; ++ ::apache::thrift::protocol::TType _etype429; ++ xfer += iprot->readListBegin(_etype429, _size426); ++ this->partNames.resize(_size426); ++ uint32_t _i430; ++ for (_i430 = 0; _i430 < _size426; ++_i430) + { +- xfer += iprot->readString(this->partNames[_i428]); ++ xfer += iprot->readString(this->partNames[_i430]); + } + xfer += iprot->readListEnd(); + } +@@ -9832,10 +9964,10 @@ uint32_t PartitionsStatsRequest::write(::apache::thrift::protocol::TProtocol* op + xfer += oprot->writeFieldBegin("colNames", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->colNames.size())); +- std::vector ::const_iterator _iter429; +- for (_iter429 = this->colNames.begin(); _iter429 != this->colNames.end(); ++_iter429) ++ std::vector ::const_iterator _iter431; ++ for (_iter431 = this->colNames.begin(); _iter431 != this->colNames.end(); ++_iter431) + { +- xfer += oprot->writeString((*_iter429)); ++ xfer += oprot->writeString((*_iter431)); + } + xfer += oprot->writeListEnd(); + } +@@ -9844,10 +9976,10 @@ uint32_t PartitionsStatsRequest::write(::apache::thrift::protocol::TProtocol* op + xfer += oprot->writeFieldBegin("partNames", ::apache::thrift::protocol::T_LIST, 4); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partNames.size())); +- std::vector ::const_iterator _iter430; +- for (_iter430 = this->partNames.begin(); _iter430 != this->partNames.end(); ++_iter430) ++ std::vector ::const_iterator _iter432; ++ for (_iter432 = this->partNames.begin(); _iter432 != this->partNames.end(); ++_iter432) + { +- xfer += oprot->writeString((*_iter430)); ++ xfer += oprot->writeString((*_iter432)); + } + xfer += oprot->writeListEnd(); + } +@@ -9866,17 +9998,17 @@ void swap(PartitionsStatsRequest &a, PartitionsStatsRequest &b) { + swap(a.partNames, b.partNames); + } + +-PartitionsStatsRequest::PartitionsStatsRequest(const PartitionsStatsRequest& other431) { +- dbName = other431.dbName; +- tblName = other431.tblName; +- colNames = other431.colNames; +- partNames = other431.partNames; ++PartitionsStatsRequest::PartitionsStatsRequest(const PartitionsStatsRequest& other433) { ++ dbName = other433.dbName; ++ tblName = other433.tblName; ++ colNames = other433.colNames; ++ partNames = other433.partNames; + } +-PartitionsStatsRequest& PartitionsStatsRequest::operator=(const PartitionsStatsRequest& other432) { +- dbName = other432.dbName; +- tblName = other432.tblName; +- colNames = other432.colNames; +- partNames = other432.partNames; ++PartitionsStatsRequest& PartitionsStatsRequest::operator=(const PartitionsStatsRequest& other434) { ++ dbName = other434.dbName; ++ tblName = other434.tblName; ++ colNames = other434.colNames; ++ partNames = other434.partNames; + return *this; + } + void PartitionsStatsRequest::printTo(std::ostream& out) const { +@@ -9924,14 +10056,14 @@ uint32_t AddPartitionsResult::read(::apache::thrift::protocol::TProtocol* iprot) + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partitions.clear(); +- uint32_t _size433; +- ::apache::thrift::protocol::TType _etype436; +- xfer += iprot->readListBegin(_etype436, _size433); +- this->partitions.resize(_size433); +- uint32_t _i437; +- for (_i437 = 0; _i437 < _size433; ++_i437) ++ uint32_t _size435; ++ ::apache::thrift::protocol::TType _etype438; ++ xfer += iprot->readListBegin(_etype438, _size435); ++ this->partitions.resize(_size435); ++ uint32_t _i439; ++ for (_i439 = 0; _i439 < _size435; ++_i439) + { +- xfer += this->partitions[_i437].read(iprot); ++ xfer += this->partitions[_i439].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -9961,10 +10093,10 @@ uint32_t AddPartitionsResult::write(::apache::thrift::protocol::TProtocol* oprot + xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitions.size())); +- std::vector ::const_iterator _iter438; +- for (_iter438 = this->partitions.begin(); _iter438 != this->partitions.end(); ++_iter438) ++ std::vector ::const_iterator _iter440; ++ for (_iter440 = this->partitions.begin(); _iter440 != this->partitions.end(); ++_iter440) + { +- xfer += (*_iter438).write(oprot); ++ xfer += (*_iter440).write(oprot); + } + xfer += oprot->writeListEnd(); + } +@@ -9981,13 +10113,13 @@ void swap(AddPartitionsResult &a, AddPartitionsResult &b) { + swap(a.__isset, b.__isset); + } + +-AddPartitionsResult::AddPartitionsResult(const AddPartitionsResult& other439) { +- partitions = other439.partitions; +- __isset = other439.__isset; ++AddPartitionsResult::AddPartitionsResult(const AddPartitionsResult& other441) { ++ partitions = other441.partitions; ++ __isset = other441.__isset; + } +-AddPartitionsResult& AddPartitionsResult::operator=(const AddPartitionsResult& other440) { +- partitions = other440.partitions; +- __isset = other440.__isset; ++AddPartitionsResult& AddPartitionsResult::operator=(const AddPartitionsResult& other442) { ++ partitions = other442.partitions; ++ __isset = other442.__isset; + return *this; + } + void AddPartitionsResult::printTo(std::ostream& out) const { +@@ -10068,14 +10200,14 @@ uint32_t AddPartitionsRequest::read(::apache::thrift::protocol::TProtocol* iprot + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->parts.clear(); +- uint32_t _size441; +- ::apache::thrift::protocol::TType _etype444; +- xfer += iprot->readListBegin(_etype444, _size441); +- this->parts.resize(_size441); +- uint32_t _i445; +- for (_i445 = 0; _i445 < _size441; ++_i445) ++ uint32_t _size443; ++ ::apache::thrift::protocol::TType _etype446; ++ xfer += iprot->readListBegin(_etype446, _size443); ++ this->parts.resize(_size443); ++ uint32_t _i447; ++ for (_i447 = 0; _i447 < _size443; ++_i447) + { +- xfer += this->parts[_i445].read(iprot); ++ xfer += this->parts[_i447].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -10136,10 +10268,10 @@ uint32_t AddPartitionsRequest::write(::apache::thrift::protocol::TProtocol* opro + xfer += oprot->writeFieldBegin("parts", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->parts.size())); +- std::vector ::const_iterator _iter446; +- for (_iter446 = this->parts.begin(); _iter446 != this->parts.end(); ++_iter446) ++ std::vector ::const_iterator _iter448; ++ for (_iter448 = this->parts.begin(); _iter448 != this->parts.end(); ++_iter448) + { +- xfer += (*_iter446).write(oprot); ++ xfer += (*_iter448).write(oprot); + } + xfer += oprot->writeListEnd(); + } +@@ -10169,21 +10301,21 @@ void swap(AddPartitionsRequest &a, AddPartitionsRequest &b) { + swap(a.__isset, b.__isset); + } + +-AddPartitionsRequest::AddPartitionsRequest(const AddPartitionsRequest& other447) { +- dbName = other447.dbName; +- tblName = other447.tblName; +- parts = other447.parts; +- ifNotExists = other447.ifNotExists; +- needResult = other447.needResult; +- __isset = other447.__isset; +-} +-AddPartitionsRequest& AddPartitionsRequest::operator=(const AddPartitionsRequest& other448) { +- dbName = other448.dbName; +- tblName = other448.tblName; +- parts = other448.parts; +- ifNotExists = other448.ifNotExists; +- needResult = other448.needResult; +- __isset = other448.__isset; ++AddPartitionsRequest::AddPartitionsRequest(const AddPartitionsRequest& other449) { ++ dbName = other449.dbName; ++ tblName = other449.tblName; ++ parts = other449.parts; ++ ifNotExists = other449.ifNotExists; ++ needResult = other449.needResult; ++ __isset = other449.__isset; ++} ++AddPartitionsRequest& AddPartitionsRequest::operator=(const AddPartitionsRequest& other450) { ++ dbName = other450.dbName; ++ tblName = other450.tblName; ++ parts = other450.parts; ++ ifNotExists = other450.ifNotExists; ++ needResult = other450.needResult; ++ __isset = other450.__isset; + return *this; + } + void AddPartitionsRequest::printTo(std::ostream& out) const { +@@ -10232,14 +10364,14 @@ uint32_t DropPartitionsResult::read(::apache::thrift::protocol::TProtocol* iprot + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partitions.clear(); +- uint32_t _size449; +- ::apache::thrift::protocol::TType _etype452; +- xfer += iprot->readListBegin(_etype452, _size449); +- this->partitions.resize(_size449); +- uint32_t _i453; +- for (_i453 = 0; _i453 < _size449; ++_i453) ++ uint32_t _size451; ++ ::apache::thrift::protocol::TType _etype454; ++ xfer += iprot->readListBegin(_etype454, _size451); ++ this->partitions.resize(_size451); ++ uint32_t _i455; ++ for (_i455 = 0; _i455 < _size451; ++_i455) + { +- xfer += this->partitions[_i453].read(iprot); ++ xfer += this->partitions[_i455].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -10269,10 +10401,10 @@ uint32_t DropPartitionsResult::write(::apache::thrift::protocol::TProtocol* opro + xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitions.size())); +- std::vector ::const_iterator _iter454; +- for (_iter454 = this->partitions.begin(); _iter454 != this->partitions.end(); ++_iter454) ++ std::vector ::const_iterator _iter456; ++ for (_iter456 = this->partitions.begin(); _iter456 != this->partitions.end(); ++_iter456) + { +- xfer += (*_iter454).write(oprot); ++ xfer += (*_iter456).write(oprot); + } + xfer += oprot->writeListEnd(); + } +@@ -10289,13 +10421,13 @@ void swap(DropPartitionsResult &a, DropPartitionsResult &b) { + swap(a.__isset, b.__isset); + } + +-DropPartitionsResult::DropPartitionsResult(const DropPartitionsResult& other455) { +- partitions = other455.partitions; +- __isset = other455.__isset; ++DropPartitionsResult::DropPartitionsResult(const DropPartitionsResult& other457) { ++ partitions = other457.partitions; ++ __isset = other457.__isset; + } +-DropPartitionsResult& DropPartitionsResult::operator=(const DropPartitionsResult& other456) { +- partitions = other456.partitions; +- __isset = other456.__isset; ++DropPartitionsResult& DropPartitionsResult::operator=(const DropPartitionsResult& other458) { ++ partitions = other458.partitions; ++ __isset = other458.__isset; + return *this; + } + void DropPartitionsResult::printTo(std::ostream& out) const { +@@ -10397,15 +10529,15 @@ void swap(DropPartitionsExpr &a, DropPartitionsExpr &b) { + swap(a.__isset, b.__isset); + } + +-DropPartitionsExpr::DropPartitionsExpr(const DropPartitionsExpr& other457) { +- expr = other457.expr; +- partArchiveLevel = other457.partArchiveLevel; +- __isset = other457.__isset; ++DropPartitionsExpr::DropPartitionsExpr(const DropPartitionsExpr& other459) { ++ expr = other459.expr; ++ partArchiveLevel = other459.partArchiveLevel; ++ __isset = other459.__isset; + } +-DropPartitionsExpr& DropPartitionsExpr::operator=(const DropPartitionsExpr& other458) { +- expr = other458.expr; +- partArchiveLevel = other458.partArchiveLevel; +- __isset = other458.__isset; ++DropPartitionsExpr& DropPartitionsExpr::operator=(const DropPartitionsExpr& other460) { ++ expr = other460.expr; ++ partArchiveLevel = other460.partArchiveLevel; ++ __isset = other460.__isset; + return *this; + } + void DropPartitionsExpr::printTo(std::ostream& out) const { +@@ -10454,14 +10586,14 @@ uint32_t RequestPartsSpec::read(::apache::thrift::protocol::TProtocol* iprot) { + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->names.clear(); +- uint32_t _size459; +- ::apache::thrift::protocol::TType _etype462; +- xfer += iprot->readListBegin(_etype462, _size459); +- this->names.resize(_size459); +- uint32_t _i463; +- for (_i463 = 0; _i463 < _size459; ++_i463) ++ uint32_t _size461; ++ ::apache::thrift::protocol::TType _etype464; ++ xfer += iprot->readListBegin(_etype464, _size461); ++ this->names.resize(_size461); ++ uint32_t _i465; ++ for (_i465 = 0; _i465 < _size461; ++_i465) + { +- xfer += iprot->readString(this->names[_i463]); ++ xfer += iprot->readString(this->names[_i465]); + } + xfer += iprot->readListEnd(); + } +@@ -10474,14 +10606,14 @@ uint32_t RequestPartsSpec::read(::apache::thrift::protocol::TProtocol* iprot) { + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->exprs.clear(); +- uint32_t _size464; +- ::apache::thrift::protocol::TType _etype467; +- xfer += iprot->readListBegin(_etype467, _size464); +- this->exprs.resize(_size464); +- uint32_t _i468; +- for (_i468 = 0; _i468 < _size464; ++_i468) ++ uint32_t _size466; ++ ::apache::thrift::protocol::TType _etype469; ++ xfer += iprot->readListBegin(_etype469, _size466); ++ this->exprs.resize(_size466); ++ uint32_t _i470; ++ for (_i470 = 0; _i470 < _size466; ++_i470) + { +- xfer += this->exprs[_i468].read(iprot); ++ xfer += this->exprs[_i470].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -10510,10 +10642,10 @@ uint32_t RequestPartsSpec::write(::apache::thrift::protocol::TProtocol* oprot) c + xfer += oprot->writeFieldBegin("names", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->names.size())); +- std::vector ::const_iterator _iter469; +- for (_iter469 = this->names.begin(); _iter469 != this->names.end(); ++_iter469) ++ std::vector ::const_iterator _iter471; ++ for (_iter471 = this->names.begin(); _iter471 != this->names.end(); ++_iter471) + { +- xfer += oprot->writeString((*_iter469)); ++ xfer += oprot->writeString((*_iter471)); + } + xfer += oprot->writeListEnd(); + } +@@ -10522,10 +10654,10 @@ uint32_t RequestPartsSpec::write(::apache::thrift::protocol::TProtocol* oprot) c + xfer += oprot->writeFieldBegin("exprs", ::apache::thrift::protocol::T_LIST, 2); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->exprs.size())); +- std::vector ::const_iterator _iter470; +- for (_iter470 = this->exprs.begin(); _iter470 != this->exprs.end(); ++_iter470) ++ std::vector ::const_iterator _iter472; ++ for (_iter472 = this->exprs.begin(); _iter472 != this->exprs.end(); ++_iter472) + { +- xfer += (*_iter470).write(oprot); ++ xfer += (*_iter472).write(oprot); + } + xfer += oprot->writeListEnd(); + } +@@ -10543,15 +10675,15 @@ void swap(RequestPartsSpec &a, RequestPartsSpec &b) { + swap(a.__isset, b.__isset); + } + +-RequestPartsSpec::RequestPartsSpec(const RequestPartsSpec& other471) { +- names = other471.names; +- exprs = other471.exprs; +- __isset = other471.__isset; ++RequestPartsSpec::RequestPartsSpec(const RequestPartsSpec& other473) { ++ names = other473.names; ++ exprs = other473.exprs; ++ __isset = other473.__isset; + } +-RequestPartsSpec& RequestPartsSpec::operator=(const RequestPartsSpec& other472) { +- names = other472.names; +- exprs = other472.exprs; +- __isset = other472.__isset; ++RequestPartsSpec& RequestPartsSpec::operator=(const RequestPartsSpec& other474) { ++ names = other474.names; ++ exprs = other474.exprs; ++ __isset = other474.__isset; + return *this; + } + void RequestPartsSpec::printTo(std::ostream& out) const { +@@ -10770,27 +10902,27 @@ void swap(DropPartitionsRequest &a, DropPartitionsRequest &b) { + swap(a.__isset, b.__isset); + } + +-DropPartitionsRequest::DropPartitionsRequest(const DropPartitionsRequest& other473) { +- dbName = other473.dbName; +- tblName = other473.tblName; +- parts = other473.parts; +- deleteData = other473.deleteData; +- ifExists = other473.ifExists; +- ignoreProtection = other473.ignoreProtection; +- environmentContext = other473.environmentContext; +- needResult = other473.needResult; +- __isset = other473.__isset; +-} +-DropPartitionsRequest& DropPartitionsRequest::operator=(const DropPartitionsRequest& other474) { +- dbName = other474.dbName; +- tblName = other474.tblName; +- parts = other474.parts; +- deleteData = other474.deleteData; +- ifExists = other474.ifExists; +- ignoreProtection = other474.ignoreProtection; +- environmentContext = other474.environmentContext; +- needResult = other474.needResult; +- __isset = other474.__isset; ++DropPartitionsRequest::DropPartitionsRequest(const DropPartitionsRequest& other475) { ++ dbName = other475.dbName; ++ tblName = other475.tblName; ++ parts = other475.parts; ++ deleteData = other475.deleteData; ++ ifExists = other475.ifExists; ++ ignoreProtection = other475.ignoreProtection; ++ environmentContext = other475.environmentContext; ++ needResult = other475.needResult; ++ __isset = other475.__isset; ++} ++DropPartitionsRequest& DropPartitionsRequest::operator=(const DropPartitionsRequest& other476) { ++ dbName = other476.dbName; ++ tblName = other476.tblName; ++ parts = other476.parts; ++ deleteData = other476.deleteData; ++ ifExists = other476.ifExists; ++ ignoreProtection = other476.ignoreProtection; ++ environmentContext = other476.environmentContext; ++ needResult = other476.needResult; ++ __isset = other476.__isset; + return *this; + } + void DropPartitionsRequest::printTo(std::ostream& out) const { +@@ -10843,9 +10975,9 @@ uint32_t ResourceUri::read(::apache::thrift::protocol::TProtocol* iprot) { + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I32) { +- int32_t ecast475; +- xfer += iprot->readI32(ecast475); +- this->resourceType = (ResourceType::type)ecast475; ++ int32_t ecast477; ++ xfer += iprot->readI32(ecast477); ++ this->resourceType = (ResourceType::type)ecast477; + this->__isset.resourceType = true; + } else { + xfer += iprot->skip(ftype); +@@ -10896,15 +11028,15 @@ void swap(ResourceUri &a, ResourceUri &b) { + swap(a.__isset, b.__isset); + } + +-ResourceUri::ResourceUri(const ResourceUri& other476) { +- resourceType = other476.resourceType; +- uri = other476.uri; +- __isset = other476.__isset; ++ResourceUri::ResourceUri(const ResourceUri& other478) { ++ resourceType = other478.resourceType; ++ uri = other478.uri; ++ __isset = other478.__isset; + } +-ResourceUri& ResourceUri::operator=(const ResourceUri& other477) { +- resourceType = other477.resourceType; +- uri = other477.uri; +- __isset = other477.__isset; ++ResourceUri& ResourceUri::operator=(const ResourceUri& other479) { ++ resourceType = other479.resourceType; ++ uri = other479.uri; ++ __isset = other479.__isset; + return *this; + } + void ResourceUri::printTo(std::ostream& out) const { +@@ -11007,9 +11139,9 @@ uint32_t Function::read(::apache::thrift::protocol::TProtocol* iprot) { + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_I32) { +- int32_t ecast478; +- xfer += iprot->readI32(ecast478); +- this->ownerType = (PrincipalType::type)ecast478; ++ int32_t ecast480; ++ xfer += iprot->readI32(ecast480); ++ this->ownerType = (PrincipalType::type)ecast480; + this->__isset.ownerType = true; + } else { + xfer += iprot->skip(ftype); +@@ -11025,9 +11157,9 @@ uint32_t Function::read(::apache::thrift::protocol::TProtocol* iprot) { + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_I32) { +- int32_t ecast479; +- xfer += iprot->readI32(ecast479); +- this->functionType = (FunctionType::type)ecast479; ++ int32_t ecast481; ++ xfer += iprot->readI32(ecast481); ++ this->functionType = (FunctionType::type)ecast481; + this->__isset.functionType = true; + } else { + xfer += iprot->skip(ftype); +@@ -11037,14 +11169,14 @@ uint32_t Function::read(::apache::thrift::protocol::TProtocol* iprot) { + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->resourceUris.clear(); +- uint32_t _size480; +- ::apache::thrift::protocol::TType _etype483; +- xfer += iprot->readListBegin(_etype483, _size480); +- this->resourceUris.resize(_size480); +- uint32_t _i484; +- for (_i484 = 0; _i484 < _size480; ++_i484) ++ uint32_t _size482; ++ ::apache::thrift::protocol::TType _etype485; ++ xfer += iprot->readListBegin(_etype485, _size482); ++ this->resourceUris.resize(_size482); ++ uint32_t _i486; ++ for (_i486 = 0; _i486 < _size482; ++_i486) + { +- xfer += this->resourceUris[_i484].read(iprot); ++ xfer += this->resourceUris[_i486].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -11101,10 +11233,10 @@ uint32_t Function::write(::apache::thrift::protocol::TProtocol* oprot) const { + xfer += oprot->writeFieldBegin("resourceUris", ::apache::thrift::protocol::T_LIST, 8); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->resourceUris.size())); +- std::vector ::const_iterator _iter485; +- for (_iter485 = this->resourceUris.begin(); _iter485 != this->resourceUris.end(); ++_iter485) ++ std::vector ::const_iterator _iter487; ++ for (_iter487 = this->resourceUris.begin(); _iter487 != this->resourceUris.end(); ++_iter487) + { +- xfer += (*_iter485).write(oprot); ++ xfer += (*_iter487).write(oprot); + } + xfer += oprot->writeListEnd(); + } +@@ -11128,27 +11260,27 @@ void swap(Function &a, Function &b) { + swap(a.__isset, b.__isset); + } + +-Function::Function(const Function& other486) { +- functionName = other486.functionName; +- dbName = other486.dbName; +- className = other486.className; +- ownerName = other486.ownerName; +- ownerType = other486.ownerType; +- createTime = other486.createTime; +- functionType = other486.functionType; +- resourceUris = other486.resourceUris; +- __isset = other486.__isset; +-} +-Function& Function::operator=(const Function& other487) { +- functionName = other487.functionName; +- dbName = other487.dbName; +- className = other487.className; +- ownerName = other487.ownerName; +- ownerType = other487.ownerType; +- createTime = other487.createTime; +- functionType = other487.functionType; +- resourceUris = other487.resourceUris; +- __isset = other487.__isset; ++Function::Function(const Function& other488) { ++ functionName = other488.functionName; ++ dbName = other488.dbName; ++ className = other488.className; ++ ownerName = other488.ownerName; ++ ownerType = other488.ownerType; ++ createTime = other488.createTime; ++ functionType = other488.functionType; ++ resourceUris = other488.resourceUris; ++ __isset = other488.__isset; ++} ++Function& Function::operator=(const Function& other489) { ++ functionName = other489.functionName; ++ dbName = other489.dbName; ++ className = other489.className; ++ ownerName = other489.ownerName; ++ ownerType = other489.ownerType; ++ createTime = other489.createTime; ++ functionType = other489.functionType; ++ resourceUris = other489.resourceUris; ++ __isset = other489.__isset; + return *this; + } + void Function::printTo(std::ostream& out) const { +@@ -11236,9 +11368,9 @@ uint32_t TxnInfo::read(::apache::thrift::protocol::TProtocol* iprot) { + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I32) { +- int32_t ecast488; +- xfer += iprot->readI32(ecast488); +- this->state = (TxnState::type)ecast488; ++ int32_t ecast490; ++ xfer += iprot->readI32(ecast490); ++ this->state = (TxnState::type)ecast490; + isset_state = true; + } else { + xfer += iprot->skip(ftype); +@@ -11357,25 +11489,25 @@ void swap(TxnInfo &a, TxnInfo &b) { + swap(a.__isset, b.__isset); + } + +-TxnInfo::TxnInfo(const TxnInfo& other489) { +- id = other489.id; +- state = other489.state; +- user = other489.user; +- hostname = other489.hostname; +- agentInfo = other489.agentInfo; +- heartbeatCount = other489.heartbeatCount; +- metaInfo = other489.metaInfo; +- __isset = other489.__isset; +-} +-TxnInfo& TxnInfo::operator=(const TxnInfo& other490) { +- id = other490.id; +- state = other490.state; +- user = other490.user; +- hostname = other490.hostname; +- agentInfo = other490.agentInfo; +- heartbeatCount = other490.heartbeatCount; +- metaInfo = other490.metaInfo; +- __isset = other490.__isset; ++TxnInfo::TxnInfo(const TxnInfo& other491) { ++ id = other491.id; ++ state = other491.state; ++ user = other491.user; ++ hostname = other491.hostname; ++ agentInfo = other491.agentInfo; ++ heartbeatCount = other491.heartbeatCount; ++ metaInfo = other491.metaInfo; ++ __isset = other491.__isset; ++} ++TxnInfo& TxnInfo::operator=(const TxnInfo& other492) { ++ id = other492.id; ++ state = other492.state; ++ user = other492.user; ++ hostname = other492.hostname; ++ agentInfo = other492.agentInfo; ++ heartbeatCount = other492.heartbeatCount; ++ metaInfo = other492.metaInfo; ++ __isset = other492.__isset; + return *this; + } + void TxnInfo::printTo(std::ostream& out) const { +@@ -11439,14 +11571,14 @@ uint32_t GetOpenTxnsInfoResponse::read(::apache::thrift::protocol::TProtocol* ip + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->open_txns.clear(); +- uint32_t _size491; +- ::apache::thrift::protocol::TType _etype494; +- xfer += iprot->readListBegin(_etype494, _size491); +- this->open_txns.resize(_size491); +- uint32_t _i495; +- for (_i495 = 0; _i495 < _size491; ++_i495) ++ uint32_t _size493; ++ ::apache::thrift::protocol::TType _etype496; ++ xfer += iprot->readListBegin(_etype496, _size493); ++ this->open_txns.resize(_size493); ++ uint32_t _i497; ++ for (_i497 = 0; _i497 < _size493; ++_i497) + { +- xfer += this->open_txns[_i495].read(iprot); ++ xfer += this->open_txns[_i497].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -11483,10 +11615,10 @@ uint32_t GetOpenTxnsInfoResponse::write(::apache::thrift::protocol::TProtocol* o + xfer += oprot->writeFieldBegin("open_txns", ::apache::thrift::protocol::T_LIST, 2); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->open_txns.size())); +- std::vector ::const_iterator _iter496; +- for (_iter496 = this->open_txns.begin(); _iter496 != this->open_txns.end(); ++_iter496) ++ std::vector ::const_iterator _iter498; ++ for (_iter498 = this->open_txns.begin(); _iter498 != this->open_txns.end(); ++_iter498) + { +- xfer += (*_iter496).write(oprot); ++ xfer += (*_iter498).write(oprot); + } + xfer += oprot->writeListEnd(); + } +@@ -11503,13 +11635,13 @@ void swap(GetOpenTxnsInfoResponse &a, GetOpenTxnsInfoResponse &b) { + swap(a.open_txns, b.open_txns); + } + +-GetOpenTxnsInfoResponse::GetOpenTxnsInfoResponse(const GetOpenTxnsInfoResponse& other497) { +- txn_high_water_mark = other497.txn_high_water_mark; +- open_txns = other497.open_txns; ++GetOpenTxnsInfoResponse::GetOpenTxnsInfoResponse(const GetOpenTxnsInfoResponse& other499) { ++ txn_high_water_mark = other499.txn_high_water_mark; ++ open_txns = other499.open_txns; + } +-GetOpenTxnsInfoResponse& GetOpenTxnsInfoResponse::operator=(const GetOpenTxnsInfoResponse& other498) { +- txn_high_water_mark = other498.txn_high_water_mark; +- open_txns = other498.open_txns; ++GetOpenTxnsInfoResponse& GetOpenTxnsInfoResponse::operator=(const GetOpenTxnsInfoResponse& other500) { ++ txn_high_water_mark = other500.txn_high_water_mark; ++ open_txns = other500.open_txns; + return *this; + } + void GetOpenTxnsInfoResponse::printTo(std::ostream& out) const { +@@ -11568,15 +11700,15 @@ uint32_t GetOpenTxnsResponse::read(::apache::thrift::protocol::TProtocol* iprot) + if (ftype == ::apache::thrift::protocol::T_SET) { + { + this->open_txns.clear(); +- uint32_t _size499; +- ::apache::thrift::protocol::TType _etype502; +- xfer += iprot->readSetBegin(_etype502, _size499); +- uint32_t _i503; +- for (_i503 = 0; _i503 < _size499; ++_i503) ++ uint32_t _size501; ++ ::apache::thrift::protocol::TType _etype504; ++ xfer += iprot->readSetBegin(_etype504, _size501); ++ uint32_t _i505; ++ for (_i505 = 0; _i505 < _size501; ++_i505) + { +- int64_t _elem504; +- xfer += iprot->readI64(_elem504); +- this->open_txns.insert(_elem504); ++ int64_t _elem506; ++ xfer += iprot->readI64(_elem506); ++ this->open_txns.insert(_elem506); + } + xfer += iprot->readSetEnd(); + } +@@ -11613,10 +11745,10 @@ uint32_t GetOpenTxnsResponse::write(::apache::thrift::protocol::TProtocol* oprot + xfer += oprot->writeFieldBegin("open_txns", ::apache::thrift::protocol::T_SET, 2); + { + xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_I64, static_cast(this->open_txns.size())); +- std::set ::const_iterator _iter505; +- for (_iter505 = this->open_txns.begin(); _iter505 != this->open_txns.end(); ++_iter505) ++ std::set ::const_iterator _iter507; ++ for (_iter507 = this->open_txns.begin(); _iter507 != this->open_txns.end(); ++_iter507) + { +- xfer += oprot->writeI64((*_iter505)); ++ xfer += oprot->writeI64((*_iter507)); + } + xfer += oprot->writeSetEnd(); + } +@@ -11633,13 +11765,13 @@ void swap(GetOpenTxnsResponse &a, GetOpenTxnsResponse &b) { + swap(a.open_txns, b.open_txns); + } + +-GetOpenTxnsResponse::GetOpenTxnsResponse(const GetOpenTxnsResponse& other506) { +- txn_high_water_mark = other506.txn_high_water_mark; +- open_txns = other506.open_txns; ++GetOpenTxnsResponse::GetOpenTxnsResponse(const GetOpenTxnsResponse& other508) { ++ txn_high_water_mark = other508.txn_high_water_mark; ++ open_txns = other508.open_txns; + } +-GetOpenTxnsResponse& GetOpenTxnsResponse::operator=(const GetOpenTxnsResponse& other507) { +- txn_high_water_mark = other507.txn_high_water_mark; +- open_txns = other507.open_txns; ++GetOpenTxnsResponse& GetOpenTxnsResponse::operator=(const GetOpenTxnsResponse& other509) { ++ txn_high_water_mark = other509.txn_high_water_mark; ++ open_txns = other509.open_txns; + return *this; + } + void GetOpenTxnsResponse::printTo(std::ostream& out) const { +@@ -11782,19 +11914,19 @@ void swap(OpenTxnRequest &a, OpenTxnRequest &b) { + swap(a.__isset, b.__isset); + } + +-OpenTxnRequest::OpenTxnRequest(const OpenTxnRequest& other508) { +- num_txns = other508.num_txns; +- user = other508.user; +- hostname = other508.hostname; +- agentInfo = other508.agentInfo; +- __isset = other508.__isset; ++OpenTxnRequest::OpenTxnRequest(const OpenTxnRequest& other510) { ++ num_txns = other510.num_txns; ++ user = other510.user; ++ hostname = other510.hostname; ++ agentInfo = other510.agentInfo; ++ __isset = other510.__isset; + } +-OpenTxnRequest& OpenTxnRequest::operator=(const OpenTxnRequest& other509) { +- num_txns = other509.num_txns; +- user = other509.user; +- hostname = other509.hostname; +- agentInfo = other509.agentInfo; +- __isset = other509.__isset; ++OpenTxnRequest& OpenTxnRequest::operator=(const OpenTxnRequest& other511) { ++ num_txns = other511.num_txns; ++ user = other511.user; ++ hostname = other511.hostname; ++ agentInfo = other511.agentInfo; ++ __isset = other511.__isset; + return *this; + } + void OpenTxnRequest::printTo(std::ostream& out) const { +@@ -11842,14 +11974,14 @@ uint32_t OpenTxnsResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->txn_ids.clear(); +- uint32_t _size510; +- ::apache::thrift::protocol::TType _etype513; +- xfer += iprot->readListBegin(_etype513, _size510); +- this->txn_ids.resize(_size510); +- uint32_t _i514; +- for (_i514 = 0; _i514 < _size510; ++_i514) ++ uint32_t _size512; ++ ::apache::thrift::protocol::TType _etype515; ++ xfer += iprot->readListBegin(_etype515, _size512); ++ this->txn_ids.resize(_size512); ++ uint32_t _i516; ++ for (_i516 = 0; _i516 < _size512; ++_i516) + { +- xfer += iprot->readI64(this->txn_ids[_i514]); ++ xfer += iprot->readI64(this->txn_ids[_i516]); + } + xfer += iprot->readListEnd(); + } +@@ -11880,10 +12012,10 @@ uint32_t OpenTxnsResponse::write(::apache::thrift::protocol::TProtocol* oprot) c + xfer += oprot->writeFieldBegin("txn_ids", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->txn_ids.size())); +- std::vector ::const_iterator _iter515; +- for (_iter515 = this->txn_ids.begin(); _iter515 != this->txn_ids.end(); ++_iter515) ++ std::vector ::const_iterator _iter517; ++ for (_iter517 = this->txn_ids.begin(); _iter517 != this->txn_ids.end(); ++_iter517) + { +- xfer += oprot->writeI64((*_iter515)); ++ xfer += oprot->writeI64((*_iter517)); + } + xfer += oprot->writeListEnd(); + } +@@ -11899,11 +12031,11 @@ void swap(OpenTxnsResponse &a, OpenTxnsResponse &b) { + swap(a.txn_ids, b.txn_ids); + } + +-OpenTxnsResponse::OpenTxnsResponse(const OpenTxnsResponse& other516) { +- txn_ids = other516.txn_ids; ++OpenTxnsResponse::OpenTxnsResponse(const OpenTxnsResponse& other518) { ++ txn_ids = other518.txn_ids; + } +-OpenTxnsResponse& OpenTxnsResponse::operator=(const OpenTxnsResponse& other517) { +- txn_ids = other517.txn_ids; ++OpenTxnsResponse& OpenTxnsResponse::operator=(const OpenTxnsResponse& other519) { ++ txn_ids = other519.txn_ids; + return *this; + } + void OpenTxnsResponse::printTo(std::ostream& out) const { +@@ -11985,11 +12117,11 @@ void swap(AbortTxnRequest &a, AbortTxnRequest &b) { + swap(a.txnid, b.txnid); + } + +-AbortTxnRequest::AbortTxnRequest(const AbortTxnRequest& other518) { +- txnid = other518.txnid; ++AbortTxnRequest::AbortTxnRequest(const AbortTxnRequest& other520) { ++ txnid = other520.txnid; + } +-AbortTxnRequest& AbortTxnRequest::operator=(const AbortTxnRequest& other519) { +- txnid = other519.txnid; ++AbortTxnRequest& AbortTxnRequest::operator=(const AbortTxnRequest& other521) { ++ txnid = other521.txnid; + return *this; + } + void AbortTxnRequest::printTo(std::ostream& out) const { +@@ -12071,11 +12203,11 @@ void swap(CommitTxnRequest &a, CommitTxnRequest &b) { + swap(a.txnid, b.txnid); + } + +-CommitTxnRequest::CommitTxnRequest(const CommitTxnRequest& other520) { +- txnid = other520.txnid; ++CommitTxnRequest::CommitTxnRequest(const CommitTxnRequest& other522) { ++ txnid = other522.txnid; + } +-CommitTxnRequest& CommitTxnRequest::operator=(const CommitTxnRequest& other521) { +- txnid = other521.txnid; ++CommitTxnRequest& CommitTxnRequest::operator=(const CommitTxnRequest& other523) { ++ txnid = other523.txnid; + return *this; + } + void CommitTxnRequest::printTo(std::ostream& out) const { +@@ -12138,9 +12270,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) { + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I32) { +- int32_t ecast522; +- xfer += iprot->readI32(ecast522); +- this->type = (LockType::type)ecast522; ++ int32_t ecast524; ++ xfer += iprot->readI32(ecast524); ++ this->type = (LockType::type)ecast524; + isset_type = true; + } else { + xfer += iprot->skip(ftype); +@@ -12148,9 +12280,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) { + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I32) { +- int32_t ecast523; +- xfer += iprot->readI32(ecast523); +- this->level = (LockLevel::type)ecast523; ++ int32_t ecast525; ++ xfer += iprot->readI32(ecast525); ++ this->level = (LockLevel::type)ecast525; + isset_level = true; + } else { + xfer += iprot->skip(ftype); +@@ -12240,21 +12372,21 @@ void swap(LockComponent &a, LockComponent &b) { + swap(a.__isset, b.__isset); + } + +-LockComponent::LockComponent(const LockComponent& other524) { +- type = other524.type; +- level = other524.level; +- dbname = other524.dbname; +- tablename = other524.tablename; +- partitionname = other524.partitionname; +- __isset = other524.__isset; +-} +-LockComponent& LockComponent::operator=(const LockComponent& other525) { +- type = other525.type; +- level = other525.level; +- dbname = other525.dbname; +- tablename = other525.tablename; +- partitionname = other525.partitionname; +- __isset = other525.__isset; ++LockComponent::LockComponent(const LockComponent& other526) { ++ type = other526.type; ++ level = other526.level; ++ dbname = other526.dbname; ++ tablename = other526.tablename; ++ partitionname = other526.partitionname; ++ __isset = other526.__isset; ++} ++LockComponent& LockComponent::operator=(const LockComponent& other527) { ++ type = other527.type; ++ level = other527.level; ++ dbname = other527.dbname; ++ tablename = other527.tablename; ++ partitionname = other527.partitionname; ++ __isset = other527.__isset; + return *this; + } + void LockComponent::printTo(std::ostream& out) const { +@@ -12323,14 +12455,14 @@ uint32_t LockRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->component.clear(); +- uint32_t _size526; +- ::apache::thrift::protocol::TType _etype529; +- xfer += iprot->readListBegin(_etype529, _size526); +- this->component.resize(_size526); +- uint32_t _i530; +- for (_i530 = 0; _i530 < _size526; ++_i530) ++ uint32_t _size528; ++ ::apache::thrift::protocol::TType _etype531; ++ xfer += iprot->readListBegin(_etype531, _size528); ++ this->component.resize(_size528); ++ uint32_t _i532; ++ for (_i532 = 0; _i532 < _size528; ++_i532) + { +- xfer += this->component[_i530].read(iprot); ++ xfer += this->component[_i532].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -12397,10 +12529,10 @@ uint32_t LockRequest::write(::apache::thrift::protocol::TProtocol* oprot) const + xfer += oprot->writeFieldBegin("component", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->component.size())); +- std::vector ::const_iterator _iter531; +- for (_iter531 = this->component.begin(); _iter531 != this->component.end(); ++_iter531) ++ std::vector ::const_iterator _iter533; ++ for (_iter533 = this->component.begin(); _iter533 != this->component.end(); ++_iter533) + { +- xfer += (*_iter531).write(oprot); ++ xfer += (*_iter533).write(oprot); + } + xfer += oprot->writeListEnd(); + } +@@ -12439,21 +12571,21 @@ void swap(LockRequest &a, LockRequest &b) { + swap(a.__isset, b.__isset); + } + +-LockRequest::LockRequest(const LockRequest& other532) { +- component = other532.component; +- txnid = other532.txnid; +- user = other532.user; +- hostname = other532.hostname; +- agentInfo = other532.agentInfo; +- __isset = other532.__isset; +-} +-LockRequest& LockRequest::operator=(const LockRequest& other533) { +- component = other533.component; +- txnid = other533.txnid; +- user = other533.user; +- hostname = other533.hostname; +- agentInfo = other533.agentInfo; +- __isset = other533.__isset; ++LockRequest::LockRequest(const LockRequest& other534) { ++ component = other534.component; ++ txnid = other534.txnid; ++ user = other534.user; ++ hostname = other534.hostname; ++ agentInfo = other534.agentInfo; ++ __isset = other534.__isset; ++} ++LockRequest& LockRequest::operator=(const LockRequest& other535) { ++ component = other535.component; ++ txnid = other535.txnid; ++ user = other535.user; ++ hostname = other535.hostname; ++ agentInfo = other535.agentInfo; ++ __isset = other535.__isset; + return *this; + } + void LockRequest::printTo(std::ostream& out) const { +@@ -12513,9 +12645,9 @@ uint32_t LockResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I32) { +- int32_t ecast534; +- xfer += iprot->readI32(ecast534); +- this->state = (LockState::type)ecast534; ++ int32_t ecast536; ++ xfer += iprot->readI32(ecast536); ++ this->state = (LockState::type)ecast536; + isset_state = true; + } else { + xfer += iprot->skip(ftype); +@@ -12561,13 +12693,13 @@ void swap(LockResponse &a, LockResponse &b) { + swap(a.state, b.state); + } + +-LockResponse::LockResponse(const LockResponse& other535) { +- lockid = other535.lockid; +- state = other535.state; ++LockResponse::LockResponse(const LockResponse& other537) { ++ lockid = other537.lockid; ++ state = other537.state; + } +-LockResponse& LockResponse::operator=(const LockResponse& other536) { +- lockid = other536.lockid; +- state = other536.state; ++LockResponse& LockResponse::operator=(const LockResponse& other538) { ++ lockid = other538.lockid; ++ state = other538.state; + return *this; + } + void LockResponse::printTo(std::ostream& out) const { +@@ -12689,17 +12821,17 @@ void swap(CheckLockRequest &a, CheckLockRequest &b) { + swap(a.__isset, b.__isset); + } + +-CheckLockRequest::CheckLockRequest(const CheckLockRequest& other537) { +- lockid = other537.lockid; +- txnid = other537.txnid; +- elapsed_ms = other537.elapsed_ms; +- __isset = other537.__isset; ++CheckLockRequest::CheckLockRequest(const CheckLockRequest& other539) { ++ lockid = other539.lockid; ++ txnid = other539.txnid; ++ elapsed_ms = other539.elapsed_ms; ++ __isset = other539.__isset; + } +-CheckLockRequest& CheckLockRequest::operator=(const CheckLockRequest& other538) { +- lockid = other538.lockid; +- txnid = other538.txnid; +- elapsed_ms = other538.elapsed_ms; +- __isset = other538.__isset; ++CheckLockRequest& CheckLockRequest::operator=(const CheckLockRequest& other540) { ++ lockid = other540.lockid; ++ txnid = other540.txnid; ++ elapsed_ms = other540.elapsed_ms; ++ __isset = other540.__isset; + return *this; + } + void CheckLockRequest::printTo(std::ostream& out) const { +@@ -12783,11 +12915,11 @@ void swap(UnlockRequest &a, UnlockRequest &b) { + swap(a.lockid, b.lockid); + } + +-UnlockRequest::UnlockRequest(const UnlockRequest& other539) { +- lockid = other539.lockid; ++UnlockRequest::UnlockRequest(const UnlockRequest& other541) { ++ lockid = other541.lockid; + } +-UnlockRequest& UnlockRequest::operator=(const UnlockRequest& other540) { +- lockid = other540.lockid; ++UnlockRequest& UnlockRequest::operator=(const UnlockRequest& other542) { ++ lockid = other542.lockid; + return *this; + } + void UnlockRequest::printTo(std::ostream& out) const { +@@ -12926,19 +13058,19 @@ void swap(ShowLocksRequest &a, ShowLocksRequest &b) { + swap(a.__isset, b.__isset); + } + +-ShowLocksRequest::ShowLocksRequest(const ShowLocksRequest& other541) { +- dbname = other541.dbname; +- tablename = other541.tablename; +- partname = other541.partname; +- isExtended = other541.isExtended; +- __isset = other541.__isset; ++ShowLocksRequest::ShowLocksRequest(const ShowLocksRequest& other543) { ++ dbname = other543.dbname; ++ tablename = other543.tablename; ++ partname = other543.partname; ++ isExtended = other543.isExtended; ++ __isset = other543.__isset; + } +-ShowLocksRequest& ShowLocksRequest::operator=(const ShowLocksRequest& other542) { +- dbname = other542.dbname; +- tablename = other542.tablename; +- partname = other542.partname; +- isExtended = other542.isExtended; +- __isset = other542.__isset; ++ShowLocksRequest& ShowLocksRequest::operator=(const ShowLocksRequest& other544) { ++ dbname = other544.dbname; ++ tablename = other544.tablename; ++ partname = other544.partname; ++ isExtended = other544.isExtended; ++ __isset = other544.__isset; + return *this; + } + void ShowLocksRequest::printTo(std::ostream& out) const { +@@ -13091,9 +13223,9 @@ uint32_t ShowLocksResponseElement::read(::apache::thrift::protocol::TProtocol* i + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_I32) { +- int32_t ecast543; +- xfer += iprot->readI32(ecast543); +- this->state = (LockState::type)ecast543; ++ int32_t ecast545; ++ xfer += iprot->readI32(ecast545); ++ this->state = (LockState::type)ecast545; + isset_state = true; + } else { + xfer += iprot->skip(ftype); +@@ -13101,9 +13233,9 @@ uint32_t ShowLocksResponseElement::read(::apache::thrift::protocol::TProtocol* i + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_I32) { +- int32_t ecast544; +- xfer += iprot->readI32(ecast544); +- this->type = (LockType::type)ecast544; ++ int32_t ecast546; ++ xfer += iprot->readI32(ecast546); ++ this->type = (LockType::type)ecast546; + isset_type = true; + } else { + xfer += iprot->skip(ftype); +@@ -13319,43 +13451,43 @@ void swap(ShowLocksResponseElement &a, ShowLocksResponseElement &b) { + swap(a.__isset, b.__isset); + } + +-ShowLocksResponseElement::ShowLocksResponseElement(const ShowLocksResponseElement& other545) { +- lockid = other545.lockid; +- dbname = other545.dbname; +- tablename = other545.tablename; +- partname = other545.partname; +- state = other545.state; +- type = other545.type; +- txnid = other545.txnid; +- lastheartbeat = other545.lastheartbeat; +- acquiredat = other545.acquiredat; +- user = other545.user; +- hostname = other545.hostname; +- heartbeatCount = other545.heartbeatCount; +- agentInfo = other545.agentInfo; +- blockedByExtId = other545.blockedByExtId; +- blockedByIntId = other545.blockedByIntId; +- lockIdInternal = other545.lockIdInternal; +- __isset = other545.__isset; +-} +-ShowLocksResponseElement& ShowLocksResponseElement::operator=(const ShowLocksResponseElement& other546) { +- lockid = other546.lockid; +- dbname = other546.dbname; +- tablename = other546.tablename; +- partname = other546.partname; +- state = other546.state; +- type = other546.type; +- txnid = other546.txnid; +- lastheartbeat = other546.lastheartbeat; +- acquiredat = other546.acquiredat; +- user = other546.user; +- hostname = other546.hostname; +- heartbeatCount = other546.heartbeatCount; +- agentInfo = other546.agentInfo; +- blockedByExtId = other546.blockedByExtId; +- blockedByIntId = other546.blockedByIntId; +- lockIdInternal = other546.lockIdInternal; +- __isset = other546.__isset; ++ShowLocksResponseElement::ShowLocksResponseElement(const ShowLocksResponseElement& other547) { ++ lockid = other547.lockid; ++ dbname = other547.dbname; ++ tablename = other547.tablename; ++ partname = other547.partname; ++ state = other547.state; ++ type = other547.type; ++ txnid = other547.txnid; ++ lastheartbeat = other547.lastheartbeat; ++ acquiredat = other547.acquiredat; ++ user = other547.user; ++ hostname = other547.hostname; ++ heartbeatCount = other547.heartbeatCount; ++ agentInfo = other547.agentInfo; ++ blockedByExtId = other547.blockedByExtId; ++ blockedByIntId = other547.blockedByIntId; ++ lockIdInternal = other547.lockIdInternal; ++ __isset = other547.__isset; ++} ++ShowLocksResponseElement& ShowLocksResponseElement::operator=(const ShowLocksResponseElement& other548) { ++ lockid = other548.lockid; ++ dbname = other548.dbname; ++ tablename = other548.tablename; ++ partname = other548.partname; ++ state = other548.state; ++ type = other548.type; ++ txnid = other548.txnid; ++ lastheartbeat = other548.lastheartbeat; ++ acquiredat = other548.acquiredat; ++ user = other548.user; ++ hostname = other548.hostname; ++ heartbeatCount = other548.heartbeatCount; ++ agentInfo = other548.agentInfo; ++ blockedByExtId = other548.blockedByExtId; ++ blockedByIntId = other548.blockedByIntId; ++ lockIdInternal = other548.lockIdInternal; ++ __isset = other548.__isset; + return *this; + } + void ShowLocksResponseElement::printTo(std::ostream& out) const { +@@ -13414,14 +13546,14 @@ uint32_t ShowLocksResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->locks.clear(); +- uint32_t _size547; +- ::apache::thrift::protocol::TType _etype550; +- xfer += iprot->readListBegin(_etype550, _size547); +- this->locks.resize(_size547); +- uint32_t _i551; +- for (_i551 = 0; _i551 < _size547; ++_i551) ++ uint32_t _size549; ++ ::apache::thrift::protocol::TType _etype552; ++ xfer += iprot->readListBegin(_etype552, _size549); ++ this->locks.resize(_size549); ++ uint32_t _i553; ++ for (_i553 = 0; _i553 < _size549; ++_i553) + { +- xfer += this->locks[_i551].read(iprot); ++ xfer += this->locks[_i553].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -13450,10 +13582,10 @@ uint32_t ShowLocksResponse::write(::apache::thrift::protocol::TProtocol* oprot) + xfer += oprot->writeFieldBegin("locks", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->locks.size())); +- std::vector ::const_iterator _iter552; +- for (_iter552 = this->locks.begin(); _iter552 != this->locks.end(); ++_iter552) ++ std::vector ::const_iterator _iter554; ++ for (_iter554 = this->locks.begin(); _iter554 != this->locks.end(); ++_iter554) + { +- xfer += (*_iter552).write(oprot); ++ xfer += (*_iter554).write(oprot); + } + xfer += oprot->writeListEnd(); + } +@@ -13470,13 +13602,13 @@ void swap(ShowLocksResponse &a, ShowLocksResponse &b) { + swap(a.__isset, b.__isset); + } + +-ShowLocksResponse::ShowLocksResponse(const ShowLocksResponse& other553) { +- locks = other553.locks; +- __isset = other553.__isset; ++ShowLocksResponse::ShowLocksResponse(const ShowLocksResponse& other555) { ++ locks = other555.locks; ++ __isset = other555.__isset; + } +-ShowLocksResponse& ShowLocksResponse::operator=(const ShowLocksResponse& other554) { +- locks = other554.locks; +- __isset = other554.__isset; ++ShowLocksResponse& ShowLocksResponse::operator=(const ShowLocksResponse& other556) { ++ locks = other556.locks; ++ __isset = other556.__isset; + return *this; + } + void ShowLocksResponse::printTo(std::ostream& out) const { +@@ -13577,15 +13709,15 @@ void swap(HeartbeatRequest &a, HeartbeatRequest &b) { + swap(a.__isset, b.__isset); + } + +-HeartbeatRequest::HeartbeatRequest(const HeartbeatRequest& other555) { +- lockid = other555.lockid; +- txnid = other555.txnid; +- __isset = other555.__isset; ++HeartbeatRequest::HeartbeatRequest(const HeartbeatRequest& other557) { ++ lockid = other557.lockid; ++ txnid = other557.txnid; ++ __isset = other557.__isset; + } +-HeartbeatRequest& HeartbeatRequest::operator=(const HeartbeatRequest& other556) { +- lockid = other556.lockid; +- txnid = other556.txnid; +- __isset = other556.__isset; ++HeartbeatRequest& HeartbeatRequest::operator=(const HeartbeatRequest& other558) { ++ lockid = other558.lockid; ++ txnid = other558.txnid; ++ __isset = other558.__isset; + return *this; + } + void HeartbeatRequest::printTo(std::ostream& out) const { +@@ -13688,13 +13820,13 @@ void swap(HeartbeatTxnRangeRequest &a, HeartbeatTxnRangeRequest &b) { + swap(a.max, b.max); + } + +-HeartbeatTxnRangeRequest::HeartbeatTxnRangeRequest(const HeartbeatTxnRangeRequest& other557) { +- min = other557.min; +- max = other557.max; ++HeartbeatTxnRangeRequest::HeartbeatTxnRangeRequest(const HeartbeatTxnRangeRequest& other559) { ++ min = other559.min; ++ max = other559.max; + } +-HeartbeatTxnRangeRequest& HeartbeatTxnRangeRequest::operator=(const HeartbeatTxnRangeRequest& other558) { +- min = other558.min; +- max = other558.max; ++HeartbeatTxnRangeRequest& HeartbeatTxnRangeRequest::operator=(const HeartbeatTxnRangeRequest& other560) { ++ min = other560.min; ++ max = other560.max; + return *this; + } + void HeartbeatTxnRangeRequest::printTo(std::ostream& out) const { +@@ -13745,15 +13877,15 @@ uint32_t HeartbeatTxnRangeResponse::read(::apache::thrift::protocol::TProtocol* + if (ftype == ::apache::thrift::protocol::T_SET) { + { + this->aborted.clear(); +- uint32_t _size559; +- ::apache::thrift::protocol::TType _etype562; +- xfer += iprot->readSetBegin(_etype562, _size559); +- uint32_t _i563; +- for (_i563 = 0; _i563 < _size559; ++_i563) ++ uint32_t _size561; ++ ::apache::thrift::protocol::TType _etype564; ++ xfer += iprot->readSetBegin(_etype564, _size561); ++ uint32_t _i565; ++ for (_i565 = 0; _i565 < _size561; ++_i565) + { +- int64_t _elem564; +- xfer += iprot->readI64(_elem564); +- this->aborted.insert(_elem564); ++ int64_t _elem566; ++ xfer += iprot->readI64(_elem566); ++ this->aborted.insert(_elem566); + } + xfer += iprot->readSetEnd(); + } +@@ -13766,15 +13898,15 @@ uint32_t HeartbeatTxnRangeResponse::read(::apache::thrift::protocol::TProtocol* + if (ftype == ::apache::thrift::protocol::T_SET) { + { + this->nosuch.clear(); +- uint32_t _size565; +- ::apache::thrift::protocol::TType _etype568; +- xfer += iprot->readSetBegin(_etype568, _size565); +- uint32_t _i569; +- for (_i569 = 0; _i569 < _size565; ++_i569) ++ uint32_t _size567; ++ ::apache::thrift::protocol::TType _etype570; ++ xfer += iprot->readSetBegin(_etype570, _size567); ++ uint32_t _i571; ++ for (_i571 = 0; _i571 < _size567; ++_i571) + { +- int64_t _elem570; +- xfer += iprot->readI64(_elem570); +- this->nosuch.insert(_elem570); ++ int64_t _elem572; ++ xfer += iprot->readI64(_elem572); ++ this->nosuch.insert(_elem572); + } + xfer += iprot->readSetEnd(); + } +@@ -13807,10 +13939,10 @@ uint32_t HeartbeatTxnRangeResponse::write(::apache::thrift::protocol::TProtocol* + xfer += oprot->writeFieldBegin("aborted", ::apache::thrift::protocol::T_SET, 1); + { + xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_I64, static_cast(this->aborted.size())); +- std::set ::const_iterator _iter571; +- for (_iter571 = this->aborted.begin(); _iter571 != this->aborted.end(); ++_iter571) ++ std::set ::const_iterator _iter573; ++ for (_iter573 = this->aborted.begin(); _iter573 != this->aborted.end(); ++_iter573) + { +- xfer += oprot->writeI64((*_iter571)); ++ xfer += oprot->writeI64((*_iter573)); + } + xfer += oprot->writeSetEnd(); + } +@@ -13819,10 +13951,10 @@ uint32_t HeartbeatTxnRangeResponse::write(::apache::thrift::protocol::TProtocol* + xfer += oprot->writeFieldBegin("nosuch", ::apache::thrift::protocol::T_SET, 2); + { + xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_I64, static_cast(this->nosuch.size())); +- std::set ::const_iterator _iter572; +- for (_iter572 = this->nosuch.begin(); _iter572 != this->nosuch.end(); ++_iter572) ++ std::set ::const_iterator _iter574; ++ for (_iter574 = this->nosuch.begin(); _iter574 != this->nosuch.end(); ++_iter574) + { +- xfer += oprot->writeI64((*_iter572)); ++ xfer += oprot->writeI64((*_iter574)); + } + xfer += oprot->writeSetEnd(); + } +@@ -13839,13 +13971,13 @@ void swap(HeartbeatTxnRangeResponse &a, HeartbeatTxnRangeResponse &b) { + swap(a.nosuch, b.nosuch); + } + +-HeartbeatTxnRangeResponse::HeartbeatTxnRangeResponse(const HeartbeatTxnRangeResponse& other573) { +- aborted = other573.aborted; +- nosuch = other573.nosuch; ++HeartbeatTxnRangeResponse::HeartbeatTxnRangeResponse(const HeartbeatTxnRangeResponse& other575) { ++ aborted = other575.aborted; ++ nosuch = other575.nosuch; + } +-HeartbeatTxnRangeResponse& HeartbeatTxnRangeResponse::operator=(const HeartbeatTxnRangeResponse& other574) { +- aborted = other574.aborted; +- nosuch = other574.nosuch; ++HeartbeatTxnRangeResponse& HeartbeatTxnRangeResponse::operator=(const HeartbeatTxnRangeResponse& other576) { ++ aborted = other576.aborted; ++ nosuch = other576.nosuch; + return *this; + } + void HeartbeatTxnRangeResponse::printTo(std::ostream& out) const { +@@ -13933,9 +14065,9 @@ uint32_t CompactionRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I32) { +- int32_t ecast575; +- xfer += iprot->readI32(ecast575); +- this->type = (CompactionType::type)ecast575; ++ int32_t ecast577; ++ xfer += iprot->readI32(ecast577); ++ this->type = (CompactionType::type)ecast577; + isset_type = true; + } else { + xfer += iprot->skip(ftype); +@@ -14009,21 +14141,21 @@ void swap(CompactionRequest &a, CompactionRequest &b) { + swap(a.__isset, b.__isset); + } + +-CompactionRequest::CompactionRequest(const CompactionRequest& other576) { +- dbname = other576.dbname; +- tablename = other576.tablename; +- partitionname = other576.partitionname; +- type = other576.type; +- runas = other576.runas; +- __isset = other576.__isset; +-} +-CompactionRequest& CompactionRequest::operator=(const CompactionRequest& other577) { +- dbname = other577.dbname; +- tablename = other577.tablename; +- partitionname = other577.partitionname; +- type = other577.type; +- runas = other577.runas; +- __isset = other577.__isset; ++CompactionRequest::CompactionRequest(const CompactionRequest& other578) { ++ dbname = other578.dbname; ++ tablename = other578.tablename; ++ partitionname = other578.partitionname; ++ type = other578.type; ++ runas = other578.runas; ++ __isset = other578.__isset; ++} ++CompactionRequest& CompactionRequest::operator=(const CompactionRequest& other579) { ++ dbname = other579.dbname; ++ tablename = other579.tablename; ++ partitionname = other579.partitionname; ++ type = other579.type; ++ runas = other579.runas; ++ __isset = other579.__isset; + return *this; + } + void CompactionRequest::printTo(std::ostream& out) const { +@@ -14086,11 +14218,11 @@ void swap(ShowCompactRequest &a, ShowCompactRequest &b) { + (void) b; + } + +-ShowCompactRequest::ShowCompactRequest(const ShowCompactRequest& other578) { +- (void) other578; ++ShowCompactRequest::ShowCompactRequest(const ShowCompactRequest& other580) { ++ (void) other580; + } +-ShowCompactRequest& ShowCompactRequest::operator=(const ShowCompactRequest& other579) { +- (void) other579; ++ShowCompactRequest& ShowCompactRequest::operator=(const ShowCompactRequest& other581) { ++ (void) other581; + return *this; + } + void ShowCompactRequest::printTo(std::ostream& out) const { +@@ -14211,9 +14343,9 @@ uint32_t ShowCompactResponseElement::read(::apache::thrift::protocol::TProtocol* + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I32) { +- int32_t ecast580; +- xfer += iprot->readI32(ecast580); +- this->type = (CompactionType::type)ecast580; ++ int32_t ecast582; ++ xfer += iprot->readI32(ecast582); ++ this->type = (CompactionType::type)ecast582; + isset_type = true; + } else { + xfer += iprot->skip(ftype); +@@ -14386,35 +14518,35 @@ void swap(ShowCompactResponseElement &a, ShowCompactResponseElement &b) { + swap(a.__isset, b.__isset); + } + +-ShowCompactResponseElement::ShowCompactResponseElement(const ShowCompactResponseElement& other581) { +- dbname = other581.dbname; +- tablename = other581.tablename; +- partitionname = other581.partitionname; +- type = other581.type; +- state = other581.state; +- workerid = other581.workerid; +- start = other581.start; +- runAs = other581.runAs; +- hightestTxnId = other581.hightestTxnId; +- metaInfo = other581.metaInfo; +- endTime = other581.endTime; +- hadoopJobId = other581.hadoopJobId; +- __isset = other581.__isset; +-} +-ShowCompactResponseElement& ShowCompactResponseElement::operator=(const ShowCompactResponseElement& other582) { +- dbname = other582.dbname; +- tablename = other582.tablename; +- partitionname = other582.partitionname; +- type = other582.type; +- state = other582.state; +- workerid = other582.workerid; +- start = other582.start; +- runAs = other582.runAs; +- hightestTxnId = other582.hightestTxnId; +- metaInfo = other582.metaInfo; +- endTime = other582.endTime; +- hadoopJobId = other582.hadoopJobId; +- __isset = other582.__isset; ++ShowCompactResponseElement::ShowCompactResponseElement(const ShowCompactResponseElement& other583) { ++ dbname = other583.dbname; ++ tablename = other583.tablename; ++ partitionname = other583.partitionname; ++ type = other583.type; ++ state = other583.state; ++ workerid = other583.workerid; ++ start = other583.start; ++ runAs = other583.runAs; ++ hightestTxnId = other583.hightestTxnId; ++ metaInfo = other583.metaInfo; ++ endTime = other583.endTime; ++ hadoopJobId = other583.hadoopJobId; ++ __isset = other583.__isset; ++} ++ShowCompactResponseElement& ShowCompactResponseElement::operator=(const ShowCompactResponseElement& other584) { ++ dbname = other584.dbname; ++ tablename = other584.tablename; ++ partitionname = other584.partitionname; ++ type = other584.type; ++ state = other584.state; ++ workerid = other584.workerid; ++ start = other584.start; ++ runAs = other584.runAs; ++ hightestTxnId = other584.hightestTxnId; ++ metaInfo = other584.metaInfo; ++ endTime = other584.endTime; ++ hadoopJobId = other584.hadoopJobId; ++ __isset = other584.__isset; + return *this; + } + void ShowCompactResponseElement::printTo(std::ostream& out) const { +@@ -14470,14 +14602,14 @@ uint32_t ShowCompactResponse::read(::apache::thrift::protocol::TProtocol* iprot) + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->compacts.clear(); +- uint32_t _size583; +- ::apache::thrift::protocol::TType _etype586; +- xfer += iprot->readListBegin(_etype586, _size583); +- this->compacts.resize(_size583); +- uint32_t _i587; +- for (_i587 = 0; _i587 < _size583; ++_i587) ++ uint32_t _size585; ++ ::apache::thrift::protocol::TType _etype588; ++ xfer += iprot->readListBegin(_etype588, _size585); ++ this->compacts.resize(_size585); ++ uint32_t _i589; ++ for (_i589 = 0; _i589 < _size585; ++_i589) + { +- xfer += this->compacts[_i587].read(iprot); ++ xfer += this->compacts[_i589].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -14508,10 +14640,10 @@ uint32_t ShowCompactResponse::write(::apache::thrift::protocol::TProtocol* oprot + xfer += oprot->writeFieldBegin("compacts", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->compacts.size())); +- std::vector ::const_iterator _iter588; +- for (_iter588 = this->compacts.begin(); _iter588 != this->compacts.end(); ++_iter588) ++ std::vector ::const_iterator _iter590; ++ for (_iter590 = this->compacts.begin(); _iter590 != this->compacts.end(); ++_iter590) + { +- xfer += (*_iter588).write(oprot); ++ xfer += (*_iter590).write(oprot); + } + xfer += oprot->writeListEnd(); + } +@@ -14527,11 +14659,11 @@ void swap(ShowCompactResponse &a, ShowCompactResponse &b) { + swap(a.compacts, b.compacts); + } + +-ShowCompactResponse::ShowCompactResponse(const ShowCompactResponse& other589) { +- compacts = other589.compacts; ++ShowCompactResponse::ShowCompactResponse(const ShowCompactResponse& other591) { ++ compacts = other591.compacts; + } +-ShowCompactResponse& ShowCompactResponse::operator=(const ShowCompactResponse& other590) { +- compacts = other590.compacts; ++ShowCompactResponse& ShowCompactResponse::operator=(const ShowCompactResponse& other592) { ++ compacts = other592.compacts; + return *this; + } + void ShowCompactResponse::printTo(std::ostream& out) const { +@@ -14615,14 +14747,14 @@ uint32_t AddDynamicPartitions::read(::apache::thrift::protocol::TProtocol* iprot + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partitionnames.clear(); +- uint32_t _size591; +- ::apache::thrift::protocol::TType _etype594; +- xfer += iprot->readListBegin(_etype594, _size591); +- this->partitionnames.resize(_size591); +- uint32_t _i595; +- for (_i595 = 0; _i595 < _size591; ++_i595) ++ uint32_t _size593; ++ ::apache::thrift::protocol::TType _etype596; ++ xfer += iprot->readListBegin(_etype596, _size593); ++ this->partitionnames.resize(_size593); ++ uint32_t _i597; ++ for (_i597 = 0; _i597 < _size593; ++_i597) + { +- xfer += iprot->readString(this->partitionnames[_i595]); ++ xfer += iprot->readString(this->partitionnames[_i597]); + } + xfer += iprot->readListEnd(); + } +@@ -14671,10 +14803,10 @@ uint32_t AddDynamicPartitions::write(::apache::thrift::protocol::TProtocol* opro + xfer += oprot->writeFieldBegin("partitionnames", ::apache::thrift::protocol::T_LIST, 4); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partitionnames.size())); +- std::vector ::const_iterator _iter596; +- for (_iter596 = this->partitionnames.begin(); _iter596 != this->partitionnames.end(); ++_iter596) ++ std::vector ::const_iterator _iter598; ++ for (_iter598 = this->partitionnames.begin(); _iter598 != this->partitionnames.end(); ++_iter598) + { +- xfer += oprot->writeString((*_iter596)); ++ xfer += oprot->writeString((*_iter598)); + } + xfer += oprot->writeListEnd(); + } +@@ -14693,17 +14825,17 @@ void swap(AddDynamicPartitions &a, AddDynamicPartitions &b) { + swap(a.partitionnames, b.partitionnames); + } + +-AddDynamicPartitions::AddDynamicPartitions(const AddDynamicPartitions& other597) { +- txnid = other597.txnid; +- dbname = other597.dbname; +- tablename = other597.tablename; +- partitionnames = other597.partitionnames; ++AddDynamicPartitions::AddDynamicPartitions(const AddDynamicPartitions& other599) { ++ txnid = other599.txnid; ++ dbname = other599.dbname; ++ tablename = other599.tablename; ++ partitionnames = other599.partitionnames; + } +-AddDynamicPartitions& AddDynamicPartitions::operator=(const AddDynamicPartitions& other598) { +- txnid = other598.txnid; +- dbname = other598.dbname; +- tablename = other598.tablename; +- partitionnames = other598.partitionnames; ++AddDynamicPartitions& AddDynamicPartitions::operator=(const AddDynamicPartitions& other600) { ++ txnid = other600.txnid; ++ dbname = other600.dbname; ++ tablename = other600.tablename; ++ partitionnames = other600.partitionnames; + return *this; + } + void AddDynamicPartitions::printTo(std::ostream& out) const { +@@ -14808,15 +14940,15 @@ void swap(NotificationEventRequest &a, NotificationEventRequest &b) { + swap(a.__isset, b.__isset); + } + +-NotificationEventRequest::NotificationEventRequest(const NotificationEventRequest& other599) { +- lastEvent = other599.lastEvent; +- maxEvents = other599.maxEvents; +- __isset = other599.__isset; ++NotificationEventRequest::NotificationEventRequest(const NotificationEventRequest& other601) { ++ lastEvent = other601.lastEvent; ++ maxEvents = other601.maxEvents; ++ __isset = other601.__isset; + } +-NotificationEventRequest& NotificationEventRequest::operator=(const NotificationEventRequest& other600) { +- lastEvent = other600.lastEvent; +- maxEvents = other600.maxEvents; +- __isset = other600.__isset; ++NotificationEventRequest& NotificationEventRequest::operator=(const NotificationEventRequest& other602) { ++ lastEvent = other602.lastEvent; ++ maxEvents = other602.maxEvents; ++ __isset = other602.__isset; + return *this; + } + void NotificationEventRequest::printTo(std::ostream& out) const { +@@ -14998,23 +15130,23 @@ void swap(NotificationEvent &a, NotificationEvent &b) { + swap(a.__isset, b.__isset); + } + +-NotificationEvent::NotificationEvent(const NotificationEvent& other601) { +- eventId = other601.eventId; +- eventTime = other601.eventTime; +- eventType = other601.eventType; +- dbName = other601.dbName; +- tableName = other601.tableName; +- message = other601.message; +- __isset = other601.__isset; +-} +-NotificationEvent& NotificationEvent::operator=(const NotificationEvent& other602) { +- eventId = other602.eventId; +- eventTime = other602.eventTime; +- eventType = other602.eventType; +- dbName = other602.dbName; +- tableName = other602.tableName; +- message = other602.message; +- __isset = other602.__isset; ++NotificationEvent::NotificationEvent(const NotificationEvent& other603) { ++ eventId = other603.eventId; ++ eventTime = other603.eventTime; ++ eventType = other603.eventType; ++ dbName = other603.dbName; ++ tableName = other603.tableName; ++ message = other603.message; ++ __isset = other603.__isset; ++} ++NotificationEvent& NotificationEvent::operator=(const NotificationEvent& other604) { ++ eventId = other604.eventId; ++ eventTime = other604.eventTime; ++ eventType = other604.eventType; ++ dbName = other604.dbName; ++ tableName = other604.tableName; ++ message = other604.message; ++ __isset = other604.__isset; + return *this; + } + void NotificationEvent::printTo(std::ostream& out) const { +@@ -15064,14 +15196,14 @@ uint32_t NotificationEventResponse::read(::apache::thrift::protocol::TProtocol* + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->events.clear(); +- uint32_t _size603; +- ::apache::thrift::protocol::TType _etype606; +- xfer += iprot->readListBegin(_etype606, _size603); +- this->events.resize(_size603); +- uint32_t _i607; +- for (_i607 = 0; _i607 < _size603; ++_i607) ++ uint32_t _size605; ++ ::apache::thrift::protocol::TType _etype608; ++ xfer += iprot->readListBegin(_etype608, _size605); ++ this->events.resize(_size605); ++ uint32_t _i609; ++ for (_i609 = 0; _i609 < _size605; ++_i609) + { +- xfer += this->events[_i607].read(iprot); ++ xfer += this->events[_i609].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -15102,10 +15234,10 @@ uint32_t NotificationEventResponse::write(::apache::thrift::protocol::TProtocol* + xfer += oprot->writeFieldBegin("events", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->events.size())); +- std::vector ::const_iterator _iter608; +- for (_iter608 = this->events.begin(); _iter608 != this->events.end(); ++_iter608) ++ std::vector ::const_iterator _iter610; ++ for (_iter610 = this->events.begin(); _iter610 != this->events.end(); ++_iter610) + { +- xfer += (*_iter608).write(oprot); ++ xfer += (*_iter610).write(oprot); + } + xfer += oprot->writeListEnd(); + } +@@ -15121,11 +15253,11 @@ void swap(NotificationEventResponse &a, NotificationEventResponse &b) { + swap(a.events, b.events); + } + +-NotificationEventResponse::NotificationEventResponse(const NotificationEventResponse& other609) { +- events = other609.events; ++NotificationEventResponse::NotificationEventResponse(const NotificationEventResponse& other611) { ++ events = other611.events; + } +-NotificationEventResponse& NotificationEventResponse::operator=(const NotificationEventResponse& other610) { +- events = other610.events; ++NotificationEventResponse& NotificationEventResponse::operator=(const NotificationEventResponse& other612) { ++ events = other612.events; + return *this; + } + void NotificationEventResponse::printTo(std::ostream& out) const { +@@ -15207,11 +15339,11 @@ void swap(CurrentNotificationEventId &a, CurrentNotificationEventId &b) { + swap(a.eventId, b.eventId); + } + +-CurrentNotificationEventId::CurrentNotificationEventId(const CurrentNotificationEventId& other611) { +- eventId = other611.eventId; ++CurrentNotificationEventId::CurrentNotificationEventId(const CurrentNotificationEventId& other613) { ++ eventId = other613.eventId; + } +-CurrentNotificationEventId& CurrentNotificationEventId::operator=(const CurrentNotificationEventId& other612) { +- eventId = other612.eventId; ++CurrentNotificationEventId& CurrentNotificationEventId::operator=(const CurrentNotificationEventId& other614) { ++ eventId = other614.eventId; + return *this; + } + void CurrentNotificationEventId::printTo(std::ostream& out) const { +@@ -15256,14 +15388,14 @@ uint32_t InsertEventRequestData::read(::apache::thrift::protocol::TProtocol* ipr + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->filesAdded.clear(); +- uint32_t _size613; +- ::apache::thrift::protocol::TType _etype616; +- xfer += iprot->readListBegin(_etype616, _size613); +- this->filesAdded.resize(_size613); +- uint32_t _i617; +- for (_i617 = 0; _i617 < _size613; ++_i617) ++ uint32_t _size615; ++ ::apache::thrift::protocol::TType _etype618; ++ xfer += iprot->readListBegin(_etype618, _size615); ++ this->filesAdded.resize(_size615); ++ uint32_t _i619; ++ for (_i619 = 0; _i619 < _size615; ++_i619) + { +- xfer += iprot->readString(this->filesAdded[_i617]); ++ xfer += iprot->readString(this->filesAdded[_i619]); + } + xfer += iprot->readListEnd(); + } +@@ -15294,10 +15426,10 @@ uint32_t InsertEventRequestData::write(::apache::thrift::protocol::TProtocol* op + xfer += oprot->writeFieldBegin("filesAdded", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->filesAdded.size())); +- std::vector ::const_iterator _iter618; +- for (_iter618 = this->filesAdded.begin(); _iter618 != this->filesAdded.end(); ++_iter618) ++ std::vector ::const_iterator _iter620; ++ for (_iter620 = this->filesAdded.begin(); _iter620 != this->filesAdded.end(); ++_iter620) + { +- xfer += oprot->writeString((*_iter618)); ++ xfer += oprot->writeString((*_iter620)); + } + xfer += oprot->writeListEnd(); + } +@@ -15313,11 +15445,11 @@ void swap(InsertEventRequestData &a, InsertEventRequestData &b) { + swap(a.filesAdded, b.filesAdded); + } + +-InsertEventRequestData::InsertEventRequestData(const InsertEventRequestData& other619) { +- filesAdded = other619.filesAdded; ++InsertEventRequestData::InsertEventRequestData(const InsertEventRequestData& other621) { ++ filesAdded = other621.filesAdded; + } +-InsertEventRequestData& InsertEventRequestData::operator=(const InsertEventRequestData& other620) { +- filesAdded = other620.filesAdded; ++InsertEventRequestData& InsertEventRequestData::operator=(const InsertEventRequestData& other622) { ++ filesAdded = other622.filesAdded; + return *this; + } + void InsertEventRequestData::printTo(std::ostream& out) const { +@@ -15397,13 +15529,13 @@ void swap(FireEventRequestData &a, FireEventRequestData &b) { + swap(a.__isset, b.__isset); + } + +-FireEventRequestData::FireEventRequestData(const FireEventRequestData& other621) { +- insertData = other621.insertData; +- __isset = other621.__isset; ++FireEventRequestData::FireEventRequestData(const FireEventRequestData& other623) { ++ insertData = other623.insertData; ++ __isset = other623.__isset; + } +-FireEventRequestData& FireEventRequestData::operator=(const FireEventRequestData& other622) { +- insertData = other622.insertData; +- __isset = other622.__isset; ++FireEventRequestData& FireEventRequestData::operator=(const FireEventRequestData& other624) { ++ insertData = other624.insertData; ++ __isset = other624.__isset; + return *this; + } + void FireEventRequestData::printTo(std::ostream& out) const { +@@ -15500,14 +15632,14 @@ uint32_t FireEventRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partitionVals.clear(); +- uint32_t _size623; +- ::apache::thrift::protocol::TType _etype626; +- xfer += iprot->readListBegin(_etype626, _size623); +- this->partitionVals.resize(_size623); +- uint32_t _i627; +- for (_i627 = 0; _i627 < _size623; ++_i627) ++ uint32_t _size625; ++ ::apache::thrift::protocol::TType _etype628; ++ xfer += iprot->readListBegin(_etype628, _size625); ++ this->partitionVals.resize(_size625); ++ uint32_t _i629; ++ for (_i629 = 0; _i629 < _size625; ++_i629) + { +- xfer += iprot->readString(this->partitionVals[_i627]); ++ xfer += iprot->readString(this->partitionVals[_i629]); + } + xfer += iprot->readListEnd(); + } +@@ -15559,10 +15691,10 @@ uint32_t FireEventRequest::write(::apache::thrift::protocol::TProtocol* oprot) c + xfer += oprot->writeFieldBegin("partitionVals", ::apache::thrift::protocol::T_LIST, 5); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partitionVals.size())); +- std::vector ::const_iterator _iter628; +- for (_iter628 = this->partitionVals.begin(); _iter628 != this->partitionVals.end(); ++_iter628) ++ std::vector ::const_iterator _iter630; ++ for (_iter630 = this->partitionVals.begin(); _iter630 != this->partitionVals.end(); ++_iter630) + { +- xfer += oprot->writeString((*_iter628)); ++ xfer += oprot->writeString((*_iter630)); + } + xfer += oprot->writeListEnd(); + } +@@ -15583,21 +15715,21 @@ void swap(FireEventRequest &a, FireEventRequest &b) { + swap(a.__isset, b.__isset); + } + +-FireEventRequest::FireEventRequest(const FireEventRequest& other629) { +- successful = other629.successful; +- data = other629.data; +- dbName = other629.dbName; +- tableName = other629.tableName; +- partitionVals = other629.partitionVals; +- __isset = other629.__isset; +-} +-FireEventRequest& FireEventRequest::operator=(const FireEventRequest& other630) { +- successful = other630.successful; +- data = other630.data; +- dbName = other630.dbName; +- tableName = other630.tableName; +- partitionVals = other630.partitionVals; +- __isset = other630.__isset; ++FireEventRequest::FireEventRequest(const FireEventRequest& other631) { ++ successful = other631.successful; ++ data = other631.data; ++ dbName = other631.dbName; ++ tableName = other631.tableName; ++ partitionVals = other631.partitionVals; ++ __isset = other631.__isset; ++} ++FireEventRequest& FireEventRequest::operator=(const FireEventRequest& other632) { ++ successful = other632.successful; ++ data = other632.data; ++ dbName = other632.dbName; ++ tableName = other632.tableName; ++ partitionVals = other632.partitionVals; ++ __isset = other632.__isset; + return *this; + } + void FireEventRequest::printTo(std::ostream& out) const { +@@ -15660,11 +15792,11 @@ void swap(FireEventResponse &a, FireEventResponse &b) { + (void) b; + } + +-FireEventResponse::FireEventResponse(const FireEventResponse& other631) { +- (void) other631; ++FireEventResponse::FireEventResponse(const FireEventResponse& other633) { ++ (void) other633; + } +-FireEventResponse& FireEventResponse::operator=(const FireEventResponse& other632) { +- (void) other632; ++FireEventResponse& FireEventResponse::operator=(const FireEventResponse& other634) { ++ (void) other634; + return *this; + } + void FireEventResponse::printTo(std::ostream& out) const { +@@ -15745,11 +15877,11 @@ void swap(GetChangeVersionRequest &a, GetChangeVersionRequest &b) { + swap(a.topic, b.topic); + } + +-GetChangeVersionRequest::GetChangeVersionRequest(const GetChangeVersionRequest& other633) { +- topic = other633.topic; ++GetChangeVersionRequest::GetChangeVersionRequest(const GetChangeVersionRequest& other635) { ++ topic = other635.topic; + } +-GetChangeVersionRequest& GetChangeVersionRequest::operator=(const GetChangeVersionRequest& other634) { +- topic = other634.topic; ++GetChangeVersionRequest& GetChangeVersionRequest::operator=(const GetChangeVersionRequest& other636) { ++ topic = other636.topic; + return *this; + } + void GetChangeVersionRequest::printTo(std::ostream& out) const { +@@ -15831,11 +15963,11 @@ void swap(GetChangeVersionResult &a, GetChangeVersionResult &b) { + swap(a.version, b.version); + } + +-GetChangeVersionResult::GetChangeVersionResult(const GetChangeVersionResult& other635) { +- version = other635.version; ++GetChangeVersionResult::GetChangeVersionResult(const GetChangeVersionResult& other637) { ++ version = other637.version; + } +-GetChangeVersionResult& GetChangeVersionResult::operator=(const GetChangeVersionResult& other636) { +- version = other636.version; ++GetChangeVersionResult& GetChangeVersionResult::operator=(const GetChangeVersionResult& other638) { ++ version = other638.version; + return *this; + } + void GetChangeVersionResult::printTo(std::ostream& out) const { +@@ -15936,15 +16068,15 @@ void swap(MetadataPpdResult &a, MetadataPpdResult &b) { + swap(a.__isset, b.__isset); + } + +-MetadataPpdResult::MetadataPpdResult(const MetadataPpdResult& other637) { +- metadata = other637.metadata; +- includeBitset = other637.includeBitset; +- __isset = other637.__isset; ++MetadataPpdResult::MetadataPpdResult(const MetadataPpdResult& other639) { ++ metadata = other639.metadata; ++ includeBitset = other639.includeBitset; ++ __isset = other639.__isset; + } +-MetadataPpdResult& MetadataPpdResult::operator=(const MetadataPpdResult& other638) { +- metadata = other638.metadata; +- includeBitset = other638.includeBitset; +- __isset = other638.__isset; ++MetadataPpdResult& MetadataPpdResult::operator=(const MetadataPpdResult& other640) { ++ metadata = other640.metadata; ++ includeBitset = other640.includeBitset; ++ __isset = other640.__isset; + return *this; + } + void MetadataPpdResult::printTo(std::ostream& out) const { +@@ -15995,17 +16127,17 @@ uint32_t GetFileMetadataByExprResult::read(::apache::thrift::protocol::TProtocol + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + this->metadata.clear(); +- uint32_t _size639; +- ::apache::thrift::protocol::TType _ktype640; +- ::apache::thrift::protocol::TType _vtype641; +- xfer += iprot->readMapBegin(_ktype640, _vtype641, _size639); +- uint32_t _i643; +- for (_i643 = 0; _i643 < _size639; ++_i643) ++ uint32_t _size641; ++ ::apache::thrift::protocol::TType _ktype642; ++ ::apache::thrift::protocol::TType _vtype643; ++ xfer += iprot->readMapBegin(_ktype642, _vtype643, _size641); ++ uint32_t _i645; ++ for (_i645 = 0; _i645 < _size641; ++_i645) + { +- int64_t _key644; +- xfer += iprot->readI64(_key644); +- MetadataPpdResult& _val645 = this->metadata[_key644]; +- xfer += _val645.read(iprot); ++ int64_t _key646; ++ xfer += iprot->readI64(_key646); ++ MetadataPpdResult& _val647 = this->metadata[_key646]; ++ xfer += _val647.read(iprot); + } + xfer += iprot->readMapEnd(); + } +@@ -16046,11 +16178,11 @@ uint32_t GetFileMetadataByExprResult::write(::apache::thrift::protocol::TProtoco + xfer += oprot->writeFieldBegin("metadata", ::apache::thrift::protocol::T_MAP, 1); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_I64, ::apache::thrift::protocol::T_STRUCT, static_cast(this->metadata.size())); +- std::map ::const_iterator _iter646; +- for (_iter646 = this->metadata.begin(); _iter646 != this->metadata.end(); ++_iter646) ++ std::map ::const_iterator _iter648; ++ for (_iter648 = this->metadata.begin(); _iter648 != this->metadata.end(); ++_iter648) + { +- xfer += oprot->writeI64(_iter646->first); +- xfer += _iter646->second.write(oprot); ++ xfer += oprot->writeI64(_iter648->first); ++ xfer += _iter648->second.write(oprot); + } + xfer += oprot->writeMapEnd(); + } +@@ -16071,13 +16203,13 @@ void swap(GetFileMetadataByExprResult &a, GetFileMetadataByExprResult &b) { + swap(a.isSupported, b.isSupported); + } + +-GetFileMetadataByExprResult::GetFileMetadataByExprResult(const GetFileMetadataByExprResult& other647) { +- metadata = other647.metadata; +- isSupported = other647.isSupported; ++GetFileMetadataByExprResult::GetFileMetadataByExprResult(const GetFileMetadataByExprResult& other649) { ++ metadata = other649.metadata; ++ isSupported = other649.isSupported; + } +-GetFileMetadataByExprResult& GetFileMetadataByExprResult::operator=(const GetFileMetadataByExprResult& other648) { +- metadata = other648.metadata; +- isSupported = other648.isSupported; ++GetFileMetadataByExprResult& GetFileMetadataByExprResult::operator=(const GetFileMetadataByExprResult& other650) { ++ metadata = other650.metadata; ++ isSupported = other650.isSupported; + return *this; + } + void GetFileMetadataByExprResult::printTo(std::ostream& out) const { +@@ -16138,14 +16270,14 @@ uint32_t GetFileMetadataByExprRequest::read(::apache::thrift::protocol::TProtoco + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->fileIds.clear(); +- uint32_t _size649; +- ::apache::thrift::protocol::TType _etype652; +- xfer += iprot->readListBegin(_etype652, _size649); +- this->fileIds.resize(_size649); +- uint32_t _i653; +- for (_i653 = 0; _i653 < _size649; ++_i653) ++ uint32_t _size651; ++ ::apache::thrift::protocol::TType _etype654; ++ xfer += iprot->readListBegin(_etype654, _size651); ++ this->fileIds.resize(_size651); ++ uint32_t _i655; ++ for (_i655 = 0; _i655 < _size651; ++_i655) + { +- xfer += iprot->readI64(this->fileIds[_i653]); ++ xfer += iprot->readI64(this->fileIds[_i655]); + } + xfer += iprot->readListEnd(); + } +@@ -16172,9 +16304,9 @@ uint32_t GetFileMetadataByExprRequest::read(::apache::thrift::protocol::TProtoco + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I32) { +- int32_t ecast654; +- xfer += iprot->readI32(ecast654); +- this->type = (FileMetadataExprType::type)ecast654; ++ int32_t ecast656; ++ xfer += iprot->readI32(ecast656); ++ this->type = (FileMetadataExprType::type)ecast656; + this->__isset.type = true; + } else { + xfer += iprot->skip(ftype); +@@ -16204,10 +16336,10 @@ uint32_t GetFileMetadataByExprRequest::write(::apache::thrift::protocol::TProtoc + xfer += oprot->writeFieldBegin("fileIds", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->fileIds.size())); +- std::vector ::const_iterator _iter655; +- for (_iter655 = this->fileIds.begin(); _iter655 != this->fileIds.end(); ++_iter655) ++ std::vector ::const_iterator _iter657; ++ for (_iter657 = this->fileIds.begin(); _iter657 != this->fileIds.end(); ++_iter657) + { +- xfer += oprot->writeI64((*_iter655)); ++ xfer += oprot->writeI64((*_iter657)); + } + xfer += oprot->writeListEnd(); + } +@@ -16241,19 +16373,19 @@ void swap(GetFileMetadataByExprRequest &a, GetFileMetadataByExprRequest &b) { + swap(a.__isset, b.__isset); + } + +-GetFileMetadataByExprRequest::GetFileMetadataByExprRequest(const GetFileMetadataByExprRequest& other656) { +- fileIds = other656.fileIds; +- expr = other656.expr; +- doGetFooters = other656.doGetFooters; +- type = other656.type; +- __isset = other656.__isset; ++GetFileMetadataByExprRequest::GetFileMetadataByExprRequest(const GetFileMetadataByExprRequest& other658) { ++ fileIds = other658.fileIds; ++ expr = other658.expr; ++ doGetFooters = other658.doGetFooters; ++ type = other658.type; ++ __isset = other658.__isset; + } +-GetFileMetadataByExprRequest& GetFileMetadataByExprRequest::operator=(const GetFileMetadataByExprRequest& other657) { +- fileIds = other657.fileIds; +- expr = other657.expr; +- doGetFooters = other657.doGetFooters; +- type = other657.type; +- __isset = other657.__isset; ++GetFileMetadataByExprRequest& GetFileMetadataByExprRequest::operator=(const GetFileMetadataByExprRequest& other659) { ++ fileIds = other659.fileIds; ++ expr = other659.expr; ++ doGetFooters = other659.doGetFooters; ++ type = other659.type; ++ __isset = other659.__isset; + return *this; + } + void GetFileMetadataByExprRequest::printTo(std::ostream& out) const { +@@ -16306,17 +16438,17 @@ uint32_t GetFileMetadataResult::read(::apache::thrift::protocol::TProtocol* ipro + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + this->metadata.clear(); +- uint32_t _size658; +- ::apache::thrift::protocol::TType _ktype659; +- ::apache::thrift::protocol::TType _vtype660; +- xfer += iprot->readMapBegin(_ktype659, _vtype660, _size658); +- uint32_t _i662; +- for (_i662 = 0; _i662 < _size658; ++_i662) ++ uint32_t _size660; ++ ::apache::thrift::protocol::TType _ktype661; ++ ::apache::thrift::protocol::TType _vtype662; ++ xfer += iprot->readMapBegin(_ktype661, _vtype662, _size660); ++ uint32_t _i664; ++ for (_i664 = 0; _i664 < _size660; ++_i664) + { +- int64_t _key663; +- xfer += iprot->readI64(_key663); +- std::string& _val664 = this->metadata[_key663]; +- xfer += iprot->readBinary(_val664); ++ int64_t _key665; ++ xfer += iprot->readI64(_key665); ++ std::string& _val666 = this->metadata[_key665]; ++ xfer += iprot->readBinary(_val666); + } + xfer += iprot->readMapEnd(); + } +@@ -16357,11 +16489,11 @@ uint32_t GetFileMetadataResult::write(::apache::thrift::protocol::TProtocol* opr + xfer += oprot->writeFieldBegin("metadata", ::apache::thrift::protocol::T_MAP, 1); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_I64, ::apache::thrift::protocol::T_STRING, static_cast(this->metadata.size())); +- std::map ::const_iterator _iter665; +- for (_iter665 = this->metadata.begin(); _iter665 != this->metadata.end(); ++_iter665) ++ std::map ::const_iterator _iter667; ++ for (_iter667 = this->metadata.begin(); _iter667 != this->metadata.end(); ++_iter667) + { +- xfer += oprot->writeI64(_iter665->first); +- xfer += oprot->writeBinary(_iter665->second); ++ xfer += oprot->writeI64(_iter667->first); ++ xfer += oprot->writeBinary(_iter667->second); + } + xfer += oprot->writeMapEnd(); + } +@@ -16382,13 +16514,13 @@ void swap(GetFileMetadataResult &a, GetFileMetadataResult &b) { + swap(a.isSupported, b.isSupported); + } + +-GetFileMetadataResult::GetFileMetadataResult(const GetFileMetadataResult& other666) { +- metadata = other666.metadata; +- isSupported = other666.isSupported; ++GetFileMetadataResult::GetFileMetadataResult(const GetFileMetadataResult& other668) { ++ metadata = other668.metadata; ++ isSupported = other668.isSupported; + } +-GetFileMetadataResult& GetFileMetadataResult::operator=(const GetFileMetadataResult& other667) { +- metadata = other667.metadata; +- isSupported = other667.isSupported; ++GetFileMetadataResult& GetFileMetadataResult::operator=(const GetFileMetadataResult& other669) { ++ metadata = other669.metadata; ++ isSupported = other669.isSupported; + return *this; + } + void GetFileMetadataResult::printTo(std::ostream& out) const { +@@ -16434,14 +16566,14 @@ uint32_t GetFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->fileIds.clear(); +- uint32_t _size668; +- ::apache::thrift::protocol::TType _etype671; +- xfer += iprot->readListBegin(_etype671, _size668); +- this->fileIds.resize(_size668); +- uint32_t _i672; +- for (_i672 = 0; _i672 < _size668; ++_i672) ++ uint32_t _size670; ++ ::apache::thrift::protocol::TType _etype673; ++ xfer += iprot->readListBegin(_etype673, _size670); ++ this->fileIds.resize(_size670); ++ uint32_t _i674; ++ for (_i674 = 0; _i674 < _size670; ++_i674) + { +- xfer += iprot->readI64(this->fileIds[_i672]); ++ xfer += iprot->readI64(this->fileIds[_i674]); + } + xfer += iprot->readListEnd(); + } +@@ -16472,10 +16604,10 @@ uint32_t GetFileMetadataRequest::write(::apache::thrift::protocol::TProtocol* op + xfer += oprot->writeFieldBegin("fileIds", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->fileIds.size())); +- std::vector ::const_iterator _iter673; +- for (_iter673 = this->fileIds.begin(); _iter673 != this->fileIds.end(); ++_iter673) ++ std::vector ::const_iterator _iter675; ++ for (_iter675 = this->fileIds.begin(); _iter675 != this->fileIds.end(); ++_iter675) + { +- xfer += oprot->writeI64((*_iter673)); ++ xfer += oprot->writeI64((*_iter675)); + } + xfer += oprot->writeListEnd(); + } +@@ -16491,11 +16623,11 @@ void swap(GetFileMetadataRequest &a, GetFileMetadataRequest &b) { + swap(a.fileIds, b.fileIds); + } + +-GetFileMetadataRequest::GetFileMetadataRequest(const GetFileMetadataRequest& other674) { +- fileIds = other674.fileIds; ++GetFileMetadataRequest::GetFileMetadataRequest(const GetFileMetadataRequest& other676) { ++ fileIds = other676.fileIds; + } +-GetFileMetadataRequest& GetFileMetadataRequest::operator=(const GetFileMetadataRequest& other675) { +- fileIds = other675.fileIds; ++GetFileMetadataRequest& GetFileMetadataRequest::operator=(const GetFileMetadataRequest& other677) { ++ fileIds = other677.fileIds; + return *this; + } + void GetFileMetadataRequest::printTo(std::ostream& out) const { +@@ -16554,11 +16686,11 @@ void swap(PutFileMetadataResult &a, PutFileMetadataResult &b) { + (void) b; + } + +-PutFileMetadataResult::PutFileMetadataResult(const PutFileMetadataResult& other676) { +- (void) other676; ++PutFileMetadataResult::PutFileMetadataResult(const PutFileMetadataResult& other678) { ++ (void) other678; + } +-PutFileMetadataResult& PutFileMetadataResult::operator=(const PutFileMetadataResult& other677) { +- (void) other677; ++PutFileMetadataResult& PutFileMetadataResult::operator=(const PutFileMetadataResult& other679) { ++ (void) other679; + return *this; + } + void PutFileMetadataResult::printTo(std::ostream& out) const { +@@ -16612,14 +16744,14 @@ uint32_t PutFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->fileIds.clear(); +- uint32_t _size678; +- ::apache::thrift::protocol::TType _etype681; +- xfer += iprot->readListBegin(_etype681, _size678); +- this->fileIds.resize(_size678); +- uint32_t _i682; +- for (_i682 = 0; _i682 < _size678; ++_i682) ++ uint32_t _size680; ++ ::apache::thrift::protocol::TType _etype683; ++ xfer += iprot->readListBegin(_etype683, _size680); ++ this->fileIds.resize(_size680); ++ uint32_t _i684; ++ for (_i684 = 0; _i684 < _size680; ++_i684) + { +- xfer += iprot->readI64(this->fileIds[_i682]); ++ xfer += iprot->readI64(this->fileIds[_i684]); + } + xfer += iprot->readListEnd(); + } +@@ -16632,14 +16764,14 @@ uint32_t PutFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->metadata.clear(); +- uint32_t _size683; +- ::apache::thrift::protocol::TType _etype686; +- xfer += iprot->readListBegin(_etype686, _size683); +- this->metadata.resize(_size683); +- uint32_t _i687; +- for (_i687 = 0; _i687 < _size683; ++_i687) ++ uint32_t _size685; ++ ::apache::thrift::protocol::TType _etype688; ++ xfer += iprot->readListBegin(_etype688, _size685); ++ this->metadata.resize(_size685); ++ uint32_t _i689; ++ for (_i689 = 0; _i689 < _size685; ++_i689) + { +- xfer += iprot->readBinary(this->metadata[_i687]); ++ xfer += iprot->readBinary(this->metadata[_i689]); + } + xfer += iprot->readListEnd(); + } +@@ -16650,9 +16782,9 @@ uint32_t PutFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I32) { +- int32_t ecast688; +- xfer += iprot->readI32(ecast688); +- this->type = (FileMetadataExprType::type)ecast688; ++ int32_t ecast690; ++ xfer += iprot->readI32(ecast690); ++ this->type = (FileMetadataExprType::type)ecast690; + this->__isset.type = true; + } else { + xfer += iprot->skip(ftype); +@@ -16682,10 +16814,10 @@ uint32_t PutFileMetadataRequest::write(::apache::thrift::protocol::TProtocol* op + xfer += oprot->writeFieldBegin("fileIds", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->fileIds.size())); +- std::vector ::const_iterator _iter689; +- for (_iter689 = this->fileIds.begin(); _iter689 != this->fileIds.end(); ++_iter689) ++ std::vector ::const_iterator _iter691; ++ for (_iter691 = this->fileIds.begin(); _iter691 != this->fileIds.end(); ++_iter691) + { +- xfer += oprot->writeI64((*_iter689)); ++ xfer += oprot->writeI64((*_iter691)); + } + xfer += oprot->writeListEnd(); + } +@@ -16694,10 +16826,10 @@ uint32_t PutFileMetadataRequest::write(::apache::thrift::protocol::TProtocol* op + xfer += oprot->writeFieldBegin("metadata", ::apache::thrift::protocol::T_LIST, 2); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->metadata.size())); +- std::vector ::const_iterator _iter690; +- for (_iter690 = this->metadata.begin(); _iter690 != this->metadata.end(); ++_iter690) ++ std::vector ::const_iterator _iter692; ++ for (_iter692 = this->metadata.begin(); _iter692 != this->metadata.end(); ++_iter692) + { +- xfer += oprot->writeBinary((*_iter690)); ++ xfer += oprot->writeBinary((*_iter692)); + } + xfer += oprot->writeListEnd(); + } +@@ -16721,17 +16853,17 @@ void swap(PutFileMetadataRequest &a, PutFileMetadataRequest &b) { + swap(a.__isset, b.__isset); + } + +-PutFileMetadataRequest::PutFileMetadataRequest(const PutFileMetadataRequest& other691) { +- fileIds = other691.fileIds; +- metadata = other691.metadata; +- type = other691.type; +- __isset = other691.__isset; ++PutFileMetadataRequest::PutFileMetadataRequest(const PutFileMetadataRequest& other693) { ++ fileIds = other693.fileIds; ++ metadata = other693.metadata; ++ type = other693.type; ++ __isset = other693.__isset; + } +-PutFileMetadataRequest& PutFileMetadataRequest::operator=(const PutFileMetadataRequest& other692) { +- fileIds = other692.fileIds; +- metadata = other692.metadata; +- type = other692.type; +- __isset = other692.__isset; ++PutFileMetadataRequest& PutFileMetadataRequest::operator=(const PutFileMetadataRequest& other694) { ++ fileIds = other694.fileIds; ++ metadata = other694.metadata; ++ type = other694.type; ++ __isset = other694.__isset; + return *this; + } + void PutFileMetadataRequest::printTo(std::ostream& out) const { +@@ -16792,11 +16924,11 @@ void swap(ClearFileMetadataResult &a, ClearFileMetadataResult &b) { + (void) b; + } + +-ClearFileMetadataResult::ClearFileMetadataResult(const ClearFileMetadataResult& other693) { +- (void) other693; ++ClearFileMetadataResult::ClearFileMetadataResult(const ClearFileMetadataResult& other695) { ++ (void) other695; + } +-ClearFileMetadataResult& ClearFileMetadataResult::operator=(const ClearFileMetadataResult& other694) { +- (void) other694; ++ClearFileMetadataResult& ClearFileMetadataResult::operator=(const ClearFileMetadataResult& other696) { ++ (void) other696; + return *this; + } + void ClearFileMetadataResult::printTo(std::ostream& out) const { +@@ -16840,14 +16972,14 @@ uint32_t ClearFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* i + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->fileIds.clear(); +- uint32_t _size695; +- ::apache::thrift::protocol::TType _etype698; +- xfer += iprot->readListBegin(_etype698, _size695); +- this->fileIds.resize(_size695); +- uint32_t _i699; +- for (_i699 = 0; _i699 < _size695; ++_i699) ++ uint32_t _size697; ++ ::apache::thrift::protocol::TType _etype700; ++ xfer += iprot->readListBegin(_etype700, _size697); ++ this->fileIds.resize(_size697); ++ uint32_t _i701; ++ for (_i701 = 0; _i701 < _size697; ++_i701) + { +- xfer += iprot->readI64(this->fileIds[_i699]); ++ xfer += iprot->readI64(this->fileIds[_i701]); + } + xfer += iprot->readListEnd(); + } +@@ -16878,10 +17010,10 @@ uint32_t ClearFileMetadataRequest::write(::apache::thrift::protocol::TProtocol* + xfer += oprot->writeFieldBegin("fileIds", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->fileIds.size())); +- std::vector ::const_iterator _iter700; +- for (_iter700 = this->fileIds.begin(); _iter700 != this->fileIds.end(); ++_iter700) ++ std::vector ::const_iterator _iter702; ++ for (_iter702 = this->fileIds.begin(); _iter702 != this->fileIds.end(); ++_iter702) + { +- xfer += oprot->writeI64((*_iter700)); ++ xfer += oprot->writeI64((*_iter702)); + } + xfer += oprot->writeListEnd(); + } +@@ -16897,11 +17029,11 @@ void swap(ClearFileMetadataRequest &a, ClearFileMetadataRequest &b) { + swap(a.fileIds, b.fileIds); + } + +-ClearFileMetadataRequest::ClearFileMetadataRequest(const ClearFileMetadataRequest& other701) { +- fileIds = other701.fileIds; ++ClearFileMetadataRequest::ClearFileMetadataRequest(const ClearFileMetadataRequest& other703) { ++ fileIds = other703.fileIds; + } +-ClearFileMetadataRequest& ClearFileMetadataRequest::operator=(const ClearFileMetadataRequest& other702) { +- fileIds = other702.fileIds; ++ClearFileMetadataRequest& ClearFileMetadataRequest::operator=(const ClearFileMetadataRequest& other704) { ++ fileIds = other704.fileIds; + return *this; + } + void ClearFileMetadataRequest::printTo(std::ostream& out) const { +@@ -16983,11 +17115,11 @@ void swap(CacheFileMetadataResult &a, CacheFileMetadataResult &b) { + swap(a.isSupported, b.isSupported); + } + +-CacheFileMetadataResult::CacheFileMetadataResult(const CacheFileMetadataResult& other703) { +- isSupported = other703.isSupported; ++CacheFileMetadataResult::CacheFileMetadataResult(const CacheFileMetadataResult& other705) { ++ isSupported = other705.isSupported; + } +-CacheFileMetadataResult& CacheFileMetadataResult::operator=(const CacheFileMetadataResult& other704) { +- isSupported = other704.isSupported; ++CacheFileMetadataResult& CacheFileMetadataResult::operator=(const CacheFileMetadataResult& other706) { ++ isSupported = other706.isSupported; + return *this; + } + void CacheFileMetadataResult::printTo(std::ostream& out) const { +@@ -17128,19 +17260,19 @@ void swap(CacheFileMetadataRequest &a, CacheFileMetadataRequest &b) { + swap(a.__isset, b.__isset); + } + +-CacheFileMetadataRequest::CacheFileMetadataRequest(const CacheFileMetadataRequest& other705) { +- dbName = other705.dbName; +- tblName = other705.tblName; +- partName = other705.partName; +- isAllParts = other705.isAllParts; +- __isset = other705.__isset; ++CacheFileMetadataRequest::CacheFileMetadataRequest(const CacheFileMetadataRequest& other707) { ++ dbName = other707.dbName; ++ tblName = other707.tblName; ++ partName = other707.partName; ++ isAllParts = other707.isAllParts; ++ __isset = other707.__isset; + } +-CacheFileMetadataRequest& CacheFileMetadataRequest::operator=(const CacheFileMetadataRequest& other706) { +- dbName = other706.dbName; +- tblName = other706.tblName; +- partName = other706.partName; +- isAllParts = other706.isAllParts; +- __isset = other706.__isset; ++CacheFileMetadataRequest& CacheFileMetadataRequest::operator=(const CacheFileMetadataRequest& other708) { ++ dbName = other708.dbName; ++ tblName = other708.tblName; ++ partName = other708.partName; ++ isAllParts = other708.isAllParts; ++ __isset = other708.__isset; + return *this; + } + void CacheFileMetadataRequest::printTo(std::ostream& out) const { +@@ -17188,14 +17320,14 @@ uint32_t GetAllFunctionsResponse::read(::apache::thrift::protocol::TProtocol* ip + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->functions.clear(); +- uint32_t _size707; +- ::apache::thrift::protocol::TType _etype710; +- xfer += iprot->readListBegin(_etype710, _size707); +- this->functions.resize(_size707); +- uint32_t _i711; +- for (_i711 = 0; _i711 < _size707; ++_i711) ++ uint32_t _size709; ++ ::apache::thrift::protocol::TType _etype712; ++ xfer += iprot->readListBegin(_etype712, _size709); ++ this->functions.resize(_size709); ++ uint32_t _i713; ++ for (_i713 = 0; _i713 < _size709; ++_i713) + { +- xfer += this->functions[_i711].read(iprot); ++ xfer += this->functions[_i713].read(iprot); + } + xfer += iprot->readListEnd(); + } +@@ -17225,10 +17357,10 @@ uint32_t GetAllFunctionsResponse::write(::apache::thrift::protocol::TProtocol* o + xfer += oprot->writeFieldBegin("functions", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->functions.size())); +- std::vector ::const_iterator _iter712; +- for (_iter712 = this->functions.begin(); _iter712 != this->functions.end(); ++_iter712) ++ std::vector ::const_iterator _iter714; ++ for (_iter714 = this->functions.begin(); _iter714 != this->functions.end(); ++_iter714) + { +- xfer += (*_iter712).write(oprot); ++ xfer += (*_iter714).write(oprot); + } + xfer += oprot->writeListEnd(); + } +@@ -17245,13 +17377,13 @@ void swap(GetAllFunctionsResponse &a, GetAllFunctionsResponse &b) { + swap(a.__isset, b.__isset); + } + +-GetAllFunctionsResponse::GetAllFunctionsResponse(const GetAllFunctionsResponse& other713) { +- functions = other713.functions; +- __isset = other713.__isset; ++GetAllFunctionsResponse::GetAllFunctionsResponse(const GetAllFunctionsResponse& other715) { ++ functions = other715.functions; ++ __isset = other715.__isset; + } +-GetAllFunctionsResponse& GetAllFunctionsResponse::operator=(const GetAllFunctionsResponse& other714) { +- functions = other714.functions; +- __isset = other714.__isset; ++GetAllFunctionsResponse& GetAllFunctionsResponse::operator=(const GetAllFunctionsResponse& other716) { ++ functions = other716.functions; ++ __isset = other716.__isset; + return *this; + } + void GetAllFunctionsResponse::printTo(std::ostream& out) const { +@@ -17393,19 +17525,19 @@ void swap(TableMeta &a, TableMeta &b) { + swap(a.__isset, b.__isset); + } + +-TableMeta::TableMeta(const TableMeta& other715) { +- dbName = other715.dbName; +- tableName = other715.tableName; +- tableType = other715.tableType; +- comments = other715.comments; +- __isset = other715.__isset; ++TableMeta::TableMeta(const TableMeta& other717) { ++ dbName = other717.dbName; ++ tableName = other717.tableName; ++ tableType = other717.tableType; ++ comments = other717.comments; ++ __isset = other717.__isset; + } +-TableMeta& TableMeta::operator=(const TableMeta& other716) { +- dbName = other716.dbName; +- tableName = other716.tableName; +- tableType = other716.tableType; +- comments = other716.comments; +- __isset = other716.__isset; ++TableMeta& TableMeta::operator=(const TableMeta& other718) { ++ dbName = other718.dbName; ++ tableName = other718.tableName; ++ tableType = other718.tableType; ++ comments = other718.comments; ++ __isset = other718.__isset; + return *this; + } + void TableMeta::printTo(std::ostream& out) const { +@@ -17488,13 +17620,13 @@ void swap(MetaException &a, MetaException &b) { + swap(a.__isset, b.__isset); + } + +-MetaException::MetaException(const MetaException& other717) : TException() { +- message = other717.message; +- __isset = other717.__isset; ++MetaException::MetaException(const MetaException& other719) : TException() { ++ message = other719.message; ++ __isset = other719.__isset; + } +-MetaException& MetaException::operator=(const MetaException& other718) { +- message = other718.message; +- __isset = other718.__isset; ++MetaException& MetaException::operator=(const MetaException& other720) { ++ message = other720.message; ++ __isset = other720.__isset; + return *this; + } + void MetaException::printTo(std::ostream& out) const { +@@ -17585,13 +17717,13 @@ void swap(UnknownTableException &a, UnknownTableException &b) { + swap(a.__isset, b.__isset); + } + +-UnknownTableException::UnknownTableException(const UnknownTableException& other719) : TException() { +- message = other719.message; +- __isset = other719.__isset; ++UnknownTableException::UnknownTableException(const UnknownTableException& other721) : TException() { ++ message = other721.message; ++ __isset = other721.__isset; + } +-UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other720) { +- message = other720.message; +- __isset = other720.__isset; ++UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other722) { ++ message = other722.message; ++ __isset = other722.__isset; + return *this; + } + void UnknownTableException::printTo(std::ostream& out) const { +@@ -17682,13 +17814,13 @@ void swap(UnknownDBException &a, UnknownDBException &b) { + swap(a.__isset, b.__isset); + } + +-UnknownDBException::UnknownDBException(const UnknownDBException& other721) : TException() { +- message = other721.message; +- __isset = other721.__isset; ++UnknownDBException::UnknownDBException(const UnknownDBException& other723) : TException() { ++ message = other723.message; ++ __isset = other723.__isset; + } +-UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other722) { +- message = other722.message; +- __isset = other722.__isset; ++UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other724) { ++ message = other724.message; ++ __isset = other724.__isset; + return *this; + } + void UnknownDBException::printTo(std::ostream& out) const { +@@ -17779,13 +17911,13 @@ void swap(AlreadyExistsException &a, AlreadyExistsException &b) { + swap(a.__isset, b.__isset); + } + +-AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other723) : TException() { +- message = other723.message; +- __isset = other723.__isset; ++AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other725) : TException() { ++ message = other725.message; ++ __isset = other725.__isset; + } +-AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other724) { +- message = other724.message; +- __isset = other724.__isset; ++AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other726) { ++ message = other726.message; ++ __isset = other726.__isset; + return *this; + } + void AlreadyExistsException::printTo(std::ostream& out) const { +@@ -17876,13 +18008,13 @@ void swap(InvalidPartitionException &a, InvalidPartitionException &b) { + swap(a.__isset, b.__isset); + } + +-InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other725) : TException() { +- message = other725.message; +- __isset = other725.__isset; ++InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other727) : TException() { ++ message = other727.message; ++ __isset = other727.__isset; + } +-InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other726) { +- message = other726.message; +- __isset = other726.__isset; ++InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other728) { ++ message = other728.message; ++ __isset = other728.__isset; + return *this; + } + void InvalidPartitionException::printTo(std::ostream& out) const { +@@ -17973,13 +18105,13 @@ void swap(UnknownPartitionException &a, UnknownPartitionException &b) { + swap(a.__isset, b.__isset); + } + +-UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other727) : TException() { +- message = other727.message; +- __isset = other727.__isset; ++UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other729) : TException() { ++ message = other729.message; ++ __isset = other729.__isset; + } +-UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other728) { +- message = other728.message; +- __isset = other728.__isset; ++UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other730) { ++ message = other730.message; ++ __isset = other730.__isset; + return *this; + } + void UnknownPartitionException::printTo(std::ostream& out) const { +@@ -18070,13 +18202,13 @@ void swap(InvalidObjectException &a, InvalidObjectException &b) { + swap(a.__isset, b.__isset); + } + +-InvalidObjectException::InvalidObjectException(const InvalidObjectException& other729) : TException() { +- message = other729.message; +- __isset = other729.__isset; ++InvalidObjectException::InvalidObjectException(const InvalidObjectException& other731) : TException() { ++ message = other731.message; ++ __isset = other731.__isset; + } +-InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other730) { +- message = other730.message; +- __isset = other730.__isset; ++InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other732) { ++ message = other732.message; ++ __isset = other732.__isset; + return *this; + } + void InvalidObjectException::printTo(std::ostream& out) const { +@@ -18167,13 +18299,13 @@ void swap(NoSuchObjectException &a, NoSuchObjectException &b) { + swap(a.__isset, b.__isset); + } + +-NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other731) : TException() { +- message = other731.message; +- __isset = other731.__isset; ++NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other733) : TException() { ++ message = other733.message; ++ __isset = other733.__isset; + } +-NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other732) { +- message = other732.message; +- __isset = other732.__isset; ++NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other734) { ++ message = other734.message; ++ __isset = other734.__isset; + return *this; + } + void NoSuchObjectException::printTo(std::ostream& out) const { +@@ -18264,13 +18396,13 @@ void swap(IndexAlreadyExistsException &a, IndexAlreadyExistsException &b) { + swap(a.__isset, b.__isset); + } + +-IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other733) : TException() { +- message = other733.message; +- __isset = other733.__isset; ++IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other735) : TException() { ++ message = other735.message; ++ __isset = other735.__isset; + } +-IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other734) { +- message = other734.message; +- __isset = other734.__isset; ++IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other736) { ++ message = other736.message; ++ __isset = other736.__isset; + return *this; + } + void IndexAlreadyExistsException::printTo(std::ostream& out) const { +@@ -18361,13 +18493,13 @@ void swap(InvalidOperationException &a, InvalidOperationException &b) { + swap(a.__isset, b.__isset); + } + +-InvalidOperationException::InvalidOperationException(const InvalidOperationException& other735) : TException() { +- message = other735.message; +- __isset = other735.__isset; ++InvalidOperationException::InvalidOperationException(const InvalidOperationException& other737) : TException() { ++ message = other737.message; ++ __isset = other737.__isset; + } +-InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other736) { +- message = other736.message; +- __isset = other736.__isset; ++InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other738) { ++ message = other738.message; ++ __isset = other738.__isset; + return *this; + } + void InvalidOperationException::printTo(std::ostream& out) const { +@@ -18458,13 +18590,13 @@ void swap(ConfigValSecurityException &a, ConfigValSecurityException &b) { + swap(a.__isset, b.__isset); + } + +-ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other737) : TException() { +- message = other737.message; +- __isset = other737.__isset; ++ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other739) : TException() { ++ message = other739.message; ++ __isset = other739.__isset; + } +-ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other738) { +- message = other738.message; +- __isset = other738.__isset; ++ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other740) { ++ message = other740.message; ++ __isset = other740.__isset; + return *this; + } + void ConfigValSecurityException::printTo(std::ostream& out) const { +@@ -18555,13 +18687,13 @@ void swap(InvalidInputException &a, InvalidInputException &b) { + swap(a.__isset, b.__isset); + } + +-InvalidInputException::InvalidInputException(const InvalidInputException& other739) : TException() { +- message = other739.message; +- __isset = other739.__isset; ++InvalidInputException::InvalidInputException(const InvalidInputException& other741) : TException() { ++ message = other741.message; ++ __isset = other741.__isset; + } +-InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other740) { +- message = other740.message; +- __isset = other740.__isset; ++InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other742) { ++ message = other742.message; ++ __isset = other742.__isset; + return *this; + } + void InvalidInputException::printTo(std::ostream& out) const { +@@ -18652,13 +18784,13 @@ void swap(NoSuchTxnException &a, NoSuchTxnException &b) { + swap(a.__isset, b.__isset); + } + +-NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other741) : TException() { +- message = other741.message; +- __isset = other741.__isset; ++NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other743) : TException() { ++ message = other743.message; ++ __isset = other743.__isset; + } +-NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other742) { +- message = other742.message; +- __isset = other742.__isset; ++NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other744) { ++ message = other744.message; ++ __isset = other744.__isset; + return *this; + } + void NoSuchTxnException::printTo(std::ostream& out) const { +@@ -18749,13 +18881,13 @@ void swap(TxnAbortedException &a, TxnAbortedException &b) { + swap(a.__isset, b.__isset); + } + +-TxnAbortedException::TxnAbortedException(const TxnAbortedException& other743) : TException() { +- message = other743.message; +- __isset = other743.__isset; ++TxnAbortedException::TxnAbortedException(const TxnAbortedException& other745) : TException() { ++ message = other745.message; ++ __isset = other745.__isset; + } +-TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other744) { +- message = other744.message; +- __isset = other744.__isset; ++TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other746) { ++ message = other746.message; ++ __isset = other746.__isset; + return *this; + } + void TxnAbortedException::printTo(std::ostream& out) const { +@@ -18846,13 +18978,13 @@ void swap(TxnOpenException &a, TxnOpenException &b) { + swap(a.__isset, b.__isset); + } + +-TxnOpenException::TxnOpenException(const TxnOpenException& other745) : TException() { +- message = other745.message; +- __isset = other745.__isset; ++TxnOpenException::TxnOpenException(const TxnOpenException& other747) : TException() { ++ message = other747.message; ++ __isset = other747.__isset; + } +-TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other746) { +- message = other746.message; +- __isset = other746.__isset; ++TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other748) { ++ message = other748.message; ++ __isset = other748.__isset; + return *this; + } + void TxnOpenException::printTo(std::ostream& out) const { +@@ -18943,13 +19075,13 @@ void swap(NoSuchLockException &a, NoSuchLockException &b) { + swap(a.__isset, b.__isset); + } + +-NoSuchLockException::NoSuchLockException(const NoSuchLockException& other747) : TException() { +- message = other747.message; +- __isset = other747.__isset; ++NoSuchLockException::NoSuchLockException(const NoSuchLockException& other749) : TException() { ++ message = other749.message; ++ __isset = other749.__isset; + } +-NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other748) { +- message = other748.message; +- __isset = other748.__isset; ++NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other750) { ++ message = other750.message; ++ __isset = other750.__isset; + return *this; + } + void NoSuchLockException::printTo(std::ostream& out) const { +diff --git a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h +index d392f67..3b3e05e 100644 +--- a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h ++++ b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h +@@ -251,6 +251,8 @@ class ForeignKeysRequest; + + class ForeignKeysResponse; + ++class DropConstraintRequest; ++ + class PartitionsByExprResult; + + class PartitionsByExprRequest; +@@ -3779,6 +3781,56 @@ inline std::ostream& operator<<(std::ostream& out, const ForeignKeysResponse& ob + } + + ++class DropConstraintRequest { ++ public: ++ ++ DropConstraintRequest(const DropConstraintRequest&); ++ DropConstraintRequest& operator=(const DropConstraintRequest&); ++ DropConstraintRequest() : dbname(), tablename(), constraintname() { ++ } ++ ++ virtual ~DropConstraintRequest() throw(); ++ std::string dbname; ++ std::string tablename; ++ std::string constraintname; ++ ++ void __set_dbname(const std::string& val); ++ ++ void __set_tablename(const std::string& val); ++ ++ void __set_constraintname(const std::string& val); ++ ++ bool operator == (const DropConstraintRequest & rhs) const ++ { ++ if (!(dbname == rhs.dbname)) ++ return false; ++ if (!(tablename == rhs.tablename)) ++ return false; ++ if (!(constraintname == rhs.constraintname)) ++ return false; ++ return true; ++ } ++ bool operator != (const DropConstraintRequest &rhs) const { ++ return !(*this == rhs); ++ } ++ ++ bool operator < (const DropConstraintRequest & ) 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(DropConstraintRequest &a, DropConstraintRequest &b); ++ ++inline std::ostream& operator<<(std::ostream& out, const DropConstraintRequest& obj) ++{ ++ obj.printTo(out); ++ return out; ++} ++ ++ + class PartitionsByExprResult { + public: + +diff --git a/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/DropConstraintRequest.java b/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/DropConstraintRequest.java +new file mode 100644 +index 0000000..4519dac +--- /dev/null ++++ b/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/DropConstraintRequest.java +@@ -0,0 +1,591 @@ ++/** ++ * Autogenerated by Thrift Compiler (0.9.3) ++ * ++ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING ++ * @generated ++ */ ++package org.apache.hadoop.hive.metastore.api; ++ ++import org.apache.thrift.scheme.IScheme; ++import org.apache.thrift.scheme.SchemeFactory; ++import org.apache.thrift.scheme.StandardScheme; ++ ++import org.apache.thrift.scheme.TupleScheme; ++import org.apache.thrift.protocol.TTupleProtocol; ++import org.apache.thrift.protocol.TProtocolException; ++import org.apache.thrift.EncodingUtils; ++import org.apache.thrift.TException; ++import org.apache.thrift.async.AsyncMethodCallback; ++import org.apache.thrift.server.AbstractNonblockingServer.*; ++import java.util.List; ++import java.util.ArrayList; ++import java.util.Map; ++import java.util.HashMap; ++import java.util.EnumMap; ++import java.util.Set; ++import java.util.HashSet; ++import java.util.EnumSet; ++import java.util.Collections; ++import java.util.BitSet; ++import java.nio.ByteBuffer; ++import java.util.Arrays; ++import javax.annotation.Generated; ++import org.slf4j.Logger; ++import org.slf4j.LoggerFactory; ++ ++@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) ++@Generated(value = "Autogenerated by Thrift Compiler (0.9.3)") ++public class DropConstraintRequest 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("DropConstraintRequest"); ++ ++ private static final org.apache.thrift.protocol.TField DBNAME_FIELD_DESC = new org.apache.thrift.protocol.TField("dbname", org.apache.thrift.protocol.TType.STRING, (short)1); ++ private static final org.apache.thrift.protocol.TField TABLENAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tablename", org.apache.thrift.protocol.TType.STRING, (short)2); ++ private static final org.apache.thrift.protocol.TField CONSTRAINTNAME_FIELD_DESC = new org.apache.thrift.protocol.TField("constraintname", org.apache.thrift.protocol.TType.STRING, (short)3); ++ ++ private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); ++ static { ++ schemes.put(StandardScheme.class, new DropConstraintRequestStandardSchemeFactory()); ++ schemes.put(TupleScheme.class, new DropConstraintRequestTupleSchemeFactory()); ++ } ++ ++ private String dbname; // required ++ private String tablename; // required ++ private String constraintname; // 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 { ++ DBNAME((short)1, "dbname"), ++ TABLENAME((short)2, "tablename"), ++ CONSTRAINTNAME((short)3, "constraintname"); ++ ++ 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: // DBNAME ++ return DBNAME; ++ case 2: // TABLENAME ++ return TABLENAME; ++ case 3: // CONSTRAINTNAME ++ return CONSTRAINTNAME; ++ 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.DBNAME, new org.apache.thrift.meta_data.FieldMetaData("dbname", org.apache.thrift.TFieldRequirementType.REQUIRED, ++ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); ++ tmpMap.put(_Fields.TABLENAME, new org.apache.thrift.meta_data.FieldMetaData("tablename", org.apache.thrift.TFieldRequirementType.REQUIRED, ++ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); ++ tmpMap.put(_Fields.CONSTRAINTNAME, new org.apache.thrift.meta_data.FieldMetaData("constraintname", org.apache.thrift.TFieldRequirementType.REQUIRED, ++ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); ++ metaDataMap = Collections.unmodifiableMap(tmpMap); ++ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(DropConstraintRequest.class, metaDataMap); ++ } ++ ++ public DropConstraintRequest() { ++ } ++ ++ public DropConstraintRequest( ++ String dbname, ++ String tablename, ++ String constraintname) ++ { ++ this(); ++ this.dbname = dbname; ++ this.tablename = tablename; ++ this.constraintname = constraintname; ++ } ++ ++ /** ++ * Performs a deep copy on other. ++ */ ++ public DropConstraintRequest(DropConstraintRequest other) { ++ if (other.isSetDbname()) { ++ this.dbname = other.dbname; ++ } ++ if (other.isSetTablename()) { ++ this.tablename = other.tablename; ++ } ++ if (other.isSetConstraintname()) { ++ this.constraintname = other.constraintname; ++ } ++ } ++ ++ public DropConstraintRequest deepCopy() { ++ return new DropConstraintRequest(this); ++ } ++ ++ @Override ++ public void clear() { ++ this.dbname = null; ++ this.tablename = null; ++ this.constraintname = null; ++ } ++ ++ public String getDbname() { ++ return this.dbname; ++ } ++ ++ public void setDbname(String dbname) { ++ this.dbname = dbname; ++ } ++ ++ public void unsetDbname() { ++ this.dbname = null; ++ } ++ ++ /** Returns true if field dbname is set (has been assigned a value) and false otherwise */ ++ public boolean isSetDbname() { ++ return this.dbname != null; ++ } ++ ++ public void setDbnameIsSet(boolean value) { ++ if (!value) { ++ this.dbname = null; ++ } ++ } ++ ++ public String getTablename() { ++ return this.tablename; ++ } ++ ++ public void setTablename(String tablename) { ++ this.tablename = tablename; ++ } ++ ++ public void unsetTablename() { ++ this.tablename = null; ++ } ++ ++ /** Returns true if field tablename is set (has been assigned a value) and false otherwise */ ++ public boolean isSetTablename() { ++ return this.tablename != null; ++ } ++ ++ public void setTablenameIsSet(boolean value) { ++ if (!value) { ++ this.tablename = null; ++ } ++ } ++ ++ public String getConstraintname() { ++ return this.constraintname; ++ } ++ ++ public void setConstraintname(String constraintname) { ++ this.constraintname = constraintname; ++ } ++ ++ public void unsetConstraintname() { ++ this.constraintname = null; ++ } ++ ++ /** Returns true if field constraintname is set (has been assigned a value) and false otherwise */ ++ public boolean isSetConstraintname() { ++ return this.constraintname != null; ++ } ++ ++ public void setConstraintnameIsSet(boolean value) { ++ if (!value) { ++ this.constraintname = null; ++ } ++ } ++ ++ public void setFieldValue(_Fields field, Object value) { ++ switch (field) { ++ case DBNAME: ++ if (value == null) { ++ unsetDbname(); ++ } else { ++ setDbname((String)value); ++ } ++ break; ++ ++ case TABLENAME: ++ if (value == null) { ++ unsetTablename(); ++ } else { ++ setTablename((String)value); ++ } ++ break; ++ ++ case CONSTRAINTNAME: ++ if (value == null) { ++ unsetConstraintname(); ++ } else { ++ setConstraintname((String)value); ++ } ++ break; ++ ++ } ++ } ++ ++ public Object getFieldValue(_Fields field) { ++ switch (field) { ++ case DBNAME: ++ return getDbname(); ++ ++ case TABLENAME: ++ return getTablename(); ++ ++ case CONSTRAINTNAME: ++ return getConstraintname(); ++ ++ } ++ 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 DBNAME: ++ return isSetDbname(); ++ case TABLENAME: ++ return isSetTablename(); ++ case CONSTRAINTNAME: ++ return isSetConstraintname(); ++ } ++ throw new IllegalStateException(); ++ } ++ ++ @Override ++ public boolean equals(Object that) { ++ if (that == null) ++ return false; ++ if (that instanceof DropConstraintRequest) ++ return this.equals((DropConstraintRequest)that); ++ return false; ++ } ++ ++ public boolean equals(DropConstraintRequest that) { ++ if (that == null) ++ return false; ++ ++ boolean this_present_dbname = true && this.isSetDbname(); ++ boolean that_present_dbname = true && that.isSetDbname(); ++ if (this_present_dbname || that_present_dbname) { ++ if (!(this_present_dbname && that_present_dbname)) ++ return false; ++ if (!this.dbname.equals(that.dbname)) ++ return false; ++ } ++ ++ boolean this_present_tablename = true && this.isSetTablename(); ++ boolean that_present_tablename = true && that.isSetTablename(); ++ if (this_present_tablename || that_present_tablename) { ++ if (!(this_present_tablename && that_present_tablename)) ++ return false; ++ if (!this.tablename.equals(that.tablename)) ++ return false; ++ } ++ ++ boolean this_present_constraintname = true && this.isSetConstraintname(); ++ boolean that_present_constraintname = true && that.isSetConstraintname(); ++ if (this_present_constraintname || that_present_constraintname) { ++ if (!(this_present_constraintname && that_present_constraintname)) ++ return false; ++ if (!this.constraintname.equals(that.constraintname)) ++ return false; ++ } ++ ++ return true; ++ } ++ ++ @Override ++ public int hashCode() { ++ List list = new ArrayList(); ++ ++ boolean present_dbname = true && (isSetDbname()); ++ list.add(present_dbname); ++ if (present_dbname) ++ list.add(dbname); ++ ++ boolean present_tablename = true && (isSetTablename()); ++ list.add(present_tablename); ++ if (present_tablename) ++ list.add(tablename); ++ ++ boolean present_constraintname = true && (isSetConstraintname()); ++ list.add(present_constraintname); ++ if (present_constraintname) ++ list.add(constraintname); ++ ++ return list.hashCode(); ++ } ++ ++ @Override ++ public int compareTo(DropConstraintRequest other) { ++ if (!getClass().equals(other.getClass())) { ++ return getClass().getName().compareTo(other.getClass().getName()); ++ } ++ ++ int lastComparison = 0; ++ ++ lastComparison = Boolean.valueOf(isSetDbname()).compareTo(other.isSetDbname()); ++ if (lastComparison != 0) { ++ return lastComparison; ++ } ++ if (isSetDbname()) { ++ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.dbname, other.dbname); ++ if (lastComparison != 0) { ++ return lastComparison; ++ } ++ } ++ lastComparison = Boolean.valueOf(isSetTablename()).compareTo(other.isSetTablename()); ++ if (lastComparison != 0) { ++ return lastComparison; ++ } ++ if (isSetTablename()) { ++ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tablename, other.tablename); ++ if (lastComparison != 0) { ++ return lastComparison; ++ } ++ } ++ lastComparison = Boolean.valueOf(isSetConstraintname()).compareTo(other.isSetConstraintname()); ++ if (lastComparison != 0) { ++ return lastComparison; ++ } ++ if (isSetConstraintname()) { ++ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.constraintname, other.constraintname); ++ 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("DropConstraintRequest("); ++ boolean first = true; ++ ++ sb.append("dbname:"); ++ if (this.dbname == null) { ++ sb.append("null"); ++ } else { ++ sb.append(this.dbname); ++ } ++ first = false; ++ if (!first) sb.append(", "); ++ sb.append("tablename:"); ++ if (this.tablename == null) { ++ sb.append("null"); ++ } else { ++ sb.append(this.tablename); ++ } ++ first = false; ++ if (!first) sb.append(", "); ++ sb.append("constraintname:"); ++ if (this.constraintname == null) { ++ sb.append("null"); ++ } else { ++ sb.append(this.constraintname); ++ } ++ first = false; ++ sb.append(")"); ++ return sb.toString(); ++ } ++ ++ public void validate() throws org.apache.thrift.TException { ++ // check for required fields ++ if (!isSetDbname()) { ++ throw new org.apache.thrift.protocol.TProtocolException("Required field 'dbname' is unset! Struct:" + toString()); ++ } ++ ++ if (!isSetTablename()) { ++ throw new org.apache.thrift.protocol.TProtocolException("Required field 'tablename' is unset! Struct:" + toString()); ++ } ++ ++ if (!isSetConstraintname()) { ++ throw new org.apache.thrift.protocol.TProtocolException("Required field 'constraintname' is unset! Struct:" + toString()); ++ } ++ ++ // check for sub-struct validity ++ } ++ ++ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { ++ try { ++ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); ++ } catch (org.apache.thrift.TException te) { ++ throw new java.io.IOException(te); ++ } ++ } ++ ++ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { ++ try { ++ 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 DropConstraintRequestStandardSchemeFactory implements SchemeFactory { ++ public DropConstraintRequestStandardScheme getScheme() { ++ return new DropConstraintRequestStandardScheme(); ++ } ++ } ++ ++ private static class DropConstraintRequestStandardScheme extends StandardScheme { ++ ++ public void read(org.apache.thrift.protocol.TProtocol iprot, DropConstraintRequest 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: // DBNAME ++ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { ++ struct.dbname = iprot.readString(); ++ struct.setDbnameIsSet(true); ++ } else { ++ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); ++ } ++ break; ++ case 2: // TABLENAME ++ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { ++ struct.tablename = iprot.readString(); ++ struct.setTablenameIsSet(true); ++ } else { ++ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); ++ } ++ break; ++ case 3: // CONSTRAINTNAME ++ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { ++ struct.constraintname = iprot.readString(); ++ struct.setConstraintnameIsSet(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, DropConstraintRequest struct) throws org.apache.thrift.TException { ++ struct.validate(); ++ ++ oprot.writeStructBegin(STRUCT_DESC); ++ if (struct.dbname != null) { ++ oprot.writeFieldBegin(DBNAME_FIELD_DESC); ++ oprot.writeString(struct.dbname); ++ oprot.writeFieldEnd(); ++ } ++ if (struct.tablename != null) { ++ oprot.writeFieldBegin(TABLENAME_FIELD_DESC); ++ oprot.writeString(struct.tablename); ++ oprot.writeFieldEnd(); ++ } ++ if (struct.constraintname != null) { ++ oprot.writeFieldBegin(CONSTRAINTNAME_FIELD_DESC); ++ oprot.writeString(struct.constraintname); ++ oprot.writeFieldEnd(); ++ } ++ oprot.writeFieldStop(); ++ oprot.writeStructEnd(); ++ } ++ ++ } ++ ++ private static class DropConstraintRequestTupleSchemeFactory implements SchemeFactory { ++ public DropConstraintRequestTupleScheme getScheme() { ++ return new DropConstraintRequestTupleScheme(); ++ } ++ } ++ ++ private static class DropConstraintRequestTupleScheme extends TupleScheme { ++ ++ @Override ++ public void write(org.apache.thrift.protocol.TProtocol prot, DropConstraintRequest struct) throws org.apache.thrift.TException { ++ TTupleProtocol oprot = (TTupleProtocol) prot; ++ oprot.writeString(struct.dbname); ++ oprot.writeString(struct.tablename); ++ oprot.writeString(struct.constraintname); ++ } ++ ++ @Override ++ public void read(org.apache.thrift.protocol.TProtocol prot, DropConstraintRequest struct) throws org.apache.thrift.TException { ++ TTupleProtocol iprot = (TTupleProtocol) prot; ++ struct.dbname = iprot.readString(); ++ struct.setDbnameIsSet(true); ++ struct.tablename = iprot.readString(); ++ struct.setTablenameIsSet(true); ++ struct.constraintname = iprot.readString(); ++ struct.setConstraintnameIsSet(true); ++ } ++ } ++ ++} ++ +diff --git a/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java b/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java +index 051c1f2..2a81c4b 100644 +--- a/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java ++++ b/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java +@@ -80,6 +80,8 @@ + + public void create_table_with_constraints(Table tbl, List primaryKeys, List foreignKeys) throws AlreadyExistsException, InvalidObjectException, MetaException, NoSuchObjectException, org.apache.thrift.TException; + ++ public void drop_constraint(DropConstraintRequest req) throws NoSuchObjectException, MetaException, org.apache.thrift.TException; ++ + public void drop_table(String dbname, String name, boolean deleteData) throws NoSuchObjectException, MetaException, org.apache.thrift.TException; + + public void drop_table_with_environment_context(String dbname, String name, boolean deleteData, EnvironmentContext environment_context) throws NoSuchObjectException, MetaException, org.apache.thrift.TException; +@@ -376,6 +378,8 @@ + + public void create_table_with_constraints(Table tbl, List primaryKeys, List foreignKeys, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + ++ public void drop_constraint(DropConstraintRequest req, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; ++ + public void drop_table(String dbname, String name, boolean deleteData, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + + public void drop_table_with_environment_context(String dbname, String name, boolean deleteData, EnvironmentContext environment_context, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; +@@ -1218,6 +1222,32 @@ public void recv_create_table_with_constraints() throws AlreadyExistsException, + return; + } + ++ public void drop_constraint(DropConstraintRequest req) throws NoSuchObjectException, MetaException, org.apache.thrift.TException ++ { ++ send_drop_constraint(req); ++ recv_drop_constraint(); ++ } ++ ++ public void send_drop_constraint(DropConstraintRequest req) throws org.apache.thrift.TException ++ { ++ drop_constraint_args args = new drop_constraint_args(); ++ args.setReq(req); ++ sendBase("drop_constraint", args); ++ } ++ ++ public void recv_drop_constraint() throws NoSuchObjectException, MetaException, org.apache.thrift.TException ++ { ++ drop_constraint_result result = new drop_constraint_result(); ++ receiveBase(result, "drop_constraint"); ++ if (result.o1 != null) { ++ throw result.o1; ++ } ++ if (result.o3 != null) { ++ throw result.o3; ++ } + return; + } -+ driver.run("select * from " + PARTITIONED_TABLE); -+ ArrayList valuesReadFromHiveDriver = new ArrayList(); -+ driver.getResults(valuesReadFromHiveDriver); -+ assertTrue(valuesReadFromHiveDriver.size() == 6); -+ -+ server.registerQuery("W = load '" + PARTITIONED_TABLE + "' using org.apache.hive.hcatalog.pig.HCatLoader();"); -+ Schema dumpedWSchema = server.dumpSchema("W"); -+ List Wfields = dumpedWSchema.getFields(); -+ assertEquals(3, Wfields.size()); -+ assertTrue(Wfields.get(0).alias.equalsIgnoreCase("a")); -+ assertTrue(Wfields.get(0).type == DataType.INTEGER); -+ assertTrue(Wfields.get(1).alias.equalsIgnoreCase("b")); -+ assertTrue(Wfields.get(1).type == DataType.CHARARRAY); -+ assertTrue(Wfields.get(2).alias.equalsIgnoreCase("bkt")); -+ assertTrue(Wfields.get(2).type == DataType.CHARARRAY); + -+ try { -+ Iterator WIter = server.openIterator("W"); -+ fail("Should failed in retriving an invalid partition"); -+ } catch (IOException ioe) { -+ // expected + public void drop_table(String dbname, String name, boolean deleteData) throws NoSuchObjectException, MetaException, org.apache.thrift.TException + { + send_drop_table(dbname, name, deleteData); +@@ -5535,6 +5565,38 @@ public void getResult() throws AlreadyExistsException, InvalidObjectException, M + } + } + ++ public void drop_constraint(DropConstraintRequest req, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { ++ checkReady(); ++ drop_constraint_call method_call = new drop_constraint_call(req, resultHandler, this, ___protocolFactory, ___transport); ++ this.___currentMethod = method_call; ++ ___manager.call(method_call); ++ } ++ ++ public static class drop_constraint_call extends org.apache.thrift.async.TAsyncMethodCall { ++ private DropConstraintRequest req; ++ public drop_constraint_call(DropConstraintRequest req, 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.req = req; ++ } ++ ++ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { ++ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("drop_constraint", org.apache.thrift.protocol.TMessageType.CALL, 0)); ++ drop_constraint_args args = new drop_constraint_args(); ++ args.setReq(req); ++ args.write(prot); ++ prot.writeMessageEnd(); ++ } ++ ++ public void getResult() throws NoSuchObjectException, MetaException, org.apache.thrift.TException { ++ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { ++ throw new IllegalStateException("Method call not finished!"); ++ } ++ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); ++ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); ++ (new Client(prot)).recv_drop_constraint(); ++ } ++ } ++ + public void drop_table(String dbname, String name, boolean deleteData, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + drop_table_call method_call = new drop_table_call(dbname, name, deleteData, resultHandler, this, ___protocolFactory, ___transport); +@@ -10078,6 +10140,7 @@ protected Processor(I iface, Map extends org.apache.thrift.ProcessFunction { ++ public drop_constraint() { ++ super("drop_constraint"); ++ } ++ ++ public drop_constraint_args getEmptyArgsInstance() { ++ return new drop_constraint_args(); ++ } ++ ++ protected boolean isOneway() { ++ return false; ++ } ++ ++ public drop_constraint_result getResult(I iface, drop_constraint_args args) throws org.apache.thrift.TException { ++ drop_constraint_result result = new drop_constraint_result(); ++ try { ++ iface.drop_constraint(args.req); ++ } catch (NoSuchObjectException o1) { ++ result.o1 = o1; ++ } catch (MetaException o3) { ++ result.o3 = o3; ++ } ++ return result; ++ } ++ } ++ + public static class drop_table extends org.apache.thrift.ProcessFunction { + public drop_table() { + super("drop_table"); +@@ -13964,6 +14053,7 @@ protected AsyncProcessor(I iface, Map extends org.apache.thrift.AsyncProcessFunction { +- public drop_table() { +- super("drop_table"); ++ public static class drop_constraint extends org.apache.thrift.AsyncProcessFunction { ++ public drop_constraint() { ++ super("drop_constraint"); + } + +- public drop_table_args getEmptyArgsInstance() { +- return new drop_table_args(); ++ public drop_constraint_args getEmptyArgsInstance() { ++ return new drop_constraint_args(); + } + + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback() { + public void onComplete(Void o) { +- drop_table_result result = new drop_table_result(); ++ drop_constraint_result result = new drop_constraint_result(); + try { + fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); + return; +@@ -15332,7 +15422,7 @@ public void onComplete(Void o) { + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; +- drop_table_result result = new drop_table_result(); ++ drop_constraint_result result = new drop_constraint_result(); + if (e instanceof NoSuchObjectException) { + result.o1 = (NoSuchObjectException) e; + result.setO1IsSet(true); +@@ -15363,25 +15453,25 @@ protected boolean isOneway() { + return false; + } + +- public void start(I iface, drop_table_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { +- iface.drop_table(args.dbname, args.name, args.deleteData,resultHandler); ++ public void start(I iface, drop_constraint_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { ++ iface.drop_constraint(args.req,resultHandler); + } + } + +- public static class drop_table_with_environment_context extends org.apache.thrift.AsyncProcessFunction { +- public drop_table_with_environment_context() { +- super("drop_table_with_environment_context"); ++ public static class drop_table extends org.apache.thrift.AsyncProcessFunction { ++ public drop_table() { ++ super("drop_table"); + } + +- public drop_table_with_environment_context_args getEmptyArgsInstance() { +- return new drop_table_with_environment_context_args(); ++ public drop_table_args getEmptyArgsInstance() { ++ return new drop_table_args(); + } + + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback() { + public void onComplete(Void o) { +- drop_table_with_environment_context_result result = new drop_table_with_environment_context_result(); ++ drop_table_result result = new drop_table_result(); + try { + fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); + return; +@@ -15393,7 +15483,7 @@ public void onComplete(Void o) { + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; +- drop_table_with_environment_context_result result = new drop_table_with_environment_context_result(); ++ drop_table_result result = new drop_table_result(); + if (e instanceof NoSuchObjectException) { + result.o1 = (NoSuchObjectException) e; + result.setO1IsSet(true); +@@ -15424,259 +15514,25 @@ protected boolean isOneway() { + return false; + } + +- public void start(I iface, drop_table_with_environment_context_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { +- iface.drop_table_with_environment_context(args.dbname, args.name, args.deleteData, args.environment_context,resultHandler); +- } +- } +- +- public static class get_tables extends org.apache.thrift.AsyncProcessFunction> { +- public get_tables() { +- super("get_tables"); +- } +- +- public get_tables_args getEmptyArgsInstance() { +- return new get_tables_args(); +- } +- +- public AsyncMethodCallback> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { +- final org.apache.thrift.AsyncProcessFunction fcall = this; +- return new AsyncMethodCallback>() { +- public void onComplete(List o) { +- get_tables_result result = new get_tables_result(); +- result.success = o; +- try { +- fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); +- return; +- } catch (Exception e) { +- LOGGER.error("Exception writing to internal frame buffer", e); +- } +- fb.close(); +- } +- public void onError(Exception e) { +- byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; +- org.apache.thrift.TBase msg; +- get_tables_result result = new get_tables_result(); +- if (e instanceof MetaException) { +- result.o1 = (MetaException) e; +- result.setO1IsSet(true); +- msg = result; +- } +- else +- { +- msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; +- msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); +- } +- try { +- fcall.sendResponse(fb,msg,msgType,seqid); +- return; +- } catch (Exception ex) { +- LOGGER.error("Exception writing to internal frame buffer", ex); +- } +- fb.close(); +- } +- }; +- } +- +- protected boolean isOneway() { +- return false; +- } +- +- public void start(I iface, get_tables_args args, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws TException { +- iface.get_tables(args.db_name, args.pattern,resultHandler); +- } +- } +- +- public static class get_table_meta extends org.apache.thrift.AsyncProcessFunction> { +- public get_table_meta() { +- super("get_table_meta"); +- } +- +- public get_table_meta_args getEmptyArgsInstance() { +- return new get_table_meta_args(); +- } +- +- public AsyncMethodCallback> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { +- final org.apache.thrift.AsyncProcessFunction fcall = this; +- return new AsyncMethodCallback>() { +- public void onComplete(List o) { +- get_table_meta_result result = new get_table_meta_result(); +- result.success = o; +- try { +- fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); +- return; +- } catch (Exception e) { +- LOGGER.error("Exception writing to internal frame buffer", e); +- } +- fb.close(); +- } +- public void onError(Exception e) { +- byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; +- org.apache.thrift.TBase msg; +- get_table_meta_result result = new get_table_meta_result(); +- if (e instanceof MetaException) { +- result.o1 = (MetaException) e; +- result.setO1IsSet(true); +- msg = result; +- } +- else +- { +- msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; +- msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); +- } +- try { +- fcall.sendResponse(fb,msg,msgType,seqid); +- return; +- } catch (Exception ex) { +- LOGGER.error("Exception writing to internal frame buffer", ex); +- } +- fb.close(); +- } +- }; +- } +- +- protected boolean isOneway() { +- return false; +- } +- +- public void start(I iface, get_table_meta_args args, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws TException { +- iface.get_table_meta(args.db_patterns, args.tbl_patterns, args.tbl_types,resultHandler); +- } +- } +- +- public static class get_all_tables extends org.apache.thrift.AsyncProcessFunction> { +- public get_all_tables() { +- super("get_all_tables"); +- } +- +- public get_all_tables_args getEmptyArgsInstance() { +- return new get_all_tables_args(); +- } +- +- public AsyncMethodCallback> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { +- final org.apache.thrift.AsyncProcessFunction fcall = this; +- return new AsyncMethodCallback>() { +- public void onComplete(List o) { +- get_all_tables_result result = new get_all_tables_result(); +- result.success = o; +- try { +- fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); +- return; +- } catch (Exception e) { +- LOGGER.error("Exception writing to internal frame buffer", e); +- } +- fb.close(); +- } +- public void onError(Exception e) { +- byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; +- org.apache.thrift.TBase msg; +- get_all_tables_result result = new get_all_tables_result(); +- if (e instanceof MetaException) { +- result.o1 = (MetaException) e; +- result.setO1IsSet(true); +- msg = result; +- } +- else +- { +- msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; +- msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); +- } +- try { +- fcall.sendResponse(fb,msg,msgType,seqid); +- return; +- } catch (Exception ex) { +- LOGGER.error("Exception writing to internal frame buffer", ex); +- } +- fb.close(); +- } +- }; +- } +- +- protected boolean isOneway() { +- return false; +- } +- +- public void start(I iface, get_all_tables_args args, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws TException { +- iface.get_all_tables(args.db_name,resultHandler); +- } +- } +- +- public static class get_table extends org.apache.thrift.AsyncProcessFunction { +- public get_table() { +- super("get_table"); +- } +- +- public get_table_args getEmptyArgsInstance() { +- return new get_table_args(); +- } +- +- public AsyncMethodCallback
getResultHandler(final AsyncFrameBuffer fb, final int seqid) { +- final org.apache.thrift.AsyncProcessFunction fcall = this; +- return new AsyncMethodCallback
() { +- public void onComplete(Table o) { +- get_table_result result = new get_table_result(); +- result.success = o; +- try { +- fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); +- return; +- } catch (Exception e) { +- LOGGER.error("Exception writing to internal frame buffer", e); +- } +- fb.close(); +- } +- public void onError(Exception e) { +- byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; +- org.apache.thrift.TBase msg; +- get_table_result result = new get_table_result(); +- if (e instanceof MetaException) { +- result.o1 = (MetaException) e; +- result.setO1IsSet(true); +- msg = result; +- } +- else if (e instanceof NoSuchObjectException) { +- result.o2 = (NoSuchObjectException) e; +- result.setO2IsSet(true); +- msg = result; +- } +- else +- { +- msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; +- msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); +- } +- try { +- fcall.sendResponse(fb,msg,msgType,seqid); +- return; +- } catch (Exception ex) { +- LOGGER.error("Exception writing to internal frame buffer", ex); +- } +- fb.close(); +- } +- }; +- } +- +- protected boolean isOneway() { +- return false; +- } +- +- public void start(I iface, get_table_args args, org.apache.thrift.async.AsyncMethodCallback
resultHandler) throws TException { +- iface.get_table(args.dbname, args.tbl_name,resultHandler); ++ public void start(I iface, drop_table_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { ++ iface.drop_table(args.dbname, args.name, args.deleteData,resultHandler); + } + } + +- public static class get_table_objects_by_name extends org.apache.thrift.AsyncProcessFunction> { +- public get_table_objects_by_name() { +- super("get_table_objects_by_name"); ++ public static class drop_table_with_environment_context extends org.apache.thrift.AsyncProcessFunction { ++ public drop_table_with_environment_context() { ++ super("drop_table_with_environment_context"); + } + +- public get_table_objects_by_name_args getEmptyArgsInstance() { +- return new get_table_objects_by_name_args(); ++ public drop_table_with_environment_context_args getEmptyArgsInstance() { ++ return new drop_table_with_environment_context_args(); + } + +- public AsyncMethodCallback> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { ++ public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; +- return new AsyncMethodCallback>() { +- public void onComplete(List
o) { +- get_table_objects_by_name_result result = new get_table_objects_by_name_result(); +- result.success = o; ++ return new AsyncMethodCallback() { ++ public void onComplete(Void o) { ++ drop_table_with_environment_context_result result = new drop_table_with_environment_context_result(); + try { + fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); + return; +@@ -15688,19 +15544,14 @@ public void onComplete(List
o) { + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; +- get_table_objects_by_name_result result = new get_table_objects_by_name_result(); +- if (e instanceof MetaException) { +- result.o1 = (MetaException) e; ++ drop_table_with_environment_context_result result = new drop_table_with_environment_context_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 UnknownDBException) { +- result.o3 = (UnknownDBException) e; ++ else if (e instanceof MetaException) { ++ result.o3 = (MetaException) e; + result.setO3IsSet(true); + msg = result; + } +@@ -15724,25 +15575,25 @@ protected boolean isOneway() { + return false; + } + +- public void start(I iface, get_table_objects_by_name_args args, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws TException { +- iface.get_table_objects_by_name(args.dbname, args.tbl_names,resultHandler); ++ public void start(I iface, drop_table_with_environment_context_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { ++ iface.drop_table_with_environment_context(args.dbname, args.name, args.deleteData, args.environment_context,resultHandler); + } + } + +- public static class get_table_names_by_filter extends org.apache.thrift.AsyncProcessFunction> { +- public get_table_names_by_filter() { +- super("get_table_names_by_filter"); ++ public static class get_tables extends org.apache.thrift.AsyncProcessFunction> { ++ public get_tables() { ++ super("get_tables"); + } + +- public get_table_names_by_filter_args getEmptyArgsInstance() { +- return new get_table_names_by_filter_args(); ++ public get_tables_args getEmptyArgsInstance() { ++ return new get_tables_args(); + } + + public AsyncMethodCallback> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback>() { + public void onComplete(List o) { +- get_table_names_by_filter_result result = new get_table_names_by_filter_result(); ++ get_tables_result result = new get_tables_result(); + result.success = o; + try { + fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); +@@ -15755,22 +15606,12 @@ public void onComplete(List o) { + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; +- get_table_names_by_filter_result result = new get_table_names_by_filter_result(); ++ get_tables_result result = new get_tables_result(); + if (e instanceof MetaException) { + result.o1 = (MetaException) e; + result.setO1IsSet(true); + msg = result; + } +- else if (e instanceof InvalidOperationException) { +- result.o2 = (InvalidOperationException) e; +- result.setO2IsSet(true); +- msg = result; +- } +- else if (e instanceof UnknownDBException) { +- result.o3 = (UnknownDBException) e; +- result.setO3IsSet(true); +- msg = result; +- } + else + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; +@@ -15791,25 +15632,26 @@ protected boolean isOneway() { + return false; + } + +- public void start(I iface, get_table_names_by_filter_args args, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws TException { +- iface.get_table_names_by_filter(args.dbname, args.filter, args.max_tables,resultHandler); ++ public void start(I iface, get_tables_args args, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws TException { ++ iface.get_tables(args.db_name, args.pattern,resultHandler); + } + } + +- public static class alter_table extends org.apache.thrift.AsyncProcessFunction { +- public alter_table() { +- super("alter_table"); ++ public static class get_table_meta extends org.apache.thrift.AsyncProcessFunction> { ++ public get_table_meta() { ++ super("get_table_meta"); + } + +- public alter_table_args getEmptyArgsInstance() { +- return new alter_table_args(); ++ public get_table_meta_args getEmptyArgsInstance() { ++ return new get_table_meta_args(); + } + +- public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { ++ public AsyncMethodCallback> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; +- return new AsyncMethodCallback() { +- public void onComplete(Void o) { +- alter_table_result result = new alter_table_result(); ++ return new AsyncMethodCallback>() { ++ public void onComplete(List o) { ++ get_table_meta_result result = new get_table_meta_result(); ++ result.success = o; + try { + fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); + return; +@@ -15821,17 +15663,12 @@ public void onComplete(Void o) { + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; +- alter_table_result result = new alter_table_result(); +- if (e instanceof InvalidOperationException) { +- result.o1 = (InvalidOperationException) e; ++ get_table_meta_result result = new get_table_meta_result(); ++ if (e instanceof MetaException) { ++ result.o1 = (MetaException) e; + result.setO1IsSet(true); + msg = result; + } +- else if (e instanceof MetaException) { +- result.o2 = (MetaException) e; +- result.setO2IsSet(true); +- msg = result; +- } + else + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; +@@ -15852,25 +15689,26 @@ protected boolean isOneway() { + return false; + } + +- public void start(I iface, alter_table_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { +- iface.alter_table(args.dbname, args.tbl_name, args.new_tbl,resultHandler); ++ public void start(I iface, get_table_meta_args args, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws TException { ++ iface.get_table_meta(args.db_patterns, args.tbl_patterns, args.tbl_types,resultHandler); + } + } + +- public static class alter_table_with_environment_context extends org.apache.thrift.AsyncProcessFunction { +- public alter_table_with_environment_context() { +- super("alter_table_with_environment_context"); ++ public static class get_all_tables extends org.apache.thrift.AsyncProcessFunction> { ++ public get_all_tables() { ++ super("get_all_tables"); + } + +- public alter_table_with_environment_context_args getEmptyArgsInstance() { +- return new alter_table_with_environment_context_args(); ++ public get_all_tables_args getEmptyArgsInstance() { ++ return new get_all_tables_args(); + } + +- public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { ++ public AsyncMethodCallback> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; +- return new AsyncMethodCallback() { +- public void onComplete(Void o) { +- alter_table_with_environment_context_result result = new alter_table_with_environment_context_result(); ++ return new AsyncMethodCallback>() { ++ public void onComplete(List o) { ++ get_all_tables_result result = new get_all_tables_result(); ++ result.success = o; + try { + fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); + return; +@@ -15882,17 +15720,12 @@ public void onComplete(Void o) { + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; +- alter_table_with_environment_context_result result = new alter_table_with_environment_context_result(); +- if (e instanceof InvalidOperationException) { +- result.o1 = (InvalidOperationException) e; ++ get_all_tables_result result = new get_all_tables_result(); ++ if (e instanceof MetaException) { ++ result.o1 = (MetaException) e; + result.setO1IsSet(true); + msg = result; + } +- else if (e instanceof MetaException) { +- result.o2 = (MetaException) e; +- result.setO2IsSet(true); +- msg = result; +- } + else + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; +@@ -15913,25 +15746,26 @@ protected boolean isOneway() { + return false; + } + +- public void start(I iface, alter_table_with_environment_context_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { +- iface.alter_table_with_environment_context(args.dbname, args.tbl_name, args.new_tbl, args.environment_context,resultHandler); ++ public void start(I iface, get_all_tables_args args, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws TException { ++ iface.get_all_tables(args.db_name,resultHandler); + } + } + +- public static class alter_table_with_cascade extends org.apache.thrift.AsyncProcessFunction { +- public alter_table_with_cascade() { +- super("alter_table_with_cascade"); ++ public static class get_table extends org.apache.thrift.AsyncProcessFunction { ++ public get_table() { ++ super("get_table"); + } + +- public alter_table_with_cascade_args getEmptyArgsInstance() { +- return new alter_table_with_cascade_args(); ++ public get_table_args getEmptyArgsInstance() { ++ return new get_table_args(); + } + +- public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { ++ public AsyncMethodCallback
getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; +- return new AsyncMethodCallback() { +- public void onComplete(Void o) { +- alter_table_with_cascade_result result = new alter_table_with_cascade_result(); ++ return new AsyncMethodCallback
() { ++ public void onComplete(Table o) { ++ get_table_result result = new get_table_result(); ++ result.success = o; + try { + fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); + return; +@@ -15943,14 +15777,14 @@ public void onComplete(Void o) { + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; +- alter_table_with_cascade_result result = new alter_table_with_cascade_result(); +- if (e instanceof InvalidOperationException) { +- result.o1 = (InvalidOperationException) e; ++ get_table_result result = new get_table_result(); ++ if (e instanceof MetaException) { ++ result.o1 = (MetaException) e; + result.setO1IsSet(true); + msg = result; + } +- else if (e instanceof MetaException) { +- result.o2 = (MetaException) e; ++ else if (e instanceof NoSuchObjectException) { ++ result.o2 = (NoSuchObjectException) e; + result.setO2IsSet(true); + msg = result; + } +@@ -15974,25 +15808,25 @@ protected boolean isOneway() { + return false; + } + +- public void start(I iface, alter_table_with_cascade_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { +- iface.alter_table_with_cascade(args.dbname, args.tbl_name, args.new_tbl, args.cascade,resultHandler); ++ public void start(I iface, get_table_args args, org.apache.thrift.async.AsyncMethodCallback
resultHandler) throws TException { ++ iface.get_table(args.dbname, args.tbl_name,resultHandler); + } + } + +- public static class add_partition extends org.apache.thrift.AsyncProcessFunction { +- public add_partition() { +- super("add_partition"); ++ public static class get_table_objects_by_name extends org.apache.thrift.AsyncProcessFunction> { ++ public get_table_objects_by_name() { ++ super("get_table_objects_by_name"); + } + +- public add_partition_args getEmptyArgsInstance() { +- return new add_partition_args(); ++ public get_table_objects_by_name_args getEmptyArgsInstance() { ++ return new get_table_objects_by_name_args(); + } + +- public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { ++ public AsyncMethodCallback> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; +- return new AsyncMethodCallback() { +- public void onComplete(Partition o) { +- add_partition_result result = new add_partition_result(); ++ return new AsyncMethodCallback>() { ++ public void onComplete(List
o) { ++ get_table_objects_by_name_result result = new get_table_objects_by_name_result(); + result.success = o; + try { + fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); +@@ -16005,19 +15839,19 @@ public void onComplete(Partition o) { + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; +- add_partition_result result = new add_partition_result(); +- if (e instanceof InvalidObjectException) { +- result.o1 = (InvalidObjectException) e; ++ get_table_objects_by_name_result result = new get_table_objects_by_name_result(); ++ if (e instanceof MetaException) { ++ result.o1 = (MetaException) e; + result.setO1IsSet(true); + msg = result; + } +- else if (e instanceof AlreadyExistsException) { +- result.o2 = (AlreadyExistsException) e; ++ else if (e instanceof InvalidOperationException) { ++ result.o2 = (InvalidOperationException) e; + result.setO2IsSet(true); + msg = result; + } +- else if (e instanceof MetaException) { +- result.o3 = (MetaException) e; ++ else if (e instanceof UnknownDBException) { ++ result.o3 = (UnknownDBException) e; + result.setO3IsSet(true); + msg = result; + } +@@ -16041,25 +15875,25 @@ protected boolean isOneway() { + return false; + } + +- public void start(I iface, add_partition_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { +- iface.add_partition(args.new_part,resultHandler); ++ public void start(I iface, get_table_objects_by_name_args args, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws TException { ++ iface.get_table_objects_by_name(args.dbname, args.tbl_names,resultHandler); + } + } + +- public static class add_partition_with_environment_context extends org.apache.thrift.AsyncProcessFunction { +- public add_partition_with_environment_context() { +- super("add_partition_with_environment_context"); ++ public static class get_table_names_by_filter extends org.apache.thrift.AsyncProcessFunction> { ++ public get_table_names_by_filter() { ++ super("get_table_names_by_filter"); + } + +- public add_partition_with_environment_context_args getEmptyArgsInstance() { +- return new add_partition_with_environment_context_args(); ++ public get_table_names_by_filter_args getEmptyArgsInstance() { ++ return new get_table_names_by_filter_args(); + } + +- public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { ++ public AsyncMethodCallback> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; +- return new AsyncMethodCallback() { +- public void onComplete(Partition o) { +- add_partition_with_environment_context_result result = new add_partition_with_environment_context_result(); ++ return new AsyncMethodCallback>() { ++ public void onComplete(List o) { ++ get_table_names_by_filter_result result = new get_table_names_by_filter_result(); + result.success = o; + try { + fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); +@@ -16072,19 +15906,19 @@ public void onComplete(Partition o) { + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; +- add_partition_with_environment_context_result result = new add_partition_with_environment_context_result(); +- if (e instanceof InvalidObjectException) { +- result.o1 = (InvalidObjectException) e; ++ get_table_names_by_filter_result result = new get_table_names_by_filter_result(); ++ if (e instanceof MetaException) { ++ result.o1 = (MetaException) e; + result.setO1IsSet(true); + msg = result; + } +- else if (e instanceof AlreadyExistsException) { +- result.o2 = (AlreadyExistsException) e; ++ else if (e instanceof InvalidOperationException) { ++ result.o2 = (InvalidOperationException) e; + result.setO2IsSet(true); + msg = result; + } +- else if (e instanceof MetaException) { +- result.o3 = (MetaException) e; ++ else if (e instanceof UnknownDBException) { ++ result.o3 = (UnknownDBException) e; + result.setO3IsSet(true); + msg = result; + } +@@ -16108,27 +15942,25 @@ protected boolean isOneway() { + return false; + } + +- public void start(I iface, add_partition_with_environment_context_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { +- iface.add_partition_with_environment_context(args.new_part, args.environment_context,resultHandler); ++ public void start(I iface, get_table_names_by_filter_args args, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws TException { ++ iface.get_table_names_by_filter(args.dbname, args.filter, args.max_tables,resultHandler); + } + } + +- public static class add_partitions extends org.apache.thrift.AsyncProcessFunction { +- public add_partitions() { +- super("add_partitions"); ++ public static class alter_table extends org.apache.thrift.AsyncProcessFunction { ++ public alter_table() { ++ super("alter_table"); + } + +- public add_partitions_args getEmptyArgsInstance() { +- return new add_partitions_args(); ++ public alter_table_args getEmptyArgsInstance() { ++ return new alter_table_args(); + } + +- public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { ++ public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; +- return new AsyncMethodCallback() { +- public void onComplete(Integer o) { +- add_partitions_result result = new add_partitions_result(); +- result.success = o; +- result.setSuccessIsSet(true); ++ return new AsyncMethodCallback() { ++ public void onComplete(Void o) { ++ alter_table_result result = new alter_table_result(); + try { + fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); + return; +@@ -16140,20 +15972,15 @@ public void onComplete(Integer o) { + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; +- add_partitions_result result = new add_partitions_result(); +- if (e instanceof InvalidObjectException) { +- result.o1 = (InvalidObjectException) e; ++ alter_table_result result = new alter_table_result(); ++ if (e instanceof InvalidOperationException) { ++ result.o1 = (InvalidOperationException) e; + result.setO1IsSet(true); + msg = result; + } +- else if (e instanceof AlreadyExistsException) { +- result.o2 = (AlreadyExistsException) e; +- result.setO2IsSet(true); +- msg = result; +- } + else if (e instanceof MetaException) { +- result.o3 = (MetaException) e; +- result.setO3IsSet(true); ++ result.o2 = (MetaException) e; ++ result.setO2IsSet(true); + msg = result; + } + else +@@ -16176,27 +16003,25 @@ protected boolean isOneway() { + return false; + } + +- public void start(I iface, add_partitions_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { +- iface.add_partitions(args.new_parts,resultHandler); ++ public void start(I iface, alter_table_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { ++ iface.alter_table(args.dbname, args.tbl_name, args.new_tbl,resultHandler); + } + } + +- public static class add_partitions_pspec extends org.apache.thrift.AsyncProcessFunction { +- public add_partitions_pspec() { +- super("add_partitions_pspec"); ++ public static class alter_table_with_environment_context extends org.apache.thrift.AsyncProcessFunction { ++ public alter_table_with_environment_context() { ++ super("alter_table_with_environment_context"); + } + +- public add_partitions_pspec_args getEmptyArgsInstance() { +- return new add_partitions_pspec_args(); ++ public alter_table_with_environment_context_args getEmptyArgsInstance() { ++ return new alter_table_with_environment_context_args(); + } + +- public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { ++ public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; +- return new AsyncMethodCallback() { +- public void onComplete(Integer o) { +- add_partitions_pspec_result result = new add_partitions_pspec_result(); +- result.success = o; +- result.setSuccessIsSet(true); ++ return new AsyncMethodCallback() { ++ public void onComplete(Void o) { ++ alter_table_with_environment_context_result result = new alter_table_with_environment_context_result(); + try { + fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); + return; +@@ -16208,20 +16033,15 @@ public void onComplete(Integer o) { + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; +- add_partitions_pspec_result result = new add_partitions_pspec_result(); +- if (e instanceof InvalidObjectException) { +- result.o1 = (InvalidObjectException) e; ++ alter_table_with_environment_context_result result = new alter_table_with_environment_context_result(); ++ if (e instanceof InvalidOperationException) { ++ result.o1 = (InvalidOperationException) e; + result.setO1IsSet(true); + msg = result; + } +- else if (e instanceof AlreadyExistsException) { +- result.o2 = (AlreadyExistsException) e; +- result.setO2IsSet(true); +- msg = result; +- } + else if (e instanceof MetaException) { +- result.o3 = (MetaException) e; +- result.setO3IsSet(true); ++ result.o2 = (MetaException) e; ++ result.setO2IsSet(true); + msg = result; + } + else +@@ -16244,26 +16064,25 @@ protected boolean isOneway() { + return false; + } + +- public void start(I iface, add_partitions_pspec_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { +- iface.add_partitions_pspec(args.new_parts,resultHandler); ++ public void start(I iface, alter_table_with_environment_context_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { ++ iface.alter_table_with_environment_context(args.dbname, args.tbl_name, args.new_tbl, args.environment_context,resultHandler); + } + } + +- public static class append_partition extends org.apache.thrift.AsyncProcessFunction { +- public append_partition() { +- super("append_partition"); ++ public static class alter_table_with_cascade extends org.apache.thrift.AsyncProcessFunction { ++ public alter_table_with_cascade() { ++ super("alter_table_with_cascade"); + } + +- public append_partition_args getEmptyArgsInstance() { +- return new append_partition_args(); ++ public alter_table_with_cascade_args getEmptyArgsInstance() { ++ return new alter_table_with_cascade_args(); + } + +- public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { ++ public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; +- return new AsyncMethodCallback() { +- public void onComplete(Partition o) { +- append_partition_result result = new append_partition_result(); +- result.success = o; ++ return new AsyncMethodCallback() { ++ public void onComplete(Void o) { ++ alter_table_with_cascade_result result = new alter_table_with_cascade_result(); + try { + fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); + return; +@@ -16275,20 +16094,15 @@ public void onComplete(Partition o) { + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; +- append_partition_result result = new append_partition_result(); +- if (e instanceof InvalidObjectException) { +- result.o1 = (InvalidObjectException) e; ++ alter_table_with_cascade_result result = new alter_table_with_cascade_result(); ++ if (e instanceof InvalidOperationException) { ++ result.o1 = (InvalidOperationException) e; + result.setO1IsSet(true); + msg = result; + } +- else if (e instanceof AlreadyExistsException) { +- result.o2 = (AlreadyExistsException) e; +- result.setO2IsSet(true); +- msg = result; +- } + else if (e instanceof MetaException) { +- result.o3 = (MetaException) e; +- result.setO3IsSet(true); ++ result.o2 = (MetaException) e; ++ result.setO2IsSet(true); + msg = result; + } + else +@@ -16311,25 +16125,25 @@ protected boolean isOneway() { + return false; + } + +- public void start(I iface, append_partition_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { +- iface.append_partition(args.db_name, args.tbl_name, args.part_vals,resultHandler); ++ public void start(I iface, alter_table_with_cascade_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { ++ iface.alter_table_with_cascade(args.dbname, args.tbl_name, args.new_tbl, args.cascade,resultHandler); + } + } + +- public static class add_partitions_req extends org.apache.thrift.AsyncProcessFunction { +- public add_partitions_req() { +- super("add_partitions_req"); ++ public static class add_partition extends org.apache.thrift.AsyncProcessFunction { ++ public add_partition() { ++ super("add_partition"); + } + +- public add_partitions_req_args getEmptyArgsInstance() { +- return new add_partitions_req_args(); ++ public add_partition_args getEmptyArgsInstance() { ++ return new add_partition_args(); + } + +- public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { ++ public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; +- return new AsyncMethodCallback() { +- public void onComplete(AddPartitionsResult o) { +- add_partitions_req_result result = new add_partitions_req_result(); ++ return new AsyncMethodCallback() { ++ public void onComplete(Partition o) { ++ add_partition_result result = new add_partition_result(); + result.success = o; + try { + fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); +@@ -16342,7 +16156,7 @@ public void onComplete(AddPartitionsResult o) { + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; +- add_partitions_req_result result = new add_partitions_req_result(); ++ add_partition_result result = new add_partition_result(); + if (e instanceof InvalidObjectException) { + result.o1 = (InvalidObjectException) e; + result.setO1IsSet(true); +@@ -16378,25 +16192,25 @@ protected boolean isOneway() { + return false; + } + +- public void start(I iface, add_partitions_req_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { +- iface.add_partitions_req(args.request,resultHandler); ++ public void start(I iface, add_partition_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { ++ iface.add_partition(args.new_part,resultHandler); + } + } + +- public static class append_partition_with_environment_context extends org.apache.thrift.AsyncProcessFunction { +- public append_partition_with_environment_context() { +- super("append_partition_with_environment_context"); ++ public static class add_partition_with_environment_context extends org.apache.thrift.AsyncProcessFunction { ++ public add_partition_with_environment_context() { ++ super("add_partition_with_environment_context"); + } + +- public append_partition_with_environment_context_args getEmptyArgsInstance() { +- return new append_partition_with_environment_context_args(); ++ public add_partition_with_environment_context_args getEmptyArgsInstance() { ++ return new add_partition_with_environment_context_args(); + } + + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback() { + public void onComplete(Partition o) { +- append_partition_with_environment_context_result result = new append_partition_with_environment_context_result(); ++ add_partition_with_environment_context_result result = new add_partition_with_environment_context_result(); + result.success = o; + try { + fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); +@@ -16409,7 +16223,7 @@ public void onComplete(Partition o) { + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; +- append_partition_with_environment_context_result result = new append_partition_with_environment_context_result(); ++ add_partition_with_environment_context_result result = new add_partition_with_environment_context_result(); + if (e instanceof InvalidObjectException) { + result.o1 = (InvalidObjectException) e; + result.setO1IsSet(true); +@@ -16445,26 +16259,27 @@ protected boolean isOneway() { + return false; + } + +- public void start(I iface, append_partition_with_environment_context_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { +- iface.append_partition_with_environment_context(args.db_name, args.tbl_name, args.part_vals, args.environment_context,resultHandler); ++ public void start(I iface, add_partition_with_environment_context_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { ++ iface.add_partition_with_environment_context(args.new_part, args.environment_context,resultHandler); + } + } + +- public static class append_partition_by_name extends org.apache.thrift.AsyncProcessFunction { +- public append_partition_by_name() { +- super("append_partition_by_name"); ++ public static class add_partitions extends org.apache.thrift.AsyncProcessFunction { ++ public add_partitions() { ++ super("add_partitions"); + } + +- public append_partition_by_name_args getEmptyArgsInstance() { +- return new append_partition_by_name_args(); ++ public add_partitions_args getEmptyArgsInstance() { ++ return new add_partitions_args(); + } + +- public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { ++ public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; +- return new AsyncMethodCallback() { +- public void onComplete(Partition o) { +- append_partition_by_name_result result = new append_partition_by_name_result(); ++ return new AsyncMethodCallback() { ++ public void onComplete(Integer o) { ++ add_partitions_result result = new add_partitions_result(); + result.success = o; ++ result.setSuccessIsSet(true); + try { + fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); + return; +@@ -16476,7 +16291,7 @@ public void onComplete(Partition o) { + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; +- append_partition_by_name_result result = new append_partition_by_name_result(); ++ add_partitions_result result = new add_partitions_result(); + if (e instanceof InvalidObjectException) { + result.o1 = (InvalidObjectException) e; + result.setO1IsSet(true); +@@ -16512,26 +16327,27 @@ protected boolean isOneway() { + return false; + } + +- public void start(I iface, append_partition_by_name_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { +- iface.append_partition_by_name(args.db_name, args.tbl_name, args.part_name,resultHandler); ++ public void start(I iface, add_partitions_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { ++ iface.add_partitions(args.new_parts,resultHandler); + } + } + +- public static class append_partition_by_name_with_environment_context extends org.apache.thrift.AsyncProcessFunction { +- public append_partition_by_name_with_environment_context() { +- super("append_partition_by_name_with_environment_context"); ++ public static class add_partitions_pspec extends org.apache.thrift.AsyncProcessFunction { ++ public add_partitions_pspec() { ++ super("add_partitions_pspec"); + } + +- public append_partition_by_name_with_environment_context_args getEmptyArgsInstance() { +- return new append_partition_by_name_with_environment_context_args(); ++ public add_partitions_pspec_args getEmptyArgsInstance() { ++ return new add_partitions_pspec_args(); + } + +- public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { ++ public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; +- return new AsyncMethodCallback() { +- public void onComplete(Partition o) { +- append_partition_by_name_with_environment_context_result result = new append_partition_by_name_with_environment_context_result(); ++ return new AsyncMethodCallback() { ++ public void onComplete(Integer o) { ++ add_partitions_pspec_result result = new add_partitions_pspec_result(); + result.success = o; ++ result.setSuccessIsSet(true); + try { + fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); + return; +@@ -16543,7 +16359,342 @@ public void onComplete(Partition o) { + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; +- append_partition_by_name_with_environment_context_result result = new append_partition_by_name_with_environment_context_result(); ++ add_partitions_pspec_result result = new add_partitions_pspec_result(); ++ if (e instanceof InvalidObjectException) { ++ result.o1 = (InvalidObjectException) e; ++ result.setO1IsSet(true); ++ msg = result; ++ } ++ else if (e instanceof AlreadyExistsException) { ++ result.o2 = (AlreadyExistsException) 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, add_partitions_pspec_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { ++ iface.add_partitions_pspec(args.new_parts,resultHandler); ++ } ++ } ++ ++ public static class append_partition extends org.apache.thrift.AsyncProcessFunction { ++ public append_partition() { ++ super("append_partition"); ++ } ++ ++ public append_partition_args getEmptyArgsInstance() { ++ return new append_partition_args(); ++ } ++ ++ public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { ++ final org.apache.thrift.AsyncProcessFunction fcall = this; ++ return new AsyncMethodCallback() { ++ public void onComplete(Partition o) { ++ append_partition_result result = new append_partition_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; ++ append_partition_result result = new append_partition_result(); ++ if (e instanceof InvalidObjectException) { ++ result.o1 = (InvalidObjectException) e; ++ result.setO1IsSet(true); ++ msg = result; ++ } ++ else if (e instanceof AlreadyExistsException) { ++ result.o2 = (AlreadyExistsException) 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, append_partition_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { ++ iface.append_partition(args.db_name, args.tbl_name, args.part_vals,resultHandler); ++ } ++ } ++ ++ public static class add_partitions_req extends org.apache.thrift.AsyncProcessFunction { ++ public add_partitions_req() { ++ super("add_partitions_req"); ++ } ++ ++ public add_partitions_req_args getEmptyArgsInstance() { ++ return new add_partitions_req_args(); ++ } ++ ++ public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { ++ final org.apache.thrift.AsyncProcessFunction fcall = this; ++ return new AsyncMethodCallback() { ++ public void onComplete(AddPartitionsResult o) { ++ add_partitions_req_result result = new add_partitions_req_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; ++ add_partitions_req_result result = new add_partitions_req_result(); ++ if (e instanceof InvalidObjectException) { ++ result.o1 = (InvalidObjectException) e; ++ result.setO1IsSet(true); ++ msg = result; ++ } ++ else if (e instanceof AlreadyExistsException) { ++ result.o2 = (AlreadyExistsException) 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, add_partitions_req_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { ++ iface.add_partitions_req(args.request,resultHandler); ++ } ++ } ++ ++ public static class append_partition_with_environment_context extends org.apache.thrift.AsyncProcessFunction { ++ public append_partition_with_environment_context() { ++ super("append_partition_with_environment_context"); ++ } ++ ++ public append_partition_with_environment_context_args getEmptyArgsInstance() { ++ return new append_partition_with_environment_context_args(); ++ } ++ ++ public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { ++ final org.apache.thrift.AsyncProcessFunction fcall = this; ++ return new AsyncMethodCallback() { ++ public void onComplete(Partition o) { ++ append_partition_with_environment_context_result result = new append_partition_with_environment_context_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; ++ append_partition_with_environment_context_result result = new append_partition_with_environment_context_result(); ++ if (e instanceof InvalidObjectException) { ++ result.o1 = (InvalidObjectException) e; ++ result.setO1IsSet(true); ++ msg = result; ++ } ++ else if (e instanceof AlreadyExistsException) { ++ result.o2 = (AlreadyExistsException) 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, append_partition_with_environment_context_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { ++ iface.append_partition_with_environment_context(args.db_name, args.tbl_name, args.part_vals, args.environment_context,resultHandler); ++ } ++ } ++ ++ public static class append_partition_by_name extends org.apache.thrift.AsyncProcessFunction { ++ public append_partition_by_name() { ++ super("append_partition_by_name"); ++ } ++ ++ public append_partition_by_name_args getEmptyArgsInstance() { ++ return new append_partition_by_name_args(); ++ } ++ ++ public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { ++ final org.apache.thrift.AsyncProcessFunction fcall = this; ++ return new AsyncMethodCallback() { ++ public void onComplete(Partition o) { ++ append_partition_by_name_result result = new append_partition_by_name_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; ++ append_partition_by_name_result result = new append_partition_by_name_result(); ++ if (e instanceof InvalidObjectException) { ++ result.o1 = (InvalidObjectException) e; ++ result.setO1IsSet(true); ++ msg = result; ++ } ++ else if (e instanceof AlreadyExistsException) { ++ result.o2 = (AlreadyExistsException) 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, append_partition_by_name_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { ++ iface.append_partition_by_name(args.db_name, args.tbl_name, args.part_name,resultHandler); ++ } ++ } ++ ++ public static class append_partition_by_name_with_environment_context extends org.apache.thrift.AsyncProcessFunction { ++ public append_partition_by_name_with_environment_context() { ++ super("append_partition_by_name_with_environment_context"); ++ } ++ ++ public append_partition_by_name_with_environment_context_args getEmptyArgsInstance() { ++ return new append_partition_by_name_with_environment_context_args(); ++ } ++ ++ public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { ++ final org.apache.thrift.AsyncProcessFunction fcall = this; ++ return new AsyncMethodCallback() { ++ public void onComplete(Partition o) { ++ append_partition_by_name_with_environment_context_result result = new append_partition_by_name_with_environment_context_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; ++ append_partition_by_name_with_environment_context_result result = new append_partition_by_name_with_environment_context_result(); + if (e instanceof InvalidObjectException) { + result.o1 = (InvalidObjectException) e; + result.setO1IsSet(true); +@@ -42513,6 +42664,835 @@ public void read(org.apache.thrift.protocol.TProtocol prot, create_table_with_co + + } + ++ public static class drop_constraint_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_constraint_args"); ++ ++ private static final org.apache.thrift.protocol.TField REQ_FIELD_DESC = new org.apache.thrift.protocol.TField("req", org.apache.thrift.protocol.TType.STRUCT, (short)1); ++ ++ private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); ++ static { ++ schemes.put(StandardScheme.class, new drop_constraint_argsStandardSchemeFactory()); ++ schemes.put(TupleScheme.class, new drop_constraint_argsTupleSchemeFactory()); ++ } ++ ++ private DropConstraintRequest req; // 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 { ++ REQ((short)1, "req"); ++ ++ 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: // REQ ++ return REQ; ++ 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.REQ, new org.apache.thrift.meta_data.FieldMetaData("req", org.apache.thrift.TFieldRequirementType.DEFAULT, ++ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, DropConstraintRequest.class))); ++ metaDataMap = Collections.unmodifiableMap(tmpMap); ++ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(drop_constraint_args.class, metaDataMap); ++ } ++ ++ public drop_constraint_args() { ++ } ++ ++ public drop_constraint_args( ++ DropConstraintRequest req) ++ { ++ this(); ++ this.req = req; ++ } ++ ++ /** ++ * Performs a deep copy on other. ++ */ ++ public drop_constraint_args(drop_constraint_args other) { ++ if (other.isSetReq()) { ++ this.req = new DropConstraintRequest(other.req); ++ } ++ } ++ ++ public drop_constraint_args deepCopy() { ++ return new drop_constraint_args(this); ++ } ++ ++ @Override ++ public void clear() { ++ this.req = null; ++ } ++ ++ public DropConstraintRequest getReq() { ++ return this.req; ++ } ++ ++ public void setReq(DropConstraintRequest req) { ++ this.req = req; ++ } ++ ++ public void unsetReq() { ++ this.req = null; ++ } ++ ++ /** Returns true if field req is set (has been assigned a value) and false otherwise */ ++ public boolean isSetReq() { ++ return this.req != null; ++ } ++ ++ public void setReqIsSet(boolean value) { ++ if (!value) { ++ this.req = null; ++ } ++ } ++ ++ public void setFieldValue(_Fields field, Object value) { ++ switch (field) { ++ case REQ: ++ if (value == null) { ++ unsetReq(); ++ } else { ++ setReq((DropConstraintRequest)value); ++ } ++ break; ++ ++ } ++ } ++ ++ public Object getFieldValue(_Fields field) { ++ switch (field) { ++ case REQ: ++ return getReq(); ++ ++ } ++ 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 REQ: ++ return isSetReq(); ++ } ++ throw new IllegalStateException(); ++ } ++ ++ @Override ++ public boolean equals(Object that) { ++ if (that == null) ++ return false; ++ if (that instanceof drop_constraint_args) ++ return this.equals((drop_constraint_args)that); ++ return false; ++ } ++ ++ public boolean equals(drop_constraint_args that) { ++ if (that == null) ++ return false; ++ ++ boolean this_present_req = true && this.isSetReq(); ++ boolean that_present_req = true && that.isSetReq(); ++ if (this_present_req || that_present_req) { ++ if (!(this_present_req && that_present_req)) ++ return false; ++ if (!this.req.equals(that.req)) ++ return false; ++ } ++ ++ return true; ++ } ++ ++ @Override ++ public int hashCode() { ++ List list = new ArrayList(); ++ ++ boolean present_req = true && (isSetReq()); ++ list.add(present_req); ++ if (present_req) ++ list.add(req); ++ ++ return list.hashCode(); ++ } ++ ++ @Override ++ public int compareTo(drop_constraint_args other) { ++ if (!getClass().equals(other.getClass())) { ++ return getClass().getName().compareTo(other.getClass().getName()); ++ } ++ ++ int lastComparison = 0; ++ ++ lastComparison = Boolean.valueOf(isSetReq()).compareTo(other.isSetReq()); ++ if (lastComparison != 0) { ++ return lastComparison; ++ } ++ if (isSetReq()) { ++ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.req, other.req); ++ 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("drop_constraint_args("); ++ boolean first = true; ++ ++ sb.append("req:"); ++ if (this.req == null) { ++ sb.append("null"); ++ } else { ++ sb.append(this.req); ++ } ++ 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 (req != null) { ++ req.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 drop_constraint_argsStandardSchemeFactory implements SchemeFactory { ++ public drop_constraint_argsStandardScheme getScheme() { ++ return new drop_constraint_argsStandardScheme(); ++ } ++ } ++ ++ private static class drop_constraint_argsStandardScheme extends StandardScheme { ++ ++ public void read(org.apache.thrift.protocol.TProtocol iprot, drop_constraint_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: // REQ ++ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { ++ struct.req = new DropConstraintRequest(); ++ struct.req.read(iprot); ++ struct.setReqIsSet(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, drop_constraint_args struct) throws org.apache.thrift.TException { ++ struct.validate(); ++ ++ oprot.writeStructBegin(STRUCT_DESC); ++ if (struct.req != null) { ++ oprot.writeFieldBegin(REQ_FIELD_DESC); ++ struct.req.write(oprot); ++ oprot.writeFieldEnd(); ++ } ++ oprot.writeFieldStop(); ++ oprot.writeStructEnd(); ++ } ++ ++ } ++ ++ private static class drop_constraint_argsTupleSchemeFactory implements SchemeFactory { ++ public drop_constraint_argsTupleScheme getScheme() { ++ return new drop_constraint_argsTupleScheme(); ++ } ++ } ++ ++ private static class drop_constraint_argsTupleScheme extends TupleScheme { ++ ++ @Override ++ public void write(org.apache.thrift.protocol.TProtocol prot, drop_constraint_args struct) throws org.apache.thrift.TException { ++ TTupleProtocol oprot = (TTupleProtocol) prot; ++ BitSet optionals = new BitSet(); ++ if (struct.isSetReq()) { ++ optionals.set(0); ++ } ++ oprot.writeBitSet(optionals, 1); ++ if (struct.isSetReq()) { ++ struct.req.write(oprot); ++ } ++ } ++ ++ @Override ++ public void read(org.apache.thrift.protocol.TProtocol prot, drop_constraint_args struct) throws org.apache.thrift.TException { ++ TTupleProtocol iprot = (TTupleProtocol) prot; ++ BitSet incoming = iprot.readBitSet(1); ++ if (incoming.get(0)) { ++ struct.req = new DropConstraintRequest(); ++ struct.req.read(iprot); ++ struct.setReqIsSet(true); ++ } ++ } ++ } ++ ++ } ++ ++ public static class drop_constraint_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_constraint_result"); ++ ++ 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 O3_FIELD_DESC = new org.apache.thrift.protocol.TField("o3", org.apache.thrift.protocol.TType.STRUCT, (short)2); ++ ++ private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); ++ static { ++ schemes.put(StandardScheme.class, new drop_constraint_resultStandardSchemeFactory()); ++ schemes.put(TupleScheme.class, new drop_constraint_resultTupleSchemeFactory()); ++ } ++ ++ private NoSuchObjectException o1; // 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 { ++ O1((short)1, "o1"), ++ O3((short)2, "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 1: // O1 ++ return O1; ++ case 2: // 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.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.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_constraint_result.class, metaDataMap); ++ } ++ ++ public drop_constraint_result() { ++ } ++ ++ public drop_constraint_result( ++ NoSuchObjectException o1, ++ MetaException o3) ++ { ++ this(); ++ this.o1 = o1; ++ this.o3 = o3; ++ } ++ ++ /** ++ * Performs a deep copy on other. ++ */ ++ public drop_constraint_result(drop_constraint_result other) { ++ if (other.isSetO1()) { ++ this.o1 = new NoSuchObjectException(other.o1); ++ } ++ if (other.isSetO3()) { ++ this.o3 = new MetaException(other.o3); ++ } ++ } ++ ++ public drop_constraint_result deepCopy() { ++ return new drop_constraint_result(this); ++ } ++ ++ @Override ++ public void clear() { ++ this.o1 = null; ++ this.o3 = 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 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 O1: ++ if (value == null) { ++ unsetO1(); ++ } else { ++ setO1((NoSuchObjectException)value); ++ } ++ break; ++ ++ case O3: ++ if (value == null) { ++ unsetO3(); ++ } else { ++ setO3((MetaException)value); ++ } ++ break; ++ ++ } ++ } ++ ++ public Object getFieldValue(_Fields field) { ++ switch (field) { ++ case O1: ++ return getO1(); ++ ++ 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 O1: ++ return isSetO1(); ++ case O3: ++ return isSetO3(); ++ } ++ throw new IllegalStateException(); ++ } ++ ++ @Override ++ public boolean equals(Object that) { ++ if (that == null) ++ return false; ++ if (that instanceof drop_constraint_result) ++ return this.equals((drop_constraint_result)that); ++ return false; ++ } ++ ++ public boolean equals(drop_constraint_result that) { ++ if (that == null) ++ 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_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_o1 = true && (isSetO1()); ++ list.add(present_o1); ++ if (present_o1) ++ list.add(o1); ++ ++ boolean present_o3 = true && (isSetO3()); ++ list.add(present_o3); ++ if (present_o3) ++ list.add(o3); ++ ++ return list.hashCode(); ++ } ++ ++ @Override ++ public int compareTo(drop_constraint_result other) { ++ if (!getClass().equals(other.getClass())) { ++ return getClass().getName().compareTo(other.getClass().getName()); ++ } ++ ++ int lastComparison = 0; ++ ++ 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(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("drop_constraint_result("); ++ boolean first = true; ++ ++ sb.append("o1:"); ++ if (this.o1 == null) { ++ sb.append("null"); ++ } else { ++ sb.append(this.o1); ++ } ++ 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 ++ } ++ ++ 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 drop_constraint_resultStandardSchemeFactory implements SchemeFactory { ++ public drop_constraint_resultStandardScheme getScheme() { ++ return new drop_constraint_resultStandardScheme(); ++ } ++ } ++ ++ private static class drop_constraint_resultStandardScheme extends StandardScheme { ++ ++ public void read(org.apache.thrift.protocol.TProtocol iprot, drop_constraint_result struct) throws org.apache.thrift.TException { ++ org.apache.thrift.protocol.TField schemeField; ++ iprot.readStructBegin(); ++ while (true) ++ { ++ schemeField = iprot.readFieldBegin(); ++ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { ++ break; ++ } ++ switch (schemeField.id) { ++ case 1: // O1 ++ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { ++ struct.o1 = new NoSuchObjectException(); ++ struct.o1.read(iprot); ++ struct.setO1IsSet(true); ++ } else { ++ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); ++ } ++ break; ++ case 2: // 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, drop_constraint_result struct) throws org.apache.thrift.TException { ++ struct.validate(); ++ ++ oprot.writeStructBegin(STRUCT_DESC); ++ if (struct.o1 != null) { ++ oprot.writeFieldBegin(O1_FIELD_DESC); ++ struct.o1.write(oprot); ++ oprot.writeFieldEnd(); ++ } ++ if (struct.o3 != null) { ++ oprot.writeFieldBegin(O3_FIELD_DESC); ++ struct.o3.write(oprot); ++ oprot.writeFieldEnd(); ++ } ++ oprot.writeFieldStop(); ++ oprot.writeStructEnd(); ++ } ++ ++ } ++ ++ private static class drop_constraint_resultTupleSchemeFactory implements SchemeFactory { ++ public drop_constraint_resultTupleScheme getScheme() { ++ return new drop_constraint_resultTupleScheme(); ++ } ++ } ++ ++ private static class drop_constraint_resultTupleScheme extends TupleScheme { ++ ++ @Override ++ public void write(org.apache.thrift.protocol.TProtocol prot, drop_constraint_result struct) throws org.apache.thrift.TException { ++ TTupleProtocol oprot = (TTupleProtocol) prot; ++ BitSet optionals = new BitSet(); ++ if (struct.isSetO1()) { ++ optionals.set(0); ++ } ++ if (struct.isSetO3()) { ++ optionals.set(1); ++ } ++ oprot.writeBitSet(optionals, 2); ++ if (struct.isSetO1()) { ++ struct.o1.write(oprot); ++ } ++ if (struct.isSetO3()) { ++ struct.o3.write(oprot); ++ } ++ } ++ ++ @Override ++ public void read(org.apache.thrift.protocol.TProtocol prot, drop_constraint_result struct) throws org.apache.thrift.TException { ++ TTupleProtocol iprot = (TTupleProtocol) prot; ++ BitSet incoming = iprot.readBitSet(2); ++ if (incoming.get(0)) { ++ struct.o1 = new NoSuchObjectException(); ++ struct.o1.read(iprot); ++ struct.setO1IsSet(true); ++ } ++ if (incoming.get(1)) { ++ struct.o3 = new MetaException(); ++ struct.o3.read(iprot); ++ struct.setO3IsSet(true); ++ } ++ } ++ } ++ ++ } ++ + public static class drop_table_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_table_args"); + +diff --git a/metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php b/metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php +index 4f0c8fd..0e7b745 100644 +--- a/metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php ++++ b/metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php +@@ -167,6 +167,12 @@ interface ThriftHiveMetastoreIf extends \FacebookServiceIf { + */ + public function create_table_with_constraints(\metastore\Table $tbl, array $primaryKeys, array $foreignKeys); + /** ++ * @param \metastore\DropConstraintRequest $req ++ * @throws \metastore\NoSuchObjectException ++ * @throws \metastore\MetaException ++ */ ++ public function drop_constraint(\metastore\DropConstraintRequest $req); ++ /** + * @param string $dbname + * @param string $name + * @param bool $deleteData +@@ -2250,6 +2256,60 @@ class ThriftHiveMetastoreClient extends \FacebookServiceClient implements \metas + return; + } + ++ public function drop_constraint(\metastore\DropConstraintRequest $req) ++ { ++ $this->send_drop_constraint($req); ++ $this->recv_drop_constraint(); ++ } ++ ++ public function send_drop_constraint(\metastore\DropConstraintRequest $req) ++ { ++ $args = new \metastore\ThriftHiveMetastore_drop_constraint_args(); ++ $args->req = $req; ++ $bin_accel = ($this->output_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_write_binary'); ++ if ($bin_accel) ++ { ++ thrift_protocol_write_binary($this->output_, 'drop_constraint', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite()); ++ } ++ else ++ { ++ $this->output_->writeMessageBegin('drop_constraint', TMessageType::CALL, $this->seqid_); ++ $args->write($this->output_); ++ $this->output_->writeMessageEnd(); ++ $this->output_->getTransport()->flush(); + } + } + -+ private static boolean removeDirectory(File dir) { -+ boolean success = false; -+ if (dir.isDirectory()) { -+ File[] files = dir.listFiles(); -+ if (files != null && files.length > 0) { -+ for (File file : files) { -+ success = removeDirectory(file); -+ if (!success) { -+ return false; -+ } -+ } ++ public function recv_drop_constraint() ++ { ++ $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_constraint_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; + } -+ success = dir.delete(); -+ } else { -+ success = dir.delete(); ++ $result = new \metastore\ThriftHiveMetastore_drop_constraint_result(); ++ $result->read($this->input_); ++ $this->input_->readMessageEnd(); ++ } ++ if ($result->o1 !== null) { ++ throw $result->o1; + } -+ return success; ++ if ($result->o3 !== null) { ++ throw $result->o3; ++ } ++ return; + } + -+ @Test - public void testProjectionsBasic() throws IOException { - assumeTrue(!TestUtil.shouldSkip(storageFormat, DISABLED_STORAGE_FORMATS)); + public function drop_table($dbname, $name, $deleteData) + { + $this->send_drop_table($dbname, $name, $deleteData); +@@ -13889,6 +13949,188 @@ class ThriftHiveMetastore_create_table_with_constraints_result { -diff --git a/hcatalog/hcatalog-pig-adapter/src/test/java/org/apache/hive/hcatalog/pig/TestHCatLoaderWithProps.java b/hcatalog/hcatalog-pig-adapter/src/test/java/org/apache/hive/hcatalog/pig/TestHCatLoaderWithProps.java -new file mode 100644 -index 0000000..41fe79b ---- /dev/null -+++ b/hcatalog/hcatalog-pig-adapter/src/test/java/org/apache/hive/hcatalog/pig/TestHCatLoaderWithProps.java -@@ -0,0 +1,305 @@ -+/** -+ * Licensed to the Apache Software Foundation (ASF) under one -+ * or more contributor license agreements. See the NOTICE file -+ * distributed with this work for additional information -+ * regarding copyright ownership. The ASF licenses this file -+ * to you under the Apache License, Version 2.0 (the -+ * "License"); you may not use this file except in compliance -+ * with the License. You may obtain a copy of the License at -+ * -+ * http://www.apache.org/licenses/LICENSE-2.0 -+ * -+ * Unless required by applicable law or agreed to in writing, -+ * software distributed under the License is distributed on an -+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -+ * KIND, either express or implied. See the License for the -+ * specific language governing permissions and limitations -+ * under the License. -+ */ -+package org.apache.hive.hcatalog.pig; -+ -+import java.io.File; -+import java.io.FileWriter; -+import java.io.IOException; -+import java.io.PrintWriter; -+import java.io.RandomAccessFile; -+import java.sql.Date; -+import java.sql.Timestamp; -+import java.util.ArrayList; -+import java.util.Collection; -+import java.util.HashMap; -+import java.util.HashSet; -+import java.util.Iterator; -+import java.util.List; -+import java.util.Map; -+import java.util.Properties; -+import java.util.Set; + } + ++class ThriftHiveMetastore_drop_constraint_args { ++ static $_TSPEC; + -+import org.apache.commons.io.FileUtils; -+import org.apache.hadoop.fs.FileSystem; -+import org.apache.hadoop.fs.FileUtil; -+import org.apache.hadoop.fs.Path; -+import org.apache.hadoop.hive.cli.CliSessionState; -+import org.apache.hadoop.hive.conf.HiveConf; -+import org.apache.hadoop.hive.ql.CommandNeedRetryException; -+import org.apache.hadoop.hive.ql.Driver; -+import org.apache.hadoop.hive.ql.WindowsPathUtil; -+import org.apache.hadoop.hive.ql.io.IOConstants; -+import org.apache.hadoop.hive.ql.io.StorageFormats; -+import org.apache.hadoop.hive.ql.processors.CommandProcessorResponse; -+import org.apache.hadoop.hive.ql.session.SessionState; -+import org.apache.hadoop.hive.serde2.ColumnProjectionUtils; -+import org.apache.hadoop.mapreduce.Job; -+import org.apache.hadoop.util.Shell; -+import org.apache.hive.hcatalog.HcatTestUtils; -+import org.apache.hive.hcatalog.common.HCatUtil; -+import org.apache.hive.hcatalog.common.HCatConstants; -+import org.apache.hive.hcatalog.data.Pair; -+import org.apache.hive.hcatalog.data.schema.HCatFieldSchema; -+import org.apache.pig.ExecType; -+import org.apache.pig.PigRunner; -+import org.apache.pig.PigServer; -+import org.apache.pig.ResourceStatistics; -+import org.apache.pig.tools.pigstats.OutputStats; -+import org.apache.pig.tools.pigstats.PigStats; -+import org.apache.pig.data.DataType; -+import org.apache.pig.data.Tuple; -+import org.apache.pig.impl.logicalLayer.schema.Schema; -+import org.apache.pig.impl.logicalLayer.schema.Schema.FieldSchema; -+import org.apache.pig.impl.util.PropertiesUtil; -+import org.joda.time.DateTime; -+import org.junit.After; -+import org.junit.Before; -+import org.junit.Test; -+import org.junit.runner.RunWith; -+import org.junit.runners.Parameterized; -+import org.slf4j.Logger; -+import org.slf4j.LoggerFactory; ++ /** ++ * @var \metastore\DropConstraintRequest ++ */ ++ public $req = null; + -+import static org.junit.Assert.*; -+import static org.junit.Assume.assumeTrue; ++ public function __construct($vals=null) { ++ if (!isset(self::$_TSPEC)) { ++ self::$_TSPEC = array( ++ 1 => array( ++ 'var' => 'req', ++ 'type' => TType::STRUCT, ++ 'class' => '\metastore\DropConstraintRequest', ++ ), ++ ); ++ } ++ if (is_array($vals)) { ++ if (isset($vals['req'])) { ++ $this->req = $vals['req']; ++ } ++ } ++ } + -+@RunWith(Parameterized.class) -+public class TestHCatLoaderWithProps { -+ private static final Logger LOG = LoggerFactory.getLogger(TestHCatLoaderWithProps.class); -+ private static final String TEST_DATA_DIR = HCatUtil.makePathASafeFileName(System.getProperty("java.io.tmpdir") + -+ File.separator + TestHCatLoaderWithProps.class.getCanonicalName() + "-" + System.currentTimeMillis()); -+ private static final String TEST_WAREHOUSE_DIR = TEST_DATA_DIR + "/warehouse"; -+ private static final String BASIC_FILE_NAME = TEST_DATA_DIR + "/basic.input.data"; ++ public function getName() { ++ return 'ThriftHiveMetastore_drop_constraint_args'; ++ } + -+ private static final String BASIC_TABLE = "junit_unparted_basic"; -+ private static final String PARTITIONED_TABLE = "junit_parted_basic"; ++ 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->req = new \metastore\DropConstraintRequest(); ++ $xfer += $this->req->read($input); ++ } else { ++ $xfer += $input->skip($ftype); ++ } ++ break; ++ default: ++ $xfer += $input->skip($ftype); ++ break; ++ } ++ $xfer += $input->readFieldEnd(); ++ } ++ $xfer += $input->readStructEnd(); ++ return $xfer; ++ } + -+ private Driver driver; -+ private Map> basicInputData; ++ public function write($output) { ++ $xfer = 0; ++ $xfer += $output->writeStructBegin('ThriftHiveMetastore_drop_constraint_args'); ++ if ($this->req !== null) { ++ if (!is_object($this->req)) { ++ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); ++ } ++ $xfer += $output->writeFieldBegin('req', TType::STRUCT, 1); ++ $xfer += $this->req->write($output); ++ $xfer += $output->writeFieldEnd(); ++ } ++ $xfer += $output->writeFieldStop(); ++ $xfer += $output->writeStructEnd(); ++ return $xfer; ++ } + -+ private static final Map> DISABLED_STORAGE_FORMATS = -+ new HashMap>() {{ -+ put(IOConstants.PARQUETFILE, new HashSet() {{ -+ add("testReadMissingPartitionBasic"); -+ }}); -+ }}; ++} + -+ private final String storageFormat; ++class ThriftHiveMetastore_drop_constraint_result { ++ static $_TSPEC; + -+ @Parameterized.Parameters -+ public static Collection generateParameters() { -+ return StorageFormats.names(); -+ } ++ /** ++ * @var \metastore\NoSuchObjectException ++ */ ++ public $o1 = null; ++ /** ++ * @var \metastore\MetaException ++ */ ++ public $o3 = null; + -+ public TestHCatLoaderWithProps(String storageFormat) { -+ this.storageFormat = storageFormat; ++ public function __construct($vals=null) { ++ if (!isset(self::$_TSPEC)) { ++ self::$_TSPEC = array( ++ 1 => array( ++ 'var' => 'o1', ++ 'type' => TType::STRUCT, ++ 'class' => '\metastore\NoSuchObjectException', ++ ), ++ 2 => array( ++ 'var' => 'o3', ++ 'type' => TType::STRUCT, ++ 'class' => '\metastore\MetaException', ++ ), ++ ); ++ } ++ if (is_array($vals)) { ++ if (isset($vals['o1'])) { ++ $this->o1 = $vals['o1']; ++ } ++ if (isset($vals['o3'])) { ++ $this->o3 = $vals['o3']; ++ } ++ } + } + -+ private void dropTable(String tablename) throws IOException, CommandNeedRetryException { -+ dropTable(tablename, driver); ++ public function getName() { ++ return 'ThriftHiveMetastore_drop_constraint_result'; + } + -+ static void dropTable(String tablename, Driver driver) throws IOException, CommandNeedRetryException { -+ driver.run("drop table if exists " + tablename); ++ 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->o1 = new \metastore\NoSuchObjectException(); ++ $xfer += $this->o1->read($input); ++ } else { ++ $xfer += $input->skip($ftype); ++ } ++ break; ++ case 2: ++ 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; + } + -+ private void createTable(String tablename, String schema, String partitionedBy) throws IOException, CommandNeedRetryException { -+ createTable(tablename, schema, partitionedBy, driver, storageFormat); ++ public function write($output) { ++ $xfer = 0; ++ $xfer += $output->writeStructBegin('ThriftHiveMetastore_drop_constraint_result'); ++ if ($this->o1 !== null) { ++ $xfer += $output->writeFieldBegin('o1', TType::STRUCT, 1); ++ $xfer += $this->o1->write($output); ++ $xfer += $output->writeFieldEnd(); ++ } ++ if ($this->o3 !== null) { ++ $xfer += $output->writeFieldBegin('o3', TType::STRUCT, 2); ++ $xfer += $this->o3->write($output); ++ $xfer += $output->writeFieldEnd(); ++ } ++ $xfer += $output->writeFieldStop(); ++ $xfer += $output->writeStructEnd(); ++ return $xfer; + } + -+ static void createTable(String tablename, String schema, String partitionedBy, Driver driver, String storageFormat) -+ throws IOException, CommandNeedRetryException { -+ String createTable; -+ createTable = "create table " + tablename + "(" + schema + ") "; -+ if ((partitionedBy != null) && (!partitionedBy.trim().isEmpty())) { -+ createTable = createTable + "partitioned by (" + partitionedBy + ") "; ++} ++ + class ThriftHiveMetastore_drop_table_args { + static $_TSPEC; + +diff --git a/metastore/src/gen/thrift/gen-php/metastore/Types.php b/metastore/src/gen/thrift/gen-php/metastore/Types.php +index e2fa963..a8a7db9 100644 +--- a/metastore/src/gen/thrift/gen-php/metastore/Types.php ++++ b/metastore/src/gen/thrift/gen-php/metastore/Types.php +@@ -9153,6 +9153,127 @@ class ForeignKeysResponse { + + } + ++class DropConstraintRequest { ++ static $_TSPEC; ++ ++ /** ++ * @var string ++ */ ++ public $dbname = null; ++ /** ++ * @var string ++ */ ++ public $tablename = null; ++ /** ++ * @var string ++ */ ++ public $constraintname = null; ++ ++ public function __construct($vals=null) { ++ if (!isset(self::$_TSPEC)) { ++ self::$_TSPEC = array( ++ 1 => array( ++ 'var' => 'dbname', ++ 'type' => TType::STRING, ++ ), ++ 2 => array( ++ 'var' => 'tablename', ++ 'type' => TType::STRING, ++ ), ++ 3 => array( ++ 'var' => 'constraintname', ++ 'type' => TType::STRING, ++ ), ++ ); ++ } ++ if (is_array($vals)) { ++ if (isset($vals['dbname'])) { ++ $this->dbname = $vals['dbname']; ++ } ++ if (isset($vals['tablename'])) { ++ $this->tablename = $vals['tablename']; ++ } ++ if (isset($vals['constraintname'])) { ++ $this->constraintname = $vals['constraintname']; ++ } + } -+ createTable = createTable + "stored as " +storageFormat; -+ executeStatementOnDriver(createTable, driver); + } + -+ private void createTable(String tablename, String schema) throws IOException, CommandNeedRetryException { -+ createTable(tablename, schema, null); ++ public function getName() { ++ return 'DropConstraintRequest'; + } + -+ /** -+ * Execute Hive CLI statement -+ * @param cmd arbitrary statement to execute -+ */ -+ static void executeStatementOnDriver(String cmd, Driver driver) throws IOException, CommandNeedRetryException { -+ LOG.debug("Executing: " + cmd); -+ CommandProcessorResponse cpr = driver.run(cmd); -+ if(cpr.getResponseCode() != 0) { -+ throw new IOException("Failed to execute \"" + cmd + "\". Driver returned " + cpr.getResponseCode() + " Error: " + cpr.getErrorMessage()); ++ 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->dbname); ++ } else { ++ $xfer += $input->skip($ftype); ++ } ++ break; ++ case 2: ++ if ($ftype == TType::STRING) { ++ $xfer += $input->readString($this->tablename); ++ } else { ++ $xfer += $input->skip($ftype); ++ } ++ break; ++ case 3: ++ if ($ftype == TType::STRING) { ++ $xfer += $input->readString($this->constraintname); ++ } else { ++ $xfer += $input->skip($ftype); ++ } ++ break; ++ default: ++ $xfer += $input->skip($ftype); ++ break; ++ } ++ $xfer += $input->readFieldEnd(); + } ++ $xfer += $input->readStructEnd(); ++ return $xfer; + } + -+ @Before -+ public void setup() throws Exception { -+ File f = new File(TEST_WAREHOUSE_DIR); -+ if (f.exists()) { -+ FileUtil.fullyDelete(f); ++ public function write($output) { ++ $xfer = 0; ++ $xfer += $output->writeStructBegin('DropConstraintRequest'); ++ if ($this->dbname !== null) { ++ $xfer += $output->writeFieldBegin('dbname', TType::STRING, 1); ++ $xfer += $output->writeString($this->dbname); ++ $xfer += $output->writeFieldEnd(); + } -+ if (!(new File(TEST_WAREHOUSE_DIR).mkdirs())) { -+ throw new RuntimeException("Could not create " + TEST_WAREHOUSE_DIR); ++ if ($this->tablename !== null) { ++ $xfer += $output->writeFieldBegin('tablename', TType::STRING, 2); ++ $xfer += $output->writeString($this->tablename); ++ $xfer += $output->writeFieldEnd(); + } ++ if ($this->constraintname !== null) { ++ $xfer += $output->writeFieldBegin('constraintname', TType::STRING, 3); ++ $xfer += $output->writeString($this->constraintname); ++ $xfer += $output->writeFieldEnd(); ++ } ++ $xfer += $output->writeFieldStop(); ++ $xfer += $output->writeStructEnd(); ++ return $xfer; ++ } ++ ++} ++ + class PartitionsByExprResult { + static $_TSPEC; + +diff --git a/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote b/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote +index 3ec46f1..5323d9f 100755 +--- a/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote ++++ b/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote +@@ -43,6 +43,7 @@ if len(sys.argv) <= 1 or sys.argv[1] == '--help': + print(' void create_table(Table tbl)') + print(' void create_table_with_environment_context(Table tbl, EnvironmentContext environment_context)') + print(' void create_table_with_constraints(Table tbl, primaryKeys, foreignKeys)') ++ print(' void drop_constraint(DropConstraintRequest req)') + print(' void drop_table(string dbname, string name, bool deleteData)') + print(' void drop_table_with_environment_context(string dbname, string name, bool deleteData, EnvironmentContext environment_context)') + print(' get_tables(string db_name, string pattern)') +@@ -353,6 +354,12 @@ elif cmd == 'create_table_with_constraints': + sys.exit(1) + pp.pprint(client.create_table_with_constraints(eval(args[0]),eval(args[1]),eval(args[2]),)) + ++elif cmd == 'drop_constraint': ++ if len(args) != 1: ++ print('drop_constraint requires 1 args') ++ sys.exit(1) ++ pp.pprint(client.drop_constraint(eval(args[0]),)) ++ + elif cmd == 'drop_table': + if len(args) != 3: + print('drop_table requires 3 args') +diff --git a/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py b/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py +index 119a5f1..bf8d383 100644 +--- a/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py ++++ b/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py +@@ -165,6 +165,13 @@ def create_table_with_constraints(self, tbl, primaryKeys, foreignKeys): + """ + pass + ++ def drop_constraint(self, req): ++ """ ++ Parameters: ++ - req ++ """ ++ pass ++ + def drop_table(self, dbname, name, deleteData): + """ + Parameters: +@@ -1875,6 +1882,39 @@ def recv_create_table_with_constraints(self): + raise result.o4 + return + ++ def drop_constraint(self, req): ++ """ ++ Parameters: ++ - req ++ """ ++ self.send_drop_constraint(req) ++ self.recv_drop_constraint() ++ ++ def send_drop_constraint(self, req): ++ self._oprot.writeMessageBegin('drop_constraint', TMessageType.CALL, self._seqid) ++ args = drop_constraint_args() ++ args.req = req ++ args.write(self._oprot) ++ self._oprot.writeMessageEnd() ++ self._oprot.trans.flush() ++ ++ def recv_drop_constraint(self): ++ iprot = self._iprot ++ (fname, mtype, rseqid) = iprot.readMessageBegin() ++ if mtype == TMessageType.EXCEPTION: ++ x = TApplicationException() ++ x.read(iprot) ++ iprot.readMessageEnd() ++ raise x ++ result = drop_constraint_result() ++ result.read(iprot) ++ iprot.readMessageEnd() ++ if result.o1 is not None: ++ raise result.o1 ++ if result.o3 is not None: ++ raise result.o3 ++ return ++ + def drop_table(self, dbname, name, deleteData): + """ + Parameters: +@@ -6499,6 +6539,7 @@ def __init__(self, handler): + self._processMap["create_table"] = Processor.process_create_table + self._processMap["create_table_with_environment_context"] = Processor.process_create_table_with_environment_context + self._processMap["create_table_with_constraints"] = Processor.process_create_table_with_constraints ++ self._processMap["drop_constraint"] = Processor.process_drop_constraint + self._processMap["drop_table"] = Processor.process_drop_table + self._processMap["drop_table_with_environment_context"] = Processor.process_drop_table_with_environment_context + self._processMap["get_tables"] = Processor.process_get_tables +@@ -7141,6 +7182,31 @@ def process_create_table_with_constraints(self, seqid, iprot, oprot): + oprot.writeMessageEnd() + oprot.trans.flush() + ++ def process_drop_constraint(self, seqid, iprot, oprot): ++ args = drop_constraint_args() ++ args.read(iprot) ++ iprot.readMessageEnd() ++ result = drop_constraint_result() ++ try: ++ self._handler.drop_constraint(args.req) ++ msg_type = TMessageType.REPLY ++ except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): ++ raise ++ except NoSuchObjectException as o1: ++ msg_type = TMessageType.REPLY ++ result.o1 = o1 ++ 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_constraint", msg_type, seqid) ++ result.write(oprot) ++ oprot.writeMessageEnd() ++ oprot.trans.flush() ++ + def process_drop_table(self, seqid, iprot, oprot): + args = drop_table_args() + args.read(iprot) +@@ -13467,6 +13533,152 @@ def __eq__(self, other): + def __ne__(self, other): + return not (self == other) + ++class drop_constraint_args: ++ """ ++ Attributes: ++ - req ++ """ ++ ++ thrift_spec = ( ++ None, # 0 ++ (1, TType.STRUCT, 'req', (DropConstraintRequest, DropConstraintRequest.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)) ++ return ++ iprot.readStructBegin() ++ while True: ++ (fname, ftype, fid) = iprot.readFieldBegin() ++ if ftype == TType.STOP: ++ break ++ if fid == 1: ++ if ftype == TType.STRUCT: ++ self.req = DropConstraintRequest() ++ self.req.read(iprot) ++ else: ++ iprot.skip(ftype) ++ else: ++ iprot.skip(ftype) ++ iprot.readFieldEnd() ++ iprot.readStructEnd() ++ ++ def write(self, oprot): ++ if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: ++ oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) ++ return ++ oprot.writeStructBegin('drop_constraint_args') ++ if self.req is not None: ++ oprot.writeFieldBegin('req', TType.STRUCT, 1) ++ self.req.write(oprot) ++ oprot.writeFieldEnd() ++ oprot.writeFieldStop() ++ oprot.writeStructEnd() ++ ++ def validate(self): ++ return ++ ++ ++ def __hash__(self): ++ value = 17 ++ value = (value * 31) ^ hash(self.req) ++ return value ++ ++ def __repr__(self): ++ L = ['%s=%r' % (key, value) ++ for key, value in self.__dict__.iteritems()] ++ return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) ++ ++ def __eq__(self, other): ++ return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ ++ ++ def __ne__(self, other): ++ return not (self == other) ++ ++class drop_constraint_result: ++ """ ++ Attributes: ++ - o1 ++ - o3 ++ """ ++ ++ thrift_spec = ( ++ None, # 0 ++ (1, TType.STRUCT, 'o1', (NoSuchObjectException, NoSuchObjectException.thrift_spec), None, ), # 1 ++ (2, TType.STRUCT, 'o3', (MetaException, MetaException.thrift_spec), None, ), # 2 ++ ) ++ ++ def __init__(self, o1=None, o3=None,): ++ self.o1 = o1 ++ self.o3 = o3 ++ ++ def read(self, iprot): ++ if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: ++ fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) ++ return ++ iprot.readStructBegin() ++ while True: ++ (fname, ftype, fid) = iprot.readFieldBegin() ++ if ftype == TType.STOP: ++ break ++ if fid == 1: ++ if ftype == TType.STRUCT: ++ self.o1 = NoSuchObjectException() ++ self.o1.read(iprot) ++ else: ++ iprot.skip(ftype) ++ elif fid == 2: ++ if ftype == TType.STRUCT: ++ self.o3 = MetaException() ++ self.o3.read(iprot) ++ else: ++ iprot.skip(ftype) ++ else: ++ iprot.skip(ftype) ++ iprot.readFieldEnd() ++ iprot.readStructEnd() ++ ++ def write(self, oprot): ++ if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: ++ oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) ++ return ++ oprot.writeStructBegin('drop_constraint_result') ++ if self.o1 is not None: ++ oprot.writeFieldBegin('o1', TType.STRUCT, 1) ++ self.o1.write(oprot) ++ oprot.writeFieldEnd() ++ if self.o3 is not None: ++ oprot.writeFieldBegin('o3', TType.STRUCT, 2) ++ self.o3.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.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 drop_table_args: + """ + Attributes: +diff --git a/metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py b/metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py +index f008788..8e0cb71 100644 +--- a/metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py ++++ b/metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py +@@ -6264,6 +6264,103 @@ def __eq__(self, other): + def __ne__(self, other): + return not (self == other) + ++class DropConstraintRequest: ++ """ ++ Attributes: ++ - dbname ++ - tablename ++ - constraintname ++ """ + -+ HiveConf hiveConf = new HiveConf(this.getClass()); -+ hiveConf.set(HiveConf.ConfVars.PREEXECHOOKS.varname, ""); -+ hiveConf.set(HiveConf.ConfVars.POSTEXECHOOKS.varname, ""); -+ hiveConf.set(HiveConf.ConfVars.HIVE_SUPPORT_CONCURRENCY.varname, "false"); -+ hiveConf.set(HiveConf.ConfVars.METASTOREWAREHOUSE.varname, TEST_WAREHOUSE_DIR); -+ hiveConf.setVar(HiveConf.ConfVars.HIVEMAPREDMODE, "nonstrict"); ++ thrift_spec = ( ++ None, # 0 ++ (1, TType.STRING, 'dbname', None, None, ), # 1 ++ (2, TType.STRING, 'tablename', None, None, ), # 2 ++ (3, TType.STRING, 'constraintname', None, None, ), # 3 ++ ) + -+ if (Shell.WINDOWS) { -+ WindowsPathUtil.convertPathsFromWindowsToHdfs(hiveConf); ++ def __init__(self, dbname=None, tablename=None, constraintname=None,): ++ self.dbname = dbname ++ self.tablename = tablename ++ self.constraintname = constraintname ++ ++ 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.dbname = iprot.readString() ++ else: ++ iprot.skip(ftype) ++ elif fid == 2: ++ if ftype == TType.STRING: ++ self.tablename = iprot.readString() ++ else: ++ iprot.skip(ftype) ++ elif fid == 3: ++ if ftype == TType.STRING: ++ self.constraintname = 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('DropConstraintRequest') ++ if self.dbname is not None: ++ oprot.writeFieldBegin('dbname', TType.STRING, 1) ++ oprot.writeString(self.dbname) ++ oprot.writeFieldEnd() ++ if self.tablename is not None: ++ oprot.writeFieldBegin('tablename', TType.STRING, 2) ++ oprot.writeString(self.tablename) ++ oprot.writeFieldEnd() ++ if self.constraintname is not None: ++ oprot.writeFieldBegin('constraintname', TType.STRING, 3) ++ oprot.writeString(self.constraintname) ++ oprot.writeFieldEnd() ++ oprot.writeFieldStop() ++ oprot.writeStructEnd() ++ ++ def validate(self): ++ if self.dbname is None: ++ raise TProtocol.TProtocolException(message='Required field dbname is unset!') ++ if self.tablename is None: ++ raise TProtocol.TProtocolException(message='Required field tablename is unset!') ++ if self.constraintname is None: ++ raise TProtocol.TProtocolException(message='Required field constraintname is unset!') ++ return ++ ++ ++ def __hash__(self): ++ value = 17 ++ value = (value * 31) ^ hash(self.dbname) ++ value = (value * 31) ^ hash(self.tablename) ++ value = (value * 31) ^ hash(self.constraintname) ++ 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 PartitionsByExprResult: + """ + Attributes: +diff --git a/metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb b/metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb +index 4a24a19..4d3e49d 100644 +--- a/metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb ++++ b/metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb +@@ -1390,6 +1390,29 @@ class ForeignKeysResponse + ::Thrift::Struct.generate_accessors self + end + ++class DropConstraintRequest ++ include ::Thrift::Struct, ::Thrift::Struct_Union ++ DBNAME = 1 ++ TABLENAME = 2 ++ CONSTRAINTNAME = 3 ++ ++ FIELDS = { ++ DBNAME => {:type => ::Thrift::Types::STRING, :name => 'dbname'}, ++ TABLENAME => {:type => ::Thrift::Types::STRING, :name => 'tablename'}, ++ CONSTRAINTNAME => {:type => ::Thrift::Types::STRING, :name => 'constraintname'} ++ } ++ ++ def struct_fields; FIELDS; end ++ ++ def validate ++ raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Required field dbname is unset!') unless @dbname ++ raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Required field tablename is unset!') unless @tablename ++ raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Required field constraintname is unset!') unless @constraintname ++ end ++ ++ ::Thrift::Struct.generate_accessors self ++end ++ + class PartitionsByExprResult + include ::Thrift::Struct, ::Thrift::Struct_Union + PARTITIONS = 1 +diff --git a/metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb b/metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb +index 99a764e..61d1832 100644 +--- a/metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb ++++ b/metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb +@@ -336,6 +336,22 @@ module ThriftHiveMetastore + return + end + ++ def drop_constraint(req) ++ send_drop_constraint(req) ++ recv_drop_constraint() ++ end ++ ++ def send_drop_constraint(req) ++ send_message('drop_constraint', Drop_constraint_args, :req => req) ++ end ++ ++ def recv_drop_constraint() ++ result = receive_message(Drop_constraint_result) ++ raise result.o1 unless result.o1.nil? ++ raise result.o3 unless result.o3.nil? ++ return ++ end ++ + def drop_table(dbname, name, deleteData) + send_drop_table(dbname, name, deleteData) + recv_drop_table() +@@ -2704,6 +2720,19 @@ module ThriftHiveMetastore + write_result(result, oprot, 'create_table_with_constraints', seqid) + end + ++ def process_drop_constraint(seqid, iprot, oprot) ++ args = read_args(iprot, Drop_constraint_args) ++ result = Drop_constraint_result.new() ++ begin ++ @handler.drop_constraint(args.req) ++ rescue ::NoSuchObjectException => o1 ++ result.o1 = o1 ++ rescue ::MetaException => o3 ++ result.o3 = o3 ++ end ++ write_result(result, oprot, 'drop_constraint', seqid) ++ end ++ + def process_drop_table(seqid, iprot, oprot) + args = read_args(iprot, Drop_table_args) + result = Drop_table_result.new() +@@ -4954,6 +4983,40 @@ module ThriftHiveMetastore + ::Thrift::Struct.generate_accessors self + end + ++ class Drop_constraint_args ++ include ::Thrift::Struct, ::Thrift::Struct_Union ++ REQ = 1 ++ ++ FIELDS = { ++ REQ => {:type => ::Thrift::Types::STRUCT, :name => 'req', :class => ::DropConstraintRequest} + } + -+ driver = new Driver(hiveConf); -+ SessionState.start(new CliSessionState(hiveConf)); ++ def struct_fields; FIELDS; end + -+ createTable(BASIC_TABLE, "a int, b string"); -+ createTable(PARTITIONED_TABLE, "a int, b string", "bkt string"); ++ def validate ++ end + -+ int LOOP_SIZE = 3; -+ String[] input = new String[LOOP_SIZE * LOOP_SIZE]; -+ basicInputData = new HashMap>(); -+ int k = 0; -+ for (int i = 1; i <= LOOP_SIZE; i++) { -+ String si = i + ""; -+ for (int j = 1; j <= LOOP_SIZE; j++) { -+ String sj = "S" + j + "S"; -+ input[k] = si + "\t" + sj; -+ basicInputData.put(k, new Pair(i, sj)); -+ k++; -+ } ++ ::Thrift::Struct.generate_accessors self ++ end ++ ++ class Drop_constraint_result ++ include ::Thrift::Struct, ::Thrift::Struct_Union ++ O1 = 1 ++ O3 = 2 ++ ++ FIELDS = { ++ O1 => {:type => ::Thrift::Types::STRUCT, :name => 'o1', :class => ::NoSuchObjectException}, ++ O3 => {:type => ::Thrift::Types::STRUCT, :name => 'o3', :class => ::MetaException} + } -+ HcatTestUtils.createTestDataFile(BASIC_FILE_NAME, input); + -+ PigServer server = new PigServer(ExecType.LOCAL); -+ server.setBatchOn(); -+ int i = 0; -+ server.registerQuery("A = load '" + BASIC_FILE_NAME + "' as (a:int, b:chararray);", ++i); ++ def struct_fields; FIELDS; end ++ ++ def validate ++ end + -+ server.registerQuery("store A into '" + BASIC_TABLE + "' using org.apache.hive.hcatalog.pig.HCatStorer();", ++i); -+ server.registerQuery("B = foreach A generate a,b;", ++i); -+ server.registerQuery("B2 = filter B by a < 2;", ++i); -+ server.registerQuery("store B2 into '" + PARTITIONED_TABLE + "' using org.apache.hive.hcatalog.pig.HCatStorer('bkt=0');", ++i); ++ ::Thrift::Struct.generate_accessors self ++ end + -+ server.registerQuery("C = foreach A generate a,b;", ++i); -+ server.registerQuery("C2 = filter C by a >= 2;", ++i); -+ server.registerQuery("store C2 into '" + PARTITIONED_TABLE + "' using org.apache.hive.hcatalog.pig.HCatStorer('bkt=1');", ++i); + class Drop_table_args + include ::Thrift::Struct, ::Thrift::Struct_Union + DBNAME = 1 +diff --git a/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java b/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java +index 4ada9c1..9a09e7a 100644 +--- a/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java ++++ b/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java +@@ -1483,6 +1483,35 @@ public void create_table_with_constraints(final Table tbl, + endFunction("create_table", success, ex, tbl.getTableName()); + } + } + -+ server.executeBatch(); ++ @Override ++ public void drop_constraint(DropConstraintRequest req) ++ throws MetaException, InvalidObjectException { ++ String dbName = req.getDbname(); ++ String tableName = req.getTablename(); ++ String constraintName = req.getConstraintname(); ++ startFunction("drop_constraint", ": " + constraintName.toString()); ++ boolean success = false; ++ Exception ex = null; ++ try { ++ getMS().dropConstraint(dbName, tableName, constraintName); ++ success = true; ++ } catch (NoSuchObjectException e) { ++ ex = e; ++ throw new InvalidObjectException(e.getMessage()); ++ } catch (Exception e) { ++ ex = e; ++ if (e instanceof MetaException) { ++ throw (MetaException) e; ++ } else if (e instanceof InvalidObjectException) { ++ throw (InvalidObjectException) e; ++ } else { ++ throw newMetaException(e); ++ } ++ } finally { ++ endFunction("drop_constraint", success, ex, constraintName); ++ } ++ } + private boolean is_table_exists(RawStore ms, String dbname, String name) + throws MetaException { + return (ms.getTable(dbname, name) != null); +diff --git a/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java b/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java +index 7d37d07..75fea5b 100644 +--- a/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java ++++ b/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java +@@ -44,6 +44,7 @@ + import org.apache.hadoop.hive.metastore.api.ConfigValSecurityException; + import org.apache.hadoop.hive.metastore.api.CurrentNotificationEventId; + import org.apache.hadoop.hive.metastore.api.Database; ++import org.apache.hadoop.hive.metastore.api.DropConstraintRequest; + import org.apache.hadoop.hive.metastore.api.DropPartitionsExpr; + import org.apache.hadoop.hive.metastore.api.DropPartitionsRequest; + import org.apache.hadoop.hive.metastore.api.EnvironmentContext; +@@ -765,6 +766,11 @@ public void createTableWithConstraints(Table tbl, + } + } + ++ @Override ++ public void dropConstraint(String dbName, String tableName, String constraintName) throws ++ NoSuchObjectException, MetaException, TException { ++ client.drop_constraint(new DropConstraintRequest(dbName, tableName, constraintName)); + } + + /** + * @param type +diff --git a/metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java b/metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java +index c900a2d..3965475 100644 +--- a/metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java ++++ b/metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java +@@ -1570,4 +1570,7 @@ void createTableWithConstraints( + List primaryKeys, List foreignKeys) + throws AlreadyExistsException, InvalidObjectException, MetaException, NoSuchObjectException, TException; + ++ void dropConstraint(String dbName, String tableName, String constraintName) throws ++ MetaException, NoSuchObjectException, TException; + -+ @After -+ public void tearDown() throws Exception { + } +diff --git a/metastore/src/java/org/apache/hadoop/hive/metastore/ObjectStore.java b/metastore/src/java/org/apache/hadoop/hive/metastore/ObjectStore.java +index f651a13..5c49be9 100644 +--- a/metastore/src/java/org/apache/hadoop/hive/metastore/ObjectStore.java ++++ b/metastore/src/java/org/apache/hadoop/hive/metastore/ObjectStore.java +@@ -1025,7 +1025,8 @@ public boolean dropTable(String dbName, String tableName) throws MetaException, + " table " + tableName + " record to delete"); + } + +- List tabConstraints = listAllTableConstraints(dbName, tableName); ++ List tabConstraints = listAllTableConstraintsWithOptionalConstraintName( ++ dbName, tableName, null); + if (tabConstraints != null && tabConstraints.size() > 0) { + pm.deletePersistentAll(tabConstraints); + } +@@ -1043,19 +1044,27 @@ public boolean dropTable(String dbName, String tableName) throws MetaException, + return success; + } + +- private List listAllTableConstraints(String dbName, String tableName) { ++ private List listAllTableConstraintsWithOptionalConstraintName ++ (String dbName, String tableName, String constraintname) { + List mConstraints = null; + List constraintNames = new ArrayList(); + Query query = null; + + try { + query = pm.newQuery("select constraintName from org.apache.hadoop.hive.metastore.model.MConstraint where " +- + "(parentTable.tableName == ptblname && parentTable.database.name == pdbname) || " +- + "(childTable != null && childTable.tableName == ctblname && childTable.database.name == cdbname)"); ++ + "((parentTable.tableName == ptblname && parentTable.database.name == pdbname) || " ++ + "(childTable != null && childTable.tableName == ctblname && " ++ + "childTable.database.name == cdbname)) " + (constraintname != null ? ++ " && constraintName == constraintname" : "")); + query.declareParameters("java.lang.String ptblname, java.lang.String pdbname," +- + "java.lang.String ctblname, java.lang.String cdbname"); +- Collection constraintNamesColl = (Collection) query. +- executeWithArray(tableName, dbName, tableName, dbName); ++ + "java.lang.String ctblname, java.lang.String cdbname" + ++ (constraintname != null ? ", java.lang.String constraintname" : "")); ++ Collection constraintNamesColl = ++ constraintname != null ? ++ ((Collection) query. ++ executeWithArray(tableName, dbName, tableName, dbName, constraintname)): ++ ((Collection) query. ++ executeWithArray(tableName, dbName, tableName, dbName)); + for (Iterator i = constraintNamesColl.iterator(); i.hasNext();) { + String currName = (String) i.next(); + constraintNames.add(currName); +@@ -8389,4 +8398,27 @@ private String getPrimaryKeyConstraintName(String db_name, String tbl_name) thro + return foreignKeys; + } + ++ @Override ++ public void dropConstraint(String dbName, String tableName, ++ String constraintName) throws NoSuchObjectException { ++ boolean success = false; + try { -+ if (driver != null) { -+ dropTable(BASIC_TABLE); -+ dropTable(PARTITIONED_TABLE); ++ openTransaction(); ++ ++ List tabConstraints = listAllTableConstraintsWithOptionalConstraintName( ++ dbName, tableName, constraintName); ++ if (tabConstraints != null && tabConstraints.size() > 0) { ++ pm.deletePersistentAll(tabConstraints); ++ } else { ++ throw new NoSuchObjectException("The constraint: " + constraintName + ++ " does not exist for the associated table: " + dbName + "." + tableName); + } ++ success = commitTransaction(); + } finally { -+ FileUtils.deleteDirectory(new File(TEST_DATA_DIR)); ++ if (!success) { ++ rollbackTransaction(); ++ } + } + } + -+ @Test -+ public void testReadMissingPartitionBasic() throws IOException, CommandNeedRetryException { -+ assumeTrue(!TestUtil.shouldSkip(storageFormat, DISABLED_STORAGE_FORMATS)); -+ Properties pigProperties = PropertiesUtil.loadDefaultProperties(); -+ pigProperties.setProperty("hcat.input.ignore.invalid.path", "true"); -+ PigServer server = new PigServer(ExecType.LOCAL, pigProperties); + } +diff --git a/metastore/src/java/org/apache/hadoop/hive/metastore/RawStore.java b/metastore/src/java/org/apache/hadoop/hive/metastore/RawStore.java +index 100c396..06b8135 100644 +--- a/metastore/src/java/org/apache/hadoop/hive/metastore/RawStore.java ++++ b/metastore/src/java/org/apache/hadoop/hive/metastore/RawStore.java +@@ -675,4 +675,6 @@ void getFileMetadataByExpr(List fileIds, FileMetadataExprType type, byte[] + + void createTableWithConstraints(Table tbl, List primaryKeys, + List foreignKeys) throws InvalidObjectException, MetaException; ++ ++ void dropConstraint(String dbName, String tableName, String constraintName) throws NoSuchObjectException; + } +diff --git a/metastore/src/java/org/apache/hadoop/hive/metastore/hbase/HBaseStore.java b/metastore/src/java/org/apache/hadoop/hive/metastore/hbase/HBaseStore.java +index d4e5da4..ec5b92c 100644 +--- a/metastore/src/java/org/apache/hadoop/hive/metastore/hbase/HBaseStore.java ++++ b/metastore/src/java/org/apache/hadoop/hive/metastore/hbase/HBaseStore.java +@@ -2615,4 +2615,10 @@ public void createTableWithConstraints(Table tbl, + throws InvalidObjectException, MetaException { + // TODO Auto-generated method stub + } ++ ++ @Override ++ public void dropConstraint(String dbName, String tableName, ++ String constraintName) throws NoSuchObjectException { ++ // TODO Auto-generated method stub ++ } + } +diff --git a/metastore/src/test/org/apache/hadoop/hive/metastore/DummyRawStoreControlledCommit.java b/metastore/src/test/org/apache/hadoop/hive/metastore/DummyRawStoreControlledCommit.java +index 86e7bea..63fcb28 100644 +--- a/metastore/src/test/org/apache/hadoop/hive/metastore/DummyRawStoreControlledCommit.java ++++ b/metastore/src/test/org/apache/hadoop/hive/metastore/DummyRawStoreControlledCommit.java +@@ -844,4 +844,10 @@ public void createTableWithConstraints(Table tbl, + throws InvalidObjectException, MetaException { + // TODO Auto-generated method stub + } ++ ++ @Override ++ public void dropConstraint(String dbName, String tableName, ++ String constraintName) throws NoSuchObjectException { ++ // TODO Auto-generated method stub ++ } + } +diff --git a/metastore/src/test/org/apache/hadoop/hive/metastore/DummyRawStoreForJdoConnection.java b/metastore/src/test/org/apache/hadoop/hive/metastore/DummyRawStoreForJdoConnection.java +index 5b32f00..386c70a 100644 +--- a/metastore/src/test/org/apache/hadoop/hive/metastore/DummyRawStoreForJdoConnection.java ++++ b/metastore/src/test/org/apache/hadoop/hive/metastore/DummyRawStoreForJdoConnection.java +@@ -860,6 +860,12 @@ public void createTableWithConstraints(Table tbl, + throws InvalidObjectException, MetaException { + // TODO Auto-generated method stub + } + -+ File removedPartitionDir = new File(TEST_WAREHOUSE_DIR + "/" + PARTITIONED_TABLE + "/bkt=0"); -+ if (!removeDirectory(removedPartitionDir)) { -+ System.out.println("Test did not run because its environment could not be set."); -+ return; -+ } -+ driver.run("select * from " + PARTITIONED_TABLE); -+ ArrayList valuesReadFromHiveDriver = new ArrayList(); -+ driver.getResults(valuesReadFromHiveDriver); -+ assertTrue(valuesReadFromHiveDriver.size() == 6); -+ -+ server.registerQuery("W = load '" + PARTITIONED_TABLE + "' using org.apache.hive.hcatalog.pig.HCatLoader();"); -+ Schema dumpedWSchema = server.dumpSchema("W"); -+ List Wfields = dumpedWSchema.getFields(); -+ assertEquals(3, Wfields.size()); -+ assertTrue(Wfields.get(0).alias.equalsIgnoreCase("a")); -+ assertTrue(Wfields.get(0).type == DataType.INTEGER); -+ assertTrue(Wfields.get(1).alias.equalsIgnoreCase("b")); -+ assertTrue(Wfields.get(1).type == DataType.CHARARRAY); -+ assertTrue(Wfields.get(2).alias.equalsIgnoreCase("bkt")); -+ assertTrue(Wfields.get(2).type == DataType.CHARARRAY); -+ -+ Iterator WIter = server.openIterator("W"); -+ Collection> valuesRead = new ArrayList>(); -+ while (WIter.hasNext()) { -+ Tuple t = WIter.next(); -+ assertTrue(t.size() == 3); -+ assertNotNull(t.get(0)); -+ assertNotNull(t.get(1)); -+ assertNotNull(t.get(2)); -+ assertTrue(t.get(0).getClass() == Integer.class); -+ assertTrue(t.get(1).getClass() == String.class); -+ assertTrue(t.get(2).getClass() == String.class); -+ valuesRead.add(new Pair((Integer) t.get(0), (String) t.get(1))); -+ // the returned partition value is always 1 -+ assertEquals("1", t.get(2)); -+ } -+ assertEquals(valuesReadFromHiveDriver.size(), valuesRead.size()); -+ -+ server.registerQuery("P1 = load '" + PARTITIONED_TABLE + "' using org.apache.hive.hcatalog.pig.HCatLoader();"); -+ server.registerQuery("P1filter = filter P1 by bkt == '0';"); -+ Iterator P1Iter = server.openIterator("P1filter"); -+ assertFalse(P1Iter.hasNext()); -+ -+ server.registerQuery("P2 = load '" + PARTITIONED_TABLE + "' using org.apache.hive.hcatalog.pig.HCatLoader();"); -+ server.registerQuery("P2filter = filter P2 by bkt == '1';"); -+ Iterator P2Iter = server.openIterator("P2filter"); -+ int count2 = 0; -+ while (P2Iter.hasNext()) { -+ Tuple t = P2Iter.next(); -+ assertEquals("1", t.get(2)); -+ assertTrue(((Integer) t.get(0)) > 1); -+ count2++; -+ } -+ assertEquals(6, count2); -+ } -+ -+ private static boolean removeDirectory(File dir) { -+ boolean success = false; -+ if (dir.isDirectory()) { -+ File[] files = dir.listFiles(); -+ if (files != null && files.length > 0) { -+ for (File file : files) { -+ success = removeDirectory(file); -+ if (!success) { -+ return false; -+ } ++ @Override ++ public void dropConstraint(String dbName, String tableName, ++ String constraintName) throws NoSuchObjectException { ++ // TODO Auto-generated method stub ++ } + } + + +diff --git a/ql/src/java/org/apache/hadoop/hive/ql/exec/DDLTask.java b/ql/src/java/org/apache/hadoop/hive/ql/exec/DDLTask.java +index 9887d77..c4d3bfb 100644 +--- a/ql/src/java/org/apache/hadoop/hive/ql/exec/DDLTask.java ++++ b/ql/src/java/org/apache/hadoop/hive/ql/exec/DDLTask.java +@@ -131,6 +131,7 @@ + import org.apache.hadoop.hive.ql.parse.BaseSemanticAnalyzer; + import org.apache.hadoop.hive.ql.parse.DDLSemanticAnalyzer; + import org.apache.hadoop.hive.ql.parse.ReplicationSpec; ++import org.apache.hadoop.hive.ql.parse.SemanticException; + import org.apache.hadoop.hive.ql.plan.AddPartitionDesc; + import org.apache.hadoop.hive.ql.plan.AlterDatabaseDesc; + import org.apache.hadoop.hive.ql.plan.AlterIndexDesc; +@@ -356,7 +357,11 @@ public int execute(DriverContext driverContext) { + + AlterTableDesc alterTbl = work.getAlterTblDesc(); + if (alterTbl != null) { +- return alterTable(db, alterTbl); ++ if (alterTbl.getOp() == AlterTableTypes.DROPCONSTRAINT ) { ++ return dropConstraint(db, alterTbl); ++ } else { ++ return alterTable(db, alterTbl); + } + } + + CreateViewDesc crtView = work.getCreateViewDesc(); +@@ -3596,7 +3601,19 @@ private int alterTableOrSinglePartition(AlterTableDesc alterTbl, Table tbl, Part + return 0; + } + +- /** ++ private int dropConstraint(Hive db, AlterTableDesc alterTbl) ++ throws SemanticException, HiveException { ++ try { ++ db.dropConstraint(Utilities.getDatabaseName(alterTbl.getOldName()), ++ Utilities.getTableName(alterTbl.getOldName()), ++ alterTbl.getConstraintName()); ++ } catch (NoSuchObjectException e) { ++ throw new HiveException(e); + } -+ success = dir.delete(); -+ } else { -+ success = dir.delete(); ++ return 0; ++ } ++ ++ /** + * Drop a given table or some partitions. DropTableDesc is currently used for both. + * + * @param db +diff --git a/ql/src/java/org/apache/hadoop/hive/ql/hooks/WriteEntity.java b/ql/src/java/org/apache/hadoop/hive/ql/hooks/WriteEntity.java +index 515f8b2..2194a6d 100644 +--- a/ql/src/java/org/apache/hadoop/hive/ql/hooks/WriteEntity.java ++++ b/ql/src/java/org/apache/hadoop/hive/ql/hooks/WriteEntity.java +@@ -203,7 +203,8 @@ public static WriteType determineAlterTableWriteType(AlterTableDesc.AlterTableTy + case ADDCOLS: + case RENAME: + case TRUNCATE: +- case MERGEFILES: return WriteType.DDL_EXCLUSIVE; ++ case MERGEFILES: ++ case DROPCONSTRAINT: return WriteType.DDL_EXCLUSIVE; + + case ADDPARTITION: + case ADDSERDEPROPS: +diff --git a/ql/src/java/org/apache/hadoop/hive/ql/metadata/Hive.java b/ql/src/java/org/apache/hadoop/hive/ql/metadata/Hive.java +index 26c458c..6862f70 100644 +--- a/ql/src/java/org/apache/hadoop/hive/ql/metadata/Hive.java ++++ b/ql/src/java/org/apache/hadoop/hive/ql/metadata/Hive.java +@@ -3593,4 +3593,13 @@ public long getPermanenFunctionsChangeVersion() throws HiveException { + } + } + ++ public void dropConstraint(String dbName, String tableName, String constraintName) ++ throws HiveException, NoSuchObjectException { ++ try { ++ getMSC().dropConstraint(dbName, tableName, constraintName); ++ } catch (Exception e) { ++ throw new HiveException(e); + } -+ return success; + } -+} ++ + }; +diff --git a/ql/src/java/org/apache/hadoop/hive/ql/parse/DDLSemanticAnalyzer.java b/ql/src/java/org/apache/hadoop/hive/ql/parse/DDLSemanticAnalyzer.java +index 04e2a41..4a6617f 100644 +--- a/ql/src/java/org/apache/hadoop/hive/ql/parse/DDLSemanticAnalyzer.java ++++ b/ql/src/java/org/apache/hadoop/hive/ql/parse/DDLSemanticAnalyzer.java +@@ -26,7 +26,6 @@ + import org.slf4j.LoggerFactory; + import org.apache.hadoop.fs.FileSystem; + import org.apache.hadoop.fs.Path; +-import org.apache.hadoop.hive.common.FileUtils; + import org.apache.hadoop.hive.common.JavaUtils; + import org.apache.hadoop.hive.common.StatsSetupConst; + import org.apache.hadoop.hive.conf.HiveConf; +@@ -88,7 +87,6 @@ + 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.DDLDesc; + import org.apache.hadoop.hive.ql.plan.DDLWork; + import org.apache.hadoop.hive.ql.plan.DescDatabaseDesc; + import org.apache.hadoop.hive.ql.plan.DescFunctionDesc; +@@ -321,6 +319,8 @@ public void analyzeInternal(ASTNode input) throws SemanticException { + analyzeAlterTableCompact(ast, tableName, partSpec); + } else if(ast.getToken().getType() == HiveParser.TOK_ALTERTABLE_UPDATECOLSTATS){ + analyzeAlterTableUpdateStats(ast, tableName, partSpec); ++ } else if(ast.getToken().getType() == HiveParser.TOK_ALTERTABLE_DROPCONSTRAINT) { ++ analyzeAlterTableDropConstraint(ast, tableName); + } + break; + } +@@ -1740,6 +1740,15 @@ private void analyzeAlterTableCompact(ASTNode ast, String tableName, + rootTasks.add(TaskFactory.get(new DDLWork(getInputs(), getOutputs(), desc), conf)); + } + ++ private void analyzeAlterTableDropConstraint(ASTNode ast, String tableName) ++ throws SemanticException { ++ String dropConstraintName = unescapeIdentifier(ast.getChild(0).getText()); ++ AlterTableDesc alterTblDesc = new AlterTableDesc(tableName, dropConstraintName); ++ ++ rootTasks.add(TaskFactory.get(new DDLWork(getInputs(), getOutputs(), ++ alterTblDesc), conf)); ++ } ++ + static HashMap getProps(ASTNode prop) { + // Must be deterministic order map for consistent q-test output across Java versions + HashMap mapProp = new LinkedHashMap(); +diff --git a/ql/src/java/org/apache/hadoop/hive/ql/parse/HiveParser.g b/ql/src/java/org/apache/hadoop/hive/ql/parse/HiveParser.g +index 6531b03..2c66396 100644 +--- a/ql/src/java/org/apache/hadoop/hive/ql/parse/HiveParser.g ++++ b/ql/src/java/org/apache/hadoop/hive/ql/parse/HiveParser.g +@@ -179,6 +179,7 @@ TOK_ALTERTABLE_SKEWED_LOCATION; + TOK_ALTERTABLE_BUCKETS; + TOK_ALTERTABLE_CLUSTER_SORT; + TOK_ALTERTABLE_COMPACT; ++TOK_ALTERTABLE_DROPCONSTRAINT; + TOK_ALTERINDEX_REBUILD; + TOK_ALTERINDEX_PROPERTIES; + TOK_MSCK; +@@ -1040,6 +1041,7 @@ alterTableStatementSuffix + | alterStatementSuffixSkewedby + | alterStatementSuffixExchangePartition + | alterStatementPartitionKeyType ++ | alterStatementSuffixDropConstraint + | partitionSpec? alterTblPartitionStatementSuffix -> alterTblPartitionStatementSuffix partitionSpec? + ; + +@@ -1129,6 +1131,13 @@ alterStatementSuffixAddCol + -> ^(TOK_ALTERTABLE_REPLACECOLS columnNameTypeList restrictOrCascade?) + ; + ++alterStatementSuffixDropConstraint ++@init { pushMsg("drop constraint statement", state); } ++@after { popMsg(state); } ++ : KW_DROP KW_CONSTRAINT cName=identifier ++ ->^(TOK_ALTERTABLE_DROPCONSTRAINT $cName) ++ ; ++ + alterStatementSuffixRenameCol + @init { pushMsg("rename column name", state); } + @after { popMsg(state); } +diff --git a/ql/src/java/org/apache/hadoop/hive/ql/parse/SemanticAnalyzerFactory.java b/ql/src/java/org/apache/hadoop/hive/ql/parse/SemanticAnalyzerFactory.java +index fb8a33c..7b83381 100644 +--- a/ql/src/java/org/apache/hadoop/hive/ql/parse/SemanticAnalyzerFactory.java ++++ b/ql/src/java/org/apache/hadoop/hive/ql/parse/SemanticAnalyzerFactory.java +@@ -62,6 +62,7 @@ + commandType.put(HiveParser.TOK_ALTERTABLE_PROPERTIES, HiveOperation.ALTERTABLE_PROPERTIES); + commandType.put(HiveParser.TOK_ALTERTABLE_DROPPROPERTIES, HiveOperation.ALTERTABLE_PROPERTIES); + commandType.put(HiveParser.TOK_ALTERTABLE_EXCHANGEPARTITION, HiveOperation.ALTERTABLE_EXCHANGEPARTITION); ++ commandType.put(HiveParser.TOK_ALTERTABLE_DROPCONSTRAINT, HiveOperation.ALTERTABLE_DROPCONSTRAINT); + commandType.put(HiveParser.TOK_SHOWDATABASES, HiveOperation.SHOWDATABASES); + commandType.put(HiveParser.TOK_SHOWTABLES, HiveOperation.SHOWTABLES); + commandType.put(HiveParser.TOK_SHOWCOLUMNS, HiveOperation.SHOWCOLUMNS); +@@ -195,6 +196,7 @@ public static BaseSemanticAnalyzer get(QueryState queryState, ASTNode tree) + case HiveParser.TOK_ALTERTABLE_DROPPROPERTIES: + case HiveParser.TOK_ALTERTABLE_EXCHANGEPARTITION: + case HiveParser.TOK_ALTERTABLE_SKEWED: ++ case HiveParser.TOK_ALTERTABLE_DROPCONSTRAINT: + queryState.setCommandType(commandType.get(child.getType())); + return new DDLSemanticAnalyzer(queryState); + } +diff --git a/ql/src/java/org/apache/hadoop/hive/ql/plan/AlterTableDesc.java b/ql/src/java/org/apache/hadoop/hive/ql/plan/AlterTableDesc.java +index 4ba51ec..38d8d5a 100644 +--- a/ql/src/java/org/apache/hadoop/hive/ql/plan/AlterTableDesc.java ++++ b/ql/src/java/org/apache/hadoop/hive/ql/plan/AlterTableDesc.java +@@ -56,7 +56,7 @@ + DROPPARTITION("drop partition"), RENAMEPARTITION("rename partition"), ADDSKEWEDBY("add skew column"), + ALTERSKEWEDLOCATION("alter skew location"), ALTERBUCKETNUM("alter bucket number"), + ALTERPARTITION("alter partition"), COMPACT("compact"), +- TRUNCATE("truncate"), MERGEFILES("merge files"); ++ TRUNCATE("truncate"), MERGEFILES("merge files"), DROPCONSTRAINT("drop constraint"); + ; + + private final String name; +@@ -116,6 +116,7 @@ + boolean isTurnOffSorting = false; + boolean isCascade = false; + EnvironmentContext environmentContext; ++ String dropConstraintName; + + public AlterTableDesc() { + } +@@ -263,6 +264,12 @@ public AlterTableDesc(String tableName, HashMap partSpec, int nu + this.numberBuckets = numBuckets; + } + ++ public AlterTableDesc(String tableName, String dropConstraintName) { ++ this.oldName = tableName; ++ this.dropConstraintName = dropConstraintName; ++ op = AlterTableTypes.DROPCONSTRAINT; ++ } ++ + @Explain(displayName = "new columns", explainLevels = { Level.USER, Level.DEFAULT, Level.EXTENDED }) + public List getNewColsString() { + return Utilities.getFieldSchemaString(getNewCols()); +@@ -408,6 +415,22 @@ public String getStorageHandler() { + } + + /** ++ * @return the drop constraint name of the table ++ */ ++ @Explain(displayName = "drop constraint name", explainLevels = { Level.USER, Level.DEFAULT, Level.EXTENDED }) ++ public String getConstraintName() { ++ return dropConstraintName; ++ } ++ ++ /** ++ * @param constraintName ++ * the dropConstraintName to set ++ */ ++ public void setDropConstraintName(String constraintName) { ++ this.dropConstraintName = constraintName; ++ } ++ ++ /** + * @param storageHandler + * the storage handler to set + */ +diff --git a/ql/src/java/org/apache/hadoop/hive/ql/plan/HiveOperation.java b/ql/src/java/org/apache/hadoop/hive/ql/plan/HiveOperation.java +index 188cd6f..e651016 100644 +--- a/ql/src/java/org/apache/hadoop/hive/ql/plan/HiveOperation.java ++++ b/ql/src/java/org/apache/hadoop/hive/ql/plan/HiveOperation.java +@@ -115,6 +115,8 @@ + new Privilege[] {Privilege.ALTER_DATA}, null), + ALTERTABLE_PARTCOLTYPE("ALTERTABLE_PARTCOLTYPE", new Privilege[] { Privilege.SELECT }, new Privilege[] { Privilege.ALTER_DATA }), + ALTERTABLE_EXCHANGEPARTITION("ALTERTABLE_EXCHANGEPARTITION", null, null), ++ ALTERTABLE_DROPCONSTRAINT("ALTERTABLE_DROPCONSTRAINT", ++ new Privilege[]{Privilege.ALTER_METADATA}, null), + ALTERVIEW_RENAME("ALTERVIEW_RENAME", new Privilege[] {Privilege.ALTER_METADATA}, null), + ALTERVIEW_AS("ALTERVIEW_AS", new Privilege[] {Privilege.ALTER_METADATA}, null), + ALTERTABLE_COMPACT("ALTERTABLE_COMPACT", new Privilege[]{Privilege.SELECT}, new Privilege[]{Privilege.ALTER_DATA}), +diff --git a/ql/src/test/queries/clientnegative/drop_invalid_constraint1.q b/ql/src/test/queries/clientnegative/drop_invalid_constraint1.q +new file mode 100644 +index 0000000..2055f9e +--- /dev/null ++++ b/ql/src/test/queries/clientnegative/drop_invalid_constraint1.q +@@ -0,0 +1,3 @@ ++CREATE TABLE table1 (a STRING, b STRING, constraint pk1 primary key (a) disable novalidate); ++ALTER TABLE table1 DROP CONSTRAINT pk1; ++ALTER TABLE table1 DROP CONSTRAINT pk1; +diff --git a/ql/src/test/queries/clientnegative/drop_invalid_constraint2.q b/ql/src/test/queries/clientnegative/drop_invalid_constraint2.q +new file mode 100644 +index 0000000..d253617 +--- /dev/null ++++ b/ql/src/test/queries/clientnegative/drop_invalid_constraint2.q +@@ -0,0 +1,2 @@ ++CREATE TABLE table2 (a STRING, b STRING, constraint pk1 primary key (a) disable novalidate); ++ALTER TABLE table1 DROP CONSTRAINT pk1; +diff --git a/ql/src/test/queries/clientnegative/drop_invalid_constraint3.q b/ql/src/test/queries/clientnegative/drop_invalid_constraint3.q +new file mode 100644 +index 0000000..04eb1fb +--- /dev/null ++++ b/ql/src/test/queries/clientnegative/drop_invalid_constraint3.q +@@ -0,0 +1,2 @@ ++CREATE TABLE table2 (a STRING, b STRING, constraint pk1 primary key (a) disable novalidate); ++ALTER TABLE table2 DROP CONSTRAINT pk2; +diff --git a/ql/src/test/queries/clientnegative/drop_invalid_constraint4.q b/ql/src/test/queries/clientnegative/drop_invalid_constraint4.q +new file mode 100644 +index 0000000..3cf2d2a +--- /dev/null ++++ b/ql/src/test/queries/clientnegative/drop_invalid_constraint4.q +@@ -0,0 +1,3 @@ ++CREATE TABLE table1 (a STRING, b STRING, constraint pk1 primary key (a) disable novalidate); ++CREATE TABLE table2 (a STRING, b STRING, constraint pk2 primary key (a) disable novalidate); ++ALTER TABLE table1 DROP CONSTRAINT pk2; +\ No newline at end of file +diff --git a/ql/src/test/queries/clientpositive/create_with_constraints.q b/ql/src/test/queries/clientpositive/create_with_constraints.q +index eef0c64..0bb92e4 100644 +--- a/ql/src/test/queries/clientpositive/create_with_constraints.q ++++ b/ql/src/test/queries/clientpositive/create_with_constraints.q +@@ -8,5 +8,17 @@ CREATE TABLE table6 (x string, y string, PRIMARY KEY (x) disable novalidate, FOR + CONSTRAINT fk4 FOREIGN KEY (y) REFERENCES table1(a) DISABLE NOVALIDATE); + CREATE TABLE table7 (a STRING, b STRING, primary key (a) disable novalidate rely); + CREATE TABLE table8 (a STRING, b STRING, constraint pk8 primary key (a) disable novalidate norely); ++CREATE TABLE table9 (a STRING, b STRING, primary key (a, b) disable novalidate rely); ++CREATE TABLE table10 (a STRING, b STRING, constraint pk10 primary key (a) disable novalidate norely, foreign key (a, b) references table9(a, b) disable novalidate); ++CREATE TABLE table11 (a STRING, b STRING, c STRING, constraint pk11 primary key (a) disable novalidate rely, foreign key (a, b) references table9(a, b) disable novalidate, ++foreign key (c) references table4(x) disable novalidate); + ++ALTER TABLE table2 DROP CONSTRAINT pk1; ++ALTER TABLE table3 DROP CONSTRAINT fk1; ++ALTER TABLE table6 DROP CONSTRAINT fk4; + ++CREATE DATABASE dbconstraint; ++USE dbconstraint; ++CREATE TABLE table2 (a STRING, b STRING, constraint pk1 primary key (a) disable novalidate); ++USE default; ++ALTER TABLE dbconstraint.table2 DROP CONSTRAINT pk1; +diff --git a/ql/src/test/results/clientnegative/drop_invalid_constraint1.q.out b/ql/src/test/results/clientnegative/drop_invalid_constraint1.q.out +new file mode 100644 +index 0000000..042827f +--- /dev/null ++++ b/ql/src/test/results/clientnegative/drop_invalid_constraint1.q.out +@@ -0,0 +1,17 @@ ++PREHOOK: query: CREATE TABLE table1 (a STRING, b STRING, constraint pk1 primary key (a) disable novalidate) ++PREHOOK: type: CREATETABLE ++PREHOOK: Output: database:default ++PREHOOK: Output: default@table1 ++POSTHOOK: query: CREATE TABLE table1 (a STRING, b STRING, constraint pk1 primary key (a) disable novalidate) ++POSTHOOK: type: CREATETABLE ++POSTHOOK: Output: database:default ++POSTHOOK: Output: default@table1 ++PREHOOK: query: ALTER TABLE table1 DROP CONSTRAINT pk1 ++PREHOOK: type: ALTERTABLE_DROPCONSTRAINT ++POSTHOOK: query: ALTER TABLE table1 DROP CONSTRAINT pk1 ++POSTHOOK: type: ALTERTABLE_DROPCONSTRAINT ++POSTHOOK: Input: default@table1 ++POSTHOOK: Output: default@table1 ++PREHOOK: query: ALTER TABLE table1 DROP CONSTRAINT pk1 ++PREHOOK: type: ALTERTABLE_DROPCONSTRAINT ++FAILED: Execution Error, return code 1 from org.apache.hadoop.hive.ql.exec.DDLTask. InvalidObjectException(message:The constraint: pk1 does not exist for the associated table: default.table1) +diff --git a/ql/src/test/results/clientnegative/drop_invalid_constraint2.q.out b/ql/src/test/results/clientnegative/drop_invalid_constraint2.q.out +new file mode 100644 +index 0000000..5dae7c2 +--- /dev/null ++++ b/ql/src/test/results/clientnegative/drop_invalid_constraint2.q.out +@@ -0,0 +1,11 @@ ++PREHOOK: query: CREATE TABLE table2 (a STRING, b STRING, constraint pk1 primary key (a) disable novalidate) ++PREHOOK: type: CREATETABLE ++PREHOOK: Output: database:default ++PREHOOK: Output: default@table2 ++POSTHOOK: query: CREATE TABLE table2 (a STRING, b STRING, constraint pk1 primary key (a) disable novalidate) ++POSTHOOK: type: CREATETABLE ++POSTHOOK: Output: database:default ++POSTHOOK: Output: default@table2 ++PREHOOK: query: ALTER TABLE table1 DROP CONSTRAINT pk1 ++PREHOOK: type: ALTERTABLE_DROPCONSTRAINT ++FAILED: Execution Error, return code 1 from org.apache.hadoop.hive.ql.exec.DDLTask. Table not found table1 +diff --git a/ql/src/test/results/clientnegative/drop_invalid_constraint3.q.out b/ql/src/test/results/clientnegative/drop_invalid_constraint3.q.out +new file mode 100644 +index 0000000..9c60e94 +--- /dev/null ++++ b/ql/src/test/results/clientnegative/drop_invalid_constraint3.q.out +@@ -0,0 +1,11 @@ ++PREHOOK: query: CREATE TABLE table2 (a STRING, b STRING, constraint pk1 primary key (a) disable novalidate) ++PREHOOK: type: CREATETABLE ++PREHOOK: Output: database:default ++PREHOOK: Output: default@table2 ++POSTHOOK: query: CREATE TABLE table2 (a STRING, b STRING, constraint pk1 primary key (a) disable novalidate) ++POSTHOOK: type: CREATETABLE ++POSTHOOK: Output: database:default ++POSTHOOK: Output: default@table2 ++PREHOOK: query: ALTER TABLE table2 DROP CONSTRAINT pk2 ++PREHOOK: type: ALTERTABLE_DROPCONSTRAINT ++FAILED: Execution Error, return code 1 from org.apache.hadoop.hive.ql.exec.DDLTask. InvalidObjectException(message:The constraint: pk2 does not exist for the associated table: default.table2) +diff --git a/ql/src/test/results/clientnegative/drop_invalid_constraint4.q.out b/ql/src/test/results/clientnegative/drop_invalid_constraint4.q.out +new file mode 100644 +index 0000000..1d93c42 +--- /dev/null ++++ b/ql/src/test/results/clientnegative/drop_invalid_constraint4.q.out +@@ -0,0 +1,19 @@ ++PREHOOK: query: CREATE TABLE table1 (a STRING, b STRING, constraint pk1 primary key (a) disable novalidate) ++PREHOOK: type: CREATETABLE ++PREHOOK: Output: database:default ++PREHOOK: Output: default@table1 ++POSTHOOK: query: CREATE TABLE table1 (a STRING, b STRING, constraint pk1 primary key (a) disable novalidate) ++POSTHOOK: type: CREATETABLE ++POSTHOOK: Output: database:default ++POSTHOOK: Output: default@table1 ++PREHOOK: query: CREATE TABLE table2 (a STRING, b STRING, constraint pk2 primary key (a) disable novalidate) ++PREHOOK: type: CREATETABLE ++PREHOOK: Output: database:default ++PREHOOK: Output: default@table2 ++POSTHOOK: query: CREATE TABLE table2 (a STRING, b STRING, constraint pk2 primary key (a) disable novalidate) ++POSTHOOK: type: CREATETABLE ++POSTHOOK: Output: database:default ++POSTHOOK: Output: default@table2 ++PREHOOK: query: ALTER TABLE table1 DROP CONSTRAINT pk2 ++PREHOOK: type: ALTERTABLE_DROPCONSTRAINT ++FAILED: Execution Error, return code 1 from org.apache.hadoop.hive.ql.exec.DDLTask. InvalidObjectException(message:The constraint: pk2 does not exist for the associated table: default.table1) +diff --git a/ql/src/test/results/clientpositive/create_with_constraints.q.out b/ql/src/test/results/clientpositive/create_with_constraints.q.out +index 5cf8d83..351c71e 100644 +--- a/ql/src/test/results/clientpositive/create_with_constraints.q.out ++++ b/ql/src/test/results/clientpositive/create_with_constraints.q.out +@@ -66,3 +66,79 @@ POSTHOOK: query: CREATE TABLE table8 (a STRING, b STRING, constraint pk8 primary + POSTHOOK: type: CREATETABLE + POSTHOOK: Output: database:default + POSTHOOK: Output: default@table8 ++PREHOOK: query: CREATE TABLE table9 (a STRING, b STRING, primary key (a, b) disable novalidate rely) ++PREHOOK: type: CREATETABLE ++PREHOOK: Output: database:default ++PREHOOK: Output: default@table9 ++POSTHOOK: query: CREATE TABLE table9 (a STRING, b STRING, primary key (a, b) disable novalidate rely) ++POSTHOOK: type: CREATETABLE ++POSTHOOK: Output: database:default ++POSTHOOK: Output: default@table9 ++PREHOOK: query: CREATE TABLE table10 (a STRING, b STRING, constraint pk10 primary key (a) disable novalidate norely, foreign key (a, b) references table9(a, b) disable novalidate) ++PREHOOK: type: CREATETABLE ++PREHOOK: Output: database:default ++PREHOOK: Output: default@table10 ++POSTHOOK: query: CREATE TABLE table10 (a STRING, b STRING, constraint pk10 primary key (a) disable novalidate norely, foreign key (a, b) references table9(a, b) disable novalidate) ++POSTHOOK: type: CREATETABLE ++POSTHOOK: Output: database:default ++POSTHOOK: Output: default@table10 ++PREHOOK: query: CREATE TABLE table11 (a STRING, b STRING, c STRING, constraint pk11 primary key (a) disable novalidate rely, foreign key (a, b) references table9(a, b) disable novalidate, ++foreign key (c) references table4(x) disable novalidate) ++PREHOOK: type: CREATETABLE ++PREHOOK: Output: database:default ++PREHOOK: Output: default@table11 ++POSTHOOK: query: CREATE TABLE table11 (a STRING, b STRING, c STRING, constraint pk11 primary key (a) disable novalidate rely, foreign key (a, b) references table9(a, b) disable novalidate, ++foreign key (c) references table4(x) disable novalidate) ++POSTHOOK: type: CREATETABLE ++POSTHOOK: Output: database:default ++POSTHOOK: Output: default@table11 ++PREHOOK: query: ALTER TABLE table2 DROP CONSTRAINT pk1 ++PREHOOK: type: ALTERTABLE_DROPCONSTRAINT ++POSTHOOK: query: ALTER TABLE table2 DROP CONSTRAINT pk1 ++POSTHOOK: type: ALTERTABLE_DROPCONSTRAINT ++POSTHOOK: Input: default@table2 ++POSTHOOK: Output: default@table2 ++PREHOOK: query: ALTER TABLE table3 DROP CONSTRAINT fk1 ++PREHOOK: type: ALTERTABLE_DROPCONSTRAINT ++POSTHOOK: query: ALTER TABLE table3 DROP CONSTRAINT fk1 ++POSTHOOK: type: ALTERTABLE_DROPCONSTRAINT ++POSTHOOK: Input: default@table3 ++POSTHOOK: Output: default@table3 ++PREHOOK: query: ALTER TABLE table6 DROP CONSTRAINT fk4 ++PREHOOK: type: ALTERTABLE_DROPCONSTRAINT ++POSTHOOK: query: ALTER TABLE table6 DROP CONSTRAINT fk4 ++POSTHOOK: type: ALTERTABLE_DROPCONSTRAINT ++POSTHOOK: Input: default@table6 ++POSTHOOK: Output: default@table6 ++PREHOOK: query: CREATE DATABASE dbconstraint ++PREHOOK: type: CREATEDATABASE ++PREHOOK: Output: database:dbconstraint ++POSTHOOK: query: CREATE DATABASE dbconstraint ++POSTHOOK: type: CREATEDATABASE ++POSTHOOK: Output: database:dbconstraint ++PREHOOK: query: USE dbconstraint ++PREHOOK: type: SWITCHDATABASE ++PREHOOK: Input: database:dbconstraint ++POSTHOOK: query: USE dbconstraint ++POSTHOOK: type: SWITCHDATABASE ++POSTHOOK: Input: database:dbconstraint ++PREHOOK: query: CREATE TABLE table2 (a STRING, b STRING, constraint pk1 primary key (a) disable novalidate) ++PREHOOK: type: CREATETABLE ++PREHOOK: Output: database:dbconstraint ++PREHOOK: Output: dbconstraint@table2 ++POSTHOOK: query: CREATE TABLE table2 (a STRING, b STRING, constraint pk1 primary key (a) disable novalidate) ++POSTHOOK: type: CREATETABLE ++POSTHOOK: Output: database:dbconstraint ++POSTHOOK: Output: dbconstraint@table2 ++PREHOOK: query: USE default ++PREHOOK: type: SWITCHDATABASE ++PREHOOK: Input: database:default ++POSTHOOK: query: USE default ++POSTHOOK: type: SWITCHDATABASE ++POSTHOOK: Input: database:default ++PREHOOK: query: ALTER TABLE dbconstraint.table2 DROP CONSTRAINT pk1 ++PREHOOK: type: ALTERTABLE_DROPCONSTRAINT ++POSTHOOK: query: ALTER TABLE dbconstraint.table2 DROP CONSTRAINT pk1 ++POSTHOOK: type: ALTERTABLE_DROPCONSTRAINT ++POSTHOOK: Input: dbconstraint@table2 ++POSTHOOK: Output: dbconstraint@table2 +diff --git a/service/src/gen/thrift/gen-py/__init__.py b/service/src/gen/thrift/gen-py/__init__.py +deleted file mode 100644 +index e69de29..0000000 diff --git a/metastore/if/hive_metastore.thrift b/metastore/if/hive_metastore.thrift index acebf7a..c8d78b6 100755 --- a/metastore/if/hive_metastore.thrift +++ b/metastore/if/hive_metastore.thrift @@ -487,6 +487,11 @@ struct ForeignKeysResponse { 1: required list foreignKeys } +struct DropConstraintRequest { + 1: required string dbname, + 2: required string tablename, + 3: required string constraintname +} // Return type for get_partitions_by_expr struct PartitionsByExprResult { @@ -993,6 +998,9 @@ service ThriftHiveMetastore extends fb303.FacebookService throws (1:AlreadyExistsException o1, 2:InvalidObjectException o2, 3:MetaException o3, 4:NoSuchObjectException o4) + void drop_constraint(1:DropConstraintRequest req) + throws(1:NoSuchObjectException o1, 2:MetaException o3) + // drops the table and all the partitions associated with it if the table has partitions // delete data (including partitions) if deleteData is set to true void drop_table(1:string dbname, 2:string name, 3:bool deleteData) diff --git a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp index 690c895..2734a1c 100644 --- a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp +++ b/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 _size749; - ::apache::thrift::protocol::TType _etype752; - xfer += iprot->readListBegin(_etype752, _size749); - this->success.resize(_size749); - uint32_t _i753; - for (_i753 = 0; _i753 < _size749; ++_i753) + uint32_t _size751; + ::apache::thrift::protocol::TType _etype754; + xfer += iprot->readListBegin(_etype754, _size751); + this->success.resize(_size751); + uint32_t _i755; + for (_i755 = 0; _i755 < _size751; ++_i755) { - xfer += iprot->readString(this->success[_i753]); + xfer += iprot->readString(this->success[_i755]); } 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 _iter754; - for (_iter754 = this->success.begin(); _iter754 != this->success.end(); ++_iter754) + std::vector ::const_iterator _iter756; + for (_iter756 = this->success.begin(); _iter756 != this->success.end(); ++_iter756) { - xfer += oprot->writeString((*_iter754)); + xfer += oprot->writeString((*_iter756)); } 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 _size755; - ::apache::thrift::protocol::TType _etype758; - xfer += iprot->readListBegin(_etype758, _size755); - (*(this->success)).resize(_size755); - uint32_t _i759; - for (_i759 = 0; _i759 < _size755; ++_i759) + uint32_t _size757; + ::apache::thrift::protocol::TType _etype760; + xfer += iprot->readListBegin(_etype760, _size757); + (*(this->success)).resize(_size757); + uint32_t _i761; + for (_i761 = 0; _i761 < _size757; ++_i761) { - xfer += iprot->readString((*(this->success))[_i759]); + xfer += iprot->readString((*(this->success))[_i761]); } 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 _size760; - ::apache::thrift::protocol::TType _etype763; - xfer += iprot->readListBegin(_etype763, _size760); - this->success.resize(_size760); - uint32_t _i764; - for (_i764 = 0; _i764 < _size760; ++_i764) + uint32_t _size762; + ::apache::thrift::protocol::TType _etype765; + xfer += iprot->readListBegin(_etype765, _size762); + this->success.resize(_size762); + uint32_t _i766; + for (_i766 = 0; _i766 < _size762; ++_i766) { - xfer += iprot->readString(this->success[_i764]); + xfer += iprot->readString(this->success[_i766]); } 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 _iter765; - for (_iter765 = this->success.begin(); _iter765 != this->success.end(); ++_iter765) + std::vector ::const_iterator _iter767; + for (_iter767 = this->success.begin(); _iter767 != this->success.end(); ++_iter767) { - xfer += oprot->writeString((*_iter765)); + xfer += oprot->writeString((*_iter767)); } 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 _size766; - ::apache::thrift::protocol::TType _etype769; - xfer += iprot->readListBegin(_etype769, _size766); - (*(this->success)).resize(_size766); - uint32_t _i770; - for (_i770 = 0; _i770 < _size766; ++_i770) + uint32_t _size768; + ::apache::thrift::protocol::TType _etype771; + xfer += iprot->readListBegin(_etype771, _size768); + (*(this->success)).resize(_size768); + uint32_t _i772; + for (_i772 = 0; _i772 < _size768; ++_i772) { - xfer += iprot->readString((*(this->success))[_i770]); + xfer += iprot->readString((*(this->success))[_i772]); } 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 _size771; - ::apache::thrift::protocol::TType _ktype772; - ::apache::thrift::protocol::TType _vtype773; - xfer += iprot->readMapBegin(_ktype772, _vtype773, _size771); - uint32_t _i775; - for (_i775 = 0; _i775 < _size771; ++_i775) + uint32_t _size773; + ::apache::thrift::protocol::TType _ktype774; + ::apache::thrift::protocol::TType _vtype775; + xfer += iprot->readMapBegin(_ktype774, _vtype775, _size773); + uint32_t _i777; + for (_i777 = 0; _i777 < _size773; ++_i777) { - std::string _key776; - xfer += iprot->readString(_key776); - Type& _val777 = this->success[_key776]; - xfer += _val777.read(iprot); + std::string _key778; + xfer += iprot->readString(_key778); + Type& _val779 = this->success[_key778]; + xfer += _val779.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 _iter778; - for (_iter778 = this->success.begin(); _iter778 != this->success.end(); ++_iter778) + std::map ::const_iterator _iter780; + for (_iter780 = this->success.begin(); _iter780 != this->success.end(); ++_iter780) { - xfer += oprot->writeString(_iter778->first); - xfer += _iter778->second.write(oprot); + xfer += oprot->writeString(_iter780->first); + xfer += _iter780->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 _size779; - ::apache::thrift::protocol::TType _ktype780; - ::apache::thrift::protocol::TType _vtype781; - xfer += iprot->readMapBegin(_ktype780, _vtype781, _size779); - uint32_t _i783; - for (_i783 = 0; _i783 < _size779; ++_i783) + uint32_t _size781; + ::apache::thrift::protocol::TType _ktype782; + ::apache::thrift::protocol::TType _vtype783; + xfer += iprot->readMapBegin(_ktype782, _vtype783, _size781); + uint32_t _i785; + for (_i785 = 0; _i785 < _size781; ++_i785) { - std::string _key784; - xfer += iprot->readString(_key784); - Type& _val785 = (*(this->success))[_key784]; - xfer += _val785.read(iprot); + std::string _key786; + xfer += iprot->readString(_key786); + Type& _val787 = (*(this->success))[_key786]; + xfer += _val787.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 _size786; - ::apache::thrift::protocol::TType _etype789; - xfer += iprot->readListBegin(_etype789, _size786); - this->success.resize(_size786); - uint32_t _i790; - for (_i790 = 0; _i790 < _size786; ++_i790) + uint32_t _size788; + ::apache::thrift::protocol::TType _etype791; + xfer += iprot->readListBegin(_etype791, _size788); + this->success.resize(_size788); + uint32_t _i792; + for (_i792 = 0; _i792 < _size788; ++_i792) { - xfer += this->success[_i790].read(iprot); + xfer += this->success[_i792].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 _iter791; - for (_iter791 = this->success.begin(); _iter791 != this->success.end(); ++_iter791) + std::vector ::const_iterator _iter793; + for (_iter793 = this->success.begin(); _iter793 != this->success.end(); ++_iter793) { - xfer += (*_iter791).write(oprot); + xfer += (*_iter793).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 _size792; - ::apache::thrift::protocol::TType _etype795; - xfer += iprot->readListBegin(_etype795, _size792); - (*(this->success)).resize(_size792); - uint32_t _i796; - for (_i796 = 0; _i796 < _size792; ++_i796) + uint32_t _size794; + ::apache::thrift::protocol::TType _etype797; + xfer += iprot->readListBegin(_etype797, _size794); + (*(this->success)).resize(_size794); + uint32_t _i798; + for (_i798 = 0; _i798 < _size794; ++_i798) { - xfer += (*(this->success))[_i796].read(iprot); + xfer += (*(this->success))[_i798].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 _size797; - ::apache::thrift::protocol::TType _etype800; - xfer += iprot->readListBegin(_etype800, _size797); - this->success.resize(_size797); - uint32_t _i801; - for (_i801 = 0; _i801 < _size797; ++_i801) + uint32_t _size799; + ::apache::thrift::protocol::TType _etype802; + xfer += iprot->readListBegin(_etype802, _size799); + this->success.resize(_size799); + uint32_t _i803; + for (_i803 = 0; _i803 < _size799; ++_i803) { - xfer += this->success[_i801].read(iprot); + xfer += this->success[_i803].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 _iter802; - for (_iter802 = this->success.begin(); _iter802 != this->success.end(); ++_iter802) + std::vector ::const_iterator _iter804; + for (_iter804 = this->success.begin(); _iter804 != this->success.end(); ++_iter804) { - xfer += (*_iter802).write(oprot); + xfer += (*_iter804).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 _size803; - ::apache::thrift::protocol::TType _etype806; - xfer += iprot->readListBegin(_etype806, _size803); - (*(this->success)).resize(_size803); - uint32_t _i807; - for (_i807 = 0; _i807 < _size803; ++_i807) + uint32_t _size805; + ::apache::thrift::protocol::TType _etype808; + xfer += iprot->readListBegin(_etype808, _size805); + (*(this->success)).resize(_size805); + uint32_t _i809; + for (_i809 = 0; _i809 < _size805; ++_i809) { - xfer += (*(this->success))[_i807].read(iprot); + xfer += (*(this->success))[_i809].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 _size808; - ::apache::thrift::protocol::TType _etype811; - xfer += iprot->readListBegin(_etype811, _size808); - this->success.resize(_size808); - uint32_t _i812; - for (_i812 = 0; _i812 < _size808; ++_i812) + uint32_t _size810; + ::apache::thrift::protocol::TType _etype813; + xfer += iprot->readListBegin(_etype813, _size810); + this->success.resize(_size810); + uint32_t _i814; + for (_i814 = 0; _i814 < _size810; ++_i814) { - xfer += this->success[_i812].read(iprot); + xfer += this->success[_i814].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 _iter813; - for (_iter813 = this->success.begin(); _iter813 != this->success.end(); ++_iter813) + std::vector ::const_iterator _iter815; + for (_iter815 = this->success.begin(); _iter815 != this->success.end(); ++_iter815) { - xfer += (*_iter813).write(oprot); + xfer += (*_iter815).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 _size814; - ::apache::thrift::protocol::TType _etype817; - xfer += iprot->readListBegin(_etype817, _size814); - (*(this->success)).resize(_size814); - uint32_t _i818; - for (_i818 = 0; _i818 < _size814; ++_i818) + uint32_t _size816; + ::apache::thrift::protocol::TType _etype819; + xfer += iprot->readListBegin(_etype819, _size816); + (*(this->success)).resize(_size816); + uint32_t _i820; + for (_i820 = 0; _i820 < _size816; ++_i820) { - xfer += (*(this->success))[_i818].read(iprot); + xfer += (*(this->success))[_i820].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 _size819; - ::apache::thrift::protocol::TType _etype822; - xfer += iprot->readListBegin(_etype822, _size819); - this->success.resize(_size819); - uint32_t _i823; - for (_i823 = 0; _i823 < _size819; ++_i823) + uint32_t _size821; + ::apache::thrift::protocol::TType _etype824; + xfer += iprot->readListBegin(_etype824, _size821); + this->success.resize(_size821); + uint32_t _i825; + for (_i825 = 0; _i825 < _size821; ++_i825) { - xfer += this->success[_i823].read(iprot); + xfer += this->success[_i825].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 _iter824; - for (_iter824 = this->success.begin(); _iter824 != this->success.end(); ++_iter824) + std::vector ::const_iterator _iter826; + for (_iter826 = this->success.begin(); _iter826 != this->success.end(); ++_iter826) { - xfer += (*_iter824).write(oprot); + xfer += (*_iter826).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 _size825; - ::apache::thrift::protocol::TType _etype828; - xfer += iprot->readListBegin(_etype828, _size825); - (*(this->success)).resize(_size825); - uint32_t _i829; - for (_i829 = 0; _i829 < _size825; ++_i829) + uint32_t _size827; + ::apache::thrift::protocol::TType _etype830; + xfer += iprot->readListBegin(_etype830, _size827); + (*(this->success)).resize(_size827); + uint32_t _i831; + for (_i831 = 0; _i831 < _size827; ++_i831) { - xfer += (*(this->success))[_i829].read(iprot); + xfer += (*(this->success))[_i831].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 _size830; - ::apache::thrift::protocol::TType _etype833; - xfer += iprot->readListBegin(_etype833, _size830); - this->primaryKeys.resize(_size830); - uint32_t _i834; - for (_i834 = 0; _i834 < _size830; ++_i834) + uint32_t _size832; + ::apache::thrift::protocol::TType _etype835; + xfer += iprot->readListBegin(_etype835, _size832); + this->primaryKeys.resize(_size832); + uint32_t _i836; + for (_i836 = 0; _i836 < _size832; ++_i836) { - xfer += this->primaryKeys[_i834].read(iprot); + xfer += this->primaryKeys[_i836].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 _size835; - ::apache::thrift::protocol::TType _etype838; - xfer += iprot->readListBegin(_etype838, _size835); - this->foreignKeys.resize(_size835); - uint32_t _i839; - for (_i839 = 0; _i839 < _size835; ++_i839) + uint32_t _size837; + ::apache::thrift::protocol::TType _etype840; + xfer += iprot->readListBegin(_etype840, _size837); + this->foreignKeys.resize(_size837); + uint32_t _i841; + for (_i841 = 0; _i841 < _size837; ++_i841) { - xfer += this->foreignKeys[_i839].read(iprot); + xfer += this->foreignKeys[_i841].read(iprot); } xfer += iprot->readListEnd(); } @@ -4578,10 +4578,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 _iter840; - for (_iter840 = this->primaryKeys.begin(); _iter840 != this->primaryKeys.end(); ++_iter840) + std::vector ::const_iterator _iter842; + for (_iter842 = this->primaryKeys.begin(); _iter842 != this->primaryKeys.end(); ++_iter842) { - xfer += (*_iter840).write(oprot); + xfer += (*_iter842).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4590,10 +4590,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 _iter841; - for (_iter841 = this->foreignKeys.begin(); _iter841 != this->foreignKeys.end(); ++_iter841) + std::vector ::const_iterator _iter843; + for (_iter843 = this->foreignKeys.begin(); _iter843 != this->foreignKeys.end(); ++_iter843) { - xfer += (*_iter841).write(oprot); + xfer += (*_iter843).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4621,10 +4621,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 _iter842; - for (_iter842 = (*(this->primaryKeys)).begin(); _iter842 != (*(this->primaryKeys)).end(); ++_iter842) + std::vector ::const_iterator _iter844; + for (_iter844 = (*(this->primaryKeys)).begin(); _iter844 != (*(this->primaryKeys)).end(); ++_iter844) { - xfer += (*_iter842).write(oprot); + xfer += (*_iter844).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4633,10 +4633,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 _iter843; - for (_iter843 = (*(this->foreignKeys)).begin(); _iter843 != (*(this->foreignKeys)).end(); ++_iter843) + std::vector ::const_iterator _iter845; + for (_iter845 = (*(this->foreignKeys)).begin(); _iter845 != (*(this->foreignKeys)).end(); ++_iter845) { - xfer += (*_iter843).write(oprot); + xfer += (*_iter845).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4816,6 +4816,213 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_presult::read(::apach } +ThriftHiveMetastore_drop_constraint_args::~ThriftHiveMetastore_drop_constraint_args() throw() { +} + + +uint32_t ThriftHiveMetastore_drop_constraint_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->req.read(iprot); + this->__isset.req = 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_constraint_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_constraint_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(); + return xfer; +} + + +ThriftHiveMetastore_drop_constraint_pargs::~ThriftHiveMetastore_drop_constraint_pargs() throw() { +} + + +uint32_t ThriftHiveMetastore_drop_constraint_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_constraint_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(); + return xfer; +} + + +ThriftHiveMetastore_drop_constraint_result::~ThriftHiveMetastore_drop_constraint_result() throw() { +} + + +uint32_t ThriftHiveMetastore_drop_constraint_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->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_constraint_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_constraint_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.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_constraint_presult::~ThriftHiveMetastore_drop_constraint_presult() throw() { +} + + +uint32_t ThriftHiveMetastore_drop_constraint_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 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->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_drop_table_args::~ThriftHiveMetastore_drop_table_args() throw() { } @@ -5434,14 +5641,14 @@ uint32_t ThriftHiveMetastore_get_tables_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size844; - ::apache::thrift::protocol::TType _etype847; - xfer += iprot->readListBegin(_etype847, _size844); - this->success.resize(_size844); - uint32_t _i848; - for (_i848 = 0; _i848 < _size844; ++_i848) + uint32_t _size846; + ::apache::thrift::protocol::TType _etype849; + xfer += iprot->readListBegin(_etype849, _size846); + this->success.resize(_size846); + uint32_t _i850; + for (_i850 = 0; _i850 < _size846; ++_i850) { - xfer += iprot->readString(this->success[_i848]); + xfer += iprot->readString(this->success[_i850]); } xfer += iprot->readListEnd(); } @@ -5480,10 +5687,10 @@ uint32_t ThriftHiveMetastore_get_tables_result::write(::apache::thrift::protocol xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter849; - for (_iter849 = this->success.begin(); _iter849 != this->success.end(); ++_iter849) + std::vector ::const_iterator _iter851; + for (_iter851 = this->success.begin(); _iter851 != this->success.end(); ++_iter851) { - xfer += oprot->writeString((*_iter849)); + xfer += oprot->writeString((*_iter851)); } xfer += oprot->writeListEnd(); } @@ -5528,14 +5735,14 @@ uint32_t ThriftHiveMetastore_get_tables_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size850; - ::apache::thrift::protocol::TType _etype853; - xfer += iprot->readListBegin(_etype853, _size850); - (*(this->success)).resize(_size850); - uint32_t _i854; - for (_i854 = 0; _i854 < _size850; ++_i854) + uint32_t _size852; + ::apache::thrift::protocol::TType _etype855; + xfer += iprot->readListBegin(_etype855, _size852); + (*(this->success)).resize(_size852); + uint32_t _i856; + for (_i856 = 0; _i856 < _size852; ++_i856) { - xfer += iprot->readString((*(this->success))[_i854]); + xfer += iprot->readString((*(this->success))[_i856]); } xfer += iprot->readListEnd(); } @@ -5610,14 +5817,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 _size855; - ::apache::thrift::protocol::TType _etype858; - xfer += iprot->readListBegin(_etype858, _size855); - this->tbl_types.resize(_size855); - uint32_t _i859; - for (_i859 = 0; _i859 < _size855; ++_i859) + uint32_t _size857; + ::apache::thrift::protocol::TType _etype860; + xfer += iprot->readListBegin(_etype860, _size857); + this->tbl_types.resize(_size857); + uint32_t _i861; + for (_i861 = 0; _i861 < _size857; ++_i861) { - xfer += iprot->readString(this->tbl_types[_i859]); + xfer += iprot->readString(this->tbl_types[_i861]); } xfer += iprot->readListEnd(); } @@ -5654,10 +5861,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 _iter860; - for (_iter860 = this->tbl_types.begin(); _iter860 != this->tbl_types.end(); ++_iter860) + std::vector ::const_iterator _iter862; + for (_iter862 = this->tbl_types.begin(); _iter862 != this->tbl_types.end(); ++_iter862) { - xfer += oprot->writeString((*_iter860)); + xfer += oprot->writeString((*_iter862)); } xfer += oprot->writeListEnd(); } @@ -5689,10 +5896,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 _iter861; - for (_iter861 = (*(this->tbl_types)).begin(); _iter861 != (*(this->tbl_types)).end(); ++_iter861) + std::vector ::const_iterator _iter863; + for (_iter863 = (*(this->tbl_types)).begin(); _iter863 != (*(this->tbl_types)).end(); ++_iter863) { - xfer += oprot->writeString((*_iter861)); + xfer += oprot->writeString((*_iter863)); } xfer += oprot->writeListEnd(); } @@ -5733,14 +5940,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size862; - ::apache::thrift::protocol::TType _etype865; - xfer += iprot->readListBegin(_etype865, _size862); - this->success.resize(_size862); - uint32_t _i866; - for (_i866 = 0; _i866 < _size862; ++_i866) + uint32_t _size864; + ::apache::thrift::protocol::TType _etype867; + xfer += iprot->readListBegin(_etype867, _size864); + this->success.resize(_size864); + uint32_t _i868; + for (_i868 = 0; _i868 < _size864; ++_i868) { - xfer += this->success[_i866].read(iprot); + xfer += this->success[_i868].read(iprot); } xfer += iprot->readListEnd(); } @@ -5779,10 +5986,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 _iter867; - for (_iter867 = this->success.begin(); _iter867 != this->success.end(); ++_iter867) + std::vector ::const_iterator _iter869; + for (_iter869 = this->success.begin(); _iter869 != this->success.end(); ++_iter869) { - xfer += (*_iter867).write(oprot); + xfer += (*_iter869).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5827,14 +6034,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size868; - ::apache::thrift::protocol::TType _etype871; - xfer += iprot->readListBegin(_etype871, _size868); - (*(this->success)).resize(_size868); - uint32_t _i872; - for (_i872 = 0; _i872 < _size868; ++_i872) + uint32_t _size870; + ::apache::thrift::protocol::TType _etype873; + xfer += iprot->readListBegin(_etype873, _size870); + (*(this->success)).resize(_size870); + uint32_t _i874; + for (_i874 = 0; _i874 < _size870; ++_i874) { - xfer += (*(this->success))[_i872].read(iprot); + xfer += (*(this->success))[_i874].read(iprot); } xfer += iprot->readListEnd(); } @@ -5972,14 +6179,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size873; - ::apache::thrift::protocol::TType _etype876; - xfer += iprot->readListBegin(_etype876, _size873); - this->success.resize(_size873); - uint32_t _i877; - for (_i877 = 0; _i877 < _size873; ++_i877) + uint32_t _size875; + ::apache::thrift::protocol::TType _etype878; + xfer += iprot->readListBegin(_etype878, _size875); + this->success.resize(_size875); + uint32_t _i879; + for (_i879 = 0; _i879 < _size875; ++_i879) { - xfer += iprot->readString(this->success[_i877]); + xfer += iprot->readString(this->success[_i879]); } xfer += iprot->readListEnd(); } @@ -6018,10 +6225,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 _iter878; - for (_iter878 = this->success.begin(); _iter878 != this->success.end(); ++_iter878) + std::vector ::const_iterator _iter880; + for (_iter880 = this->success.begin(); _iter880 != this->success.end(); ++_iter880) { - xfer += oprot->writeString((*_iter878)); + xfer += oprot->writeString((*_iter880)); } xfer += oprot->writeListEnd(); } @@ -6066,14 +6273,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size879; - ::apache::thrift::protocol::TType _etype882; - xfer += iprot->readListBegin(_etype882, _size879); - (*(this->success)).resize(_size879); - uint32_t _i883; - for (_i883 = 0; _i883 < _size879; ++_i883) + uint32_t _size881; + ::apache::thrift::protocol::TType _etype884; + xfer += iprot->readListBegin(_etype884, _size881); + (*(this->success)).resize(_size881); + uint32_t _i885; + for (_i885 = 0; _i885 < _size881; ++_i885) { - xfer += iprot->readString((*(this->success))[_i883]); + xfer += iprot->readString((*(this->success))[_i885]); } xfer += iprot->readListEnd(); } @@ -6383,14 +6590,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 _size884; - ::apache::thrift::protocol::TType _etype887; - xfer += iprot->readListBegin(_etype887, _size884); - this->tbl_names.resize(_size884); - uint32_t _i888; - for (_i888 = 0; _i888 < _size884; ++_i888) + uint32_t _size886; + ::apache::thrift::protocol::TType _etype889; + xfer += iprot->readListBegin(_etype889, _size886); + this->tbl_names.resize(_size886); + uint32_t _i890; + for (_i890 = 0; _i890 < _size886; ++_i890) { - xfer += iprot->readString(this->tbl_names[_i888]); + xfer += iprot->readString(this->tbl_names[_i890]); } xfer += iprot->readListEnd(); } @@ -6423,10 +6630,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 _iter889; - for (_iter889 = this->tbl_names.begin(); _iter889 != this->tbl_names.end(); ++_iter889) + std::vector ::const_iterator _iter891; + for (_iter891 = this->tbl_names.begin(); _iter891 != this->tbl_names.end(); ++_iter891) { - xfer += oprot->writeString((*_iter889)); + xfer += oprot->writeString((*_iter891)); } xfer += oprot->writeListEnd(); } @@ -6454,10 +6661,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 _iter890; - for (_iter890 = (*(this->tbl_names)).begin(); _iter890 != (*(this->tbl_names)).end(); ++_iter890) + std::vector ::const_iterator _iter892; + for (_iter892 = (*(this->tbl_names)).begin(); _iter892 != (*(this->tbl_names)).end(); ++_iter892) { - xfer += oprot->writeString((*_iter890)); + xfer += oprot->writeString((*_iter892)); } xfer += oprot->writeListEnd(); } @@ -6498,14 +6705,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 _size891; - ::apache::thrift::protocol::TType _etype894; - xfer += iprot->readListBegin(_etype894, _size891); - this->success.resize(_size891); - uint32_t _i895; - for (_i895 = 0; _i895 < _size891; ++_i895) + uint32_t _size893; + ::apache::thrift::protocol::TType _etype896; + xfer += iprot->readListBegin(_etype896, _size893); + this->success.resize(_size893); + uint32_t _i897; + for (_i897 = 0; _i897 < _size893; ++_i897) { - xfer += this->success[_i895].read(iprot); + xfer += this->success[_i897].read(iprot); } xfer += iprot->readListEnd(); } @@ -6560,10 +6767,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 _iter896; - for (_iter896 = this->success.begin(); _iter896 != this->success.end(); ++_iter896) + std::vector
::const_iterator _iter898; + for (_iter898 = this->success.begin(); _iter898 != this->success.end(); ++_iter898) { - xfer += (*_iter896).write(oprot); + xfer += (*_iter898).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6616,14 +6823,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 _size897; - ::apache::thrift::protocol::TType _etype900; - xfer += iprot->readListBegin(_etype900, _size897); - (*(this->success)).resize(_size897); - uint32_t _i901; - for (_i901 = 0; _i901 < _size897; ++_i901) + uint32_t _size899; + ::apache::thrift::protocol::TType _etype902; + xfer += iprot->readListBegin(_etype902, _size899); + (*(this->success)).resize(_size899); + uint32_t _i903; + for (_i903 = 0; _i903 < _size899; ++_i903) { - xfer += (*(this->success))[_i901].read(iprot); + xfer += (*(this->success))[_i903].read(iprot); } xfer += iprot->readListEnd(); } @@ -6809,14 +7016,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 _size902; - ::apache::thrift::protocol::TType _etype905; - xfer += iprot->readListBegin(_etype905, _size902); - this->success.resize(_size902); - uint32_t _i906; - for (_i906 = 0; _i906 < _size902; ++_i906) + uint32_t _size904; + ::apache::thrift::protocol::TType _etype907; + xfer += iprot->readListBegin(_etype907, _size904); + this->success.resize(_size904); + uint32_t _i908; + for (_i908 = 0; _i908 < _size904; ++_i908) { - xfer += iprot->readString(this->success[_i906]); + xfer += iprot->readString(this->success[_i908]); } xfer += iprot->readListEnd(); } @@ -6871,10 +7078,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 _iter907; - for (_iter907 = this->success.begin(); _iter907 != this->success.end(); ++_iter907) + std::vector ::const_iterator _iter909; + for (_iter909 = this->success.begin(); _iter909 != this->success.end(); ++_iter909) { - xfer += oprot->writeString((*_iter907)); + xfer += oprot->writeString((*_iter909)); } xfer += oprot->writeListEnd(); } @@ -6927,14 +7134,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 _size908; - ::apache::thrift::protocol::TType _etype911; - xfer += iprot->readListBegin(_etype911, _size908); - (*(this->success)).resize(_size908); - uint32_t _i912; - for (_i912 = 0; _i912 < _size908; ++_i912) + uint32_t _size910; + ::apache::thrift::protocol::TType _etype913; + xfer += iprot->readListBegin(_etype913, _size910); + (*(this->success)).resize(_size910); + uint32_t _i914; + for (_i914 = 0; _i914 < _size910; ++_i914) { - xfer += iprot->readString((*(this->success))[_i912]); + xfer += iprot->readString((*(this->success))[_i914]); } xfer += iprot->readListEnd(); } @@ -8268,14 +8475,14 @@ uint32_t ThriftHiveMetastore_add_partitions_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size913; - ::apache::thrift::protocol::TType _etype916; - xfer += iprot->readListBegin(_etype916, _size913); - this->new_parts.resize(_size913); - uint32_t _i917; - for (_i917 = 0; _i917 < _size913; ++_i917) + uint32_t _size915; + ::apache::thrift::protocol::TType _etype918; + xfer += iprot->readListBegin(_etype918, _size915); + this->new_parts.resize(_size915); + uint32_t _i919; + for (_i919 = 0; _i919 < _size915; ++_i919) { - xfer += this->new_parts[_i917].read(iprot); + xfer += this->new_parts[_i919].read(iprot); } xfer += iprot->readListEnd(); } @@ -8304,10 +8511,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 _iter918; - for (_iter918 = this->new_parts.begin(); _iter918 != this->new_parts.end(); ++_iter918) + std::vector ::const_iterator _iter920; + for (_iter920 = this->new_parts.begin(); _iter920 != this->new_parts.end(); ++_iter920) { - xfer += (*_iter918).write(oprot); + xfer += (*_iter920).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8331,10 +8538,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 _iter919; - for (_iter919 = (*(this->new_parts)).begin(); _iter919 != (*(this->new_parts)).end(); ++_iter919) + std::vector ::const_iterator _iter921; + for (_iter921 = (*(this->new_parts)).begin(); _iter921 != (*(this->new_parts)).end(); ++_iter921) { - xfer += (*_iter919).write(oprot); + xfer += (*_iter921).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8543,14 +8750,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 _size920; - ::apache::thrift::protocol::TType _etype923; - xfer += iprot->readListBegin(_etype923, _size920); - this->new_parts.resize(_size920); - uint32_t _i924; - for (_i924 = 0; _i924 < _size920; ++_i924) + uint32_t _size922; + ::apache::thrift::protocol::TType _etype925; + xfer += iprot->readListBegin(_etype925, _size922); + this->new_parts.resize(_size922); + uint32_t _i926; + for (_i926 = 0; _i926 < _size922; ++_i926) { - xfer += this->new_parts[_i924].read(iprot); + xfer += this->new_parts[_i926].read(iprot); } xfer += iprot->readListEnd(); } @@ -8579,10 +8786,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 _iter925; - for (_iter925 = this->new_parts.begin(); _iter925 != this->new_parts.end(); ++_iter925) + std::vector ::const_iterator _iter927; + for (_iter927 = this->new_parts.begin(); _iter927 != this->new_parts.end(); ++_iter927) { - xfer += (*_iter925).write(oprot); + xfer += (*_iter927).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8606,10 +8813,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 _iter926; - for (_iter926 = (*(this->new_parts)).begin(); _iter926 != (*(this->new_parts)).end(); ++_iter926) + std::vector ::const_iterator _iter928; + for (_iter928 = (*(this->new_parts)).begin(); _iter928 != (*(this->new_parts)).end(); ++_iter928) { - xfer += (*_iter926).write(oprot); + xfer += (*_iter928).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8834,14 +9041,14 @@ uint32_t ThriftHiveMetastore_append_partition_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size927; - ::apache::thrift::protocol::TType _etype930; - xfer += iprot->readListBegin(_etype930, _size927); - this->part_vals.resize(_size927); - uint32_t _i931; - for (_i931 = 0; _i931 < _size927; ++_i931) + uint32_t _size929; + ::apache::thrift::protocol::TType _etype932; + xfer += iprot->readListBegin(_etype932, _size929); + this->part_vals.resize(_size929); + uint32_t _i933; + for (_i933 = 0; _i933 < _size929; ++_i933) { - xfer += iprot->readString(this->part_vals[_i931]); + xfer += iprot->readString(this->part_vals[_i933]); } xfer += iprot->readListEnd(); } @@ -8878,10 +9085,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 _iter932; - for (_iter932 = this->part_vals.begin(); _iter932 != this->part_vals.end(); ++_iter932) + std::vector ::const_iterator _iter934; + for (_iter934 = this->part_vals.begin(); _iter934 != this->part_vals.end(); ++_iter934) { - xfer += oprot->writeString((*_iter932)); + xfer += oprot->writeString((*_iter934)); } xfer += oprot->writeListEnd(); } @@ -8913,10 +9120,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 _iter933; - for (_iter933 = (*(this->part_vals)).begin(); _iter933 != (*(this->part_vals)).end(); ++_iter933) + std::vector ::const_iterator _iter935; + for (_iter935 = (*(this->part_vals)).begin(); _iter935 != (*(this->part_vals)).end(); ++_iter935) { - xfer += oprot->writeString((*_iter933)); + xfer += oprot->writeString((*_iter935)); } xfer += oprot->writeListEnd(); } @@ -9388,14 +9595,14 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::rea if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size934; - ::apache::thrift::protocol::TType _etype937; - xfer += iprot->readListBegin(_etype937, _size934); - this->part_vals.resize(_size934); - uint32_t _i938; - for (_i938 = 0; _i938 < _size934; ++_i938) + uint32_t _size936; + ::apache::thrift::protocol::TType _etype939; + xfer += iprot->readListBegin(_etype939, _size936); + this->part_vals.resize(_size936); + uint32_t _i940; + for (_i940 = 0; _i940 < _size936; ++_i940) { - xfer += iprot->readString(this->part_vals[_i938]); + xfer += iprot->readString(this->part_vals[_i940]); } xfer += iprot->readListEnd(); } @@ -9440,10 +9647,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 _iter939; - for (_iter939 = this->part_vals.begin(); _iter939 != this->part_vals.end(); ++_iter939) + std::vector ::const_iterator _iter941; + for (_iter941 = this->part_vals.begin(); _iter941 != this->part_vals.end(); ++_iter941) { - xfer += oprot->writeString((*_iter939)); + xfer += oprot->writeString((*_iter941)); } xfer += oprot->writeListEnd(); } @@ -9479,10 +9686,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 _iter940; - for (_iter940 = (*(this->part_vals)).begin(); _iter940 != (*(this->part_vals)).end(); ++_iter940) + std::vector ::const_iterator _iter942; + for (_iter942 = (*(this->part_vals)).begin(); _iter942 != (*(this->part_vals)).end(); ++_iter942) { - xfer += oprot->writeString((*_iter940)); + xfer += oprot->writeString((*_iter942)); } xfer += oprot->writeListEnd(); } @@ -10285,14 +10492,14 @@ uint32_t ThriftHiveMetastore_drop_partition_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size941; - ::apache::thrift::protocol::TType _etype944; - xfer += iprot->readListBegin(_etype944, _size941); - this->part_vals.resize(_size941); - uint32_t _i945; - for (_i945 = 0; _i945 < _size941; ++_i945) + uint32_t _size943; + ::apache::thrift::protocol::TType _etype946; + xfer += iprot->readListBegin(_etype946, _size943); + this->part_vals.resize(_size943); + uint32_t _i947; + for (_i947 = 0; _i947 < _size943; ++_i947) { - xfer += iprot->readString(this->part_vals[_i945]); + xfer += iprot->readString(this->part_vals[_i947]); } xfer += iprot->readListEnd(); } @@ -10337,10 +10544,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 _iter946; - for (_iter946 = this->part_vals.begin(); _iter946 != this->part_vals.end(); ++_iter946) + std::vector ::const_iterator _iter948; + for (_iter948 = this->part_vals.begin(); _iter948 != this->part_vals.end(); ++_iter948) { - xfer += oprot->writeString((*_iter946)); + xfer += oprot->writeString((*_iter948)); } xfer += oprot->writeListEnd(); } @@ -10376,10 +10583,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 _iter947; - for (_iter947 = (*(this->part_vals)).begin(); _iter947 != (*(this->part_vals)).end(); ++_iter947) + std::vector ::const_iterator _iter949; + for (_iter949 = (*(this->part_vals)).begin(); _iter949 != (*(this->part_vals)).end(); ++_iter949) { - xfer += oprot->writeString((*_iter947)); + xfer += oprot->writeString((*_iter949)); } xfer += oprot->writeListEnd(); } @@ -10588,14 +10795,14 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::read( if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size948; - ::apache::thrift::protocol::TType _etype951; - xfer += iprot->readListBegin(_etype951, _size948); - this->part_vals.resize(_size948); - uint32_t _i952; - for (_i952 = 0; _i952 < _size948; ++_i952) + uint32_t _size950; + ::apache::thrift::protocol::TType _etype953; + xfer += iprot->readListBegin(_etype953, _size950); + this->part_vals.resize(_size950); + uint32_t _i954; + for (_i954 = 0; _i954 < _size950; ++_i954) { - xfer += iprot->readString(this->part_vals[_i952]); + xfer += iprot->readString(this->part_vals[_i954]); } xfer += iprot->readListEnd(); } @@ -10648,10 +10855,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 _iter953; - for (_iter953 = this->part_vals.begin(); _iter953 != this->part_vals.end(); ++_iter953) + std::vector ::const_iterator _iter955; + for (_iter955 = this->part_vals.begin(); _iter955 != this->part_vals.end(); ++_iter955) { - xfer += oprot->writeString((*_iter953)); + xfer += oprot->writeString((*_iter955)); } xfer += oprot->writeListEnd(); } @@ -10691,10 +10898,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 _iter954; - for (_iter954 = (*(this->part_vals)).begin(); _iter954 != (*(this->part_vals)).end(); ++_iter954) + std::vector ::const_iterator _iter956; + for (_iter956 = (*(this->part_vals)).begin(); _iter956 != (*(this->part_vals)).end(); ++_iter956) { - xfer += oprot->writeString((*_iter954)); + xfer += oprot->writeString((*_iter956)); } xfer += oprot->writeListEnd(); } @@ -11700,14 +11907,14 @@ uint32_t ThriftHiveMetastore_get_partition_args::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size955; - ::apache::thrift::protocol::TType _etype958; - xfer += iprot->readListBegin(_etype958, _size955); - this->part_vals.resize(_size955); - uint32_t _i959; - for (_i959 = 0; _i959 < _size955; ++_i959) + uint32_t _size957; + ::apache::thrift::protocol::TType _etype960; + xfer += iprot->readListBegin(_etype960, _size957); + this->part_vals.resize(_size957); + uint32_t _i961; + for (_i961 = 0; _i961 < _size957; ++_i961) { - xfer += iprot->readString(this->part_vals[_i959]); + xfer += iprot->readString(this->part_vals[_i961]); } xfer += iprot->readListEnd(); } @@ -11744,10 +11951,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 _iter960; - for (_iter960 = this->part_vals.begin(); _iter960 != this->part_vals.end(); ++_iter960) + std::vector ::const_iterator _iter962; + for (_iter962 = this->part_vals.begin(); _iter962 != this->part_vals.end(); ++_iter962) { - xfer += oprot->writeString((*_iter960)); + xfer += oprot->writeString((*_iter962)); } xfer += oprot->writeListEnd(); } @@ -11779,10 +11986,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 _iter961; - for (_iter961 = (*(this->part_vals)).begin(); _iter961 != (*(this->part_vals)).end(); ++_iter961) + std::vector ::const_iterator _iter963; + for (_iter963 = (*(this->part_vals)).begin(); _iter963 != (*(this->part_vals)).end(); ++_iter963) { - xfer += oprot->writeString((*_iter961)); + xfer += oprot->writeString((*_iter963)); } xfer += oprot->writeListEnd(); } @@ -11971,17 +12178,17 @@ uint32_t ThriftHiveMetastore_exchange_partition_args::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size962; - ::apache::thrift::protocol::TType _ktype963; - ::apache::thrift::protocol::TType _vtype964; - xfer += iprot->readMapBegin(_ktype963, _vtype964, _size962); - uint32_t _i966; - for (_i966 = 0; _i966 < _size962; ++_i966) + uint32_t _size964; + ::apache::thrift::protocol::TType _ktype965; + ::apache::thrift::protocol::TType _vtype966; + xfer += iprot->readMapBegin(_ktype965, _vtype966, _size964); + uint32_t _i968; + for (_i968 = 0; _i968 < _size964; ++_i968) { - std::string _key967; - xfer += iprot->readString(_key967); - std::string& _val968 = this->partitionSpecs[_key967]; - xfer += iprot->readString(_val968); + std::string _key969; + xfer += iprot->readString(_key969); + std::string& _val970 = this->partitionSpecs[_key969]; + xfer += iprot->readString(_val970); } xfer += iprot->readMapEnd(); } @@ -12042,11 +12249,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 _iter969; - for (_iter969 = this->partitionSpecs.begin(); _iter969 != this->partitionSpecs.end(); ++_iter969) + std::map ::const_iterator _iter971; + for (_iter971 = this->partitionSpecs.begin(); _iter971 != this->partitionSpecs.end(); ++_iter971) { - xfer += oprot->writeString(_iter969->first); - xfer += oprot->writeString(_iter969->second); + xfer += oprot->writeString(_iter971->first); + xfer += oprot->writeString(_iter971->second); } xfer += oprot->writeMapEnd(); } @@ -12086,11 +12293,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 _iter970; - for (_iter970 = (*(this->partitionSpecs)).begin(); _iter970 != (*(this->partitionSpecs)).end(); ++_iter970) + std::map ::const_iterator _iter972; + for (_iter972 = (*(this->partitionSpecs)).begin(); _iter972 != (*(this->partitionSpecs)).end(); ++_iter972) { - xfer += oprot->writeString(_iter970->first); - xfer += oprot->writeString(_iter970->second); + xfer += oprot->writeString(_iter972->first); + xfer += oprot->writeString(_iter972->second); } xfer += oprot->writeMapEnd(); } @@ -12335,17 +12542,17 @@ uint32_t ThriftHiveMetastore_exchange_partitions_args::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size971; - ::apache::thrift::protocol::TType _ktype972; - ::apache::thrift::protocol::TType _vtype973; - xfer += iprot->readMapBegin(_ktype972, _vtype973, _size971); - uint32_t _i975; - for (_i975 = 0; _i975 < _size971; ++_i975) + uint32_t _size973; + ::apache::thrift::protocol::TType _ktype974; + ::apache::thrift::protocol::TType _vtype975; + xfer += iprot->readMapBegin(_ktype974, _vtype975, _size973); + uint32_t _i977; + for (_i977 = 0; _i977 < _size973; ++_i977) { - std::string _key976; - xfer += iprot->readString(_key976); - std::string& _val977 = this->partitionSpecs[_key976]; - xfer += iprot->readString(_val977); + std::string _key978; + xfer += iprot->readString(_key978); + std::string& _val979 = this->partitionSpecs[_key978]; + xfer += iprot->readString(_val979); } xfer += iprot->readMapEnd(); } @@ -12406,11 +12613,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 _iter978; - for (_iter978 = this->partitionSpecs.begin(); _iter978 != this->partitionSpecs.end(); ++_iter978) + std::map ::const_iterator _iter980; + for (_iter980 = this->partitionSpecs.begin(); _iter980 != this->partitionSpecs.end(); ++_iter980) { - xfer += oprot->writeString(_iter978->first); - xfer += oprot->writeString(_iter978->second); + xfer += oprot->writeString(_iter980->first); + xfer += oprot->writeString(_iter980->second); } xfer += oprot->writeMapEnd(); } @@ -12450,11 +12657,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 _iter979; - for (_iter979 = (*(this->partitionSpecs)).begin(); _iter979 != (*(this->partitionSpecs)).end(); ++_iter979) + std::map ::const_iterator _iter981; + for (_iter981 = (*(this->partitionSpecs)).begin(); _iter981 != (*(this->partitionSpecs)).end(); ++_iter981) { - xfer += oprot->writeString(_iter979->first); - xfer += oprot->writeString(_iter979->second); + xfer += oprot->writeString(_iter981->first); + xfer += oprot->writeString(_iter981->second); } xfer += oprot->writeMapEnd(); } @@ -12511,14 +12718,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size980; - ::apache::thrift::protocol::TType _etype983; - xfer += iprot->readListBegin(_etype983, _size980); - this->success.resize(_size980); - uint32_t _i984; - for (_i984 = 0; _i984 < _size980; ++_i984) + 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 += this->success[_i984].read(iprot); + xfer += this->success[_i986].read(iprot); } xfer += iprot->readListEnd(); } @@ -12581,10 +12788,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 _iter985; - for (_iter985 = this->success.begin(); _iter985 != this->success.end(); ++_iter985) + std::vector ::const_iterator _iter987; + for (_iter987 = this->success.begin(); _iter987 != this->success.end(); ++_iter987) { - xfer += (*_iter985).write(oprot); + xfer += (*_iter987).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12641,14 +12848,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size986; - ::apache::thrift::protocol::TType _etype989; - xfer += iprot->readListBegin(_etype989, _size986); - (*(this->success)).resize(_size986); - uint32_t _i990; - for (_i990 = 0; _i990 < _size986; ++_i990) + uint32_t _size988; + ::apache::thrift::protocol::TType _etype991; + xfer += iprot->readListBegin(_etype991, _size988); + (*(this->success)).resize(_size988); + uint32_t _i992; + for (_i992 = 0; _i992 < _size988; ++_i992) { - xfer += (*(this->success))[_i990].read(iprot); + xfer += (*(this->success))[_i992].read(iprot); } xfer += iprot->readListEnd(); } @@ -12747,14 +12954,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 _size991; - ::apache::thrift::protocol::TType _etype994; - xfer += iprot->readListBegin(_etype994, _size991); - this->part_vals.resize(_size991); - uint32_t _i995; - for (_i995 = 0; _i995 < _size991; ++_i995) + uint32_t _size993; + ::apache::thrift::protocol::TType _etype996; + xfer += iprot->readListBegin(_etype996, _size993); + this->part_vals.resize(_size993); + uint32_t _i997; + for (_i997 = 0; _i997 < _size993; ++_i997) { - xfer += iprot->readString(this->part_vals[_i995]); + xfer += iprot->readString(this->part_vals[_i997]); } xfer += iprot->readListEnd(); } @@ -12775,14 +12982,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 _size996; - ::apache::thrift::protocol::TType _etype999; - xfer += iprot->readListBegin(_etype999, _size996); - this->group_names.resize(_size996); - uint32_t _i1000; - for (_i1000 = 0; _i1000 < _size996; ++_i1000) + uint32_t _size998; + ::apache::thrift::protocol::TType _etype1001; + xfer += iprot->readListBegin(_etype1001, _size998); + this->group_names.resize(_size998); + uint32_t _i1002; + for (_i1002 = 0; _i1002 < _size998; ++_i1002) { - xfer += iprot->readString(this->group_names[_i1000]); + xfer += iprot->readString(this->group_names[_i1002]); } xfer += iprot->readListEnd(); } @@ -12819,10 +13026,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 _iter1001; - for (_iter1001 = this->part_vals.begin(); _iter1001 != this->part_vals.end(); ++_iter1001) + std::vector ::const_iterator _iter1003; + for (_iter1003 = this->part_vals.begin(); _iter1003 != this->part_vals.end(); ++_iter1003) { - xfer += oprot->writeString((*_iter1001)); + xfer += oprot->writeString((*_iter1003)); } xfer += oprot->writeListEnd(); } @@ -12835,10 +13042,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 _iter1002; - for (_iter1002 = this->group_names.begin(); _iter1002 != this->group_names.end(); ++_iter1002) + std::vector ::const_iterator _iter1004; + for (_iter1004 = this->group_names.begin(); _iter1004 != this->group_names.end(); ++_iter1004) { - xfer += oprot->writeString((*_iter1002)); + xfer += oprot->writeString((*_iter1004)); } xfer += oprot->writeListEnd(); } @@ -12870,10 +13077,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 _iter1003; - for (_iter1003 = (*(this->part_vals)).begin(); _iter1003 != (*(this->part_vals)).end(); ++_iter1003) + std::vector ::const_iterator _iter1005; + for (_iter1005 = (*(this->part_vals)).begin(); _iter1005 != (*(this->part_vals)).end(); ++_iter1005) { - xfer += oprot->writeString((*_iter1003)); + xfer += oprot->writeString((*_iter1005)); } xfer += oprot->writeListEnd(); } @@ -12886,10 +13093,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 _iter1004; - for (_iter1004 = (*(this->group_names)).begin(); _iter1004 != (*(this->group_names)).end(); ++_iter1004) + std::vector ::const_iterator _iter1006; + for (_iter1006 = (*(this->group_names)).begin(); _iter1006 != (*(this->group_names)).end(); ++_iter1006) { - xfer += oprot->writeString((*_iter1004)); + xfer += oprot->writeString((*_iter1006)); } xfer += oprot->writeListEnd(); } @@ -13448,14 +13655,14 @@ uint32_t ThriftHiveMetastore_get_partitions_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1005; - ::apache::thrift::protocol::TType _etype1008; - xfer += iprot->readListBegin(_etype1008, _size1005); - this->success.resize(_size1005); - uint32_t _i1009; - for (_i1009 = 0; _i1009 < _size1005; ++_i1009) + uint32_t _size1007; + ::apache::thrift::protocol::TType _etype1010; + xfer += iprot->readListBegin(_etype1010, _size1007); + this->success.resize(_size1007); + uint32_t _i1011; + for (_i1011 = 0; _i1011 < _size1007; ++_i1011) { - xfer += this->success[_i1009].read(iprot); + xfer += this->success[_i1011].read(iprot); } xfer += iprot->readListEnd(); } @@ -13502,10 +13709,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 _iter1010; - for (_iter1010 = this->success.begin(); _iter1010 != this->success.end(); ++_iter1010) + std::vector ::const_iterator _iter1012; + for (_iter1012 = this->success.begin(); _iter1012 != this->success.end(); ++_iter1012) { - xfer += (*_iter1010).write(oprot); + xfer += (*_iter1012).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13554,14 +13761,14 @@ uint32_t ThriftHiveMetastore_get_partitions_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1011; - ::apache::thrift::protocol::TType _etype1014; - xfer += iprot->readListBegin(_etype1014, _size1011); - (*(this->success)).resize(_size1011); - uint32_t _i1015; - for (_i1015 = 0; _i1015 < _size1011; ++_i1015) + 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))[_i1015].read(iprot); + xfer += (*(this->success))[_i1017].read(iprot); } xfer += iprot->readListEnd(); } @@ -13660,14 +13867,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 _size1016; - ::apache::thrift::protocol::TType _etype1019; - xfer += iprot->readListBegin(_etype1019, _size1016); - this->group_names.resize(_size1016); - uint32_t _i1020; - for (_i1020 = 0; _i1020 < _size1016; ++_i1020) + uint32_t _size1018; + ::apache::thrift::protocol::TType _etype1021; + xfer += iprot->readListBegin(_etype1021, _size1018); + this->group_names.resize(_size1018); + uint32_t _i1022; + for (_i1022 = 0; _i1022 < _size1018; ++_i1022) { - xfer += iprot->readString(this->group_names[_i1020]); + xfer += iprot->readString(this->group_names[_i1022]); } xfer += iprot->readListEnd(); } @@ -13712,10 +13919,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 _iter1021; - for (_iter1021 = this->group_names.begin(); _iter1021 != this->group_names.end(); ++_iter1021) + std::vector ::const_iterator _iter1023; + for (_iter1023 = this->group_names.begin(); _iter1023 != this->group_names.end(); ++_iter1023) { - xfer += oprot->writeString((*_iter1021)); + xfer += oprot->writeString((*_iter1023)); } xfer += oprot->writeListEnd(); } @@ -13755,10 +13962,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 _iter1022; - for (_iter1022 = (*(this->group_names)).begin(); _iter1022 != (*(this->group_names)).end(); ++_iter1022) + std::vector ::const_iterator _iter1024; + for (_iter1024 = (*(this->group_names)).begin(); _iter1024 != (*(this->group_names)).end(); ++_iter1024) { - xfer += oprot->writeString((*_iter1022)); + xfer += oprot->writeString((*_iter1024)); } xfer += oprot->writeListEnd(); } @@ -13799,14 +14006,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1023; - ::apache::thrift::protocol::TType _etype1026; - xfer += iprot->readListBegin(_etype1026, _size1023); - this->success.resize(_size1023); - uint32_t _i1027; - for (_i1027 = 0; _i1027 < _size1023; ++_i1027) + uint32_t _size1025; + ::apache::thrift::protocol::TType _etype1028; + xfer += iprot->readListBegin(_etype1028, _size1025); + this->success.resize(_size1025); + uint32_t _i1029; + for (_i1029 = 0; _i1029 < _size1025; ++_i1029) { - xfer += this->success[_i1027].read(iprot); + xfer += this->success[_i1029].read(iprot); } xfer += iprot->readListEnd(); } @@ -13853,10 +14060,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 _iter1028; - for (_iter1028 = this->success.begin(); _iter1028 != this->success.end(); ++_iter1028) + std::vector ::const_iterator _iter1030; + for (_iter1030 = this->success.begin(); _iter1030 != this->success.end(); ++_iter1030) { - xfer += (*_iter1028).write(oprot); + xfer += (*_iter1030).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13905,14 +14112,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1029; - ::apache::thrift::protocol::TType _etype1032; - xfer += iprot->readListBegin(_etype1032, _size1029); - (*(this->success)).resize(_size1029); - uint32_t _i1033; - for (_i1033 = 0; _i1033 < _size1029; ++_i1033) + uint32_t _size1031; + ::apache::thrift::protocol::TType _etype1034; + xfer += iprot->readListBegin(_etype1034, _size1031); + (*(this->success)).resize(_size1031); + uint32_t _i1035; + for (_i1035 = 0; _i1035 < _size1031; ++_i1035) { - xfer += (*(this->success))[_i1033].read(iprot); + xfer += (*(this->success))[_i1035].read(iprot); } xfer += iprot->readListEnd(); } @@ -14090,14 +14297,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_result::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1034; - ::apache::thrift::protocol::TType _etype1037; - xfer += iprot->readListBegin(_etype1037, _size1034); - this->success.resize(_size1034); - uint32_t _i1038; - for (_i1038 = 0; _i1038 < _size1034; ++_i1038) + uint32_t _size1036; + ::apache::thrift::protocol::TType _etype1039; + xfer += iprot->readListBegin(_etype1039, _size1036); + this->success.resize(_size1036); + uint32_t _i1040; + for (_i1040 = 0; _i1040 < _size1036; ++_i1040) { - xfer += this->success[_i1038].read(iprot); + xfer += this->success[_i1040].read(iprot); } xfer += iprot->readListEnd(); } @@ -14144,10 +14351,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 _iter1039; - for (_iter1039 = this->success.begin(); _iter1039 != this->success.end(); ++_iter1039) + std::vector ::const_iterator _iter1041; + for (_iter1041 = this->success.begin(); _iter1041 != this->success.end(); ++_iter1041) { - xfer += (*_iter1039).write(oprot); + xfer += (*_iter1041).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14196,14 +14403,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_presult::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1040; - ::apache::thrift::protocol::TType _etype1043; - xfer += iprot->readListBegin(_etype1043, _size1040); - (*(this->success)).resize(_size1040); - uint32_t _i1044; - for (_i1044 = 0; _i1044 < _size1040; ++_i1044) + uint32_t _size1042; + ::apache::thrift::protocol::TType _etype1045; + xfer += iprot->readListBegin(_etype1045, _size1042); + (*(this->success)).resize(_size1042); + uint32_t _i1046; + for (_i1046 = 0; _i1046 < _size1042; ++_i1046) { - xfer += (*(this->success))[_i1044].read(iprot); + xfer += (*(this->success))[_i1046].read(iprot); } xfer += iprot->readListEnd(); } @@ -14381,14 +14588,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1045; - ::apache::thrift::protocol::TType _etype1048; - xfer += iprot->readListBegin(_etype1048, _size1045); - this->success.resize(_size1045); - uint32_t _i1049; - for (_i1049 = 0; _i1049 < _size1045; ++_i1049) + uint32_t _size1047; + ::apache::thrift::protocol::TType _etype1050; + xfer += iprot->readListBegin(_etype1050, _size1047); + this->success.resize(_size1047); + uint32_t _i1051; + for (_i1051 = 0; _i1051 < _size1047; ++_i1051) { - xfer += iprot->readString(this->success[_i1049]); + xfer += iprot->readString(this->success[_i1051]); } xfer += iprot->readListEnd(); } @@ -14427,10 +14634,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 _iter1050; - for (_iter1050 = this->success.begin(); _iter1050 != this->success.end(); ++_iter1050) + std::vector ::const_iterator _iter1052; + for (_iter1052 = this->success.begin(); _iter1052 != this->success.end(); ++_iter1052) { - xfer += oprot->writeString((*_iter1050)); + xfer += oprot->writeString((*_iter1052)); } xfer += oprot->writeListEnd(); } @@ -14475,14 +14682,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1051; - ::apache::thrift::protocol::TType _etype1054; - xfer += iprot->readListBegin(_etype1054, _size1051); - (*(this->success)).resize(_size1051); - uint32_t _i1055; - for (_i1055 = 0; _i1055 < _size1051; ++_i1055) + uint32_t _size1053; + ::apache::thrift::protocol::TType _etype1056; + xfer += iprot->readListBegin(_etype1056, _size1053); + (*(this->success)).resize(_size1053); + uint32_t _i1057; + for (_i1057 = 0; _i1057 < _size1053; ++_i1057) { - xfer += iprot->readString((*(this->success))[_i1055]); + xfer += iprot->readString((*(this->success))[_i1057]); } xfer += iprot->readListEnd(); } @@ -14557,14 +14764,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 _size1056; - ::apache::thrift::protocol::TType _etype1059; - xfer += iprot->readListBegin(_etype1059, _size1056); - this->part_vals.resize(_size1056); - uint32_t _i1060; - for (_i1060 = 0; _i1060 < _size1056; ++_i1060) + uint32_t _size1058; + ::apache::thrift::protocol::TType _etype1061; + xfer += iprot->readListBegin(_etype1061, _size1058); + this->part_vals.resize(_size1058); + uint32_t _i1062; + for (_i1062 = 0; _i1062 < _size1058; ++_i1062) { - xfer += iprot->readString(this->part_vals[_i1060]); + xfer += iprot->readString(this->part_vals[_i1062]); } xfer += iprot->readListEnd(); } @@ -14609,10 +14816,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 _iter1061; - for (_iter1061 = this->part_vals.begin(); _iter1061 != this->part_vals.end(); ++_iter1061) + std::vector ::const_iterator _iter1063; + for (_iter1063 = this->part_vals.begin(); _iter1063 != this->part_vals.end(); ++_iter1063) { - xfer += oprot->writeString((*_iter1061)); + xfer += oprot->writeString((*_iter1063)); } xfer += oprot->writeListEnd(); } @@ -14648,10 +14855,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 _iter1062; - for (_iter1062 = (*(this->part_vals)).begin(); _iter1062 != (*(this->part_vals)).end(); ++_iter1062) + std::vector ::const_iterator _iter1064; + for (_iter1064 = (*(this->part_vals)).begin(); _iter1064 != (*(this->part_vals)).end(); ++_iter1064) { - xfer += oprot->writeString((*_iter1062)); + xfer += oprot->writeString((*_iter1064)); } xfer += oprot->writeListEnd(); } @@ -14696,14 +14903,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_result::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1063; - ::apache::thrift::protocol::TType _etype1066; - xfer += iprot->readListBegin(_etype1066, _size1063); - this->success.resize(_size1063); - uint32_t _i1067; - for (_i1067 = 0; _i1067 < _size1063; ++_i1067) + uint32_t _size1065; + ::apache::thrift::protocol::TType _etype1068; + xfer += iprot->readListBegin(_etype1068, _size1065); + this->success.resize(_size1065); + uint32_t _i1069; + for (_i1069 = 0; _i1069 < _size1065; ++_i1069) { - xfer += this->success[_i1067].read(iprot); + xfer += this->success[_i1069].read(iprot); } xfer += iprot->readListEnd(); } @@ -14750,10 +14957,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 _iter1068; - for (_iter1068 = this->success.begin(); _iter1068 != this->success.end(); ++_iter1068) + std::vector ::const_iterator _iter1070; + for (_iter1070 = this->success.begin(); _iter1070 != this->success.end(); ++_iter1070) { - xfer += (*_iter1068).write(oprot); + xfer += (*_iter1070).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14802,14 +15009,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_presult::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1069; - ::apache::thrift::protocol::TType _etype1072; - xfer += iprot->readListBegin(_etype1072, _size1069); - (*(this->success)).resize(_size1069); - uint32_t _i1073; - for (_i1073 = 0; _i1073 < _size1069; ++_i1073) + uint32_t _size1071; + ::apache::thrift::protocol::TType _etype1074; + xfer += iprot->readListBegin(_etype1074, _size1071); + (*(this->success)).resize(_size1071); + uint32_t _i1075; + for (_i1075 = 0; _i1075 < _size1071; ++_i1075) { - xfer += (*(this->success))[_i1073].read(iprot); + xfer += (*(this->success))[_i1075].read(iprot); } xfer += iprot->readListEnd(); } @@ -14892,14 +15099,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 _size1074; - ::apache::thrift::protocol::TType _etype1077; - xfer += iprot->readListBegin(_etype1077, _size1074); - this->part_vals.resize(_size1074); - uint32_t _i1078; - for (_i1078 = 0; _i1078 < _size1074; ++_i1078) + uint32_t _size1076; + ::apache::thrift::protocol::TType _etype1079; + xfer += iprot->readListBegin(_etype1079, _size1076); + this->part_vals.resize(_size1076); + uint32_t _i1080; + for (_i1080 = 0; _i1080 < _size1076; ++_i1080) { - xfer += iprot->readString(this->part_vals[_i1078]); + xfer += iprot->readString(this->part_vals[_i1080]); } xfer += iprot->readListEnd(); } @@ -14928,14 +15135,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size1079; - ::apache::thrift::protocol::TType _etype1082; - xfer += iprot->readListBegin(_etype1082, _size1079); - this->group_names.resize(_size1079); - uint32_t _i1083; - for (_i1083 = 0; _i1083 < _size1079; ++_i1083) + uint32_t _size1081; + ::apache::thrift::protocol::TType _etype1084; + xfer += iprot->readListBegin(_etype1084, _size1081); + this->group_names.resize(_size1081); + uint32_t _i1085; + for (_i1085 = 0; _i1085 < _size1081; ++_i1085) { - xfer += iprot->readString(this->group_names[_i1083]); + xfer += iprot->readString(this->group_names[_i1085]); } xfer += iprot->readListEnd(); } @@ -14972,10 +15179,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::write(::apache::t xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter1084; - for (_iter1084 = this->part_vals.begin(); _iter1084 != this->part_vals.end(); ++_iter1084) + std::vector ::const_iterator _iter1086; + for (_iter1086 = this->part_vals.begin(); _iter1086 != this->part_vals.end(); ++_iter1086) { - xfer += oprot->writeString((*_iter1084)); + xfer += oprot->writeString((*_iter1086)); } xfer += oprot->writeListEnd(); } @@ -14992,10 +15199,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::write(::apache::t xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 6); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->group_names.size())); - std::vector ::const_iterator _iter1085; - for (_iter1085 = this->group_names.begin(); _iter1085 != this->group_names.end(); ++_iter1085) + std::vector ::const_iterator _iter1087; + for (_iter1087 = this->group_names.begin(); _iter1087 != this->group_names.end(); ++_iter1087) { - xfer += oprot->writeString((*_iter1085)); + xfer += oprot->writeString((*_iter1087)); } xfer += oprot->writeListEnd(); } @@ -15027,10 +15234,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_pargs::write(::apache:: xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter1086; - for (_iter1086 = (*(this->part_vals)).begin(); _iter1086 != (*(this->part_vals)).end(); ++_iter1086) + std::vector ::const_iterator _iter1088; + for (_iter1088 = (*(this->part_vals)).begin(); _iter1088 != (*(this->part_vals)).end(); ++_iter1088) { - xfer += oprot->writeString((*_iter1086)); + xfer += oprot->writeString((*_iter1088)); } xfer += oprot->writeListEnd(); } @@ -15047,10 +15254,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_pargs::write(::apache:: xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 6); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->group_names)).size())); - std::vector ::const_iterator _iter1087; - for (_iter1087 = (*(this->group_names)).begin(); _iter1087 != (*(this->group_names)).end(); ++_iter1087) + std::vector ::const_iterator _iter1089; + for (_iter1089 = (*(this->group_names)).begin(); _iter1089 != (*(this->group_names)).end(); ++_iter1089) { - xfer += oprot->writeString((*_iter1087)); + xfer += oprot->writeString((*_iter1089)); } xfer += oprot->writeListEnd(); } @@ -15091,14 +15298,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_result::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1088; - ::apache::thrift::protocol::TType _etype1091; - xfer += iprot->readListBegin(_etype1091, _size1088); - this->success.resize(_size1088); - uint32_t _i1092; - for (_i1092 = 0; _i1092 < _size1088; ++_i1092) + uint32_t _size1090; + ::apache::thrift::protocol::TType _etype1093; + xfer += iprot->readListBegin(_etype1093, _size1090); + this->success.resize(_size1090); + uint32_t _i1094; + for (_i1094 = 0; _i1094 < _size1090; ++_i1094) { - xfer += this->success[_i1092].read(iprot); + xfer += this->success[_i1094].read(iprot); } xfer += iprot->readListEnd(); } @@ -15145,10 +15352,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_result::write(::apache: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1093; - for (_iter1093 = this->success.begin(); _iter1093 != this->success.end(); ++_iter1093) + std::vector ::const_iterator _iter1095; + for (_iter1095 = this->success.begin(); _iter1095 != this->success.end(); ++_iter1095) { - xfer += (*_iter1093).write(oprot); + xfer += (*_iter1095).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15197,14 +15404,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_presult::read(::apache: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1094; - ::apache::thrift::protocol::TType _etype1097; - xfer += iprot->readListBegin(_etype1097, _size1094); - (*(this->success)).resize(_size1094); - uint32_t _i1098; - for (_i1098 = 0; _i1098 < _size1094; ++_i1098) + uint32_t _size1096; + ::apache::thrift::protocol::TType _etype1099; + xfer += iprot->readListBegin(_etype1099, _size1096); + (*(this->success)).resize(_size1096); + uint32_t _i1100; + for (_i1100 = 0; _i1100 < _size1096; ++_i1100) { - xfer += (*(this->success))[_i1098].read(iprot); + xfer += (*(this->success))[_i1100].read(iprot); } xfer += iprot->readListEnd(); } @@ -15287,14 +15494,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_args::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1099; - ::apache::thrift::protocol::TType _etype1102; - xfer += iprot->readListBegin(_etype1102, _size1099); - this->part_vals.resize(_size1099); - uint32_t _i1103; - for (_i1103 = 0; _i1103 < _size1099; ++_i1103) + uint32_t _size1101; + ::apache::thrift::protocol::TType _etype1104; + xfer += iprot->readListBegin(_etype1104, _size1101); + this->part_vals.resize(_size1101); + uint32_t _i1105; + for (_i1105 = 0; _i1105 < _size1101; ++_i1105) { - xfer += iprot->readString(this->part_vals[_i1103]); + xfer += iprot->readString(this->part_vals[_i1105]); } xfer += iprot->readListEnd(); } @@ -15339,10 +15546,10 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_args::write(::apache::thrift xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter1104; - for (_iter1104 = this->part_vals.begin(); _iter1104 != this->part_vals.end(); ++_iter1104) + std::vector ::const_iterator _iter1106; + for (_iter1106 = this->part_vals.begin(); _iter1106 != this->part_vals.end(); ++_iter1106) { - xfer += oprot->writeString((*_iter1104)); + xfer += oprot->writeString((*_iter1106)); } xfer += oprot->writeListEnd(); } @@ -15378,10 +15585,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 _iter1105; - for (_iter1105 = (*(this->part_vals)).begin(); _iter1105 != (*(this->part_vals)).end(); ++_iter1105) + std::vector ::const_iterator _iter1107; + for (_iter1107 = (*(this->part_vals)).begin(); _iter1107 != (*(this->part_vals)).end(); ++_iter1107) { - xfer += oprot->writeString((*_iter1105)); + xfer += oprot->writeString((*_iter1107)); } xfer += oprot->writeListEnd(); } @@ -15426,14 +15633,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1106; - ::apache::thrift::protocol::TType _etype1109; - xfer += iprot->readListBegin(_etype1109, _size1106); - this->success.resize(_size1106); - uint32_t _i1110; - for (_i1110 = 0; _i1110 < _size1106; ++_i1110) + uint32_t _size1108; + ::apache::thrift::protocol::TType _etype1111; + xfer += iprot->readListBegin(_etype1111, _size1108); + this->success.resize(_size1108); + uint32_t _i1112; + for (_i1112 = 0; _i1112 < _size1108; ++_i1112) { - xfer += iprot->readString(this->success[_i1110]); + xfer += iprot->readString(this->success[_i1112]); } xfer += iprot->readListEnd(); } @@ -15480,10 +15687,10 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_result::write(::apache::thri xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1111; - for (_iter1111 = this->success.begin(); _iter1111 != this->success.end(); ++_iter1111) + std::vector ::const_iterator _iter1113; + for (_iter1113 = this->success.begin(); _iter1113 != this->success.end(); ++_iter1113) { - xfer += oprot->writeString((*_iter1111)); + xfer += oprot->writeString((*_iter1113)); } xfer += oprot->writeListEnd(); } @@ -15532,14 +15739,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_presult::read(::apache::thri 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 _size1114; + ::apache::thrift::protocol::TType _etype1117; + xfer += iprot->readListBegin(_etype1117, _size1114); + (*(this->success)).resize(_size1114); + uint32_t _i1118; + for (_i1118 = 0; _i1118 < _size1114; ++_i1118) { - xfer += iprot->readString((*(this->success))[_i1116]); + xfer += iprot->readString((*(this->success))[_i1118]); } xfer += iprot->readListEnd(); } @@ -15733,14 +15940,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1117; - ::apache::thrift::protocol::TType _etype1120; - xfer += iprot->readListBegin(_etype1120, _size1117); - this->success.resize(_size1117); - uint32_t _i1121; - for (_i1121 = 0; _i1121 < _size1117; ++_i1121) + uint32_t _size1119; + ::apache::thrift::protocol::TType _etype1122; + xfer += iprot->readListBegin(_etype1122, _size1119); + this->success.resize(_size1119); + uint32_t _i1123; + for (_i1123 = 0; _i1123 < _size1119; ++_i1123) { - xfer += this->success[_i1121].read(iprot); + xfer += this->success[_i1123].read(iprot); } xfer += iprot->readListEnd(); } @@ -15787,10 +15994,10 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_result::write(::apache::th xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1122; - for (_iter1122 = this->success.begin(); _iter1122 != this->success.end(); ++_iter1122) + std::vector ::const_iterator _iter1124; + for (_iter1124 = this->success.begin(); _iter1124 != this->success.end(); ++_iter1124) { - xfer += (*_iter1122).write(oprot); + xfer += (*_iter1124).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15839,14 +16046,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1123; - ::apache::thrift::protocol::TType _etype1126; - xfer += iprot->readListBegin(_etype1126, _size1123); - (*(this->success)).resize(_size1123); - uint32_t _i1127; - for (_i1127 = 0; _i1127 < _size1123; ++_i1127) + uint32_t _size1125; + ::apache::thrift::protocol::TType _etype1128; + xfer += iprot->readListBegin(_etype1128, _size1125); + (*(this->success)).resize(_size1125); + uint32_t _i1129; + for (_i1129 = 0; _i1129 < _size1125; ++_i1129) { - xfer += (*(this->success))[_i1127].read(iprot); + xfer += (*(this->success))[_i1129].read(iprot); } xfer += iprot->readListEnd(); } @@ -16040,14 +16247,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 _size1128; - ::apache::thrift::protocol::TType _etype1131; - xfer += iprot->readListBegin(_etype1131, _size1128); - this->success.resize(_size1128); - uint32_t _i1132; - for (_i1132 = 0; _i1132 < _size1128; ++_i1132) + uint32_t _size1130; + ::apache::thrift::protocol::TType _etype1133; + xfer += iprot->readListBegin(_etype1133, _size1130); + this->success.resize(_size1130); + uint32_t _i1134; + for (_i1134 = 0; _i1134 < _size1130; ++_i1134) { - xfer += this->success[_i1132].read(iprot); + xfer += this->success[_i1134].read(iprot); } xfer += iprot->readListEnd(); } @@ -16094,10 +16301,10 @@ uint32_t ThriftHiveMetastore_get_part_specs_by_filter_result::write(::apache::th xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1133; - for (_iter1133 = this->success.begin(); _iter1133 != this->success.end(); ++_iter1133) + std::vector ::const_iterator _iter1135; + for (_iter1135 = this->success.begin(); _iter1135 != this->success.end(); ++_iter1135) { - xfer += (*_iter1133).write(oprot); + xfer += (*_iter1135).write(oprot); } xfer += oprot->writeListEnd(); } @@ -16146,14 +16353,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 _size1134; - ::apache::thrift::protocol::TType _etype1137; - xfer += iprot->readListBegin(_etype1137, _size1134); - (*(this->success)).resize(_size1134); - uint32_t _i1138; - for (_i1138 = 0; _i1138 < _size1134; ++_i1138) + uint32_t _size1136; + ::apache::thrift::protocol::TType _etype1139; + xfer += iprot->readListBegin(_etype1139, _size1136); + (*(this->success)).resize(_size1136); + uint32_t _i1140; + for (_i1140 = 0; _i1140 < _size1136; ++_i1140) { - xfer += (*(this->success))[_i1138].read(iprot); + xfer += (*(this->success))[_i1140].read(iprot); } xfer += iprot->readListEnd(); } @@ -16722,14 +16929,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_args::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { this->names.clear(); - uint32_t _size1139; - ::apache::thrift::protocol::TType _etype1142; - xfer += iprot->readListBegin(_etype1142, _size1139); - this->names.resize(_size1139); - uint32_t _i1143; - for (_i1143 = 0; _i1143 < _size1139; ++_i1143) + uint32_t _size1141; + ::apache::thrift::protocol::TType _etype1144; + xfer += iprot->readListBegin(_etype1144, _size1141); + this->names.resize(_size1141); + uint32_t _i1145; + for (_i1145 = 0; _i1145 < _size1141; ++_i1145) { - xfer += iprot->readString(this->names[_i1143]); + xfer += iprot->readString(this->names[_i1145]); } xfer += iprot->readListEnd(); } @@ -16766,10 +16973,10 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_args::write(::apache::thrif xfer += oprot->writeFieldBegin("names", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->names.size())); - std::vector ::const_iterator _iter1144; - for (_iter1144 = this->names.begin(); _iter1144 != this->names.end(); ++_iter1144) + std::vector ::const_iterator _iter1146; + for (_iter1146 = this->names.begin(); _iter1146 != this->names.end(); ++_iter1146) { - xfer += oprot->writeString((*_iter1144)); + xfer += oprot->writeString((*_iter1146)); } xfer += oprot->writeListEnd(); } @@ -16801,10 +17008,10 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_pargs::write(::apache::thri xfer += oprot->writeFieldBegin("names", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->names)).size())); - std::vector ::const_iterator _iter1145; - for (_iter1145 = (*(this->names)).begin(); _iter1145 != (*(this->names)).end(); ++_iter1145) + std::vector ::const_iterator _iter1147; + for (_iter1147 = (*(this->names)).begin(); _iter1147 != (*(this->names)).end(); ++_iter1147) { - xfer += oprot->writeString((*_iter1145)); + xfer += oprot->writeString((*_iter1147)); } xfer += oprot->writeListEnd(); } @@ -16845,14 +17052,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_result::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1146; - ::apache::thrift::protocol::TType _etype1149; - xfer += iprot->readListBegin(_etype1149, _size1146); - this->success.resize(_size1146); - uint32_t _i1150; - for (_i1150 = 0; _i1150 < _size1146; ++_i1150) + uint32_t _size1148; + ::apache::thrift::protocol::TType _etype1151; + xfer += iprot->readListBegin(_etype1151, _size1148); + this->success.resize(_size1148); + uint32_t _i1152; + for (_i1152 = 0; _i1152 < _size1148; ++_i1152) { - xfer += this->success[_i1150].read(iprot); + xfer += this->success[_i1152].read(iprot); } xfer += iprot->readListEnd(); } @@ -16899,10 +17106,10 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_result::write(::apache::thr xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1151; - for (_iter1151 = this->success.begin(); _iter1151 != this->success.end(); ++_iter1151) + std::vector ::const_iterator _iter1153; + for (_iter1153 = this->success.begin(); _iter1153 != this->success.end(); ++_iter1153) { - xfer += (*_iter1151).write(oprot); + xfer += (*_iter1153).write(oprot); } xfer += oprot->writeListEnd(); } @@ -16951,14 +17158,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_presult::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1152; - ::apache::thrift::protocol::TType _etype1155; - xfer += iprot->readListBegin(_etype1155, _size1152); - (*(this->success)).resize(_size1152); - uint32_t _i1156; - for (_i1156 = 0; _i1156 < _size1152; ++_i1156) + uint32_t _size1154; + ::apache::thrift::protocol::TType _etype1157; + xfer += iprot->readListBegin(_etype1157, _size1154); + (*(this->success)).resize(_size1154); + uint32_t _i1158; + for (_i1158 = 0; _i1158 < _size1154; ++_i1158) { - xfer += (*(this->success))[_i1156].read(iprot); + xfer += (*(this->success))[_i1158].read(iprot); } xfer += iprot->readListEnd(); } @@ -17280,14 +17487,14 @@ uint32_t ThriftHiveMetastore_alter_partitions_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size1157; - ::apache::thrift::protocol::TType _etype1160; - xfer += iprot->readListBegin(_etype1160, _size1157); - this->new_parts.resize(_size1157); - uint32_t _i1161; - for (_i1161 = 0; _i1161 < _size1157; ++_i1161) + uint32_t _size1159; + ::apache::thrift::protocol::TType _etype1162; + xfer += iprot->readListBegin(_etype1162, _size1159); + this->new_parts.resize(_size1159); + uint32_t _i1163; + for (_i1163 = 0; _i1163 < _size1159; ++_i1163) { - xfer += this->new_parts[_i1161].read(iprot); + xfer += this->new_parts[_i1163].read(iprot); } xfer += iprot->readListEnd(); } @@ -17324,10 +17531,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 _iter1162; - for (_iter1162 = this->new_parts.begin(); _iter1162 != this->new_parts.end(); ++_iter1162) + std::vector ::const_iterator _iter1164; + for (_iter1164 = this->new_parts.begin(); _iter1164 != this->new_parts.end(); ++_iter1164) { - xfer += (*_iter1162).write(oprot); + xfer += (*_iter1164).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17359,10 +17566,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 _iter1163; - for (_iter1163 = (*(this->new_parts)).begin(); _iter1163 != (*(this->new_parts)).end(); ++_iter1163) + std::vector ::const_iterator _iter1165; + for (_iter1165 = (*(this->new_parts)).begin(); _iter1165 != (*(this->new_parts)).end(); ++_iter1165) { - xfer += (*_iter1163).write(oprot); + xfer += (*_iter1165).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17547,14 +17754,14 @@ uint32_t ThriftHiveMetastore_alter_partitions_with_environment_context_args::rea if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size1164; - ::apache::thrift::protocol::TType _etype1167; - xfer += iprot->readListBegin(_etype1167, _size1164); - this->new_parts.resize(_size1164); - uint32_t _i1168; - for (_i1168 = 0; _i1168 < _size1164; ++_i1168) + uint32_t _size1166; + ::apache::thrift::protocol::TType _etype1169; + xfer += iprot->readListBegin(_etype1169, _size1166); + this->new_parts.resize(_size1166); + uint32_t _i1170; + for (_i1170 = 0; _i1170 < _size1166; ++_i1170) { - xfer += this->new_parts[_i1168].read(iprot); + xfer += this->new_parts[_i1170].read(iprot); } xfer += iprot->readListEnd(); } @@ -17599,10 +17806,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 _iter1169; - for (_iter1169 = this->new_parts.begin(); _iter1169 != this->new_parts.end(); ++_iter1169) + std::vector ::const_iterator _iter1171; + for (_iter1171 = this->new_parts.begin(); _iter1171 != this->new_parts.end(); ++_iter1171) { - xfer += (*_iter1169).write(oprot); + xfer += (*_iter1171).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17638,10 +17845,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 _iter1170; - for (_iter1170 = (*(this->new_parts)).begin(); _iter1170 != (*(this->new_parts)).end(); ++_iter1170) + std::vector ::const_iterator _iter1172; + for (_iter1172 = (*(this->new_parts)).begin(); _iter1172 != (*(this->new_parts)).end(); ++_iter1172) { - xfer += (*_iter1170).write(oprot); + xfer += (*_iter1172).write(oprot); } xfer += oprot->writeListEnd(); } @@ -18085,14 +18292,14 @@ uint32_t ThriftHiveMetastore_rename_partition_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1171; - ::apache::thrift::protocol::TType _etype1174; - xfer += iprot->readListBegin(_etype1174, _size1171); - this->part_vals.resize(_size1171); - uint32_t _i1175; - for (_i1175 = 0; _i1175 < _size1171; ++_i1175) + uint32_t _size1173; + ::apache::thrift::protocol::TType _etype1176; + xfer += iprot->readListBegin(_etype1176, _size1173); + this->part_vals.resize(_size1173); + uint32_t _i1177; + for (_i1177 = 0; _i1177 < _size1173; ++_i1177) { - xfer += iprot->readString(this->part_vals[_i1175]); + xfer += iprot->readString(this->part_vals[_i1177]); } xfer += iprot->readListEnd(); } @@ -18137,10 +18344,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 _iter1176; - for (_iter1176 = this->part_vals.begin(); _iter1176 != this->part_vals.end(); ++_iter1176) + std::vector ::const_iterator _iter1178; + for (_iter1178 = this->part_vals.begin(); _iter1178 != this->part_vals.end(); ++_iter1178) { - xfer += oprot->writeString((*_iter1176)); + xfer += oprot->writeString((*_iter1178)); } xfer += oprot->writeListEnd(); } @@ -18176,10 +18383,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 _iter1177; - for (_iter1177 = (*(this->part_vals)).begin(); _iter1177 != (*(this->part_vals)).end(); ++_iter1177) + std::vector ::const_iterator _iter1179; + for (_iter1179 = (*(this->part_vals)).begin(); _iter1179 != (*(this->part_vals)).end(); ++_iter1179) { - xfer += oprot->writeString((*_iter1177)); + xfer += oprot->writeString((*_iter1179)); } xfer += oprot->writeListEnd(); } @@ -18352,14 +18559,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 _size1178; - ::apache::thrift::protocol::TType _etype1181; - xfer += iprot->readListBegin(_etype1181, _size1178); - this->part_vals.resize(_size1178); - uint32_t _i1182; - for (_i1182 = 0; _i1182 < _size1178; ++_i1182) + uint32_t _size1180; + ::apache::thrift::protocol::TType _etype1183; + xfer += iprot->readListBegin(_etype1183, _size1180); + this->part_vals.resize(_size1180); + uint32_t _i1184; + for (_i1184 = 0; _i1184 < _size1180; ++_i1184) { - xfer += iprot->readString(this->part_vals[_i1182]); + xfer += iprot->readString(this->part_vals[_i1184]); } xfer += iprot->readListEnd(); } @@ -18396,10 +18603,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 _iter1183; - for (_iter1183 = this->part_vals.begin(); _iter1183 != this->part_vals.end(); ++_iter1183) + std::vector ::const_iterator _iter1185; + for (_iter1185 = this->part_vals.begin(); _iter1185 != this->part_vals.end(); ++_iter1185) { - xfer += oprot->writeString((*_iter1183)); + xfer += oprot->writeString((*_iter1185)); } xfer += oprot->writeListEnd(); } @@ -18427,10 +18634,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 _iter1184; - for (_iter1184 = (*(this->part_vals)).begin(); _iter1184 != (*(this->part_vals)).end(); ++_iter1184) + std::vector ::const_iterator _iter1186; + for (_iter1186 = (*(this->part_vals)).begin(); _iter1186 != (*(this->part_vals)).end(); ++_iter1186) { - xfer += oprot->writeString((*_iter1184)); + xfer += oprot->writeString((*_iter1186)); } xfer += oprot->writeListEnd(); } @@ -18905,14 +19112,14 @@ uint32_t ThriftHiveMetastore_partition_name_to_vals_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1185; - ::apache::thrift::protocol::TType _etype1188; - xfer += iprot->readListBegin(_etype1188, _size1185); - this->success.resize(_size1185); - uint32_t _i1189; - for (_i1189 = 0; _i1189 < _size1185; ++_i1189) + uint32_t _size1187; + ::apache::thrift::protocol::TType _etype1190; + xfer += iprot->readListBegin(_etype1190, _size1187); + this->success.resize(_size1187); + uint32_t _i1191; + for (_i1191 = 0; _i1191 < _size1187; ++_i1191) { - xfer += iprot->readString(this->success[_i1189]); + xfer += iprot->readString(this->success[_i1191]); } xfer += iprot->readListEnd(); } @@ -18951,10 +19158,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 _iter1190; - for (_iter1190 = this->success.begin(); _iter1190 != this->success.end(); ++_iter1190) + std::vector ::const_iterator _iter1192; + for (_iter1192 = this->success.begin(); _iter1192 != this->success.end(); ++_iter1192) { - xfer += oprot->writeString((*_iter1190)); + xfer += oprot->writeString((*_iter1192)); } xfer += oprot->writeListEnd(); } @@ -18999,14 +19206,14 @@ uint32_t ThriftHiveMetastore_partition_name_to_vals_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1191; - ::apache::thrift::protocol::TType _etype1194; - xfer += iprot->readListBegin(_etype1194, _size1191); - (*(this->success)).resize(_size1191); - uint32_t _i1195; - for (_i1195 = 0; _i1195 < _size1191; ++_i1195) + uint32_t _size1193; + ::apache::thrift::protocol::TType _etype1196; + xfer += iprot->readListBegin(_etype1196, _size1193); + (*(this->success)).resize(_size1193); + uint32_t _i1197; + for (_i1197 = 0; _i1197 < _size1193; ++_i1197) { - xfer += iprot->readString((*(this->success))[_i1195]); + xfer += iprot->readString((*(this->success))[_i1197]); } xfer += iprot->readListEnd(); } @@ -19144,17 +19351,17 @@ uint32_t ThriftHiveMetastore_partition_name_to_spec_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_MAP) { { this->success.clear(); - uint32_t _size1196; - ::apache::thrift::protocol::TType _ktype1197; - ::apache::thrift::protocol::TType _vtype1198; - xfer += iprot->readMapBegin(_ktype1197, _vtype1198, _size1196); - uint32_t _i1200; - for (_i1200 = 0; _i1200 < _size1196; ++_i1200) + uint32_t _size1198; + ::apache::thrift::protocol::TType _ktype1199; + ::apache::thrift::protocol::TType _vtype1200; + xfer += iprot->readMapBegin(_ktype1199, _vtype1200, _size1198); + uint32_t _i1202; + for (_i1202 = 0; _i1202 < _size1198; ++_i1202) { - std::string _key1201; - xfer += iprot->readString(_key1201); - std::string& _val1202 = this->success[_key1201]; - xfer += iprot->readString(_val1202); + std::string _key1203; + xfer += iprot->readString(_key1203); + std::string& _val1204 = this->success[_key1203]; + xfer += iprot->readString(_val1204); } xfer += iprot->readMapEnd(); } @@ -19193,11 +19400,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 _iter1203; - for (_iter1203 = this->success.begin(); _iter1203 != this->success.end(); ++_iter1203) + std::map ::const_iterator _iter1205; + for (_iter1205 = this->success.begin(); _iter1205 != this->success.end(); ++_iter1205) { - xfer += oprot->writeString(_iter1203->first); - xfer += oprot->writeString(_iter1203->second); + xfer += oprot->writeString(_iter1205->first); + xfer += oprot->writeString(_iter1205->second); } xfer += oprot->writeMapEnd(); } @@ -19242,17 +19449,17 @@ uint32_t ThriftHiveMetastore_partition_name_to_spec_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_MAP) { { (*(this->success)).clear(); - uint32_t _size1204; - ::apache::thrift::protocol::TType _ktype1205; - ::apache::thrift::protocol::TType _vtype1206; - xfer += iprot->readMapBegin(_ktype1205, _vtype1206, _size1204); - uint32_t _i1208; - for (_i1208 = 0; _i1208 < _size1204; ++_i1208) + uint32_t _size1206; + ::apache::thrift::protocol::TType _ktype1207; + ::apache::thrift::protocol::TType _vtype1208; + xfer += iprot->readMapBegin(_ktype1207, _vtype1208, _size1206); + uint32_t _i1210; + for (_i1210 = 0; _i1210 < _size1206; ++_i1210) { - std::string _key1209; - xfer += iprot->readString(_key1209); - std::string& _val1210 = (*(this->success))[_key1209]; - xfer += iprot->readString(_val1210); + std::string _key1211; + xfer += iprot->readString(_key1211); + std::string& _val1212 = (*(this->success))[_key1211]; + xfer += iprot->readString(_val1212); } xfer += iprot->readMapEnd(); } @@ -19327,17 +19534,17 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_args::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_MAP) { { this->part_vals.clear(); - uint32_t _size1211; - ::apache::thrift::protocol::TType _ktype1212; - ::apache::thrift::protocol::TType _vtype1213; - xfer += iprot->readMapBegin(_ktype1212, _vtype1213, _size1211); - uint32_t _i1215; - for (_i1215 = 0; _i1215 < _size1211; ++_i1215) + uint32_t _size1213; + ::apache::thrift::protocol::TType _ktype1214; + ::apache::thrift::protocol::TType _vtype1215; + xfer += iprot->readMapBegin(_ktype1214, _vtype1215, _size1213); + uint32_t _i1217; + for (_i1217 = 0; _i1217 < _size1213; ++_i1217) { - std::string _key1216; - xfer += iprot->readString(_key1216); - std::string& _val1217 = this->part_vals[_key1216]; - xfer += iprot->readString(_val1217); + std::string _key1218; + xfer += iprot->readString(_key1218); + std::string& _val1219 = this->part_vals[_key1218]; + xfer += iprot->readString(_val1219); } xfer += iprot->readMapEnd(); } @@ -19348,9 +19555,9 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_args::read(::apache::thrift:: break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1218; - xfer += iprot->readI32(ecast1218); - this->eventType = (PartitionEventType::type)ecast1218; + int32_t ecast1220; + xfer += iprot->readI32(ecast1220); + this->eventType = (PartitionEventType::type)ecast1220; this->__isset.eventType = true; } else { xfer += iprot->skip(ftype); @@ -19384,11 +19591,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 _iter1219; - for (_iter1219 = this->part_vals.begin(); _iter1219 != this->part_vals.end(); ++_iter1219) + std::map ::const_iterator _iter1221; + for (_iter1221 = this->part_vals.begin(); _iter1221 != this->part_vals.end(); ++_iter1221) { - xfer += oprot->writeString(_iter1219->first); - xfer += oprot->writeString(_iter1219->second); + xfer += oprot->writeString(_iter1221->first); + xfer += oprot->writeString(_iter1221->second); } xfer += oprot->writeMapEnd(); } @@ -19424,11 +19631,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 _iter1220; - for (_iter1220 = (*(this->part_vals)).begin(); _iter1220 != (*(this->part_vals)).end(); ++_iter1220) + std::map ::const_iterator _iter1222; + for (_iter1222 = (*(this->part_vals)).begin(); _iter1222 != (*(this->part_vals)).end(); ++_iter1222) { - xfer += oprot->writeString(_iter1220->first); - xfer += oprot->writeString(_iter1220->second); + xfer += oprot->writeString(_iter1222->first); + xfer += oprot->writeString(_iter1222->second); } xfer += oprot->writeMapEnd(); } @@ -19697,17 +19904,17 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_MAP) { { this->part_vals.clear(); - 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) + uint32_t _size1223; + ::apache::thrift::protocol::TType _ktype1224; + ::apache::thrift::protocol::TType _vtype1225; + xfer += iprot->readMapBegin(_ktype1224, _vtype1225, _size1223); + uint32_t _i1227; + for (_i1227 = 0; _i1227 < _size1223; ++_i1227) { - std::string _key1226; - xfer += iprot->readString(_key1226); - std::string& _val1227 = this->part_vals[_key1226]; - xfer += iprot->readString(_val1227); + std::string _key1228; + xfer += iprot->readString(_key1228); + std::string& _val1229 = this->part_vals[_key1228]; + xfer += iprot->readString(_val1229); } xfer += iprot->readMapEnd(); } @@ -19718,9 +19925,9 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::read(::apache::thri break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1228; - xfer += iprot->readI32(ecast1228); - this->eventType = (PartitionEventType::type)ecast1228; + int32_t ecast1230; + xfer += iprot->readI32(ecast1230); + this->eventType = (PartitionEventType::type)ecast1230; this->__isset.eventType = true; } else { xfer += iprot->skip(ftype); @@ -19754,11 +19961,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 _iter1229; - for (_iter1229 = this->part_vals.begin(); _iter1229 != this->part_vals.end(); ++_iter1229) + std::map ::const_iterator _iter1231; + for (_iter1231 = this->part_vals.begin(); _iter1231 != this->part_vals.end(); ++_iter1231) { - xfer += oprot->writeString(_iter1229->first); - xfer += oprot->writeString(_iter1229->second); + xfer += oprot->writeString(_iter1231->first); + xfer += oprot->writeString(_iter1231->second); } xfer += oprot->writeMapEnd(); } @@ -19794,11 +20001,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 _iter1230; - for (_iter1230 = (*(this->part_vals)).begin(); _iter1230 != (*(this->part_vals)).end(); ++_iter1230) + std::map ::const_iterator _iter1232; + for (_iter1232 = (*(this->part_vals)).begin(); _iter1232 != (*(this->part_vals)).end(); ++_iter1232) { - xfer += oprot->writeString(_iter1230->first); - xfer += oprot->writeString(_iter1230->second); + xfer += oprot->writeString(_iter1232->first); + xfer += oprot->writeString(_iter1232->second); } xfer += oprot->writeMapEnd(); } @@ -21234,14 +21441,14 @@ uint32_t ThriftHiveMetastore_get_indexes_result::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1231; - ::apache::thrift::protocol::TType _etype1234; - xfer += iprot->readListBegin(_etype1234, _size1231); - this->success.resize(_size1231); - uint32_t _i1235; - for (_i1235 = 0; _i1235 < _size1231; ++_i1235) + uint32_t _size1233; + ::apache::thrift::protocol::TType _etype1236; + xfer += iprot->readListBegin(_etype1236, _size1233); + this->success.resize(_size1233); + uint32_t _i1237; + for (_i1237 = 0; _i1237 < _size1233; ++_i1237) { - xfer += this->success[_i1235].read(iprot); + xfer += this->success[_i1237].read(iprot); } xfer += iprot->readListEnd(); } @@ -21288,10 +21495,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 _iter1236; - for (_iter1236 = this->success.begin(); _iter1236 != this->success.end(); ++_iter1236) + std::vector ::const_iterator _iter1238; + for (_iter1238 = this->success.begin(); _iter1238 != this->success.end(); ++_iter1238) { - xfer += (*_iter1236).write(oprot); + xfer += (*_iter1238).write(oprot); } xfer += oprot->writeListEnd(); } @@ -21340,14 +21547,14 @@ uint32_t ThriftHiveMetastore_get_indexes_presult::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1237; - ::apache::thrift::protocol::TType _etype1240; - xfer += iprot->readListBegin(_etype1240, _size1237); - (*(this->success)).resize(_size1237); - uint32_t _i1241; - for (_i1241 = 0; _i1241 < _size1237; ++_i1241) + 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))[_i1241].read(iprot); + xfer += (*(this->success))[_i1243].read(iprot); } xfer += iprot->readListEnd(); } @@ -21525,14 +21732,14 @@ uint32_t ThriftHiveMetastore_get_index_names_result::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1242; - ::apache::thrift::protocol::TType _etype1245; - xfer += iprot->readListBegin(_etype1245, _size1242); - this->success.resize(_size1242); - uint32_t _i1246; - for (_i1246 = 0; _i1246 < _size1242; ++_i1246) + uint32_t _size1244; + ::apache::thrift::protocol::TType _etype1247; + xfer += iprot->readListBegin(_etype1247, _size1244); + this->success.resize(_size1244); + uint32_t _i1248; + for (_i1248 = 0; _i1248 < _size1244; ++_i1248) { - xfer += iprot->readString(this->success[_i1246]); + xfer += iprot->readString(this->success[_i1248]); } xfer += iprot->readListEnd(); } @@ -21571,10 +21778,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 _iter1247; - for (_iter1247 = this->success.begin(); _iter1247 != this->success.end(); ++_iter1247) + std::vector ::const_iterator _iter1249; + for (_iter1249 = this->success.begin(); _iter1249 != this->success.end(); ++_iter1249) { - xfer += oprot->writeString((*_iter1247)); + xfer += oprot->writeString((*_iter1249)); } xfer += oprot->writeListEnd(); } @@ -21619,14 +21826,14 @@ uint32_t ThriftHiveMetastore_get_index_names_presult::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1248; - ::apache::thrift::protocol::TType _etype1251; - xfer += iprot->readListBegin(_etype1251, _size1248); - (*(this->success)).resize(_size1248); - uint32_t _i1252; - for (_i1252 = 0; _i1252 < _size1248; ++_i1252) + uint32_t _size1250; + ::apache::thrift::protocol::TType _etype1253; + xfer += iprot->readListBegin(_etype1253, _size1250); + (*(this->success)).resize(_size1250); + uint32_t _i1254; + for (_i1254 = 0; _i1254 < _size1250; ++_i1254) { - xfer += iprot->readString((*(this->success))[_i1252]); + xfer += iprot->readString((*(this->success))[_i1254]); } xfer += iprot->readListEnd(); } @@ -25653,14 +25860,14 @@ uint32_t ThriftHiveMetastore_get_functions_result::read(::apache::thrift::protoc if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1253; - ::apache::thrift::protocol::TType _etype1256; - xfer += iprot->readListBegin(_etype1256, _size1253); - this->success.resize(_size1253); - uint32_t _i1257; - for (_i1257 = 0; _i1257 < _size1253; ++_i1257) + uint32_t _size1255; + ::apache::thrift::protocol::TType _etype1258; + xfer += iprot->readListBegin(_etype1258, _size1255); + this->success.resize(_size1255); + uint32_t _i1259; + for (_i1259 = 0; _i1259 < _size1255; ++_i1259) { - xfer += iprot->readString(this->success[_i1257]); + xfer += iprot->readString(this->success[_i1259]); } xfer += iprot->readListEnd(); } @@ -25699,10 +25906,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 _iter1258; - for (_iter1258 = this->success.begin(); _iter1258 != this->success.end(); ++_iter1258) + std::vector ::const_iterator _iter1260; + for (_iter1260 = this->success.begin(); _iter1260 != this->success.end(); ++_iter1260) { - xfer += oprot->writeString((*_iter1258)); + xfer += oprot->writeString((*_iter1260)); } xfer += oprot->writeListEnd(); } @@ -25747,14 +25954,14 @@ uint32_t ThriftHiveMetastore_get_functions_presult::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1259; - ::apache::thrift::protocol::TType _etype1262; - xfer += iprot->readListBegin(_etype1262, _size1259); - (*(this->success)).resize(_size1259); - uint32_t _i1263; - for (_i1263 = 0; _i1263 < _size1259; ++_i1263) + uint32_t _size1261; + ::apache::thrift::protocol::TType _etype1264; + xfer += iprot->readListBegin(_etype1264, _size1261); + (*(this->success)).resize(_size1261); + uint32_t _i1265; + for (_i1265 = 0; _i1265 < _size1261; ++_i1265) { - xfer += iprot->readString((*(this->success))[_i1263]); + xfer += iprot->readString((*(this->success))[_i1265]); } xfer += iprot->readListEnd(); } @@ -26714,14 +26921,14 @@ uint32_t ThriftHiveMetastore_get_role_names_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1264; - ::apache::thrift::protocol::TType _etype1267; - xfer += iprot->readListBegin(_etype1267, _size1264); - this->success.resize(_size1264); - uint32_t _i1268; - for (_i1268 = 0; _i1268 < _size1264; ++_i1268) + uint32_t _size1266; + ::apache::thrift::protocol::TType _etype1269; + xfer += iprot->readListBegin(_etype1269, _size1266); + this->success.resize(_size1266); + uint32_t _i1270; + for (_i1270 = 0; _i1270 < _size1266; ++_i1270) { - xfer += iprot->readString(this->success[_i1268]); + xfer += iprot->readString(this->success[_i1270]); } xfer += iprot->readListEnd(); } @@ -26760,10 +26967,10 @@ uint32_t ThriftHiveMetastore_get_role_names_result::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1269; - for (_iter1269 = this->success.begin(); _iter1269 != this->success.end(); ++_iter1269) + std::vector ::const_iterator _iter1271; + for (_iter1271 = this->success.begin(); _iter1271 != this->success.end(); ++_iter1271) { - xfer += oprot->writeString((*_iter1269)); + xfer += oprot->writeString((*_iter1271)); } xfer += oprot->writeListEnd(); } @@ -26808,14 +27015,14 @@ uint32_t ThriftHiveMetastore_get_role_names_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - 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) + uint32_t _size1272; + ::apache::thrift::protocol::TType _etype1275; + xfer += iprot->readListBegin(_etype1275, _size1272); + (*(this->success)).resize(_size1272); + uint32_t _i1276; + for (_i1276 = 0; _i1276 < _size1272; ++_i1276) { - xfer += iprot->readString((*(this->success))[_i1274]); + xfer += iprot->readString((*(this->success))[_i1276]); } xfer += iprot->readListEnd(); } @@ -26888,9 +27095,9 @@ uint32_t ThriftHiveMetastore_grant_role_args::read(::apache::thrift::protocol::T break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1275; - xfer += iprot->readI32(ecast1275); - this->principal_type = (PrincipalType::type)ecast1275; + int32_t ecast1277; + xfer += iprot->readI32(ecast1277); + this->principal_type = (PrincipalType::type)ecast1277; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -26906,9 +27113,9 @@ uint32_t ThriftHiveMetastore_grant_role_args::read(::apache::thrift::protocol::T break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1276; - xfer += iprot->readI32(ecast1276); - this->grantorType = (PrincipalType::type)ecast1276; + int32_t ecast1278; + xfer += iprot->readI32(ecast1278); + this->grantorType = (PrincipalType::type)ecast1278; this->__isset.grantorType = true; } else { xfer += iprot->skip(ftype); @@ -27179,9 +27386,9 @@ uint32_t ThriftHiveMetastore_revoke_role_args::read(::apache::thrift::protocol:: break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1277; - xfer += iprot->readI32(ecast1277); - this->principal_type = (PrincipalType::type)ecast1277; + int32_t ecast1279; + xfer += iprot->readI32(ecast1279); + this->principal_type = (PrincipalType::type)ecast1279; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -27412,9 +27619,9 @@ uint32_t ThriftHiveMetastore_list_roles_args::read(::apache::thrift::protocol::T break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1278; - xfer += iprot->readI32(ecast1278); - this->principal_type = (PrincipalType::type)ecast1278; + int32_t ecast1280; + xfer += iprot->readI32(ecast1280); + this->principal_type = (PrincipalType::type)ecast1280; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -27503,14 +27710,14 @@ uint32_t ThriftHiveMetastore_list_roles_result::read(::apache::thrift::protocol: 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 _size1281; + ::apache::thrift::protocol::TType _etype1284; + xfer += iprot->readListBegin(_etype1284, _size1281); + this->success.resize(_size1281); + uint32_t _i1285; + for (_i1285 = 0; _i1285 < _size1281; ++_i1285) { - xfer += this->success[_i1283].read(iprot); + xfer += this->success[_i1285].read(iprot); } xfer += iprot->readListEnd(); } @@ -27549,10 +27756,10 @@ uint32_t ThriftHiveMetastore_list_roles_result::write(::apache::thrift::protocol xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1284; - for (_iter1284 = this->success.begin(); _iter1284 != this->success.end(); ++_iter1284) + std::vector ::const_iterator _iter1286; + for (_iter1286 = this->success.begin(); _iter1286 != this->success.end(); ++_iter1286) { - xfer += (*_iter1284).write(oprot); + xfer += (*_iter1286).write(oprot); } xfer += oprot->writeListEnd(); } @@ -27597,14 +27804,14 @@ uint32_t ThriftHiveMetastore_list_roles_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1285; - ::apache::thrift::protocol::TType _etype1288; - xfer += iprot->readListBegin(_etype1288, _size1285); - (*(this->success)).resize(_size1285); - uint32_t _i1289; - for (_i1289 = 0; _i1289 < _size1285; ++_i1289) + uint32_t _size1287; + ::apache::thrift::protocol::TType _etype1290; + xfer += iprot->readListBegin(_etype1290, _size1287); + (*(this->success)).resize(_size1287); + uint32_t _i1291; + for (_i1291 = 0; _i1291 < _size1287; ++_i1291) { - xfer += (*(this->success))[_i1289].read(iprot); + xfer += (*(this->success))[_i1291].read(iprot); } xfer += iprot->readListEnd(); } @@ -28300,14 +28507,14 @@ uint32_t ThriftHiveMetastore_get_privilege_set_args::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size1290; - ::apache::thrift::protocol::TType _etype1293; - xfer += iprot->readListBegin(_etype1293, _size1290); - this->group_names.resize(_size1290); - uint32_t _i1294; - for (_i1294 = 0; _i1294 < _size1290; ++_i1294) + uint32_t _size1292; + ::apache::thrift::protocol::TType _etype1295; + xfer += iprot->readListBegin(_etype1295, _size1292); + this->group_names.resize(_size1292); + uint32_t _i1296; + for (_i1296 = 0; _i1296 < _size1292; ++_i1296) { - xfer += iprot->readString(this->group_names[_i1294]); + xfer += iprot->readString(this->group_names[_i1296]); } xfer += iprot->readListEnd(); } @@ -28344,10 +28551,10 @@ uint32_t ThriftHiveMetastore_get_privilege_set_args::write(::apache::thrift::pro xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->group_names.size())); - std::vector ::const_iterator _iter1295; - for (_iter1295 = this->group_names.begin(); _iter1295 != this->group_names.end(); ++_iter1295) + std::vector ::const_iterator _iter1297; + for (_iter1297 = this->group_names.begin(); _iter1297 != this->group_names.end(); ++_iter1297) { - xfer += oprot->writeString((*_iter1295)); + xfer += oprot->writeString((*_iter1297)); } xfer += oprot->writeListEnd(); } @@ -28379,10 +28586,10 @@ uint32_t ThriftHiveMetastore_get_privilege_set_pargs::write(::apache::thrift::pr xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->group_names)).size())); - std::vector ::const_iterator _iter1296; - for (_iter1296 = (*(this->group_names)).begin(); _iter1296 != (*(this->group_names)).end(); ++_iter1296) + std::vector ::const_iterator _iter1298; + for (_iter1298 = (*(this->group_names)).begin(); _iter1298 != (*(this->group_names)).end(); ++_iter1298) { - xfer += oprot->writeString((*_iter1296)); + xfer += oprot->writeString((*_iter1298)); } xfer += oprot->writeListEnd(); } @@ -28557,9 +28764,9 @@ uint32_t ThriftHiveMetastore_list_privileges_args::read(::apache::thrift::protoc break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1297; - xfer += iprot->readI32(ecast1297); - this->principal_type = (PrincipalType::type)ecast1297; + int32_t ecast1299; + xfer += iprot->readI32(ecast1299); + this->principal_type = (PrincipalType::type)ecast1299; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -28664,14 +28871,14 @@ uint32_t ThriftHiveMetastore_list_privileges_result::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1298; - ::apache::thrift::protocol::TType _etype1301; - xfer += iprot->readListBegin(_etype1301, _size1298); - this->success.resize(_size1298); - uint32_t _i1302; - for (_i1302 = 0; _i1302 < _size1298; ++_i1302) + uint32_t _size1300; + ::apache::thrift::protocol::TType _etype1303; + xfer += iprot->readListBegin(_etype1303, _size1300); + this->success.resize(_size1300); + uint32_t _i1304; + for (_i1304 = 0; _i1304 < _size1300; ++_i1304) { - xfer += this->success[_i1302].read(iprot); + xfer += this->success[_i1304].read(iprot); } xfer += iprot->readListEnd(); } @@ -28710,10 +28917,10 @@ uint32_t ThriftHiveMetastore_list_privileges_result::write(::apache::thrift::pro xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1303; - for (_iter1303 = this->success.begin(); _iter1303 != this->success.end(); ++_iter1303) + std::vector ::const_iterator _iter1305; + for (_iter1305 = this->success.begin(); _iter1305 != this->success.end(); ++_iter1305) { - xfer += (*_iter1303).write(oprot); + xfer += (*_iter1305).write(oprot); } xfer += oprot->writeListEnd(); } @@ -28758,14 +28965,14 @@ uint32_t ThriftHiveMetastore_list_privileges_presult::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - 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) + uint32_t _size1306; + ::apache::thrift::protocol::TType _etype1309; + xfer += iprot->readListBegin(_etype1309, _size1306); + (*(this->success)).resize(_size1306); + uint32_t _i1310; + for (_i1310 = 0; _i1310 < _size1306; ++_i1310) { - xfer += (*(this->success))[_i1308].read(iprot); + xfer += (*(this->success))[_i1310].read(iprot); } xfer += iprot->readListEnd(); } @@ -29453,14 +29660,14 @@ uint32_t ThriftHiveMetastore_set_ugi_args::read(::apache::thrift::protocol::TPro if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size1309; - ::apache::thrift::protocol::TType _etype1312; - xfer += iprot->readListBegin(_etype1312, _size1309); - this->group_names.resize(_size1309); - uint32_t _i1313; - for (_i1313 = 0; _i1313 < _size1309; ++_i1313) + uint32_t _size1311; + ::apache::thrift::protocol::TType _etype1314; + xfer += iprot->readListBegin(_etype1314, _size1311); + this->group_names.resize(_size1311); + uint32_t _i1315; + for (_i1315 = 0; _i1315 < _size1311; ++_i1315) { - xfer += iprot->readString(this->group_names[_i1313]); + xfer += iprot->readString(this->group_names[_i1315]); } xfer += iprot->readListEnd(); } @@ -29493,10 +29700,10 @@ uint32_t ThriftHiveMetastore_set_ugi_args::write(::apache::thrift::protocol::TPr xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->group_names.size())); - std::vector ::const_iterator _iter1314; - for (_iter1314 = this->group_names.begin(); _iter1314 != this->group_names.end(); ++_iter1314) + std::vector ::const_iterator _iter1316; + for (_iter1316 = this->group_names.begin(); _iter1316 != this->group_names.end(); ++_iter1316) { - xfer += oprot->writeString((*_iter1314)); + xfer += oprot->writeString((*_iter1316)); } xfer += oprot->writeListEnd(); } @@ -29524,10 +29731,10 @@ uint32_t ThriftHiveMetastore_set_ugi_pargs::write(::apache::thrift::protocol::TP xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->group_names)).size())); - std::vector ::const_iterator _iter1315; - for (_iter1315 = (*(this->group_names)).begin(); _iter1315 != (*(this->group_names)).end(); ++_iter1315) + std::vector ::const_iterator _iter1317; + for (_iter1317 = (*(this->group_names)).begin(); _iter1317 != (*(this->group_names)).end(); ++_iter1317) { - xfer += oprot->writeString((*_iter1315)); + xfer += oprot->writeString((*_iter1317)); } xfer += oprot->writeListEnd(); } @@ -29568,14 +29775,14 @@ uint32_t ThriftHiveMetastore_set_ugi_result::read(::apache::thrift::protocol::TP if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1316; - ::apache::thrift::protocol::TType _etype1319; - xfer += iprot->readListBegin(_etype1319, _size1316); - this->success.resize(_size1316); - uint32_t _i1320; - for (_i1320 = 0; _i1320 < _size1316; ++_i1320) + uint32_t _size1318; + ::apache::thrift::protocol::TType _etype1321; + xfer += iprot->readListBegin(_etype1321, _size1318); + this->success.resize(_size1318); + uint32_t _i1322; + for (_i1322 = 0; _i1322 < _size1318; ++_i1322) { - xfer += iprot->readString(this->success[_i1320]); + xfer += iprot->readString(this->success[_i1322]); } xfer += iprot->readListEnd(); } @@ -29614,10 +29821,10 @@ uint32_t ThriftHiveMetastore_set_ugi_result::write(::apache::thrift::protocol::T xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1321; - for (_iter1321 = this->success.begin(); _iter1321 != this->success.end(); ++_iter1321) + std::vector ::const_iterator _iter1323; + for (_iter1323 = this->success.begin(); _iter1323 != this->success.end(); ++_iter1323) { - xfer += oprot->writeString((*_iter1321)); + xfer += oprot->writeString((*_iter1323)); } xfer += oprot->writeListEnd(); } @@ -29662,14 +29869,14 @@ uint32_t ThriftHiveMetastore_set_ugi_presult::read(::apache::thrift::protocol::T if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - 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) + uint32_t _size1324; + ::apache::thrift::protocol::TType _etype1327; + xfer += iprot->readListBegin(_etype1327, _size1324); + (*(this->success)).resize(_size1324); + uint32_t _i1328; + for (_i1328 = 0; _i1328 < _size1324; ++_i1328) { - xfer += iprot->readString((*(this->success))[_i1326]); + xfer += iprot->readString((*(this->success))[_i1328]); } xfer += iprot->readListEnd(); } @@ -30980,14 +31187,14 @@ uint32_t ThriftHiveMetastore_get_all_token_identifiers_result::read(::apache::th 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) + uint32_t _size1329; + ::apache::thrift::protocol::TType _etype1332; + xfer += iprot->readListBegin(_etype1332, _size1329); + this->success.resize(_size1329); + uint32_t _i1333; + for (_i1333 = 0; _i1333 < _size1329; ++_i1333) { - xfer += iprot->readString(this->success[_i1331]); + xfer += iprot->readString(this->success[_i1333]); } xfer += iprot->readListEnd(); } @@ -31018,10 +31225,10 @@ uint32_t ThriftHiveMetastore_get_all_token_identifiers_result::write(::apache::t xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1332; - for (_iter1332 = this->success.begin(); _iter1332 != this->success.end(); ++_iter1332) + std::vector ::const_iterator _iter1334; + for (_iter1334 = this->success.begin(); _iter1334 != this->success.end(); ++_iter1334) { - xfer += oprot->writeString((*_iter1332)); + xfer += oprot->writeString((*_iter1334)); } xfer += oprot->writeListEnd(); } @@ -31062,14 +31269,14 @@ uint32_t ThriftHiveMetastore_get_all_token_identifiers_presult::read(::apache::t 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) + uint32_t _size1335; + ::apache::thrift::protocol::TType _etype1338; + xfer += iprot->readListBegin(_etype1338, _size1335); + (*(this->success)).resize(_size1335); + uint32_t _i1339; + for (_i1339 = 0; _i1339 < _size1335; ++_i1339) { - xfer += iprot->readString((*(this->success))[_i1337]); + xfer += iprot->readString((*(this->success))[_i1339]); } xfer += iprot->readListEnd(); } @@ -31795,14 +32002,14 @@ uint32_t ThriftHiveMetastore_get_master_keys_result::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1338; - ::apache::thrift::protocol::TType _etype1341; - xfer += iprot->readListBegin(_etype1341, _size1338); - this->success.resize(_size1338); - uint32_t _i1342; - for (_i1342 = 0; _i1342 < _size1338; ++_i1342) + uint32_t _size1340; + ::apache::thrift::protocol::TType _etype1343; + xfer += iprot->readListBegin(_etype1343, _size1340); + this->success.resize(_size1340); + uint32_t _i1344; + for (_i1344 = 0; _i1344 < _size1340; ++_i1344) { - xfer += iprot->readString(this->success[_i1342]); + xfer += iprot->readString(this->success[_i1344]); } xfer += iprot->readListEnd(); } @@ -31833,10 +32040,10 @@ uint32_t ThriftHiveMetastore_get_master_keys_result::write(::apache::thrift::pro xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1343; - for (_iter1343 = this->success.begin(); _iter1343 != this->success.end(); ++_iter1343) + std::vector ::const_iterator _iter1345; + for (_iter1345 = this->success.begin(); _iter1345 != this->success.end(); ++_iter1345) { - xfer += oprot->writeString((*_iter1343)); + xfer += oprot->writeString((*_iter1345)); } xfer += oprot->writeListEnd(); } @@ -31877,14 +32084,14 @@ uint32_t ThriftHiveMetastore_get_master_keys_presult::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1344; - ::apache::thrift::protocol::TType _etype1347; - xfer += iprot->readListBegin(_etype1347, _size1344); - (*(this->success)).resize(_size1344); - uint32_t _i1348; - for (_i1348 = 0; _i1348 < _size1344; ++_i1348) + uint32_t _size1346; + ::apache::thrift::protocol::TType _etype1349; + xfer += iprot->readListBegin(_etype1349, _size1346); + (*(this->success)).resize(_size1346); + uint32_t _i1350; + for (_i1350 = 0; _i1350 < _size1346; ++_i1350) { - xfer += iprot->readString((*(this->success))[_i1348]); + xfer += iprot->readString((*(this->success))[_i1350]); } xfer += iprot->readListEnd(); } @@ -37664,6 +37871,65 @@ void ThriftHiveMetastoreClient::recv_create_table_with_constraints() return; } +void ThriftHiveMetastoreClient::drop_constraint(const DropConstraintRequest& req) +{ + send_drop_constraint(req); + recv_drop_constraint(); +} + +void ThriftHiveMetastoreClient::send_drop_constraint(const DropConstraintRequest& req) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("drop_constraint", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_constraint_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_drop_constraint() +{ + + 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_constraint") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_drop_constraint_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o3) { + throw result.o3; + } + return; +} + void ThriftHiveMetastoreClient::drop_table(const std::string& dbname, const std::string& name, const bool deleteData) { send_drop_table(dbname, name, deleteData); @@ -46883,6 +47149,65 @@ void ThriftHiveMetastoreProcessor::process_create_table_with_constraints(int32_t } } +void ThriftHiveMetastoreProcessor::process_drop_constraint(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_constraint", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.drop_constraint"); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.drop_constraint"); + } + + ThriftHiveMetastore_drop_constraint_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.drop_constraint", bytes); + } + + ThriftHiveMetastore_drop_constraint_result result; + try { + iface_->drop_constraint(args.req); + } catch (NoSuchObjectException &o1) { + result.o1 = o1; + result.__isset.o1 = 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_constraint"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("drop_constraint", ::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_constraint"); + } + + oprot->writeMessageBegin("drop_constraint", ::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_constraint", bytes); + } +} + void ThriftHiveMetastoreProcessor::process_drop_table(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) { void* ctx = NULL; @@ -56131,6 +56456,92 @@ void ThriftHiveMetastoreConcurrentClient::recv_create_table_with_constraints(con } // end while(true) } +void ThriftHiveMetastoreConcurrentClient::drop_constraint(const DropConstraintRequest& req) +{ + int32_t seqid = send_drop_constraint(req); + recv_drop_constraint(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_drop_constraint(const DropConstraintRequest& req) +{ + int32_t cseqid = this->sync_.generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); + oprot_->writeMessageBegin("drop_constraint", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_constraint_pargs args; + args.req = &req; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_drop_constraint(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_constraint") != 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_drop_constraint_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_.updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_.waitForWork(seqid); + } // end while(true) +} + void ThriftHiveMetastoreConcurrentClient::drop_table(const std::string& dbname, const std::string& name, const bool deleteData) { int32_t seqid = send_drop_table(dbname, name, deleteData); diff --git a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h index 11d3322..990be15 100644 --- a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h +++ b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h @@ -41,6 +41,7 @@ class ThriftHiveMetastoreIf : virtual public ::facebook::fb303::FacebookService virtual void create_table(const Table& tbl) = 0; virtual void create_table_with_environment_context(const Table& tbl, const EnvironmentContext& environment_context) = 0; virtual void create_table_with_constraints(const Table& tbl, const std::vector & primaryKeys, const std::vector & foreignKeys) = 0; + virtual void drop_constraint(const DropConstraintRequest& req) = 0; virtual void drop_table(const std::string& dbname, const std::string& name, const bool deleteData) = 0; virtual void drop_table_with_environment_context(const std::string& dbname, const std::string& name, const bool deleteData, const EnvironmentContext& environment_context) = 0; virtual void get_tables(std::vector & _return, const std::string& db_name, const std::string& pattern) = 0; @@ -256,6 +257,9 @@ class ThriftHiveMetastoreNull : virtual public ThriftHiveMetastoreIf , virtual p void create_table_with_constraints(const Table& /* tbl */, const std::vector & /* primaryKeys */, const std::vector & /* foreignKeys */) { return; } + void drop_constraint(const DropConstraintRequest& /* req */) { + return; + } void drop_table(const std::string& /* dbname */, const std::string& /* name */, const bool /* deleteData */) { return; } @@ -3032,6 +3036,118 @@ class ThriftHiveMetastore_create_table_with_constraints_presult { }; +typedef struct _ThriftHiveMetastore_drop_constraint_args__isset { + _ThriftHiveMetastore_drop_constraint_args__isset() : req(false) {} + bool req :1; +} _ThriftHiveMetastore_drop_constraint_args__isset; + +class ThriftHiveMetastore_drop_constraint_args { + public: + + ThriftHiveMetastore_drop_constraint_args(const ThriftHiveMetastore_drop_constraint_args&); + ThriftHiveMetastore_drop_constraint_args& operator=(const ThriftHiveMetastore_drop_constraint_args&); + ThriftHiveMetastore_drop_constraint_args() { + } + + virtual ~ThriftHiveMetastore_drop_constraint_args() throw(); + DropConstraintRequest req; + + _ThriftHiveMetastore_drop_constraint_args__isset __isset; + + void __set_req(const DropConstraintRequest& val); + + bool operator == (const ThriftHiveMetastore_drop_constraint_args & rhs) const + { + if (!(req == rhs.req)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_drop_constraint_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_constraint_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_drop_constraint_pargs { + public: + + + virtual ~ThriftHiveMetastore_drop_constraint_pargs() throw(); + const DropConstraintRequest* req; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_constraint_result__isset { + _ThriftHiveMetastore_drop_constraint_result__isset() : o1(false), o3(false) {} + bool o1 :1; + bool o3 :1; +} _ThriftHiveMetastore_drop_constraint_result__isset; + +class ThriftHiveMetastore_drop_constraint_result { + public: + + ThriftHiveMetastore_drop_constraint_result(const ThriftHiveMetastore_drop_constraint_result&); + ThriftHiveMetastore_drop_constraint_result& operator=(const ThriftHiveMetastore_drop_constraint_result&); + ThriftHiveMetastore_drop_constraint_result() { + } + + virtual ~ThriftHiveMetastore_drop_constraint_result() throw(); + NoSuchObjectException o1; + MetaException o3; + + _ThriftHiveMetastore_drop_constraint_result__isset __isset; + + void __set_o1(const NoSuchObjectException& val); + + void __set_o3(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_drop_constraint_result & rhs) const + { + if (!(o1 == rhs.o1)) + return false; + if (!(o3 == rhs.o3)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_drop_constraint_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_constraint_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_constraint_presult__isset { + _ThriftHiveMetastore_drop_constraint_presult__isset() : o1(false), o3(false) {} + bool o1 :1; + bool o3 :1; +} _ThriftHiveMetastore_drop_constraint_presult__isset; + +class ThriftHiveMetastore_drop_constraint_presult { + public: + + + virtual ~ThriftHiveMetastore_drop_constraint_presult() throw(); + NoSuchObjectException o1; + MetaException o3; + + _ThriftHiveMetastore_drop_constraint_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + typedef struct _ThriftHiveMetastore_drop_table_args__isset { _ThriftHiveMetastore_drop_table_args__isset() : dbname(false), name(false), deleteData(false) {} bool dbname :1; @@ -18851,6 +18967,9 @@ class ThriftHiveMetastoreClient : virtual public ThriftHiveMetastoreIf, public void create_table_with_constraints(const Table& tbl, const std::vector & primaryKeys, const std::vector & foreignKeys); void send_create_table_with_constraints(const Table& tbl, const std::vector & primaryKeys, const std::vector & foreignKeys); void recv_create_table_with_constraints(); + void drop_constraint(const DropConstraintRequest& req); + void send_drop_constraint(const DropConstraintRequest& req); + void recv_drop_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(); @@ -19261,6 +19380,7 @@ class ThriftHiveMetastoreProcessor : public ::facebook::fb303::FacebookServiceP void process_create_table(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_create_table_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_create_table_with_constraints(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_drop_constraint(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_drop_table(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_drop_table_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_get_tables(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); @@ -19411,6 +19531,7 @@ class ThriftHiveMetastoreProcessor : public ::facebook::fb303::FacebookServiceP processMap_["create_table"] = &ThriftHiveMetastoreProcessor::process_create_table; processMap_["create_table_with_environment_context"] = &ThriftHiveMetastoreProcessor::process_create_table_with_environment_context; processMap_["create_table_with_constraints"] = &ThriftHiveMetastoreProcessor::process_create_table_with_constraints; + processMap_["drop_constraint"] = &ThriftHiveMetastoreProcessor::process_drop_constraint; processMap_["drop_table"] = &ThriftHiveMetastoreProcessor::process_drop_table; processMap_["drop_table_with_environment_context"] = &ThriftHiveMetastoreProcessor::process_drop_table_with_environment_context; processMap_["get_tables"] = &ThriftHiveMetastoreProcessor::process_get_tables; @@ -19752,6 +19873,15 @@ class ThriftHiveMetastoreMultiface : virtual public ThriftHiveMetastoreIf, publi ifaces_[i]->create_table_with_constraints(tbl, primaryKeys, foreignKeys); } + void drop_constraint(const DropConstraintRequest& req) { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->drop_constraint(req); + } + ifaces_[i]->drop_constraint(req); + } + void drop_table(const std::string& dbname, const std::string& name, const bool deleteData) { size_t sz = ifaces_.size(); size_t i = 0; @@ -21045,6 +21175,9 @@ class ThriftHiveMetastoreConcurrentClient : virtual public ThriftHiveMetastoreIf void create_table_with_constraints(const Table& tbl, const std::vector & primaryKeys, const std::vector & foreignKeys); int32_t send_create_table_with_constraints(const Table& tbl, const std::vector & primaryKeys, const std::vector & foreignKeys); void recv_create_table_with_constraints(const int32_t seqid); + void drop_constraint(const DropConstraintRequest& req); + int32_t send_drop_constraint(const DropConstraintRequest& req); + void recv_drop_constraint(const int32_t seqid); void drop_table(const std::string& dbname, const std::string& name, const bool deleteData); int32_t send_drop_table(const std::string& dbname, const std::string& name, const bool deleteData); void recv_drop_table(const int32_t seqid); diff --git a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp index fa87e34..2d13e77 100644 --- a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp +++ b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp @@ -117,6 +117,11 @@ class ThriftHiveMetastoreHandler : virtual public ThriftHiveMetastoreIf { printf("create_table_with_constraints\n"); } + void drop_constraint(const DropConstraintRequest& req) { + // Your implementation goes here + printf("drop_constraint\n"); + } + void drop_table(const std::string& dbname, const std::string& name, const bool deleteData) { // Your implementation goes here printf("drop_table\n"); diff --git a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp index 8da883d..36a0f96 100644 --- a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp +++ b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp @@ -8999,6 +8999,138 @@ void ForeignKeysResponse::printTo(std::ostream& out) const { } +DropConstraintRequest::~DropConstraintRequest() throw() { +} + + +void DropConstraintRequest::__set_dbname(const std::string& val) { + this->dbname = val; +} + +void DropConstraintRequest::__set_tablename(const std::string& val) { + this->tablename = val; +} + +void DropConstraintRequest::__set_constraintname(const std::string& val) { + this->constraintname = val; +} + +uint32_t DropConstraintRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_dbname = false; + bool isset_tablename = false; + bool isset_constraintname = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbname); + isset_dbname = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tablename); + isset_tablename = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->constraintname); + isset_constraintname = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_dbname) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tablename) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_constraintname) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t DropConstraintRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("DropConstraintRequest"); + + xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbname); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tablename", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tablename); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("constraintname", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->constraintname); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(DropConstraintRequest &a, DropConstraintRequest &b) { + using ::std::swap; + swap(a.dbname, b.dbname); + swap(a.tablename, b.tablename); + swap(a.constraintname, b.constraintname); +} + +DropConstraintRequest::DropConstraintRequest(const DropConstraintRequest& other377) { + dbname = other377.dbname; + tablename = other377.tablename; + constraintname = other377.constraintname; +} +DropConstraintRequest& DropConstraintRequest::operator=(const DropConstraintRequest& other378) { + dbname = other378.dbname; + tablename = other378.tablename; + constraintname = other378.constraintname; + return *this; +} +void DropConstraintRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "DropConstraintRequest("; + out << "dbname=" << to_string(dbname); + out << ", " << "tablename=" << to_string(tablename); + out << ", " << "constraintname=" << to_string(constraintname); + out << ")"; +} + + PartitionsByExprResult::~PartitionsByExprResult() throw() { } @@ -9038,14 +9170,14 @@ uint32_t PartitionsByExprResult::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size377; - ::apache::thrift::protocol::TType _etype380; - xfer += iprot->readListBegin(_etype380, _size377); - this->partitions.resize(_size377); - uint32_t _i381; - for (_i381 = 0; _i381 < _size377; ++_i381) + uint32_t _size379; + ::apache::thrift::protocol::TType _etype382; + xfer += iprot->readListBegin(_etype382, _size379); + this->partitions.resize(_size379); + uint32_t _i383; + for (_i383 = 0; _i383 < _size379; ++_i383) { - xfer += this->partitions[_i381].read(iprot); + xfer += this->partitions[_i383].read(iprot); } xfer += iprot->readListEnd(); } @@ -9086,10 +9218,10 @@ uint32_t PartitionsByExprResult::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitions.size())); - std::vector ::const_iterator _iter382; - for (_iter382 = this->partitions.begin(); _iter382 != this->partitions.end(); ++_iter382) + std::vector ::const_iterator _iter384; + for (_iter384 = this->partitions.begin(); _iter384 != this->partitions.end(); ++_iter384) { - xfer += (*_iter382).write(oprot); + xfer += (*_iter384).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9110,13 +9242,13 @@ void swap(PartitionsByExprResult &a, PartitionsByExprResult &b) { swap(a.hasUnknownPartitions, b.hasUnknownPartitions); } -PartitionsByExprResult::PartitionsByExprResult(const PartitionsByExprResult& other383) { - partitions = other383.partitions; - hasUnknownPartitions = other383.hasUnknownPartitions; +PartitionsByExprResult::PartitionsByExprResult(const PartitionsByExprResult& other385) { + partitions = other385.partitions; + hasUnknownPartitions = other385.hasUnknownPartitions; } -PartitionsByExprResult& PartitionsByExprResult::operator=(const PartitionsByExprResult& other384) { - partitions = other384.partitions; - hasUnknownPartitions = other384.hasUnknownPartitions; +PartitionsByExprResult& PartitionsByExprResult::operator=(const PartitionsByExprResult& other386) { + partitions = other386.partitions; + hasUnknownPartitions = other386.hasUnknownPartitions; return *this; } void PartitionsByExprResult::printTo(std::ostream& out) const { @@ -9278,21 +9410,21 @@ void swap(PartitionsByExprRequest &a, PartitionsByExprRequest &b) { swap(a.__isset, b.__isset); } -PartitionsByExprRequest::PartitionsByExprRequest(const PartitionsByExprRequest& other385) { - dbName = other385.dbName; - tblName = other385.tblName; - expr = other385.expr; - defaultPartitionName = other385.defaultPartitionName; - maxParts = other385.maxParts; - __isset = other385.__isset; -} -PartitionsByExprRequest& PartitionsByExprRequest::operator=(const PartitionsByExprRequest& other386) { - dbName = other386.dbName; - tblName = other386.tblName; - expr = other386.expr; - defaultPartitionName = other386.defaultPartitionName; - maxParts = other386.maxParts; - __isset = other386.__isset; +PartitionsByExprRequest::PartitionsByExprRequest(const PartitionsByExprRequest& other387) { + dbName = other387.dbName; + tblName = other387.tblName; + expr = other387.expr; + defaultPartitionName = other387.defaultPartitionName; + maxParts = other387.maxParts; + __isset = other387.__isset; +} +PartitionsByExprRequest& PartitionsByExprRequest::operator=(const PartitionsByExprRequest& other388) { + dbName = other388.dbName; + tblName = other388.tblName; + expr = other388.expr; + defaultPartitionName = other388.defaultPartitionName; + maxParts = other388.maxParts; + __isset = other388.__isset; return *this; } void PartitionsByExprRequest::printTo(std::ostream& out) const { @@ -9341,14 +9473,14 @@ uint32_t TableStatsResult::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tableStats.clear(); - uint32_t _size387; - ::apache::thrift::protocol::TType _etype390; - xfer += iprot->readListBegin(_etype390, _size387); - this->tableStats.resize(_size387); - uint32_t _i391; - for (_i391 = 0; _i391 < _size387; ++_i391) + uint32_t _size389; + ::apache::thrift::protocol::TType _etype392; + xfer += iprot->readListBegin(_etype392, _size389); + this->tableStats.resize(_size389); + uint32_t _i393; + for (_i393 = 0; _i393 < _size389; ++_i393) { - xfer += this->tableStats[_i391].read(iprot); + xfer += this->tableStats[_i393].read(iprot); } xfer += iprot->readListEnd(); } @@ -9379,10 +9511,10 @@ uint32_t TableStatsResult::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("tableStats", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->tableStats.size())); - std::vector ::const_iterator _iter392; - for (_iter392 = this->tableStats.begin(); _iter392 != this->tableStats.end(); ++_iter392) + std::vector ::const_iterator _iter394; + for (_iter394 = this->tableStats.begin(); _iter394 != this->tableStats.end(); ++_iter394) { - xfer += (*_iter392).write(oprot); + xfer += (*_iter394).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9398,11 +9530,11 @@ void swap(TableStatsResult &a, TableStatsResult &b) { swap(a.tableStats, b.tableStats); } -TableStatsResult::TableStatsResult(const TableStatsResult& other393) { - tableStats = other393.tableStats; +TableStatsResult::TableStatsResult(const TableStatsResult& other395) { + tableStats = other395.tableStats; } -TableStatsResult& TableStatsResult::operator=(const TableStatsResult& other394) { - tableStats = other394.tableStats; +TableStatsResult& TableStatsResult::operator=(const TableStatsResult& other396) { + tableStats = other396.tableStats; return *this; } void TableStatsResult::printTo(std::ostream& out) const { @@ -9447,26 +9579,26 @@ uint32_t PartitionsStatsResult::read(::apache::thrift::protocol::TProtocol* ipro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partStats.clear(); - uint32_t _size395; - ::apache::thrift::protocol::TType _ktype396; - ::apache::thrift::protocol::TType _vtype397; - xfer += iprot->readMapBegin(_ktype396, _vtype397, _size395); - uint32_t _i399; - for (_i399 = 0; _i399 < _size395; ++_i399) + uint32_t _size397; + ::apache::thrift::protocol::TType _ktype398; + ::apache::thrift::protocol::TType _vtype399; + xfer += iprot->readMapBegin(_ktype398, _vtype399, _size397); + uint32_t _i401; + for (_i401 = 0; _i401 < _size397; ++_i401) { - std::string _key400; - xfer += iprot->readString(_key400); - std::vector & _val401 = this->partStats[_key400]; + std::string _key402; + xfer += iprot->readString(_key402); + std::vector & _val403 = this->partStats[_key402]; { - _val401.clear(); - uint32_t _size402; - ::apache::thrift::protocol::TType _etype405; - xfer += iprot->readListBegin(_etype405, _size402); - _val401.resize(_size402); - uint32_t _i406; - for (_i406 = 0; _i406 < _size402; ++_i406) + _val403.clear(); + uint32_t _size404; + ::apache::thrift::protocol::TType _etype407; + xfer += iprot->readListBegin(_etype407, _size404); + _val403.resize(_size404); + uint32_t _i408; + for (_i408 = 0; _i408 < _size404; ++_i408) { - xfer += _val401[_i406].read(iprot); + xfer += _val403[_i408].read(iprot); } xfer += iprot->readListEnd(); } @@ -9500,16 +9632,16 @@ uint32_t PartitionsStatsResult::write(::apache::thrift::protocol::TProtocol* opr xfer += oprot->writeFieldBegin("partStats", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_LIST, static_cast(this->partStats.size())); - std::map > ::const_iterator _iter407; - for (_iter407 = this->partStats.begin(); _iter407 != this->partStats.end(); ++_iter407) + std::map > ::const_iterator _iter409; + for (_iter409 = this->partStats.begin(); _iter409 != this->partStats.end(); ++_iter409) { - xfer += oprot->writeString(_iter407->first); + xfer += oprot->writeString(_iter409->first); { - xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(_iter407->second.size())); - std::vector ::const_iterator _iter408; - for (_iter408 = _iter407->second.begin(); _iter408 != _iter407->second.end(); ++_iter408) + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(_iter409->second.size())); + std::vector ::const_iterator _iter410; + for (_iter410 = _iter409->second.begin(); _iter410 != _iter409->second.end(); ++_iter410) { - xfer += (*_iter408).write(oprot); + xfer += (*_iter410).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9528,11 +9660,11 @@ void swap(PartitionsStatsResult &a, PartitionsStatsResult &b) { swap(a.partStats, b.partStats); } -PartitionsStatsResult::PartitionsStatsResult(const PartitionsStatsResult& other409) { - partStats = other409.partStats; +PartitionsStatsResult::PartitionsStatsResult(const PartitionsStatsResult& other411) { + partStats = other411.partStats; } -PartitionsStatsResult& PartitionsStatsResult::operator=(const PartitionsStatsResult& other410) { - partStats = other410.partStats; +PartitionsStatsResult& PartitionsStatsResult::operator=(const PartitionsStatsResult& other412) { + partStats = other412.partStats; return *this; } void PartitionsStatsResult::printTo(std::ostream& out) const { @@ -9603,14 +9735,14 @@ uint32_t TableStatsRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->colNames.clear(); - uint32_t _size411; - ::apache::thrift::protocol::TType _etype414; - xfer += iprot->readListBegin(_etype414, _size411); - this->colNames.resize(_size411); - uint32_t _i415; - for (_i415 = 0; _i415 < _size411; ++_i415) + uint32_t _size413; + ::apache::thrift::protocol::TType _etype416; + xfer += iprot->readListBegin(_etype416, _size413); + this->colNames.resize(_size413); + uint32_t _i417; + for (_i417 = 0; _i417 < _size413; ++_i417) { - xfer += iprot->readString(this->colNames[_i415]); + xfer += iprot->readString(this->colNames[_i417]); } xfer += iprot->readListEnd(); } @@ -9653,10 +9785,10 @@ uint32_t TableStatsRequest::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("colNames", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->colNames.size())); - std::vector ::const_iterator _iter416; - for (_iter416 = this->colNames.begin(); _iter416 != this->colNames.end(); ++_iter416) + std::vector ::const_iterator _iter418; + for (_iter418 = this->colNames.begin(); _iter418 != this->colNames.end(); ++_iter418) { - xfer += oprot->writeString((*_iter416)); + xfer += oprot->writeString((*_iter418)); } xfer += oprot->writeListEnd(); } @@ -9674,15 +9806,15 @@ void swap(TableStatsRequest &a, TableStatsRequest &b) { swap(a.colNames, b.colNames); } -TableStatsRequest::TableStatsRequest(const TableStatsRequest& other417) { - dbName = other417.dbName; - tblName = other417.tblName; - colNames = other417.colNames; +TableStatsRequest::TableStatsRequest(const TableStatsRequest& other419) { + dbName = other419.dbName; + tblName = other419.tblName; + colNames = other419.colNames; } -TableStatsRequest& TableStatsRequest::operator=(const TableStatsRequest& other418) { - dbName = other418.dbName; - tblName = other418.tblName; - colNames = other418.colNames; +TableStatsRequest& TableStatsRequest::operator=(const TableStatsRequest& other420) { + dbName = other420.dbName; + tblName = other420.tblName; + colNames = other420.colNames; return *this; } void TableStatsRequest::printTo(std::ostream& out) const { @@ -9760,14 +9892,14 @@ uint32_t PartitionsStatsRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->colNames.clear(); - uint32_t _size419; - ::apache::thrift::protocol::TType _etype422; - xfer += iprot->readListBegin(_etype422, _size419); - this->colNames.resize(_size419); - uint32_t _i423; - for (_i423 = 0; _i423 < _size419; ++_i423) + uint32_t _size421; + ::apache::thrift::protocol::TType _etype424; + xfer += iprot->readListBegin(_etype424, _size421); + this->colNames.resize(_size421); + uint32_t _i425; + for (_i425 = 0; _i425 < _size421; ++_i425) { - xfer += iprot->readString(this->colNames[_i423]); + xfer += iprot->readString(this->colNames[_i425]); } xfer += iprot->readListEnd(); } @@ -9780,14 +9912,14 @@ uint32_t PartitionsStatsRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partNames.clear(); - uint32_t _size424; - ::apache::thrift::protocol::TType _etype427; - xfer += iprot->readListBegin(_etype427, _size424); - this->partNames.resize(_size424); - uint32_t _i428; - for (_i428 = 0; _i428 < _size424; ++_i428) + uint32_t _size426; + ::apache::thrift::protocol::TType _etype429; + xfer += iprot->readListBegin(_etype429, _size426); + this->partNames.resize(_size426); + uint32_t _i430; + for (_i430 = 0; _i430 < _size426; ++_i430) { - xfer += iprot->readString(this->partNames[_i428]); + xfer += iprot->readString(this->partNames[_i430]); } xfer += iprot->readListEnd(); } @@ -9832,10 +9964,10 @@ uint32_t PartitionsStatsRequest::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("colNames", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->colNames.size())); - std::vector ::const_iterator _iter429; - for (_iter429 = this->colNames.begin(); _iter429 != this->colNames.end(); ++_iter429) + std::vector ::const_iterator _iter431; + for (_iter431 = this->colNames.begin(); _iter431 != this->colNames.end(); ++_iter431) { - xfer += oprot->writeString((*_iter429)); + xfer += oprot->writeString((*_iter431)); } xfer += oprot->writeListEnd(); } @@ -9844,10 +9976,10 @@ uint32_t PartitionsStatsRequest::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("partNames", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partNames.size())); - std::vector ::const_iterator _iter430; - for (_iter430 = this->partNames.begin(); _iter430 != this->partNames.end(); ++_iter430) + std::vector ::const_iterator _iter432; + for (_iter432 = this->partNames.begin(); _iter432 != this->partNames.end(); ++_iter432) { - xfer += oprot->writeString((*_iter430)); + xfer += oprot->writeString((*_iter432)); } xfer += oprot->writeListEnd(); } @@ -9866,17 +9998,17 @@ void swap(PartitionsStatsRequest &a, PartitionsStatsRequest &b) { swap(a.partNames, b.partNames); } -PartitionsStatsRequest::PartitionsStatsRequest(const PartitionsStatsRequest& other431) { - dbName = other431.dbName; - tblName = other431.tblName; - colNames = other431.colNames; - partNames = other431.partNames; +PartitionsStatsRequest::PartitionsStatsRequest(const PartitionsStatsRequest& other433) { + dbName = other433.dbName; + tblName = other433.tblName; + colNames = other433.colNames; + partNames = other433.partNames; } -PartitionsStatsRequest& PartitionsStatsRequest::operator=(const PartitionsStatsRequest& other432) { - dbName = other432.dbName; - tblName = other432.tblName; - colNames = other432.colNames; - partNames = other432.partNames; +PartitionsStatsRequest& PartitionsStatsRequest::operator=(const PartitionsStatsRequest& other434) { + dbName = other434.dbName; + tblName = other434.tblName; + colNames = other434.colNames; + partNames = other434.partNames; return *this; } void PartitionsStatsRequest::printTo(std::ostream& out) const { @@ -9924,14 +10056,14 @@ uint32_t AddPartitionsResult::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size433; - ::apache::thrift::protocol::TType _etype436; - xfer += iprot->readListBegin(_etype436, _size433); - this->partitions.resize(_size433); - uint32_t _i437; - for (_i437 = 0; _i437 < _size433; ++_i437) + uint32_t _size435; + ::apache::thrift::protocol::TType _etype438; + xfer += iprot->readListBegin(_etype438, _size435); + this->partitions.resize(_size435); + uint32_t _i439; + for (_i439 = 0; _i439 < _size435; ++_i439) { - xfer += this->partitions[_i437].read(iprot); + xfer += this->partitions[_i439].read(iprot); } xfer += iprot->readListEnd(); } @@ -9961,10 +10093,10 @@ uint32_t AddPartitionsResult::write(::apache::thrift::protocol::TProtocol* oprot xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitions.size())); - std::vector ::const_iterator _iter438; - for (_iter438 = this->partitions.begin(); _iter438 != this->partitions.end(); ++_iter438) + std::vector ::const_iterator _iter440; + for (_iter440 = this->partitions.begin(); _iter440 != this->partitions.end(); ++_iter440) { - xfer += (*_iter438).write(oprot); + xfer += (*_iter440).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9981,13 +10113,13 @@ void swap(AddPartitionsResult &a, AddPartitionsResult &b) { swap(a.__isset, b.__isset); } -AddPartitionsResult::AddPartitionsResult(const AddPartitionsResult& other439) { - partitions = other439.partitions; - __isset = other439.__isset; +AddPartitionsResult::AddPartitionsResult(const AddPartitionsResult& other441) { + partitions = other441.partitions; + __isset = other441.__isset; } -AddPartitionsResult& AddPartitionsResult::operator=(const AddPartitionsResult& other440) { - partitions = other440.partitions; - __isset = other440.__isset; +AddPartitionsResult& AddPartitionsResult::operator=(const AddPartitionsResult& other442) { + partitions = other442.partitions; + __isset = other442.__isset; return *this; } void AddPartitionsResult::printTo(std::ostream& out) const { @@ -10068,14 +10200,14 @@ uint32_t AddPartitionsRequest::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->parts.clear(); - uint32_t _size441; - ::apache::thrift::protocol::TType _etype444; - xfer += iprot->readListBegin(_etype444, _size441); - this->parts.resize(_size441); - uint32_t _i445; - for (_i445 = 0; _i445 < _size441; ++_i445) + uint32_t _size443; + ::apache::thrift::protocol::TType _etype446; + xfer += iprot->readListBegin(_etype446, _size443); + this->parts.resize(_size443); + uint32_t _i447; + for (_i447 = 0; _i447 < _size443; ++_i447) { - xfer += this->parts[_i445].read(iprot); + xfer += this->parts[_i447].read(iprot); } xfer += iprot->readListEnd(); } @@ -10136,10 +10268,10 @@ uint32_t AddPartitionsRequest::write(::apache::thrift::protocol::TProtocol* opro xfer += oprot->writeFieldBegin("parts", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->parts.size())); - std::vector ::const_iterator _iter446; - for (_iter446 = this->parts.begin(); _iter446 != this->parts.end(); ++_iter446) + std::vector ::const_iterator _iter448; + for (_iter448 = this->parts.begin(); _iter448 != this->parts.end(); ++_iter448) { - xfer += (*_iter446).write(oprot); + xfer += (*_iter448).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10169,21 +10301,21 @@ void swap(AddPartitionsRequest &a, AddPartitionsRequest &b) { swap(a.__isset, b.__isset); } -AddPartitionsRequest::AddPartitionsRequest(const AddPartitionsRequest& other447) { - dbName = other447.dbName; - tblName = other447.tblName; - parts = other447.parts; - ifNotExists = other447.ifNotExists; - needResult = other447.needResult; - __isset = other447.__isset; -} -AddPartitionsRequest& AddPartitionsRequest::operator=(const AddPartitionsRequest& other448) { - dbName = other448.dbName; - tblName = other448.tblName; - parts = other448.parts; - ifNotExists = other448.ifNotExists; - needResult = other448.needResult; - __isset = other448.__isset; +AddPartitionsRequest::AddPartitionsRequest(const AddPartitionsRequest& other449) { + dbName = other449.dbName; + tblName = other449.tblName; + parts = other449.parts; + ifNotExists = other449.ifNotExists; + needResult = other449.needResult; + __isset = other449.__isset; +} +AddPartitionsRequest& AddPartitionsRequest::operator=(const AddPartitionsRequest& other450) { + dbName = other450.dbName; + tblName = other450.tblName; + parts = other450.parts; + ifNotExists = other450.ifNotExists; + needResult = other450.needResult; + __isset = other450.__isset; return *this; } void AddPartitionsRequest::printTo(std::ostream& out) const { @@ -10232,14 +10364,14 @@ uint32_t DropPartitionsResult::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size449; - ::apache::thrift::protocol::TType _etype452; - xfer += iprot->readListBegin(_etype452, _size449); - this->partitions.resize(_size449); - uint32_t _i453; - for (_i453 = 0; _i453 < _size449; ++_i453) + uint32_t _size451; + ::apache::thrift::protocol::TType _etype454; + xfer += iprot->readListBegin(_etype454, _size451); + this->partitions.resize(_size451); + uint32_t _i455; + for (_i455 = 0; _i455 < _size451; ++_i455) { - xfer += this->partitions[_i453].read(iprot); + xfer += this->partitions[_i455].read(iprot); } xfer += iprot->readListEnd(); } @@ -10269,10 +10401,10 @@ uint32_t DropPartitionsResult::write(::apache::thrift::protocol::TProtocol* opro xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitions.size())); - std::vector ::const_iterator _iter454; - for (_iter454 = this->partitions.begin(); _iter454 != this->partitions.end(); ++_iter454) + std::vector ::const_iterator _iter456; + for (_iter456 = this->partitions.begin(); _iter456 != this->partitions.end(); ++_iter456) { - xfer += (*_iter454).write(oprot); + xfer += (*_iter456).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10289,13 +10421,13 @@ void swap(DropPartitionsResult &a, DropPartitionsResult &b) { swap(a.__isset, b.__isset); } -DropPartitionsResult::DropPartitionsResult(const DropPartitionsResult& other455) { - partitions = other455.partitions; - __isset = other455.__isset; +DropPartitionsResult::DropPartitionsResult(const DropPartitionsResult& other457) { + partitions = other457.partitions; + __isset = other457.__isset; } -DropPartitionsResult& DropPartitionsResult::operator=(const DropPartitionsResult& other456) { - partitions = other456.partitions; - __isset = other456.__isset; +DropPartitionsResult& DropPartitionsResult::operator=(const DropPartitionsResult& other458) { + partitions = other458.partitions; + __isset = other458.__isset; return *this; } void DropPartitionsResult::printTo(std::ostream& out) const { @@ -10397,15 +10529,15 @@ void swap(DropPartitionsExpr &a, DropPartitionsExpr &b) { swap(a.__isset, b.__isset); } -DropPartitionsExpr::DropPartitionsExpr(const DropPartitionsExpr& other457) { - expr = other457.expr; - partArchiveLevel = other457.partArchiveLevel; - __isset = other457.__isset; +DropPartitionsExpr::DropPartitionsExpr(const DropPartitionsExpr& other459) { + expr = other459.expr; + partArchiveLevel = other459.partArchiveLevel; + __isset = other459.__isset; } -DropPartitionsExpr& DropPartitionsExpr::operator=(const DropPartitionsExpr& other458) { - expr = other458.expr; - partArchiveLevel = other458.partArchiveLevel; - __isset = other458.__isset; +DropPartitionsExpr& DropPartitionsExpr::operator=(const DropPartitionsExpr& other460) { + expr = other460.expr; + partArchiveLevel = other460.partArchiveLevel; + __isset = other460.__isset; return *this; } void DropPartitionsExpr::printTo(std::ostream& out) const { @@ -10454,14 +10586,14 @@ uint32_t RequestPartsSpec::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->names.clear(); - uint32_t _size459; - ::apache::thrift::protocol::TType _etype462; - xfer += iprot->readListBegin(_etype462, _size459); - this->names.resize(_size459); - uint32_t _i463; - for (_i463 = 0; _i463 < _size459; ++_i463) + uint32_t _size461; + ::apache::thrift::protocol::TType _etype464; + xfer += iprot->readListBegin(_etype464, _size461); + this->names.resize(_size461); + uint32_t _i465; + for (_i465 = 0; _i465 < _size461; ++_i465) { - xfer += iprot->readString(this->names[_i463]); + xfer += iprot->readString(this->names[_i465]); } xfer += iprot->readListEnd(); } @@ -10474,14 +10606,14 @@ uint32_t RequestPartsSpec::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->exprs.clear(); - uint32_t _size464; - ::apache::thrift::protocol::TType _etype467; - xfer += iprot->readListBegin(_etype467, _size464); - this->exprs.resize(_size464); - uint32_t _i468; - for (_i468 = 0; _i468 < _size464; ++_i468) + uint32_t _size466; + ::apache::thrift::protocol::TType _etype469; + xfer += iprot->readListBegin(_etype469, _size466); + this->exprs.resize(_size466); + uint32_t _i470; + for (_i470 = 0; _i470 < _size466; ++_i470) { - xfer += this->exprs[_i468].read(iprot); + xfer += this->exprs[_i470].read(iprot); } xfer += iprot->readListEnd(); } @@ -10510,10 +10642,10 @@ uint32_t RequestPartsSpec::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("names", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->names.size())); - std::vector ::const_iterator _iter469; - for (_iter469 = this->names.begin(); _iter469 != this->names.end(); ++_iter469) + std::vector ::const_iterator _iter471; + for (_iter471 = this->names.begin(); _iter471 != this->names.end(); ++_iter471) { - xfer += oprot->writeString((*_iter469)); + xfer += oprot->writeString((*_iter471)); } xfer += oprot->writeListEnd(); } @@ -10522,10 +10654,10 @@ uint32_t RequestPartsSpec::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("exprs", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->exprs.size())); - std::vector ::const_iterator _iter470; - for (_iter470 = this->exprs.begin(); _iter470 != this->exprs.end(); ++_iter470) + std::vector ::const_iterator _iter472; + for (_iter472 = this->exprs.begin(); _iter472 != this->exprs.end(); ++_iter472) { - xfer += (*_iter470).write(oprot); + xfer += (*_iter472).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10543,15 +10675,15 @@ void swap(RequestPartsSpec &a, RequestPartsSpec &b) { swap(a.__isset, b.__isset); } -RequestPartsSpec::RequestPartsSpec(const RequestPartsSpec& other471) { - names = other471.names; - exprs = other471.exprs; - __isset = other471.__isset; +RequestPartsSpec::RequestPartsSpec(const RequestPartsSpec& other473) { + names = other473.names; + exprs = other473.exprs; + __isset = other473.__isset; } -RequestPartsSpec& RequestPartsSpec::operator=(const RequestPartsSpec& other472) { - names = other472.names; - exprs = other472.exprs; - __isset = other472.__isset; +RequestPartsSpec& RequestPartsSpec::operator=(const RequestPartsSpec& other474) { + names = other474.names; + exprs = other474.exprs; + __isset = other474.__isset; return *this; } void RequestPartsSpec::printTo(std::ostream& out) const { @@ -10770,27 +10902,27 @@ void swap(DropPartitionsRequest &a, DropPartitionsRequest &b) { swap(a.__isset, b.__isset); } -DropPartitionsRequest::DropPartitionsRequest(const DropPartitionsRequest& other473) { - dbName = other473.dbName; - tblName = other473.tblName; - parts = other473.parts; - deleteData = other473.deleteData; - ifExists = other473.ifExists; - ignoreProtection = other473.ignoreProtection; - environmentContext = other473.environmentContext; - needResult = other473.needResult; - __isset = other473.__isset; -} -DropPartitionsRequest& DropPartitionsRequest::operator=(const DropPartitionsRequest& other474) { - dbName = other474.dbName; - tblName = other474.tblName; - parts = other474.parts; - deleteData = other474.deleteData; - ifExists = other474.ifExists; - ignoreProtection = other474.ignoreProtection; - environmentContext = other474.environmentContext; - needResult = other474.needResult; - __isset = other474.__isset; +DropPartitionsRequest::DropPartitionsRequest(const DropPartitionsRequest& other475) { + dbName = other475.dbName; + tblName = other475.tblName; + parts = other475.parts; + deleteData = other475.deleteData; + ifExists = other475.ifExists; + ignoreProtection = other475.ignoreProtection; + environmentContext = other475.environmentContext; + needResult = other475.needResult; + __isset = other475.__isset; +} +DropPartitionsRequest& DropPartitionsRequest::operator=(const DropPartitionsRequest& other476) { + dbName = other476.dbName; + tblName = other476.tblName; + parts = other476.parts; + deleteData = other476.deleteData; + ifExists = other476.ifExists; + ignoreProtection = other476.ignoreProtection; + environmentContext = other476.environmentContext; + needResult = other476.needResult; + __isset = other476.__isset; return *this; } void DropPartitionsRequest::printTo(std::ostream& out) const { @@ -10843,9 +10975,9 @@ uint32_t ResourceUri::read(::apache::thrift::protocol::TProtocol* iprot) { { case 1: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast475; - xfer += iprot->readI32(ecast475); - this->resourceType = (ResourceType::type)ecast475; + int32_t ecast477; + xfer += iprot->readI32(ecast477); + this->resourceType = (ResourceType::type)ecast477; this->__isset.resourceType = true; } else { xfer += iprot->skip(ftype); @@ -10896,15 +11028,15 @@ void swap(ResourceUri &a, ResourceUri &b) { swap(a.__isset, b.__isset); } -ResourceUri::ResourceUri(const ResourceUri& other476) { - resourceType = other476.resourceType; - uri = other476.uri; - __isset = other476.__isset; +ResourceUri::ResourceUri(const ResourceUri& other478) { + resourceType = other478.resourceType; + uri = other478.uri; + __isset = other478.__isset; } -ResourceUri& ResourceUri::operator=(const ResourceUri& other477) { - resourceType = other477.resourceType; - uri = other477.uri; - __isset = other477.__isset; +ResourceUri& ResourceUri::operator=(const ResourceUri& other479) { + resourceType = other479.resourceType; + uri = other479.uri; + __isset = other479.__isset; return *this; } void ResourceUri::printTo(std::ostream& out) const { @@ -11007,9 +11139,9 @@ uint32_t Function::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast478; - xfer += iprot->readI32(ecast478); - this->ownerType = (PrincipalType::type)ecast478; + int32_t ecast480; + xfer += iprot->readI32(ecast480); + this->ownerType = (PrincipalType::type)ecast480; this->__isset.ownerType = true; } else { xfer += iprot->skip(ftype); @@ -11025,9 +11157,9 @@ uint32_t Function::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 7: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast479; - xfer += iprot->readI32(ecast479); - this->functionType = (FunctionType::type)ecast479; + int32_t ecast481; + xfer += iprot->readI32(ecast481); + this->functionType = (FunctionType::type)ecast481; this->__isset.functionType = true; } else { xfer += iprot->skip(ftype); @@ -11037,14 +11169,14 @@ uint32_t Function::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->resourceUris.clear(); - uint32_t _size480; - ::apache::thrift::protocol::TType _etype483; - xfer += iprot->readListBegin(_etype483, _size480); - this->resourceUris.resize(_size480); - uint32_t _i484; - for (_i484 = 0; _i484 < _size480; ++_i484) + uint32_t _size482; + ::apache::thrift::protocol::TType _etype485; + xfer += iprot->readListBegin(_etype485, _size482); + this->resourceUris.resize(_size482); + uint32_t _i486; + for (_i486 = 0; _i486 < _size482; ++_i486) { - xfer += this->resourceUris[_i484].read(iprot); + xfer += this->resourceUris[_i486].read(iprot); } xfer += iprot->readListEnd(); } @@ -11101,10 +11233,10 @@ uint32_t Function::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("resourceUris", ::apache::thrift::protocol::T_LIST, 8); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->resourceUris.size())); - std::vector ::const_iterator _iter485; - for (_iter485 = this->resourceUris.begin(); _iter485 != this->resourceUris.end(); ++_iter485) + std::vector ::const_iterator _iter487; + for (_iter487 = this->resourceUris.begin(); _iter487 != this->resourceUris.end(); ++_iter487) { - xfer += (*_iter485).write(oprot); + xfer += (*_iter487).write(oprot); } xfer += oprot->writeListEnd(); } @@ -11128,27 +11260,27 @@ void swap(Function &a, Function &b) { swap(a.__isset, b.__isset); } -Function::Function(const Function& other486) { - functionName = other486.functionName; - dbName = other486.dbName; - className = other486.className; - ownerName = other486.ownerName; - ownerType = other486.ownerType; - createTime = other486.createTime; - functionType = other486.functionType; - resourceUris = other486.resourceUris; - __isset = other486.__isset; -} -Function& Function::operator=(const Function& other487) { - functionName = other487.functionName; - dbName = other487.dbName; - className = other487.className; - ownerName = other487.ownerName; - ownerType = other487.ownerType; - createTime = other487.createTime; - functionType = other487.functionType; - resourceUris = other487.resourceUris; - __isset = other487.__isset; +Function::Function(const Function& other488) { + functionName = other488.functionName; + dbName = other488.dbName; + className = other488.className; + ownerName = other488.ownerName; + ownerType = other488.ownerType; + createTime = other488.createTime; + functionType = other488.functionType; + resourceUris = other488.resourceUris; + __isset = other488.__isset; +} +Function& Function::operator=(const Function& other489) { + functionName = other489.functionName; + dbName = other489.dbName; + className = other489.className; + ownerName = other489.ownerName; + ownerType = other489.ownerType; + createTime = other489.createTime; + functionType = other489.functionType; + resourceUris = other489.resourceUris; + __isset = other489.__isset; return *this; } void Function::printTo(std::ostream& out) const { @@ -11236,9 +11368,9 @@ uint32_t TxnInfo::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast488; - xfer += iprot->readI32(ecast488); - this->state = (TxnState::type)ecast488; + int32_t ecast490; + xfer += iprot->readI32(ecast490); + this->state = (TxnState::type)ecast490; isset_state = true; } else { xfer += iprot->skip(ftype); @@ -11357,25 +11489,25 @@ void swap(TxnInfo &a, TxnInfo &b) { swap(a.__isset, b.__isset); } -TxnInfo::TxnInfo(const TxnInfo& other489) { - id = other489.id; - state = other489.state; - user = other489.user; - hostname = other489.hostname; - agentInfo = other489.agentInfo; - heartbeatCount = other489.heartbeatCount; - metaInfo = other489.metaInfo; - __isset = other489.__isset; -} -TxnInfo& TxnInfo::operator=(const TxnInfo& other490) { - id = other490.id; - state = other490.state; - user = other490.user; - hostname = other490.hostname; - agentInfo = other490.agentInfo; - heartbeatCount = other490.heartbeatCount; - metaInfo = other490.metaInfo; - __isset = other490.__isset; +TxnInfo::TxnInfo(const TxnInfo& other491) { + id = other491.id; + state = other491.state; + user = other491.user; + hostname = other491.hostname; + agentInfo = other491.agentInfo; + heartbeatCount = other491.heartbeatCount; + metaInfo = other491.metaInfo; + __isset = other491.__isset; +} +TxnInfo& TxnInfo::operator=(const TxnInfo& other492) { + id = other492.id; + state = other492.state; + user = other492.user; + hostname = other492.hostname; + agentInfo = other492.agentInfo; + heartbeatCount = other492.heartbeatCount; + metaInfo = other492.metaInfo; + __isset = other492.__isset; return *this; } void TxnInfo::printTo(std::ostream& out) const { @@ -11439,14 +11571,14 @@ uint32_t GetOpenTxnsInfoResponse::read(::apache::thrift::protocol::TProtocol* ip if (ftype == ::apache::thrift::protocol::T_LIST) { { this->open_txns.clear(); - uint32_t _size491; - ::apache::thrift::protocol::TType _etype494; - xfer += iprot->readListBegin(_etype494, _size491); - this->open_txns.resize(_size491); - uint32_t _i495; - for (_i495 = 0; _i495 < _size491; ++_i495) + uint32_t _size493; + ::apache::thrift::protocol::TType _etype496; + xfer += iprot->readListBegin(_etype496, _size493); + this->open_txns.resize(_size493); + uint32_t _i497; + for (_i497 = 0; _i497 < _size493; ++_i497) { - xfer += this->open_txns[_i495].read(iprot); + xfer += this->open_txns[_i497].read(iprot); } xfer += iprot->readListEnd(); } @@ -11483,10 +11615,10 @@ uint32_t GetOpenTxnsInfoResponse::write(::apache::thrift::protocol::TProtocol* o xfer += oprot->writeFieldBegin("open_txns", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->open_txns.size())); - std::vector ::const_iterator _iter496; - for (_iter496 = this->open_txns.begin(); _iter496 != this->open_txns.end(); ++_iter496) + std::vector ::const_iterator _iter498; + for (_iter498 = this->open_txns.begin(); _iter498 != this->open_txns.end(); ++_iter498) { - xfer += (*_iter496).write(oprot); + xfer += (*_iter498).write(oprot); } xfer += oprot->writeListEnd(); } @@ -11503,13 +11635,13 @@ void swap(GetOpenTxnsInfoResponse &a, GetOpenTxnsInfoResponse &b) { swap(a.open_txns, b.open_txns); } -GetOpenTxnsInfoResponse::GetOpenTxnsInfoResponse(const GetOpenTxnsInfoResponse& other497) { - txn_high_water_mark = other497.txn_high_water_mark; - open_txns = other497.open_txns; +GetOpenTxnsInfoResponse::GetOpenTxnsInfoResponse(const GetOpenTxnsInfoResponse& other499) { + txn_high_water_mark = other499.txn_high_water_mark; + open_txns = other499.open_txns; } -GetOpenTxnsInfoResponse& GetOpenTxnsInfoResponse::operator=(const GetOpenTxnsInfoResponse& other498) { - txn_high_water_mark = other498.txn_high_water_mark; - open_txns = other498.open_txns; +GetOpenTxnsInfoResponse& GetOpenTxnsInfoResponse::operator=(const GetOpenTxnsInfoResponse& other500) { + txn_high_water_mark = other500.txn_high_water_mark; + open_txns = other500.open_txns; return *this; } void GetOpenTxnsInfoResponse::printTo(std::ostream& out) const { @@ -11568,15 +11700,15 @@ uint32_t GetOpenTxnsResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_SET) { { this->open_txns.clear(); - uint32_t _size499; - ::apache::thrift::protocol::TType _etype502; - xfer += iprot->readSetBegin(_etype502, _size499); - uint32_t _i503; - for (_i503 = 0; _i503 < _size499; ++_i503) + uint32_t _size501; + ::apache::thrift::protocol::TType _etype504; + xfer += iprot->readSetBegin(_etype504, _size501); + uint32_t _i505; + for (_i505 = 0; _i505 < _size501; ++_i505) { - int64_t _elem504; - xfer += iprot->readI64(_elem504); - this->open_txns.insert(_elem504); + int64_t _elem506; + xfer += iprot->readI64(_elem506); + this->open_txns.insert(_elem506); } xfer += iprot->readSetEnd(); } @@ -11613,10 +11745,10 @@ uint32_t GetOpenTxnsResponse::write(::apache::thrift::protocol::TProtocol* oprot xfer += oprot->writeFieldBegin("open_txns", ::apache::thrift::protocol::T_SET, 2); { xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_I64, static_cast(this->open_txns.size())); - std::set ::const_iterator _iter505; - for (_iter505 = this->open_txns.begin(); _iter505 != this->open_txns.end(); ++_iter505) + std::set ::const_iterator _iter507; + for (_iter507 = this->open_txns.begin(); _iter507 != this->open_txns.end(); ++_iter507) { - xfer += oprot->writeI64((*_iter505)); + xfer += oprot->writeI64((*_iter507)); } xfer += oprot->writeSetEnd(); } @@ -11633,13 +11765,13 @@ void swap(GetOpenTxnsResponse &a, GetOpenTxnsResponse &b) { swap(a.open_txns, b.open_txns); } -GetOpenTxnsResponse::GetOpenTxnsResponse(const GetOpenTxnsResponse& other506) { - txn_high_water_mark = other506.txn_high_water_mark; - open_txns = other506.open_txns; +GetOpenTxnsResponse::GetOpenTxnsResponse(const GetOpenTxnsResponse& other508) { + txn_high_water_mark = other508.txn_high_water_mark; + open_txns = other508.open_txns; } -GetOpenTxnsResponse& GetOpenTxnsResponse::operator=(const GetOpenTxnsResponse& other507) { - txn_high_water_mark = other507.txn_high_water_mark; - open_txns = other507.open_txns; +GetOpenTxnsResponse& GetOpenTxnsResponse::operator=(const GetOpenTxnsResponse& other509) { + txn_high_water_mark = other509.txn_high_water_mark; + open_txns = other509.open_txns; return *this; } void GetOpenTxnsResponse::printTo(std::ostream& out) const { @@ -11782,19 +11914,19 @@ void swap(OpenTxnRequest &a, OpenTxnRequest &b) { swap(a.__isset, b.__isset); } -OpenTxnRequest::OpenTxnRequest(const OpenTxnRequest& other508) { - num_txns = other508.num_txns; - user = other508.user; - hostname = other508.hostname; - agentInfo = other508.agentInfo; - __isset = other508.__isset; +OpenTxnRequest::OpenTxnRequest(const OpenTxnRequest& other510) { + num_txns = other510.num_txns; + user = other510.user; + hostname = other510.hostname; + agentInfo = other510.agentInfo; + __isset = other510.__isset; } -OpenTxnRequest& OpenTxnRequest::operator=(const OpenTxnRequest& other509) { - num_txns = other509.num_txns; - user = other509.user; - hostname = other509.hostname; - agentInfo = other509.agentInfo; - __isset = other509.__isset; +OpenTxnRequest& OpenTxnRequest::operator=(const OpenTxnRequest& other511) { + num_txns = other511.num_txns; + user = other511.user; + hostname = other511.hostname; + agentInfo = other511.agentInfo; + __isset = other511.__isset; return *this; } void OpenTxnRequest::printTo(std::ostream& out) const { @@ -11842,14 +11974,14 @@ uint32_t OpenTxnsResponse::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->txn_ids.clear(); - uint32_t _size510; - ::apache::thrift::protocol::TType _etype513; - xfer += iprot->readListBegin(_etype513, _size510); - this->txn_ids.resize(_size510); - uint32_t _i514; - for (_i514 = 0; _i514 < _size510; ++_i514) + uint32_t _size512; + ::apache::thrift::protocol::TType _etype515; + xfer += iprot->readListBegin(_etype515, _size512); + this->txn_ids.resize(_size512); + uint32_t _i516; + for (_i516 = 0; _i516 < _size512; ++_i516) { - xfer += iprot->readI64(this->txn_ids[_i514]); + xfer += iprot->readI64(this->txn_ids[_i516]); } xfer += iprot->readListEnd(); } @@ -11880,10 +12012,10 @@ uint32_t OpenTxnsResponse::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("txn_ids", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->txn_ids.size())); - std::vector ::const_iterator _iter515; - for (_iter515 = this->txn_ids.begin(); _iter515 != this->txn_ids.end(); ++_iter515) + std::vector ::const_iterator _iter517; + for (_iter517 = this->txn_ids.begin(); _iter517 != this->txn_ids.end(); ++_iter517) { - xfer += oprot->writeI64((*_iter515)); + xfer += oprot->writeI64((*_iter517)); } xfer += oprot->writeListEnd(); } @@ -11899,11 +12031,11 @@ void swap(OpenTxnsResponse &a, OpenTxnsResponse &b) { swap(a.txn_ids, b.txn_ids); } -OpenTxnsResponse::OpenTxnsResponse(const OpenTxnsResponse& other516) { - txn_ids = other516.txn_ids; +OpenTxnsResponse::OpenTxnsResponse(const OpenTxnsResponse& other518) { + txn_ids = other518.txn_ids; } -OpenTxnsResponse& OpenTxnsResponse::operator=(const OpenTxnsResponse& other517) { - txn_ids = other517.txn_ids; +OpenTxnsResponse& OpenTxnsResponse::operator=(const OpenTxnsResponse& other519) { + txn_ids = other519.txn_ids; return *this; } void OpenTxnsResponse::printTo(std::ostream& out) const { @@ -11985,11 +12117,11 @@ void swap(AbortTxnRequest &a, AbortTxnRequest &b) { swap(a.txnid, b.txnid); } -AbortTxnRequest::AbortTxnRequest(const AbortTxnRequest& other518) { - txnid = other518.txnid; +AbortTxnRequest::AbortTxnRequest(const AbortTxnRequest& other520) { + txnid = other520.txnid; } -AbortTxnRequest& AbortTxnRequest::operator=(const AbortTxnRequest& other519) { - txnid = other519.txnid; +AbortTxnRequest& AbortTxnRequest::operator=(const AbortTxnRequest& other521) { + txnid = other521.txnid; return *this; } void AbortTxnRequest::printTo(std::ostream& out) const { @@ -12071,11 +12203,11 @@ void swap(CommitTxnRequest &a, CommitTxnRequest &b) { swap(a.txnid, b.txnid); } -CommitTxnRequest::CommitTxnRequest(const CommitTxnRequest& other520) { - txnid = other520.txnid; +CommitTxnRequest::CommitTxnRequest(const CommitTxnRequest& other522) { + txnid = other522.txnid; } -CommitTxnRequest& CommitTxnRequest::operator=(const CommitTxnRequest& other521) { - txnid = other521.txnid; +CommitTxnRequest& CommitTxnRequest::operator=(const CommitTxnRequest& other523) { + txnid = other523.txnid; return *this; } void CommitTxnRequest::printTo(std::ostream& out) const { @@ -12138,9 +12270,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) { { case 1: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast522; - xfer += iprot->readI32(ecast522); - this->type = (LockType::type)ecast522; + int32_t ecast524; + xfer += iprot->readI32(ecast524); + this->type = (LockType::type)ecast524; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -12148,9 +12280,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast523; - xfer += iprot->readI32(ecast523); - this->level = (LockLevel::type)ecast523; + int32_t ecast525; + xfer += iprot->readI32(ecast525); + this->level = (LockLevel::type)ecast525; isset_level = true; } else { xfer += iprot->skip(ftype); @@ -12240,21 +12372,21 @@ void swap(LockComponent &a, LockComponent &b) { swap(a.__isset, b.__isset); } -LockComponent::LockComponent(const LockComponent& other524) { - type = other524.type; - level = other524.level; - dbname = other524.dbname; - tablename = other524.tablename; - partitionname = other524.partitionname; - __isset = other524.__isset; -} -LockComponent& LockComponent::operator=(const LockComponent& other525) { - type = other525.type; - level = other525.level; - dbname = other525.dbname; - tablename = other525.tablename; - partitionname = other525.partitionname; - __isset = other525.__isset; +LockComponent::LockComponent(const LockComponent& other526) { + type = other526.type; + level = other526.level; + dbname = other526.dbname; + tablename = other526.tablename; + partitionname = other526.partitionname; + __isset = other526.__isset; +} +LockComponent& LockComponent::operator=(const LockComponent& other527) { + type = other527.type; + level = other527.level; + dbname = other527.dbname; + tablename = other527.tablename; + partitionname = other527.partitionname; + __isset = other527.__isset; return *this; } void LockComponent::printTo(std::ostream& out) const { @@ -12323,14 +12455,14 @@ uint32_t LockRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->component.clear(); - uint32_t _size526; - ::apache::thrift::protocol::TType _etype529; - xfer += iprot->readListBegin(_etype529, _size526); - this->component.resize(_size526); - uint32_t _i530; - for (_i530 = 0; _i530 < _size526; ++_i530) + uint32_t _size528; + ::apache::thrift::protocol::TType _etype531; + xfer += iprot->readListBegin(_etype531, _size528); + this->component.resize(_size528); + uint32_t _i532; + for (_i532 = 0; _i532 < _size528; ++_i532) { - xfer += this->component[_i530].read(iprot); + xfer += this->component[_i532].read(iprot); } xfer += iprot->readListEnd(); } @@ -12397,10 +12529,10 @@ uint32_t LockRequest::write(::apache::thrift::protocol::TProtocol* oprot) const xfer += oprot->writeFieldBegin("component", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->component.size())); - std::vector ::const_iterator _iter531; - for (_iter531 = this->component.begin(); _iter531 != this->component.end(); ++_iter531) + std::vector ::const_iterator _iter533; + for (_iter533 = this->component.begin(); _iter533 != this->component.end(); ++_iter533) { - xfer += (*_iter531).write(oprot); + xfer += (*_iter533).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12439,21 +12571,21 @@ void swap(LockRequest &a, LockRequest &b) { swap(a.__isset, b.__isset); } -LockRequest::LockRequest(const LockRequest& other532) { - component = other532.component; - txnid = other532.txnid; - user = other532.user; - hostname = other532.hostname; - agentInfo = other532.agentInfo; - __isset = other532.__isset; -} -LockRequest& LockRequest::operator=(const LockRequest& other533) { - component = other533.component; - txnid = other533.txnid; - user = other533.user; - hostname = other533.hostname; - agentInfo = other533.agentInfo; - __isset = other533.__isset; +LockRequest::LockRequest(const LockRequest& other534) { + component = other534.component; + txnid = other534.txnid; + user = other534.user; + hostname = other534.hostname; + agentInfo = other534.agentInfo; + __isset = other534.__isset; +} +LockRequest& LockRequest::operator=(const LockRequest& other535) { + component = other535.component; + txnid = other535.txnid; + user = other535.user; + hostname = other535.hostname; + agentInfo = other535.agentInfo; + __isset = other535.__isset; return *this; } void LockRequest::printTo(std::ostream& out) const { @@ -12513,9 +12645,9 @@ uint32_t LockResponse::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast534; - xfer += iprot->readI32(ecast534); - this->state = (LockState::type)ecast534; + int32_t ecast536; + xfer += iprot->readI32(ecast536); + this->state = (LockState::type)ecast536; isset_state = true; } else { xfer += iprot->skip(ftype); @@ -12561,13 +12693,13 @@ void swap(LockResponse &a, LockResponse &b) { swap(a.state, b.state); } -LockResponse::LockResponse(const LockResponse& other535) { - lockid = other535.lockid; - state = other535.state; +LockResponse::LockResponse(const LockResponse& other537) { + lockid = other537.lockid; + state = other537.state; } -LockResponse& LockResponse::operator=(const LockResponse& other536) { - lockid = other536.lockid; - state = other536.state; +LockResponse& LockResponse::operator=(const LockResponse& other538) { + lockid = other538.lockid; + state = other538.state; return *this; } void LockResponse::printTo(std::ostream& out) const { @@ -12689,17 +12821,17 @@ void swap(CheckLockRequest &a, CheckLockRequest &b) { swap(a.__isset, b.__isset); } -CheckLockRequest::CheckLockRequest(const CheckLockRequest& other537) { - lockid = other537.lockid; - txnid = other537.txnid; - elapsed_ms = other537.elapsed_ms; - __isset = other537.__isset; +CheckLockRequest::CheckLockRequest(const CheckLockRequest& other539) { + lockid = other539.lockid; + txnid = other539.txnid; + elapsed_ms = other539.elapsed_ms; + __isset = other539.__isset; } -CheckLockRequest& CheckLockRequest::operator=(const CheckLockRequest& other538) { - lockid = other538.lockid; - txnid = other538.txnid; - elapsed_ms = other538.elapsed_ms; - __isset = other538.__isset; +CheckLockRequest& CheckLockRequest::operator=(const CheckLockRequest& other540) { + lockid = other540.lockid; + txnid = other540.txnid; + elapsed_ms = other540.elapsed_ms; + __isset = other540.__isset; return *this; } void CheckLockRequest::printTo(std::ostream& out) const { @@ -12783,11 +12915,11 @@ void swap(UnlockRequest &a, UnlockRequest &b) { swap(a.lockid, b.lockid); } -UnlockRequest::UnlockRequest(const UnlockRequest& other539) { - lockid = other539.lockid; +UnlockRequest::UnlockRequest(const UnlockRequest& other541) { + lockid = other541.lockid; } -UnlockRequest& UnlockRequest::operator=(const UnlockRequest& other540) { - lockid = other540.lockid; +UnlockRequest& UnlockRequest::operator=(const UnlockRequest& other542) { + lockid = other542.lockid; return *this; } void UnlockRequest::printTo(std::ostream& out) const { @@ -12926,19 +13058,19 @@ void swap(ShowLocksRequest &a, ShowLocksRequest &b) { swap(a.__isset, b.__isset); } -ShowLocksRequest::ShowLocksRequest(const ShowLocksRequest& other541) { - dbname = other541.dbname; - tablename = other541.tablename; - partname = other541.partname; - isExtended = other541.isExtended; - __isset = other541.__isset; +ShowLocksRequest::ShowLocksRequest(const ShowLocksRequest& other543) { + dbname = other543.dbname; + tablename = other543.tablename; + partname = other543.partname; + isExtended = other543.isExtended; + __isset = other543.__isset; } -ShowLocksRequest& ShowLocksRequest::operator=(const ShowLocksRequest& other542) { - dbname = other542.dbname; - tablename = other542.tablename; - partname = other542.partname; - isExtended = other542.isExtended; - __isset = other542.__isset; +ShowLocksRequest& ShowLocksRequest::operator=(const ShowLocksRequest& other544) { + dbname = other544.dbname; + tablename = other544.tablename; + partname = other544.partname; + isExtended = other544.isExtended; + __isset = other544.__isset; return *this; } void ShowLocksRequest::printTo(std::ostream& out) const { @@ -13091,9 +13223,9 @@ uint32_t ShowLocksResponseElement::read(::apache::thrift::protocol::TProtocol* i break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast543; - xfer += iprot->readI32(ecast543); - this->state = (LockState::type)ecast543; + int32_t ecast545; + xfer += iprot->readI32(ecast545); + this->state = (LockState::type)ecast545; isset_state = true; } else { xfer += iprot->skip(ftype); @@ -13101,9 +13233,9 @@ uint32_t ShowLocksResponseElement::read(::apache::thrift::protocol::TProtocol* i break; case 6: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast544; - xfer += iprot->readI32(ecast544); - this->type = (LockType::type)ecast544; + int32_t ecast546; + xfer += iprot->readI32(ecast546); + this->type = (LockType::type)ecast546; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -13319,43 +13451,43 @@ void swap(ShowLocksResponseElement &a, ShowLocksResponseElement &b) { swap(a.__isset, b.__isset); } -ShowLocksResponseElement::ShowLocksResponseElement(const ShowLocksResponseElement& other545) { - lockid = other545.lockid; - dbname = other545.dbname; - tablename = other545.tablename; - partname = other545.partname; - state = other545.state; - type = other545.type; - txnid = other545.txnid; - lastheartbeat = other545.lastheartbeat; - acquiredat = other545.acquiredat; - user = other545.user; - hostname = other545.hostname; - heartbeatCount = other545.heartbeatCount; - agentInfo = other545.agentInfo; - blockedByExtId = other545.blockedByExtId; - blockedByIntId = other545.blockedByIntId; - lockIdInternal = other545.lockIdInternal; - __isset = other545.__isset; -} -ShowLocksResponseElement& ShowLocksResponseElement::operator=(const ShowLocksResponseElement& other546) { - lockid = other546.lockid; - dbname = other546.dbname; - tablename = other546.tablename; - partname = other546.partname; - state = other546.state; - type = other546.type; - txnid = other546.txnid; - lastheartbeat = other546.lastheartbeat; - acquiredat = other546.acquiredat; - user = other546.user; - hostname = other546.hostname; - heartbeatCount = other546.heartbeatCount; - agentInfo = other546.agentInfo; - blockedByExtId = other546.blockedByExtId; - blockedByIntId = other546.blockedByIntId; - lockIdInternal = other546.lockIdInternal; - __isset = other546.__isset; +ShowLocksResponseElement::ShowLocksResponseElement(const ShowLocksResponseElement& other547) { + lockid = other547.lockid; + dbname = other547.dbname; + tablename = other547.tablename; + partname = other547.partname; + state = other547.state; + type = other547.type; + txnid = other547.txnid; + lastheartbeat = other547.lastheartbeat; + acquiredat = other547.acquiredat; + user = other547.user; + hostname = other547.hostname; + heartbeatCount = other547.heartbeatCount; + agentInfo = other547.agentInfo; + blockedByExtId = other547.blockedByExtId; + blockedByIntId = other547.blockedByIntId; + lockIdInternal = other547.lockIdInternal; + __isset = other547.__isset; +} +ShowLocksResponseElement& ShowLocksResponseElement::operator=(const ShowLocksResponseElement& other548) { + lockid = other548.lockid; + dbname = other548.dbname; + tablename = other548.tablename; + partname = other548.partname; + state = other548.state; + type = other548.type; + txnid = other548.txnid; + lastheartbeat = other548.lastheartbeat; + acquiredat = other548.acquiredat; + user = other548.user; + hostname = other548.hostname; + heartbeatCount = other548.heartbeatCount; + agentInfo = other548.agentInfo; + blockedByExtId = other548.blockedByExtId; + blockedByIntId = other548.blockedByIntId; + lockIdInternal = other548.lockIdInternal; + __isset = other548.__isset; return *this; } void ShowLocksResponseElement::printTo(std::ostream& out) const { @@ -13414,14 +13546,14 @@ uint32_t ShowLocksResponse::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->locks.clear(); - uint32_t _size547; - ::apache::thrift::protocol::TType _etype550; - xfer += iprot->readListBegin(_etype550, _size547); - this->locks.resize(_size547); - uint32_t _i551; - for (_i551 = 0; _i551 < _size547; ++_i551) + uint32_t _size549; + ::apache::thrift::protocol::TType _etype552; + xfer += iprot->readListBegin(_etype552, _size549); + this->locks.resize(_size549); + uint32_t _i553; + for (_i553 = 0; _i553 < _size549; ++_i553) { - xfer += this->locks[_i551].read(iprot); + xfer += this->locks[_i553].read(iprot); } xfer += iprot->readListEnd(); } @@ -13450,10 +13582,10 @@ uint32_t ShowLocksResponse::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("locks", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->locks.size())); - std::vector ::const_iterator _iter552; - for (_iter552 = this->locks.begin(); _iter552 != this->locks.end(); ++_iter552) + std::vector ::const_iterator _iter554; + for (_iter554 = this->locks.begin(); _iter554 != this->locks.end(); ++_iter554) { - xfer += (*_iter552).write(oprot); + xfer += (*_iter554).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13470,13 +13602,13 @@ void swap(ShowLocksResponse &a, ShowLocksResponse &b) { swap(a.__isset, b.__isset); } -ShowLocksResponse::ShowLocksResponse(const ShowLocksResponse& other553) { - locks = other553.locks; - __isset = other553.__isset; +ShowLocksResponse::ShowLocksResponse(const ShowLocksResponse& other555) { + locks = other555.locks; + __isset = other555.__isset; } -ShowLocksResponse& ShowLocksResponse::operator=(const ShowLocksResponse& other554) { - locks = other554.locks; - __isset = other554.__isset; +ShowLocksResponse& ShowLocksResponse::operator=(const ShowLocksResponse& other556) { + locks = other556.locks; + __isset = other556.__isset; return *this; } void ShowLocksResponse::printTo(std::ostream& out) const { @@ -13577,15 +13709,15 @@ void swap(HeartbeatRequest &a, HeartbeatRequest &b) { swap(a.__isset, b.__isset); } -HeartbeatRequest::HeartbeatRequest(const HeartbeatRequest& other555) { - lockid = other555.lockid; - txnid = other555.txnid; - __isset = other555.__isset; +HeartbeatRequest::HeartbeatRequest(const HeartbeatRequest& other557) { + lockid = other557.lockid; + txnid = other557.txnid; + __isset = other557.__isset; } -HeartbeatRequest& HeartbeatRequest::operator=(const HeartbeatRequest& other556) { - lockid = other556.lockid; - txnid = other556.txnid; - __isset = other556.__isset; +HeartbeatRequest& HeartbeatRequest::operator=(const HeartbeatRequest& other558) { + lockid = other558.lockid; + txnid = other558.txnid; + __isset = other558.__isset; return *this; } void HeartbeatRequest::printTo(std::ostream& out) const { @@ -13688,13 +13820,13 @@ void swap(HeartbeatTxnRangeRequest &a, HeartbeatTxnRangeRequest &b) { swap(a.max, b.max); } -HeartbeatTxnRangeRequest::HeartbeatTxnRangeRequest(const HeartbeatTxnRangeRequest& other557) { - min = other557.min; - max = other557.max; +HeartbeatTxnRangeRequest::HeartbeatTxnRangeRequest(const HeartbeatTxnRangeRequest& other559) { + min = other559.min; + max = other559.max; } -HeartbeatTxnRangeRequest& HeartbeatTxnRangeRequest::operator=(const HeartbeatTxnRangeRequest& other558) { - min = other558.min; - max = other558.max; +HeartbeatTxnRangeRequest& HeartbeatTxnRangeRequest::operator=(const HeartbeatTxnRangeRequest& other560) { + min = other560.min; + max = other560.max; return *this; } void HeartbeatTxnRangeRequest::printTo(std::ostream& out) const { @@ -13745,15 +13877,15 @@ uint32_t HeartbeatTxnRangeResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_SET) { { this->aborted.clear(); - uint32_t _size559; - ::apache::thrift::protocol::TType _etype562; - xfer += iprot->readSetBegin(_etype562, _size559); - uint32_t _i563; - for (_i563 = 0; _i563 < _size559; ++_i563) + uint32_t _size561; + ::apache::thrift::protocol::TType _etype564; + xfer += iprot->readSetBegin(_etype564, _size561); + uint32_t _i565; + for (_i565 = 0; _i565 < _size561; ++_i565) { - int64_t _elem564; - xfer += iprot->readI64(_elem564); - this->aborted.insert(_elem564); + int64_t _elem566; + xfer += iprot->readI64(_elem566); + this->aborted.insert(_elem566); } xfer += iprot->readSetEnd(); } @@ -13766,15 +13898,15 @@ uint32_t HeartbeatTxnRangeResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_SET) { { this->nosuch.clear(); - uint32_t _size565; - ::apache::thrift::protocol::TType _etype568; - xfer += iprot->readSetBegin(_etype568, _size565); - uint32_t _i569; - for (_i569 = 0; _i569 < _size565; ++_i569) + uint32_t _size567; + ::apache::thrift::protocol::TType _etype570; + xfer += iprot->readSetBegin(_etype570, _size567); + uint32_t _i571; + for (_i571 = 0; _i571 < _size567; ++_i571) { - int64_t _elem570; - xfer += iprot->readI64(_elem570); - this->nosuch.insert(_elem570); + int64_t _elem572; + xfer += iprot->readI64(_elem572); + this->nosuch.insert(_elem572); } xfer += iprot->readSetEnd(); } @@ -13807,10 +13939,10 @@ uint32_t HeartbeatTxnRangeResponse::write(::apache::thrift::protocol::TProtocol* xfer += oprot->writeFieldBegin("aborted", ::apache::thrift::protocol::T_SET, 1); { xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_I64, static_cast(this->aborted.size())); - std::set ::const_iterator _iter571; - for (_iter571 = this->aborted.begin(); _iter571 != this->aborted.end(); ++_iter571) + std::set ::const_iterator _iter573; + for (_iter573 = this->aborted.begin(); _iter573 != this->aborted.end(); ++_iter573) { - xfer += oprot->writeI64((*_iter571)); + xfer += oprot->writeI64((*_iter573)); } xfer += oprot->writeSetEnd(); } @@ -13819,10 +13951,10 @@ uint32_t HeartbeatTxnRangeResponse::write(::apache::thrift::protocol::TProtocol* xfer += oprot->writeFieldBegin("nosuch", ::apache::thrift::protocol::T_SET, 2); { xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_I64, static_cast(this->nosuch.size())); - std::set ::const_iterator _iter572; - for (_iter572 = this->nosuch.begin(); _iter572 != this->nosuch.end(); ++_iter572) + std::set ::const_iterator _iter574; + for (_iter574 = this->nosuch.begin(); _iter574 != this->nosuch.end(); ++_iter574) { - xfer += oprot->writeI64((*_iter572)); + xfer += oprot->writeI64((*_iter574)); } xfer += oprot->writeSetEnd(); } @@ -13839,13 +13971,13 @@ void swap(HeartbeatTxnRangeResponse &a, HeartbeatTxnRangeResponse &b) { swap(a.nosuch, b.nosuch); } -HeartbeatTxnRangeResponse::HeartbeatTxnRangeResponse(const HeartbeatTxnRangeResponse& other573) { - aborted = other573.aborted; - nosuch = other573.nosuch; +HeartbeatTxnRangeResponse::HeartbeatTxnRangeResponse(const HeartbeatTxnRangeResponse& other575) { + aborted = other575.aborted; + nosuch = other575.nosuch; } -HeartbeatTxnRangeResponse& HeartbeatTxnRangeResponse::operator=(const HeartbeatTxnRangeResponse& other574) { - aborted = other574.aborted; - nosuch = other574.nosuch; +HeartbeatTxnRangeResponse& HeartbeatTxnRangeResponse::operator=(const HeartbeatTxnRangeResponse& other576) { + aborted = other576.aborted; + nosuch = other576.nosuch; return *this; } void HeartbeatTxnRangeResponse::printTo(std::ostream& out) const { @@ -13933,9 +14065,9 @@ uint32_t CompactionRequest::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast575; - xfer += iprot->readI32(ecast575); - this->type = (CompactionType::type)ecast575; + int32_t ecast577; + xfer += iprot->readI32(ecast577); + this->type = (CompactionType::type)ecast577; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -14009,21 +14141,21 @@ void swap(CompactionRequest &a, CompactionRequest &b) { swap(a.__isset, b.__isset); } -CompactionRequest::CompactionRequest(const CompactionRequest& other576) { - dbname = other576.dbname; - tablename = other576.tablename; - partitionname = other576.partitionname; - type = other576.type; - runas = other576.runas; - __isset = other576.__isset; -} -CompactionRequest& CompactionRequest::operator=(const CompactionRequest& other577) { - dbname = other577.dbname; - tablename = other577.tablename; - partitionname = other577.partitionname; - type = other577.type; - runas = other577.runas; - __isset = other577.__isset; +CompactionRequest::CompactionRequest(const CompactionRequest& other578) { + dbname = other578.dbname; + tablename = other578.tablename; + partitionname = other578.partitionname; + type = other578.type; + runas = other578.runas; + __isset = other578.__isset; +} +CompactionRequest& CompactionRequest::operator=(const CompactionRequest& other579) { + dbname = other579.dbname; + tablename = other579.tablename; + partitionname = other579.partitionname; + type = other579.type; + runas = other579.runas; + __isset = other579.__isset; return *this; } void CompactionRequest::printTo(std::ostream& out) const { @@ -14086,11 +14218,11 @@ void swap(ShowCompactRequest &a, ShowCompactRequest &b) { (void) b; } -ShowCompactRequest::ShowCompactRequest(const ShowCompactRequest& other578) { - (void) other578; +ShowCompactRequest::ShowCompactRequest(const ShowCompactRequest& other580) { + (void) other580; } -ShowCompactRequest& ShowCompactRequest::operator=(const ShowCompactRequest& other579) { - (void) other579; +ShowCompactRequest& ShowCompactRequest::operator=(const ShowCompactRequest& other581) { + (void) other581; return *this; } void ShowCompactRequest::printTo(std::ostream& out) const { @@ -14211,9 +14343,9 @@ uint32_t ShowCompactResponseElement::read(::apache::thrift::protocol::TProtocol* break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast580; - xfer += iprot->readI32(ecast580); - this->type = (CompactionType::type)ecast580; + int32_t ecast582; + xfer += iprot->readI32(ecast582); + this->type = (CompactionType::type)ecast582; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -14386,35 +14518,35 @@ void swap(ShowCompactResponseElement &a, ShowCompactResponseElement &b) { swap(a.__isset, b.__isset); } -ShowCompactResponseElement::ShowCompactResponseElement(const ShowCompactResponseElement& other581) { - dbname = other581.dbname; - tablename = other581.tablename; - partitionname = other581.partitionname; - type = other581.type; - state = other581.state; - workerid = other581.workerid; - start = other581.start; - runAs = other581.runAs; - hightestTxnId = other581.hightestTxnId; - metaInfo = other581.metaInfo; - endTime = other581.endTime; - hadoopJobId = other581.hadoopJobId; - __isset = other581.__isset; -} -ShowCompactResponseElement& ShowCompactResponseElement::operator=(const ShowCompactResponseElement& other582) { - dbname = other582.dbname; - tablename = other582.tablename; - partitionname = other582.partitionname; - type = other582.type; - state = other582.state; - workerid = other582.workerid; - start = other582.start; - runAs = other582.runAs; - hightestTxnId = other582.hightestTxnId; - metaInfo = other582.metaInfo; - endTime = other582.endTime; - hadoopJobId = other582.hadoopJobId; - __isset = other582.__isset; +ShowCompactResponseElement::ShowCompactResponseElement(const ShowCompactResponseElement& other583) { + dbname = other583.dbname; + tablename = other583.tablename; + partitionname = other583.partitionname; + type = other583.type; + state = other583.state; + workerid = other583.workerid; + start = other583.start; + runAs = other583.runAs; + hightestTxnId = other583.hightestTxnId; + metaInfo = other583.metaInfo; + endTime = other583.endTime; + hadoopJobId = other583.hadoopJobId; + __isset = other583.__isset; +} +ShowCompactResponseElement& ShowCompactResponseElement::operator=(const ShowCompactResponseElement& other584) { + dbname = other584.dbname; + tablename = other584.tablename; + partitionname = other584.partitionname; + type = other584.type; + state = other584.state; + workerid = other584.workerid; + start = other584.start; + runAs = other584.runAs; + hightestTxnId = other584.hightestTxnId; + metaInfo = other584.metaInfo; + endTime = other584.endTime; + hadoopJobId = other584.hadoopJobId; + __isset = other584.__isset; return *this; } void ShowCompactResponseElement::printTo(std::ostream& out) const { @@ -14470,14 +14602,14 @@ uint32_t ShowCompactResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->compacts.clear(); - uint32_t _size583; - ::apache::thrift::protocol::TType _etype586; - xfer += iprot->readListBegin(_etype586, _size583); - this->compacts.resize(_size583); - uint32_t _i587; - for (_i587 = 0; _i587 < _size583; ++_i587) + uint32_t _size585; + ::apache::thrift::protocol::TType _etype588; + xfer += iprot->readListBegin(_etype588, _size585); + this->compacts.resize(_size585); + uint32_t _i589; + for (_i589 = 0; _i589 < _size585; ++_i589) { - xfer += this->compacts[_i587].read(iprot); + xfer += this->compacts[_i589].read(iprot); } xfer += iprot->readListEnd(); } @@ -14508,10 +14640,10 @@ uint32_t ShowCompactResponse::write(::apache::thrift::protocol::TProtocol* oprot xfer += oprot->writeFieldBegin("compacts", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->compacts.size())); - std::vector ::const_iterator _iter588; - for (_iter588 = this->compacts.begin(); _iter588 != this->compacts.end(); ++_iter588) + std::vector ::const_iterator _iter590; + for (_iter590 = this->compacts.begin(); _iter590 != this->compacts.end(); ++_iter590) { - xfer += (*_iter588).write(oprot); + xfer += (*_iter590).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14527,11 +14659,11 @@ void swap(ShowCompactResponse &a, ShowCompactResponse &b) { swap(a.compacts, b.compacts); } -ShowCompactResponse::ShowCompactResponse(const ShowCompactResponse& other589) { - compacts = other589.compacts; +ShowCompactResponse::ShowCompactResponse(const ShowCompactResponse& other591) { + compacts = other591.compacts; } -ShowCompactResponse& ShowCompactResponse::operator=(const ShowCompactResponse& other590) { - compacts = other590.compacts; +ShowCompactResponse& ShowCompactResponse::operator=(const ShowCompactResponse& other592) { + compacts = other592.compacts; return *this; } void ShowCompactResponse::printTo(std::ostream& out) const { @@ -14615,14 +14747,14 @@ uint32_t AddDynamicPartitions::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionnames.clear(); - uint32_t _size591; - ::apache::thrift::protocol::TType _etype594; - xfer += iprot->readListBegin(_etype594, _size591); - this->partitionnames.resize(_size591); - uint32_t _i595; - for (_i595 = 0; _i595 < _size591; ++_i595) + uint32_t _size593; + ::apache::thrift::protocol::TType _etype596; + xfer += iprot->readListBegin(_etype596, _size593); + this->partitionnames.resize(_size593); + uint32_t _i597; + for (_i597 = 0; _i597 < _size593; ++_i597) { - xfer += iprot->readString(this->partitionnames[_i595]); + xfer += iprot->readString(this->partitionnames[_i597]); } xfer += iprot->readListEnd(); } @@ -14671,10 +14803,10 @@ uint32_t AddDynamicPartitions::write(::apache::thrift::protocol::TProtocol* opro xfer += oprot->writeFieldBegin("partitionnames", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partitionnames.size())); - std::vector ::const_iterator _iter596; - for (_iter596 = this->partitionnames.begin(); _iter596 != this->partitionnames.end(); ++_iter596) + std::vector ::const_iterator _iter598; + for (_iter598 = this->partitionnames.begin(); _iter598 != this->partitionnames.end(); ++_iter598) { - xfer += oprot->writeString((*_iter596)); + xfer += oprot->writeString((*_iter598)); } xfer += oprot->writeListEnd(); } @@ -14693,17 +14825,17 @@ void swap(AddDynamicPartitions &a, AddDynamicPartitions &b) { swap(a.partitionnames, b.partitionnames); } -AddDynamicPartitions::AddDynamicPartitions(const AddDynamicPartitions& other597) { - txnid = other597.txnid; - dbname = other597.dbname; - tablename = other597.tablename; - partitionnames = other597.partitionnames; +AddDynamicPartitions::AddDynamicPartitions(const AddDynamicPartitions& other599) { + txnid = other599.txnid; + dbname = other599.dbname; + tablename = other599.tablename; + partitionnames = other599.partitionnames; } -AddDynamicPartitions& AddDynamicPartitions::operator=(const AddDynamicPartitions& other598) { - txnid = other598.txnid; - dbname = other598.dbname; - tablename = other598.tablename; - partitionnames = other598.partitionnames; +AddDynamicPartitions& AddDynamicPartitions::operator=(const AddDynamicPartitions& other600) { + txnid = other600.txnid; + dbname = other600.dbname; + tablename = other600.tablename; + partitionnames = other600.partitionnames; return *this; } void AddDynamicPartitions::printTo(std::ostream& out) const { @@ -14808,15 +14940,15 @@ void swap(NotificationEventRequest &a, NotificationEventRequest &b) { swap(a.__isset, b.__isset); } -NotificationEventRequest::NotificationEventRequest(const NotificationEventRequest& other599) { - lastEvent = other599.lastEvent; - maxEvents = other599.maxEvents; - __isset = other599.__isset; +NotificationEventRequest::NotificationEventRequest(const NotificationEventRequest& other601) { + lastEvent = other601.lastEvent; + maxEvents = other601.maxEvents; + __isset = other601.__isset; } -NotificationEventRequest& NotificationEventRequest::operator=(const NotificationEventRequest& other600) { - lastEvent = other600.lastEvent; - maxEvents = other600.maxEvents; - __isset = other600.__isset; +NotificationEventRequest& NotificationEventRequest::operator=(const NotificationEventRequest& other602) { + lastEvent = other602.lastEvent; + maxEvents = other602.maxEvents; + __isset = other602.__isset; return *this; } void NotificationEventRequest::printTo(std::ostream& out) const { @@ -14998,23 +15130,23 @@ void swap(NotificationEvent &a, NotificationEvent &b) { swap(a.__isset, b.__isset); } -NotificationEvent::NotificationEvent(const NotificationEvent& other601) { - eventId = other601.eventId; - eventTime = other601.eventTime; - eventType = other601.eventType; - dbName = other601.dbName; - tableName = other601.tableName; - message = other601.message; - __isset = other601.__isset; -} -NotificationEvent& NotificationEvent::operator=(const NotificationEvent& other602) { - eventId = other602.eventId; - eventTime = other602.eventTime; - eventType = other602.eventType; - dbName = other602.dbName; - tableName = other602.tableName; - message = other602.message; - __isset = other602.__isset; +NotificationEvent::NotificationEvent(const NotificationEvent& other603) { + eventId = other603.eventId; + eventTime = other603.eventTime; + eventType = other603.eventType; + dbName = other603.dbName; + tableName = other603.tableName; + message = other603.message; + __isset = other603.__isset; +} +NotificationEvent& NotificationEvent::operator=(const NotificationEvent& other604) { + eventId = other604.eventId; + eventTime = other604.eventTime; + eventType = other604.eventType; + dbName = other604.dbName; + tableName = other604.tableName; + message = other604.message; + __isset = other604.__isset; return *this; } void NotificationEvent::printTo(std::ostream& out) const { @@ -15064,14 +15196,14 @@ uint32_t NotificationEventResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->events.clear(); - uint32_t _size603; - ::apache::thrift::protocol::TType _etype606; - xfer += iprot->readListBegin(_etype606, _size603); - this->events.resize(_size603); - uint32_t _i607; - for (_i607 = 0; _i607 < _size603; ++_i607) + uint32_t _size605; + ::apache::thrift::protocol::TType _etype608; + xfer += iprot->readListBegin(_etype608, _size605); + this->events.resize(_size605); + uint32_t _i609; + for (_i609 = 0; _i609 < _size605; ++_i609) { - xfer += this->events[_i607].read(iprot); + xfer += this->events[_i609].read(iprot); } xfer += iprot->readListEnd(); } @@ -15102,10 +15234,10 @@ uint32_t NotificationEventResponse::write(::apache::thrift::protocol::TProtocol* xfer += oprot->writeFieldBegin("events", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->events.size())); - std::vector ::const_iterator _iter608; - for (_iter608 = this->events.begin(); _iter608 != this->events.end(); ++_iter608) + std::vector ::const_iterator _iter610; + for (_iter610 = this->events.begin(); _iter610 != this->events.end(); ++_iter610) { - xfer += (*_iter608).write(oprot); + xfer += (*_iter610).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15121,11 +15253,11 @@ void swap(NotificationEventResponse &a, NotificationEventResponse &b) { swap(a.events, b.events); } -NotificationEventResponse::NotificationEventResponse(const NotificationEventResponse& other609) { - events = other609.events; +NotificationEventResponse::NotificationEventResponse(const NotificationEventResponse& other611) { + events = other611.events; } -NotificationEventResponse& NotificationEventResponse::operator=(const NotificationEventResponse& other610) { - events = other610.events; +NotificationEventResponse& NotificationEventResponse::operator=(const NotificationEventResponse& other612) { + events = other612.events; return *this; } void NotificationEventResponse::printTo(std::ostream& out) const { @@ -15207,11 +15339,11 @@ void swap(CurrentNotificationEventId &a, CurrentNotificationEventId &b) { swap(a.eventId, b.eventId); } -CurrentNotificationEventId::CurrentNotificationEventId(const CurrentNotificationEventId& other611) { - eventId = other611.eventId; +CurrentNotificationEventId::CurrentNotificationEventId(const CurrentNotificationEventId& other613) { + eventId = other613.eventId; } -CurrentNotificationEventId& CurrentNotificationEventId::operator=(const CurrentNotificationEventId& other612) { - eventId = other612.eventId; +CurrentNotificationEventId& CurrentNotificationEventId::operator=(const CurrentNotificationEventId& other614) { + eventId = other614.eventId; return *this; } void CurrentNotificationEventId::printTo(std::ostream& out) const { @@ -15256,14 +15388,14 @@ uint32_t InsertEventRequestData::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->filesAdded.clear(); - uint32_t _size613; - ::apache::thrift::protocol::TType _etype616; - xfer += iprot->readListBegin(_etype616, _size613); - this->filesAdded.resize(_size613); - uint32_t _i617; - for (_i617 = 0; _i617 < _size613; ++_i617) + uint32_t _size615; + ::apache::thrift::protocol::TType _etype618; + xfer += iprot->readListBegin(_etype618, _size615); + this->filesAdded.resize(_size615); + uint32_t _i619; + for (_i619 = 0; _i619 < _size615; ++_i619) { - xfer += iprot->readString(this->filesAdded[_i617]); + xfer += iprot->readString(this->filesAdded[_i619]); } xfer += iprot->readListEnd(); } @@ -15294,10 +15426,10 @@ uint32_t InsertEventRequestData::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("filesAdded", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->filesAdded.size())); - std::vector ::const_iterator _iter618; - for (_iter618 = this->filesAdded.begin(); _iter618 != this->filesAdded.end(); ++_iter618) + std::vector ::const_iterator _iter620; + for (_iter620 = this->filesAdded.begin(); _iter620 != this->filesAdded.end(); ++_iter620) { - xfer += oprot->writeString((*_iter618)); + xfer += oprot->writeString((*_iter620)); } xfer += oprot->writeListEnd(); } @@ -15313,11 +15445,11 @@ void swap(InsertEventRequestData &a, InsertEventRequestData &b) { swap(a.filesAdded, b.filesAdded); } -InsertEventRequestData::InsertEventRequestData(const InsertEventRequestData& other619) { - filesAdded = other619.filesAdded; +InsertEventRequestData::InsertEventRequestData(const InsertEventRequestData& other621) { + filesAdded = other621.filesAdded; } -InsertEventRequestData& InsertEventRequestData::operator=(const InsertEventRequestData& other620) { - filesAdded = other620.filesAdded; +InsertEventRequestData& InsertEventRequestData::operator=(const InsertEventRequestData& other622) { + filesAdded = other622.filesAdded; return *this; } void InsertEventRequestData::printTo(std::ostream& out) const { @@ -15397,13 +15529,13 @@ void swap(FireEventRequestData &a, FireEventRequestData &b) { swap(a.__isset, b.__isset); } -FireEventRequestData::FireEventRequestData(const FireEventRequestData& other621) { - insertData = other621.insertData; - __isset = other621.__isset; +FireEventRequestData::FireEventRequestData(const FireEventRequestData& other623) { + insertData = other623.insertData; + __isset = other623.__isset; } -FireEventRequestData& FireEventRequestData::operator=(const FireEventRequestData& other622) { - insertData = other622.insertData; - __isset = other622.__isset; +FireEventRequestData& FireEventRequestData::operator=(const FireEventRequestData& other624) { + insertData = other624.insertData; + __isset = other624.__isset; return *this; } void FireEventRequestData::printTo(std::ostream& out) const { @@ -15500,14 +15632,14 @@ uint32_t FireEventRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionVals.clear(); - uint32_t _size623; - ::apache::thrift::protocol::TType _etype626; - xfer += iprot->readListBegin(_etype626, _size623); - this->partitionVals.resize(_size623); - uint32_t _i627; - for (_i627 = 0; _i627 < _size623; ++_i627) + uint32_t _size625; + ::apache::thrift::protocol::TType _etype628; + xfer += iprot->readListBegin(_etype628, _size625); + this->partitionVals.resize(_size625); + uint32_t _i629; + for (_i629 = 0; _i629 < _size625; ++_i629) { - xfer += iprot->readString(this->partitionVals[_i627]); + xfer += iprot->readString(this->partitionVals[_i629]); } xfer += iprot->readListEnd(); } @@ -15559,10 +15691,10 @@ uint32_t FireEventRequest::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("partitionVals", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partitionVals.size())); - std::vector ::const_iterator _iter628; - for (_iter628 = this->partitionVals.begin(); _iter628 != this->partitionVals.end(); ++_iter628) + std::vector ::const_iterator _iter630; + for (_iter630 = this->partitionVals.begin(); _iter630 != this->partitionVals.end(); ++_iter630) { - xfer += oprot->writeString((*_iter628)); + xfer += oprot->writeString((*_iter630)); } xfer += oprot->writeListEnd(); } @@ -15583,21 +15715,21 @@ void swap(FireEventRequest &a, FireEventRequest &b) { swap(a.__isset, b.__isset); } -FireEventRequest::FireEventRequest(const FireEventRequest& other629) { - successful = other629.successful; - data = other629.data; - dbName = other629.dbName; - tableName = other629.tableName; - partitionVals = other629.partitionVals; - __isset = other629.__isset; -} -FireEventRequest& FireEventRequest::operator=(const FireEventRequest& other630) { - successful = other630.successful; - data = other630.data; - dbName = other630.dbName; - tableName = other630.tableName; - partitionVals = other630.partitionVals; - __isset = other630.__isset; +FireEventRequest::FireEventRequest(const FireEventRequest& other631) { + successful = other631.successful; + data = other631.data; + dbName = other631.dbName; + tableName = other631.tableName; + partitionVals = other631.partitionVals; + __isset = other631.__isset; +} +FireEventRequest& FireEventRequest::operator=(const FireEventRequest& other632) { + successful = other632.successful; + data = other632.data; + dbName = other632.dbName; + tableName = other632.tableName; + partitionVals = other632.partitionVals; + __isset = other632.__isset; return *this; } void FireEventRequest::printTo(std::ostream& out) const { @@ -15660,11 +15792,11 @@ void swap(FireEventResponse &a, FireEventResponse &b) { (void) b; } -FireEventResponse::FireEventResponse(const FireEventResponse& other631) { - (void) other631; +FireEventResponse::FireEventResponse(const FireEventResponse& other633) { + (void) other633; } -FireEventResponse& FireEventResponse::operator=(const FireEventResponse& other632) { - (void) other632; +FireEventResponse& FireEventResponse::operator=(const FireEventResponse& other634) { + (void) other634; return *this; } void FireEventResponse::printTo(std::ostream& out) const { @@ -15745,11 +15877,11 @@ void swap(GetChangeVersionRequest &a, GetChangeVersionRequest &b) { swap(a.topic, b.topic); } -GetChangeVersionRequest::GetChangeVersionRequest(const GetChangeVersionRequest& other633) { - topic = other633.topic; +GetChangeVersionRequest::GetChangeVersionRequest(const GetChangeVersionRequest& other635) { + topic = other635.topic; } -GetChangeVersionRequest& GetChangeVersionRequest::operator=(const GetChangeVersionRequest& other634) { - topic = other634.topic; +GetChangeVersionRequest& GetChangeVersionRequest::operator=(const GetChangeVersionRequest& other636) { + topic = other636.topic; return *this; } void GetChangeVersionRequest::printTo(std::ostream& out) const { @@ -15831,11 +15963,11 @@ void swap(GetChangeVersionResult &a, GetChangeVersionResult &b) { swap(a.version, b.version); } -GetChangeVersionResult::GetChangeVersionResult(const GetChangeVersionResult& other635) { - version = other635.version; +GetChangeVersionResult::GetChangeVersionResult(const GetChangeVersionResult& other637) { + version = other637.version; } -GetChangeVersionResult& GetChangeVersionResult::operator=(const GetChangeVersionResult& other636) { - version = other636.version; +GetChangeVersionResult& GetChangeVersionResult::operator=(const GetChangeVersionResult& other638) { + version = other638.version; return *this; } void GetChangeVersionResult::printTo(std::ostream& out) const { @@ -15936,15 +16068,15 @@ void swap(MetadataPpdResult &a, MetadataPpdResult &b) { swap(a.__isset, b.__isset); } -MetadataPpdResult::MetadataPpdResult(const MetadataPpdResult& other637) { - metadata = other637.metadata; - includeBitset = other637.includeBitset; - __isset = other637.__isset; +MetadataPpdResult::MetadataPpdResult(const MetadataPpdResult& other639) { + metadata = other639.metadata; + includeBitset = other639.includeBitset; + __isset = other639.__isset; } -MetadataPpdResult& MetadataPpdResult::operator=(const MetadataPpdResult& other638) { - metadata = other638.metadata; - includeBitset = other638.includeBitset; - __isset = other638.__isset; +MetadataPpdResult& MetadataPpdResult::operator=(const MetadataPpdResult& other640) { + metadata = other640.metadata; + includeBitset = other640.includeBitset; + __isset = other640.__isset; return *this; } void MetadataPpdResult::printTo(std::ostream& out) const { @@ -15995,17 +16127,17 @@ uint32_t GetFileMetadataByExprResult::read(::apache::thrift::protocol::TProtocol if (ftype == ::apache::thrift::protocol::T_MAP) { { this->metadata.clear(); - uint32_t _size639; - ::apache::thrift::protocol::TType _ktype640; - ::apache::thrift::protocol::TType _vtype641; - xfer += iprot->readMapBegin(_ktype640, _vtype641, _size639); - uint32_t _i643; - for (_i643 = 0; _i643 < _size639; ++_i643) + uint32_t _size641; + ::apache::thrift::protocol::TType _ktype642; + ::apache::thrift::protocol::TType _vtype643; + xfer += iprot->readMapBegin(_ktype642, _vtype643, _size641); + uint32_t _i645; + for (_i645 = 0; _i645 < _size641; ++_i645) { - int64_t _key644; - xfer += iprot->readI64(_key644); - MetadataPpdResult& _val645 = this->metadata[_key644]; - xfer += _val645.read(iprot); + int64_t _key646; + xfer += iprot->readI64(_key646); + MetadataPpdResult& _val647 = this->metadata[_key646]; + xfer += _val647.read(iprot); } xfer += iprot->readMapEnd(); } @@ -16046,11 +16178,11 @@ uint32_t GetFileMetadataByExprResult::write(::apache::thrift::protocol::TProtoco xfer += oprot->writeFieldBegin("metadata", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_I64, ::apache::thrift::protocol::T_STRUCT, static_cast(this->metadata.size())); - std::map ::const_iterator _iter646; - for (_iter646 = this->metadata.begin(); _iter646 != this->metadata.end(); ++_iter646) + std::map ::const_iterator _iter648; + for (_iter648 = this->metadata.begin(); _iter648 != this->metadata.end(); ++_iter648) { - xfer += oprot->writeI64(_iter646->first); - xfer += _iter646->second.write(oprot); + xfer += oprot->writeI64(_iter648->first); + xfer += _iter648->second.write(oprot); } xfer += oprot->writeMapEnd(); } @@ -16071,13 +16203,13 @@ void swap(GetFileMetadataByExprResult &a, GetFileMetadataByExprResult &b) { swap(a.isSupported, b.isSupported); } -GetFileMetadataByExprResult::GetFileMetadataByExprResult(const GetFileMetadataByExprResult& other647) { - metadata = other647.metadata; - isSupported = other647.isSupported; +GetFileMetadataByExprResult::GetFileMetadataByExprResult(const GetFileMetadataByExprResult& other649) { + metadata = other649.metadata; + isSupported = other649.isSupported; } -GetFileMetadataByExprResult& GetFileMetadataByExprResult::operator=(const GetFileMetadataByExprResult& other648) { - metadata = other648.metadata; - isSupported = other648.isSupported; +GetFileMetadataByExprResult& GetFileMetadataByExprResult::operator=(const GetFileMetadataByExprResult& other650) { + metadata = other650.metadata; + isSupported = other650.isSupported; return *this; } void GetFileMetadataByExprResult::printTo(std::ostream& out) const { @@ -16138,14 +16270,14 @@ uint32_t GetFileMetadataByExprRequest::read(::apache::thrift::protocol::TProtoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size649; - ::apache::thrift::protocol::TType _etype652; - xfer += iprot->readListBegin(_etype652, _size649); - this->fileIds.resize(_size649); - uint32_t _i653; - for (_i653 = 0; _i653 < _size649; ++_i653) + uint32_t _size651; + ::apache::thrift::protocol::TType _etype654; + xfer += iprot->readListBegin(_etype654, _size651); + this->fileIds.resize(_size651); + uint32_t _i655; + for (_i655 = 0; _i655 < _size651; ++_i655) { - xfer += iprot->readI64(this->fileIds[_i653]); + xfer += iprot->readI64(this->fileIds[_i655]); } xfer += iprot->readListEnd(); } @@ -16172,9 +16304,9 @@ uint32_t GetFileMetadataByExprRequest::read(::apache::thrift::protocol::TProtoco break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast654; - xfer += iprot->readI32(ecast654); - this->type = (FileMetadataExprType::type)ecast654; + int32_t ecast656; + xfer += iprot->readI32(ecast656); + this->type = (FileMetadataExprType::type)ecast656; this->__isset.type = true; } else { xfer += iprot->skip(ftype); @@ -16204,10 +16336,10 @@ uint32_t GetFileMetadataByExprRequest::write(::apache::thrift::protocol::TProtoc xfer += oprot->writeFieldBegin("fileIds", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->fileIds.size())); - std::vector ::const_iterator _iter655; - for (_iter655 = this->fileIds.begin(); _iter655 != this->fileIds.end(); ++_iter655) + std::vector ::const_iterator _iter657; + for (_iter657 = this->fileIds.begin(); _iter657 != this->fileIds.end(); ++_iter657) { - xfer += oprot->writeI64((*_iter655)); + xfer += oprot->writeI64((*_iter657)); } xfer += oprot->writeListEnd(); } @@ -16241,19 +16373,19 @@ void swap(GetFileMetadataByExprRequest &a, GetFileMetadataByExprRequest &b) { swap(a.__isset, b.__isset); } -GetFileMetadataByExprRequest::GetFileMetadataByExprRequest(const GetFileMetadataByExprRequest& other656) { - fileIds = other656.fileIds; - expr = other656.expr; - doGetFooters = other656.doGetFooters; - type = other656.type; - __isset = other656.__isset; +GetFileMetadataByExprRequest::GetFileMetadataByExprRequest(const GetFileMetadataByExprRequest& other658) { + fileIds = other658.fileIds; + expr = other658.expr; + doGetFooters = other658.doGetFooters; + type = other658.type; + __isset = other658.__isset; } -GetFileMetadataByExprRequest& GetFileMetadataByExprRequest::operator=(const GetFileMetadataByExprRequest& other657) { - fileIds = other657.fileIds; - expr = other657.expr; - doGetFooters = other657.doGetFooters; - type = other657.type; - __isset = other657.__isset; +GetFileMetadataByExprRequest& GetFileMetadataByExprRequest::operator=(const GetFileMetadataByExprRequest& other659) { + fileIds = other659.fileIds; + expr = other659.expr; + doGetFooters = other659.doGetFooters; + type = other659.type; + __isset = other659.__isset; return *this; } void GetFileMetadataByExprRequest::printTo(std::ostream& out) const { @@ -16306,17 +16438,17 @@ uint32_t GetFileMetadataResult::read(::apache::thrift::protocol::TProtocol* ipro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->metadata.clear(); - uint32_t _size658; - ::apache::thrift::protocol::TType _ktype659; - ::apache::thrift::protocol::TType _vtype660; - xfer += iprot->readMapBegin(_ktype659, _vtype660, _size658); - uint32_t _i662; - for (_i662 = 0; _i662 < _size658; ++_i662) + uint32_t _size660; + ::apache::thrift::protocol::TType _ktype661; + ::apache::thrift::protocol::TType _vtype662; + xfer += iprot->readMapBegin(_ktype661, _vtype662, _size660); + uint32_t _i664; + for (_i664 = 0; _i664 < _size660; ++_i664) { - int64_t _key663; - xfer += iprot->readI64(_key663); - std::string& _val664 = this->metadata[_key663]; - xfer += iprot->readBinary(_val664); + int64_t _key665; + xfer += iprot->readI64(_key665); + std::string& _val666 = this->metadata[_key665]; + xfer += iprot->readBinary(_val666); } xfer += iprot->readMapEnd(); } @@ -16357,11 +16489,11 @@ uint32_t GetFileMetadataResult::write(::apache::thrift::protocol::TProtocol* opr xfer += oprot->writeFieldBegin("metadata", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_I64, ::apache::thrift::protocol::T_STRING, static_cast(this->metadata.size())); - std::map ::const_iterator _iter665; - for (_iter665 = this->metadata.begin(); _iter665 != this->metadata.end(); ++_iter665) + std::map ::const_iterator _iter667; + for (_iter667 = this->metadata.begin(); _iter667 != this->metadata.end(); ++_iter667) { - xfer += oprot->writeI64(_iter665->first); - xfer += oprot->writeBinary(_iter665->second); + xfer += oprot->writeI64(_iter667->first); + xfer += oprot->writeBinary(_iter667->second); } xfer += oprot->writeMapEnd(); } @@ -16382,13 +16514,13 @@ void swap(GetFileMetadataResult &a, GetFileMetadataResult &b) { swap(a.isSupported, b.isSupported); } -GetFileMetadataResult::GetFileMetadataResult(const GetFileMetadataResult& other666) { - metadata = other666.metadata; - isSupported = other666.isSupported; +GetFileMetadataResult::GetFileMetadataResult(const GetFileMetadataResult& other668) { + metadata = other668.metadata; + isSupported = other668.isSupported; } -GetFileMetadataResult& GetFileMetadataResult::operator=(const GetFileMetadataResult& other667) { - metadata = other667.metadata; - isSupported = other667.isSupported; +GetFileMetadataResult& GetFileMetadataResult::operator=(const GetFileMetadataResult& other669) { + metadata = other669.metadata; + isSupported = other669.isSupported; return *this; } void GetFileMetadataResult::printTo(std::ostream& out) const { @@ -16434,14 +16566,14 @@ uint32_t GetFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size668; - ::apache::thrift::protocol::TType _etype671; - xfer += iprot->readListBegin(_etype671, _size668); - this->fileIds.resize(_size668); - uint32_t _i672; - for (_i672 = 0; _i672 < _size668; ++_i672) + uint32_t _size670; + ::apache::thrift::protocol::TType _etype673; + xfer += iprot->readListBegin(_etype673, _size670); + this->fileIds.resize(_size670); + uint32_t _i674; + for (_i674 = 0; _i674 < _size670; ++_i674) { - xfer += iprot->readI64(this->fileIds[_i672]); + xfer += iprot->readI64(this->fileIds[_i674]); } xfer += iprot->readListEnd(); } @@ -16472,10 +16604,10 @@ uint32_t GetFileMetadataRequest::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("fileIds", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->fileIds.size())); - std::vector ::const_iterator _iter673; - for (_iter673 = this->fileIds.begin(); _iter673 != this->fileIds.end(); ++_iter673) + std::vector ::const_iterator _iter675; + for (_iter675 = this->fileIds.begin(); _iter675 != this->fileIds.end(); ++_iter675) { - xfer += oprot->writeI64((*_iter673)); + xfer += oprot->writeI64((*_iter675)); } xfer += oprot->writeListEnd(); } @@ -16491,11 +16623,11 @@ void swap(GetFileMetadataRequest &a, GetFileMetadataRequest &b) { swap(a.fileIds, b.fileIds); } -GetFileMetadataRequest::GetFileMetadataRequest(const GetFileMetadataRequest& other674) { - fileIds = other674.fileIds; +GetFileMetadataRequest::GetFileMetadataRequest(const GetFileMetadataRequest& other676) { + fileIds = other676.fileIds; } -GetFileMetadataRequest& GetFileMetadataRequest::operator=(const GetFileMetadataRequest& other675) { - fileIds = other675.fileIds; +GetFileMetadataRequest& GetFileMetadataRequest::operator=(const GetFileMetadataRequest& other677) { + fileIds = other677.fileIds; return *this; } void GetFileMetadataRequest::printTo(std::ostream& out) const { @@ -16554,11 +16686,11 @@ void swap(PutFileMetadataResult &a, PutFileMetadataResult &b) { (void) b; } -PutFileMetadataResult::PutFileMetadataResult(const PutFileMetadataResult& other676) { - (void) other676; +PutFileMetadataResult::PutFileMetadataResult(const PutFileMetadataResult& other678) { + (void) other678; } -PutFileMetadataResult& PutFileMetadataResult::operator=(const PutFileMetadataResult& other677) { - (void) other677; +PutFileMetadataResult& PutFileMetadataResult::operator=(const PutFileMetadataResult& other679) { + (void) other679; return *this; } void PutFileMetadataResult::printTo(std::ostream& out) const { @@ -16612,14 +16744,14 @@ uint32_t PutFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size678; - ::apache::thrift::protocol::TType _etype681; - xfer += iprot->readListBegin(_etype681, _size678); - this->fileIds.resize(_size678); - uint32_t _i682; - for (_i682 = 0; _i682 < _size678; ++_i682) + uint32_t _size680; + ::apache::thrift::protocol::TType _etype683; + xfer += iprot->readListBegin(_etype683, _size680); + this->fileIds.resize(_size680); + uint32_t _i684; + for (_i684 = 0; _i684 < _size680; ++_i684) { - xfer += iprot->readI64(this->fileIds[_i682]); + xfer += iprot->readI64(this->fileIds[_i684]); } xfer += iprot->readListEnd(); } @@ -16632,14 +16764,14 @@ uint32_t PutFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->metadata.clear(); - uint32_t _size683; - ::apache::thrift::protocol::TType _etype686; - xfer += iprot->readListBegin(_etype686, _size683); - this->metadata.resize(_size683); - uint32_t _i687; - for (_i687 = 0; _i687 < _size683; ++_i687) + uint32_t _size685; + ::apache::thrift::protocol::TType _etype688; + xfer += iprot->readListBegin(_etype688, _size685); + this->metadata.resize(_size685); + uint32_t _i689; + for (_i689 = 0; _i689 < _size685; ++_i689) { - xfer += iprot->readBinary(this->metadata[_i687]); + xfer += iprot->readBinary(this->metadata[_i689]); } xfer += iprot->readListEnd(); } @@ -16650,9 +16782,9 @@ uint32_t PutFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast688; - xfer += iprot->readI32(ecast688); - this->type = (FileMetadataExprType::type)ecast688; + int32_t ecast690; + xfer += iprot->readI32(ecast690); + this->type = (FileMetadataExprType::type)ecast690; this->__isset.type = true; } else { xfer += iprot->skip(ftype); @@ -16682,10 +16814,10 @@ uint32_t PutFileMetadataRequest::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("fileIds", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->fileIds.size())); - std::vector ::const_iterator _iter689; - for (_iter689 = this->fileIds.begin(); _iter689 != this->fileIds.end(); ++_iter689) + std::vector ::const_iterator _iter691; + for (_iter691 = this->fileIds.begin(); _iter691 != this->fileIds.end(); ++_iter691) { - xfer += oprot->writeI64((*_iter689)); + xfer += oprot->writeI64((*_iter691)); } xfer += oprot->writeListEnd(); } @@ -16694,10 +16826,10 @@ uint32_t PutFileMetadataRequest::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("metadata", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->metadata.size())); - std::vector ::const_iterator _iter690; - for (_iter690 = this->metadata.begin(); _iter690 != this->metadata.end(); ++_iter690) + std::vector ::const_iterator _iter692; + for (_iter692 = this->metadata.begin(); _iter692 != this->metadata.end(); ++_iter692) { - xfer += oprot->writeBinary((*_iter690)); + xfer += oprot->writeBinary((*_iter692)); } xfer += oprot->writeListEnd(); } @@ -16721,17 +16853,17 @@ void swap(PutFileMetadataRequest &a, PutFileMetadataRequest &b) { swap(a.__isset, b.__isset); } -PutFileMetadataRequest::PutFileMetadataRequest(const PutFileMetadataRequest& other691) { - fileIds = other691.fileIds; - metadata = other691.metadata; - type = other691.type; - __isset = other691.__isset; +PutFileMetadataRequest::PutFileMetadataRequest(const PutFileMetadataRequest& other693) { + fileIds = other693.fileIds; + metadata = other693.metadata; + type = other693.type; + __isset = other693.__isset; } -PutFileMetadataRequest& PutFileMetadataRequest::operator=(const PutFileMetadataRequest& other692) { - fileIds = other692.fileIds; - metadata = other692.metadata; - type = other692.type; - __isset = other692.__isset; +PutFileMetadataRequest& PutFileMetadataRequest::operator=(const PutFileMetadataRequest& other694) { + fileIds = other694.fileIds; + metadata = other694.metadata; + type = other694.type; + __isset = other694.__isset; return *this; } void PutFileMetadataRequest::printTo(std::ostream& out) const { @@ -16792,11 +16924,11 @@ void swap(ClearFileMetadataResult &a, ClearFileMetadataResult &b) { (void) b; } -ClearFileMetadataResult::ClearFileMetadataResult(const ClearFileMetadataResult& other693) { - (void) other693; +ClearFileMetadataResult::ClearFileMetadataResult(const ClearFileMetadataResult& other695) { + (void) other695; } -ClearFileMetadataResult& ClearFileMetadataResult::operator=(const ClearFileMetadataResult& other694) { - (void) other694; +ClearFileMetadataResult& ClearFileMetadataResult::operator=(const ClearFileMetadataResult& other696) { + (void) other696; return *this; } void ClearFileMetadataResult::printTo(std::ostream& out) const { @@ -16840,14 +16972,14 @@ uint32_t ClearFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* i if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size695; - ::apache::thrift::protocol::TType _etype698; - xfer += iprot->readListBegin(_etype698, _size695); - this->fileIds.resize(_size695); - uint32_t _i699; - for (_i699 = 0; _i699 < _size695; ++_i699) + uint32_t _size697; + ::apache::thrift::protocol::TType _etype700; + xfer += iprot->readListBegin(_etype700, _size697); + this->fileIds.resize(_size697); + uint32_t _i701; + for (_i701 = 0; _i701 < _size697; ++_i701) { - xfer += iprot->readI64(this->fileIds[_i699]); + xfer += iprot->readI64(this->fileIds[_i701]); } xfer += iprot->readListEnd(); } @@ -16878,10 +17010,10 @@ uint32_t ClearFileMetadataRequest::write(::apache::thrift::protocol::TProtocol* xfer += oprot->writeFieldBegin("fileIds", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->fileIds.size())); - std::vector ::const_iterator _iter700; - for (_iter700 = this->fileIds.begin(); _iter700 != this->fileIds.end(); ++_iter700) + std::vector ::const_iterator _iter702; + for (_iter702 = this->fileIds.begin(); _iter702 != this->fileIds.end(); ++_iter702) { - xfer += oprot->writeI64((*_iter700)); + xfer += oprot->writeI64((*_iter702)); } xfer += oprot->writeListEnd(); } @@ -16897,11 +17029,11 @@ void swap(ClearFileMetadataRequest &a, ClearFileMetadataRequest &b) { swap(a.fileIds, b.fileIds); } -ClearFileMetadataRequest::ClearFileMetadataRequest(const ClearFileMetadataRequest& other701) { - fileIds = other701.fileIds; +ClearFileMetadataRequest::ClearFileMetadataRequest(const ClearFileMetadataRequest& other703) { + fileIds = other703.fileIds; } -ClearFileMetadataRequest& ClearFileMetadataRequest::operator=(const ClearFileMetadataRequest& other702) { - fileIds = other702.fileIds; +ClearFileMetadataRequest& ClearFileMetadataRequest::operator=(const ClearFileMetadataRequest& other704) { + fileIds = other704.fileIds; return *this; } void ClearFileMetadataRequest::printTo(std::ostream& out) const { @@ -16983,11 +17115,11 @@ void swap(CacheFileMetadataResult &a, CacheFileMetadataResult &b) { swap(a.isSupported, b.isSupported); } -CacheFileMetadataResult::CacheFileMetadataResult(const CacheFileMetadataResult& other703) { - isSupported = other703.isSupported; +CacheFileMetadataResult::CacheFileMetadataResult(const CacheFileMetadataResult& other705) { + isSupported = other705.isSupported; } -CacheFileMetadataResult& CacheFileMetadataResult::operator=(const CacheFileMetadataResult& other704) { - isSupported = other704.isSupported; +CacheFileMetadataResult& CacheFileMetadataResult::operator=(const CacheFileMetadataResult& other706) { + isSupported = other706.isSupported; return *this; } void CacheFileMetadataResult::printTo(std::ostream& out) const { @@ -17128,19 +17260,19 @@ void swap(CacheFileMetadataRequest &a, CacheFileMetadataRequest &b) { swap(a.__isset, b.__isset); } -CacheFileMetadataRequest::CacheFileMetadataRequest(const CacheFileMetadataRequest& other705) { - dbName = other705.dbName; - tblName = other705.tblName; - partName = other705.partName; - isAllParts = other705.isAllParts; - __isset = other705.__isset; +CacheFileMetadataRequest::CacheFileMetadataRequest(const CacheFileMetadataRequest& other707) { + dbName = other707.dbName; + tblName = other707.tblName; + partName = other707.partName; + isAllParts = other707.isAllParts; + __isset = other707.__isset; } -CacheFileMetadataRequest& CacheFileMetadataRequest::operator=(const CacheFileMetadataRequest& other706) { - dbName = other706.dbName; - tblName = other706.tblName; - partName = other706.partName; - isAllParts = other706.isAllParts; - __isset = other706.__isset; +CacheFileMetadataRequest& CacheFileMetadataRequest::operator=(const CacheFileMetadataRequest& other708) { + dbName = other708.dbName; + tblName = other708.tblName; + partName = other708.partName; + isAllParts = other708.isAllParts; + __isset = other708.__isset; return *this; } void CacheFileMetadataRequest::printTo(std::ostream& out) const { @@ -17188,14 +17320,14 @@ uint32_t GetAllFunctionsResponse::read(::apache::thrift::protocol::TProtocol* ip if (ftype == ::apache::thrift::protocol::T_LIST) { { this->functions.clear(); - uint32_t _size707; - ::apache::thrift::protocol::TType _etype710; - xfer += iprot->readListBegin(_etype710, _size707); - this->functions.resize(_size707); - uint32_t _i711; - for (_i711 = 0; _i711 < _size707; ++_i711) + uint32_t _size709; + ::apache::thrift::protocol::TType _etype712; + xfer += iprot->readListBegin(_etype712, _size709); + this->functions.resize(_size709); + uint32_t _i713; + for (_i713 = 0; _i713 < _size709; ++_i713) { - xfer += this->functions[_i711].read(iprot); + xfer += this->functions[_i713].read(iprot); } xfer += iprot->readListEnd(); } @@ -17225,10 +17357,10 @@ uint32_t GetAllFunctionsResponse::write(::apache::thrift::protocol::TProtocol* o xfer += oprot->writeFieldBegin("functions", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->functions.size())); - std::vector ::const_iterator _iter712; - for (_iter712 = this->functions.begin(); _iter712 != this->functions.end(); ++_iter712) + std::vector ::const_iterator _iter714; + for (_iter714 = this->functions.begin(); _iter714 != this->functions.end(); ++_iter714) { - xfer += (*_iter712).write(oprot); + xfer += (*_iter714).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17245,13 +17377,13 @@ void swap(GetAllFunctionsResponse &a, GetAllFunctionsResponse &b) { swap(a.__isset, b.__isset); } -GetAllFunctionsResponse::GetAllFunctionsResponse(const GetAllFunctionsResponse& other713) { - functions = other713.functions; - __isset = other713.__isset; +GetAllFunctionsResponse::GetAllFunctionsResponse(const GetAllFunctionsResponse& other715) { + functions = other715.functions; + __isset = other715.__isset; } -GetAllFunctionsResponse& GetAllFunctionsResponse::operator=(const GetAllFunctionsResponse& other714) { - functions = other714.functions; - __isset = other714.__isset; +GetAllFunctionsResponse& GetAllFunctionsResponse::operator=(const GetAllFunctionsResponse& other716) { + functions = other716.functions; + __isset = other716.__isset; return *this; } void GetAllFunctionsResponse::printTo(std::ostream& out) const { @@ -17393,19 +17525,19 @@ void swap(TableMeta &a, TableMeta &b) { swap(a.__isset, b.__isset); } -TableMeta::TableMeta(const TableMeta& other715) { - dbName = other715.dbName; - tableName = other715.tableName; - tableType = other715.tableType; - comments = other715.comments; - __isset = other715.__isset; +TableMeta::TableMeta(const TableMeta& other717) { + dbName = other717.dbName; + tableName = other717.tableName; + tableType = other717.tableType; + comments = other717.comments; + __isset = other717.__isset; } -TableMeta& TableMeta::operator=(const TableMeta& other716) { - dbName = other716.dbName; - tableName = other716.tableName; - tableType = other716.tableType; - comments = other716.comments; - __isset = other716.__isset; +TableMeta& TableMeta::operator=(const TableMeta& other718) { + dbName = other718.dbName; + tableName = other718.tableName; + tableType = other718.tableType; + comments = other718.comments; + __isset = other718.__isset; return *this; } void TableMeta::printTo(std::ostream& out) const { @@ -17488,13 +17620,13 @@ void swap(MetaException &a, MetaException &b) { swap(a.__isset, b.__isset); } -MetaException::MetaException(const MetaException& other717) : TException() { - message = other717.message; - __isset = other717.__isset; +MetaException::MetaException(const MetaException& other719) : TException() { + message = other719.message; + __isset = other719.__isset; } -MetaException& MetaException::operator=(const MetaException& other718) { - message = other718.message; - __isset = other718.__isset; +MetaException& MetaException::operator=(const MetaException& other720) { + message = other720.message; + __isset = other720.__isset; return *this; } void MetaException::printTo(std::ostream& out) const { @@ -17585,13 +17717,13 @@ void swap(UnknownTableException &a, UnknownTableException &b) { swap(a.__isset, b.__isset); } -UnknownTableException::UnknownTableException(const UnknownTableException& other719) : TException() { - message = other719.message; - __isset = other719.__isset; +UnknownTableException::UnknownTableException(const UnknownTableException& other721) : TException() { + message = other721.message; + __isset = other721.__isset; } -UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other720) { - message = other720.message; - __isset = other720.__isset; +UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other722) { + message = other722.message; + __isset = other722.__isset; return *this; } void UnknownTableException::printTo(std::ostream& out) const { @@ -17682,13 +17814,13 @@ void swap(UnknownDBException &a, UnknownDBException &b) { swap(a.__isset, b.__isset); } -UnknownDBException::UnknownDBException(const UnknownDBException& other721) : TException() { - message = other721.message; - __isset = other721.__isset; +UnknownDBException::UnknownDBException(const UnknownDBException& other723) : TException() { + message = other723.message; + __isset = other723.__isset; } -UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other722) { - message = other722.message; - __isset = other722.__isset; +UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other724) { + message = other724.message; + __isset = other724.__isset; return *this; } void UnknownDBException::printTo(std::ostream& out) const { @@ -17779,13 +17911,13 @@ void swap(AlreadyExistsException &a, AlreadyExistsException &b) { swap(a.__isset, b.__isset); } -AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other723) : TException() { - message = other723.message; - __isset = other723.__isset; +AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other725) : TException() { + message = other725.message; + __isset = other725.__isset; } -AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other724) { - message = other724.message; - __isset = other724.__isset; +AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other726) { + message = other726.message; + __isset = other726.__isset; return *this; } void AlreadyExistsException::printTo(std::ostream& out) const { @@ -17876,13 +18008,13 @@ void swap(InvalidPartitionException &a, InvalidPartitionException &b) { swap(a.__isset, b.__isset); } -InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other725) : TException() { - message = other725.message; - __isset = other725.__isset; +InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other727) : TException() { + message = other727.message; + __isset = other727.__isset; } -InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other726) { - message = other726.message; - __isset = other726.__isset; +InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other728) { + message = other728.message; + __isset = other728.__isset; return *this; } void InvalidPartitionException::printTo(std::ostream& out) const { @@ -17973,13 +18105,13 @@ void swap(UnknownPartitionException &a, UnknownPartitionException &b) { swap(a.__isset, b.__isset); } -UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other727) : TException() { - message = other727.message; - __isset = other727.__isset; +UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other729) : TException() { + message = other729.message; + __isset = other729.__isset; } -UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other728) { - message = other728.message; - __isset = other728.__isset; +UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other730) { + message = other730.message; + __isset = other730.__isset; return *this; } void UnknownPartitionException::printTo(std::ostream& out) const { @@ -18070,13 +18202,13 @@ void swap(InvalidObjectException &a, InvalidObjectException &b) { swap(a.__isset, b.__isset); } -InvalidObjectException::InvalidObjectException(const InvalidObjectException& other729) : TException() { - message = other729.message; - __isset = other729.__isset; +InvalidObjectException::InvalidObjectException(const InvalidObjectException& other731) : TException() { + message = other731.message; + __isset = other731.__isset; } -InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other730) { - message = other730.message; - __isset = other730.__isset; +InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other732) { + message = other732.message; + __isset = other732.__isset; return *this; } void InvalidObjectException::printTo(std::ostream& out) const { @@ -18167,13 +18299,13 @@ void swap(NoSuchObjectException &a, NoSuchObjectException &b) { swap(a.__isset, b.__isset); } -NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other731) : TException() { - message = other731.message; - __isset = other731.__isset; +NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other733) : TException() { + message = other733.message; + __isset = other733.__isset; } -NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other732) { - message = other732.message; - __isset = other732.__isset; +NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other734) { + message = other734.message; + __isset = other734.__isset; return *this; } void NoSuchObjectException::printTo(std::ostream& out) const { @@ -18264,13 +18396,13 @@ void swap(IndexAlreadyExistsException &a, IndexAlreadyExistsException &b) { swap(a.__isset, b.__isset); } -IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other733) : TException() { - message = other733.message; - __isset = other733.__isset; +IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other735) : TException() { + message = other735.message; + __isset = other735.__isset; } -IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other734) { - message = other734.message; - __isset = other734.__isset; +IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other736) { + message = other736.message; + __isset = other736.__isset; return *this; } void IndexAlreadyExistsException::printTo(std::ostream& out) const { @@ -18361,13 +18493,13 @@ void swap(InvalidOperationException &a, InvalidOperationException &b) { swap(a.__isset, b.__isset); } -InvalidOperationException::InvalidOperationException(const InvalidOperationException& other735) : TException() { - message = other735.message; - __isset = other735.__isset; +InvalidOperationException::InvalidOperationException(const InvalidOperationException& other737) : TException() { + message = other737.message; + __isset = other737.__isset; } -InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other736) { - message = other736.message; - __isset = other736.__isset; +InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other738) { + message = other738.message; + __isset = other738.__isset; return *this; } void InvalidOperationException::printTo(std::ostream& out) const { @@ -18458,13 +18590,13 @@ void swap(ConfigValSecurityException &a, ConfigValSecurityException &b) { swap(a.__isset, b.__isset); } -ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other737) : TException() { - message = other737.message; - __isset = other737.__isset; +ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other739) : TException() { + message = other739.message; + __isset = other739.__isset; } -ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other738) { - message = other738.message; - __isset = other738.__isset; +ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other740) { + message = other740.message; + __isset = other740.__isset; return *this; } void ConfigValSecurityException::printTo(std::ostream& out) const { @@ -18555,13 +18687,13 @@ void swap(InvalidInputException &a, InvalidInputException &b) { swap(a.__isset, b.__isset); } -InvalidInputException::InvalidInputException(const InvalidInputException& other739) : TException() { - message = other739.message; - __isset = other739.__isset; +InvalidInputException::InvalidInputException(const InvalidInputException& other741) : TException() { + message = other741.message; + __isset = other741.__isset; } -InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other740) { - message = other740.message; - __isset = other740.__isset; +InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other742) { + message = other742.message; + __isset = other742.__isset; return *this; } void InvalidInputException::printTo(std::ostream& out) const { @@ -18652,13 +18784,13 @@ void swap(NoSuchTxnException &a, NoSuchTxnException &b) { swap(a.__isset, b.__isset); } -NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other741) : TException() { - message = other741.message; - __isset = other741.__isset; +NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other743) : TException() { + message = other743.message; + __isset = other743.__isset; } -NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other742) { - message = other742.message; - __isset = other742.__isset; +NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other744) { + message = other744.message; + __isset = other744.__isset; return *this; } void NoSuchTxnException::printTo(std::ostream& out) const { @@ -18749,13 +18881,13 @@ void swap(TxnAbortedException &a, TxnAbortedException &b) { swap(a.__isset, b.__isset); } -TxnAbortedException::TxnAbortedException(const TxnAbortedException& other743) : TException() { - message = other743.message; - __isset = other743.__isset; +TxnAbortedException::TxnAbortedException(const TxnAbortedException& other745) : TException() { + message = other745.message; + __isset = other745.__isset; } -TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other744) { - message = other744.message; - __isset = other744.__isset; +TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other746) { + message = other746.message; + __isset = other746.__isset; return *this; } void TxnAbortedException::printTo(std::ostream& out) const { @@ -18846,13 +18978,13 @@ void swap(TxnOpenException &a, TxnOpenException &b) { swap(a.__isset, b.__isset); } -TxnOpenException::TxnOpenException(const TxnOpenException& other745) : TException() { - message = other745.message; - __isset = other745.__isset; +TxnOpenException::TxnOpenException(const TxnOpenException& other747) : TException() { + message = other747.message; + __isset = other747.__isset; } -TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other746) { - message = other746.message; - __isset = other746.__isset; +TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other748) { + message = other748.message; + __isset = other748.__isset; return *this; } void TxnOpenException::printTo(std::ostream& out) const { @@ -18943,13 +19075,13 @@ void swap(NoSuchLockException &a, NoSuchLockException &b) { swap(a.__isset, b.__isset); } -NoSuchLockException::NoSuchLockException(const NoSuchLockException& other747) : TException() { - message = other747.message; - __isset = other747.__isset; +NoSuchLockException::NoSuchLockException(const NoSuchLockException& other749) : TException() { + message = other749.message; + __isset = other749.__isset; } -NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other748) { - message = other748.message; - __isset = other748.__isset; +NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other750) { + message = other750.message; + __isset = other750.__isset; return *this; } void NoSuchLockException::printTo(std::ostream& out) const { diff --git a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h index d392f67..3b3e05e 100644 --- a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h +++ b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h @@ -251,6 +251,8 @@ class ForeignKeysRequest; class ForeignKeysResponse; +class DropConstraintRequest; + class PartitionsByExprResult; class PartitionsByExprRequest; @@ -3779,6 +3781,56 @@ inline std::ostream& operator<<(std::ostream& out, const ForeignKeysResponse& ob } +class DropConstraintRequest { + public: + + DropConstraintRequest(const DropConstraintRequest&); + DropConstraintRequest& operator=(const DropConstraintRequest&); + DropConstraintRequest() : dbname(), tablename(), constraintname() { + } + + virtual ~DropConstraintRequest() throw(); + std::string dbname; + std::string tablename; + std::string constraintname; + + void __set_dbname(const std::string& val); + + void __set_tablename(const std::string& val); + + void __set_constraintname(const std::string& val); + + bool operator == (const DropConstraintRequest & rhs) const + { + if (!(dbname == rhs.dbname)) + return false; + if (!(tablename == rhs.tablename)) + return false; + if (!(constraintname == rhs.constraintname)) + return false; + return true; + } + bool operator != (const DropConstraintRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const DropConstraintRequest & ) 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(DropConstraintRequest &a, DropConstraintRequest &b); + +inline std::ostream& operator<<(std::ostream& out, const DropConstraintRequest& obj) +{ + obj.printTo(out); + return out; +} + + class PartitionsByExprResult { public: diff --git a/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/DropConstraintRequest.java b/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/DropConstraintRequest.java new file mode 100644 index 0000000..4519dac --- /dev/null +++ b/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/DropConstraintRequest.java @@ -0,0 +1,591 @@ +/** + * Autogenerated by Thrift Compiler (0.9.3) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +package org.apache.hadoop.hive.metastore.api; + +import org.apache.thrift.scheme.IScheme; +import org.apache.thrift.scheme.SchemeFactory; +import org.apache.thrift.scheme.StandardScheme; + +import org.apache.thrift.scheme.TupleScheme; +import org.apache.thrift.protocol.TTupleProtocol; +import org.apache.thrift.protocol.TProtocolException; +import org.apache.thrift.EncodingUtils; +import org.apache.thrift.TException; +import org.apache.thrift.async.AsyncMethodCallback; +import org.apache.thrift.server.AbstractNonblockingServer.*; +import java.util.List; +import java.util.ArrayList; +import java.util.Map; +import java.util.HashMap; +import java.util.EnumMap; +import java.util.Set; +import java.util.HashSet; +import java.util.EnumSet; +import java.util.Collections; +import java.util.BitSet; +import java.nio.ByteBuffer; +import java.util.Arrays; +import javax.annotation.Generated; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) +@Generated(value = "Autogenerated by Thrift Compiler (0.9.3)") +public class DropConstraintRequest 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("DropConstraintRequest"); + + private static final org.apache.thrift.protocol.TField DBNAME_FIELD_DESC = new org.apache.thrift.protocol.TField("dbname", org.apache.thrift.protocol.TType.STRING, (short)1); + private static final org.apache.thrift.protocol.TField TABLENAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tablename", org.apache.thrift.protocol.TType.STRING, (short)2); + private static final org.apache.thrift.protocol.TField CONSTRAINTNAME_FIELD_DESC = new org.apache.thrift.protocol.TField("constraintname", org.apache.thrift.protocol.TType.STRING, (short)3); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new DropConstraintRequestStandardSchemeFactory()); + schemes.put(TupleScheme.class, new DropConstraintRequestTupleSchemeFactory()); + } + + private String dbname; // required + private String tablename; // required + private String constraintname; // 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 { + DBNAME((short)1, "dbname"), + TABLENAME((short)2, "tablename"), + CONSTRAINTNAME((short)3, "constraintname"); + + 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: // DBNAME + return DBNAME; + case 2: // TABLENAME + return TABLENAME; + case 3: // CONSTRAINTNAME + return CONSTRAINTNAME; + 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.DBNAME, new org.apache.thrift.meta_data.FieldMetaData("dbname", org.apache.thrift.TFieldRequirementType.REQUIRED, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.TABLENAME, new org.apache.thrift.meta_data.FieldMetaData("tablename", org.apache.thrift.TFieldRequirementType.REQUIRED, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.CONSTRAINTNAME, new org.apache.thrift.meta_data.FieldMetaData("constraintname", org.apache.thrift.TFieldRequirementType.REQUIRED, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(DropConstraintRequest.class, metaDataMap); + } + + public DropConstraintRequest() { + } + + public DropConstraintRequest( + String dbname, + String tablename, + String constraintname) + { + this(); + this.dbname = dbname; + this.tablename = tablename; + this.constraintname = constraintname; + } + + /** + * Performs a deep copy on other. + */ + public DropConstraintRequest(DropConstraintRequest other) { + if (other.isSetDbname()) { + this.dbname = other.dbname; + } + if (other.isSetTablename()) { + this.tablename = other.tablename; + } + if (other.isSetConstraintname()) { + this.constraintname = other.constraintname; + } + } + + public DropConstraintRequest deepCopy() { + return new DropConstraintRequest(this); + } + + @Override + public void clear() { + this.dbname = null; + this.tablename = null; + this.constraintname = null; + } + + public String getDbname() { + return this.dbname; + } + + public void setDbname(String dbname) { + this.dbname = dbname; + } + + public void unsetDbname() { + this.dbname = null; + } + + /** Returns true if field dbname is set (has been assigned a value) and false otherwise */ + public boolean isSetDbname() { + return this.dbname != null; + } + + public void setDbnameIsSet(boolean value) { + if (!value) { + this.dbname = null; + } + } + + public String getTablename() { + return this.tablename; + } + + public void setTablename(String tablename) { + this.tablename = tablename; + } + + public void unsetTablename() { + this.tablename = null; + } + + /** Returns true if field tablename is set (has been assigned a value) and false otherwise */ + public boolean isSetTablename() { + return this.tablename != null; + } + + public void setTablenameIsSet(boolean value) { + if (!value) { + this.tablename = null; + } + } + + public String getConstraintname() { + return this.constraintname; + } + + public void setConstraintname(String constraintname) { + this.constraintname = constraintname; + } + + public void unsetConstraintname() { + this.constraintname = null; + } + + /** Returns true if field constraintname is set (has been assigned a value) and false otherwise */ + public boolean isSetConstraintname() { + return this.constraintname != null; + } + + public void setConstraintnameIsSet(boolean value) { + if (!value) { + this.constraintname = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case DBNAME: + if (value == null) { + unsetDbname(); + } else { + setDbname((String)value); + } + break; + + case TABLENAME: + if (value == null) { + unsetTablename(); + } else { + setTablename((String)value); + } + break; + + case CONSTRAINTNAME: + if (value == null) { + unsetConstraintname(); + } else { + setConstraintname((String)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case DBNAME: + return getDbname(); + + case TABLENAME: + return getTablename(); + + case CONSTRAINTNAME: + return getConstraintname(); + + } + 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 DBNAME: + return isSetDbname(); + case TABLENAME: + return isSetTablename(); + case CONSTRAINTNAME: + return isSetConstraintname(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof DropConstraintRequest) + return this.equals((DropConstraintRequest)that); + return false; + } + + public boolean equals(DropConstraintRequest that) { + if (that == null) + return false; + + boolean this_present_dbname = true && this.isSetDbname(); + boolean that_present_dbname = true && that.isSetDbname(); + if (this_present_dbname || that_present_dbname) { + if (!(this_present_dbname && that_present_dbname)) + return false; + if (!this.dbname.equals(that.dbname)) + return false; + } + + boolean this_present_tablename = true && this.isSetTablename(); + boolean that_present_tablename = true && that.isSetTablename(); + if (this_present_tablename || that_present_tablename) { + if (!(this_present_tablename && that_present_tablename)) + return false; + if (!this.tablename.equals(that.tablename)) + return false; + } + + boolean this_present_constraintname = true && this.isSetConstraintname(); + boolean that_present_constraintname = true && that.isSetConstraintname(); + if (this_present_constraintname || that_present_constraintname) { + if (!(this_present_constraintname && that_present_constraintname)) + return false; + if (!this.constraintname.equals(that.constraintname)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + boolean present_dbname = true && (isSetDbname()); + list.add(present_dbname); + if (present_dbname) + list.add(dbname); + + boolean present_tablename = true && (isSetTablename()); + list.add(present_tablename); + if (present_tablename) + list.add(tablename); + + boolean present_constraintname = true && (isSetConstraintname()); + list.add(present_constraintname); + if (present_constraintname) + list.add(constraintname); + + return list.hashCode(); + } + + @Override + public int compareTo(DropConstraintRequest other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetDbname()).compareTo(other.isSetDbname()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetDbname()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.dbname, other.dbname); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetTablename()).compareTo(other.isSetTablename()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetTablename()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tablename, other.tablename); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetConstraintname()).compareTo(other.isSetConstraintname()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetConstraintname()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.constraintname, other.constraintname); + 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("DropConstraintRequest("); + boolean first = true; + + sb.append("dbname:"); + if (this.dbname == null) { + sb.append("null"); + } else { + sb.append(this.dbname); + } + first = false; + if (!first) sb.append(", "); + sb.append("tablename:"); + if (this.tablename == null) { + sb.append("null"); + } else { + sb.append(this.tablename); + } + first = false; + if (!first) sb.append(", "); + sb.append("constraintname:"); + if (this.constraintname == null) { + sb.append("null"); + } else { + sb.append(this.constraintname); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + if (!isSetDbname()) { + throw new org.apache.thrift.protocol.TProtocolException("Required field 'dbname' is unset! Struct:" + toString()); + } + + if (!isSetTablename()) { + throw new org.apache.thrift.protocol.TProtocolException("Required field 'tablename' is unset! Struct:" + toString()); + } + + if (!isSetConstraintname()) { + throw new org.apache.thrift.protocol.TProtocolException("Required field 'constraintname' is unset! Struct:" + toString()); + } + + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + 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 DropConstraintRequestStandardSchemeFactory implements SchemeFactory { + public DropConstraintRequestStandardScheme getScheme() { + return new DropConstraintRequestStandardScheme(); + } + } + + private static class DropConstraintRequestStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, DropConstraintRequest 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: // DBNAME + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.dbname = iprot.readString(); + struct.setDbnameIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // TABLENAME + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.tablename = iprot.readString(); + struct.setTablenameIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 3: // CONSTRAINTNAME + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.constraintname = iprot.readString(); + struct.setConstraintnameIsSet(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, DropConstraintRequest struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.dbname != null) { + oprot.writeFieldBegin(DBNAME_FIELD_DESC); + oprot.writeString(struct.dbname); + oprot.writeFieldEnd(); + } + if (struct.tablename != null) { + oprot.writeFieldBegin(TABLENAME_FIELD_DESC); + oprot.writeString(struct.tablename); + oprot.writeFieldEnd(); + } + if (struct.constraintname != null) { + oprot.writeFieldBegin(CONSTRAINTNAME_FIELD_DESC); + oprot.writeString(struct.constraintname); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class DropConstraintRequestTupleSchemeFactory implements SchemeFactory { + public DropConstraintRequestTupleScheme getScheme() { + return new DropConstraintRequestTupleScheme(); + } + } + + private static class DropConstraintRequestTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, DropConstraintRequest struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + oprot.writeString(struct.dbname); + oprot.writeString(struct.tablename); + oprot.writeString(struct.constraintname); + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, DropConstraintRequest struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + struct.dbname = iprot.readString(); + struct.setDbnameIsSet(true); + struct.tablename = iprot.readString(); + struct.setTablenameIsSet(true); + struct.constraintname = iprot.readString(); + struct.setConstraintnameIsSet(true); + } + } + +} + diff --git a/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java b/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java index 051c1f2..2a81c4b 100644 --- a/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java +++ b/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java @@ -80,6 +80,8 @@ public void create_table_with_constraints(Table tbl, List primaryKeys, List foreignKeys) throws AlreadyExistsException, InvalidObjectException, MetaException, NoSuchObjectException, org.apache.thrift.TException; + public void drop_constraint(DropConstraintRequest req) throws NoSuchObjectException, MetaException, org.apache.thrift.TException; + public void drop_table(String dbname, String name, boolean deleteData) throws NoSuchObjectException, MetaException, org.apache.thrift.TException; public void drop_table_with_environment_context(String dbname, String name, boolean deleteData, EnvironmentContext environment_context) throws NoSuchObjectException, MetaException, org.apache.thrift.TException; @@ -376,6 +378,8 @@ public void create_table_with_constraints(Table tbl, List primaryKeys, List foreignKeys, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void drop_constraint(DropConstraintRequest req, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void drop_table(String dbname, String name, boolean deleteData, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; public void drop_table_with_environment_context(String dbname, String name, boolean deleteData, EnvironmentContext environment_context, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; @@ -1218,6 +1222,32 @@ public void recv_create_table_with_constraints() throws AlreadyExistsException, return; } + public void drop_constraint(DropConstraintRequest req) throws NoSuchObjectException, MetaException, org.apache.thrift.TException + { + send_drop_constraint(req); + recv_drop_constraint(); + } + + public void send_drop_constraint(DropConstraintRequest req) throws org.apache.thrift.TException + { + drop_constraint_args args = new drop_constraint_args(); + args.setReq(req); + sendBase("drop_constraint", args); + } + + public void recv_drop_constraint() throws NoSuchObjectException, MetaException, org.apache.thrift.TException + { + drop_constraint_result result = new drop_constraint_result(); + receiveBase(result, "drop_constraint"); + if (result.o1 != null) { + throw result.o1; + } + if (result.o3 != null) { + throw result.o3; + } + return; + } + public void drop_table(String dbname, String name, boolean deleteData) throws NoSuchObjectException, MetaException, org.apache.thrift.TException { send_drop_table(dbname, name, deleteData); @@ -5535,6 +5565,38 @@ public void getResult() throws AlreadyExistsException, InvalidObjectException, M } } + public void drop_constraint(DropConstraintRequest req, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + drop_constraint_call method_call = new drop_constraint_call(req, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class drop_constraint_call extends org.apache.thrift.async.TAsyncMethodCall { + private DropConstraintRequest req; + public drop_constraint_call(DropConstraintRequest req, 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.req = req; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("drop_constraint", org.apache.thrift.protocol.TMessageType.CALL, 0)); + drop_constraint_args args = new drop_constraint_args(); + args.setReq(req); + args.write(prot); + prot.writeMessageEnd(); + } + + public void getResult() throws NoSuchObjectException, MetaException, org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + (new Client(prot)).recv_drop_constraint(); + } + } + public void drop_table(String dbname, String name, boolean deleteData, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { checkReady(); drop_table_call method_call = new drop_table_call(dbname, name, deleteData, resultHandler, this, ___protocolFactory, ___transport); @@ -10078,6 +10140,7 @@ protected Processor(I iface, Map extends org.apache.thrift.ProcessFunction { + public drop_constraint() { + super("drop_constraint"); + } + + public drop_constraint_args getEmptyArgsInstance() { + return new drop_constraint_args(); + } + + protected boolean isOneway() { + return false; + } + + public drop_constraint_result getResult(I iface, drop_constraint_args args) throws org.apache.thrift.TException { + drop_constraint_result result = new drop_constraint_result(); + try { + iface.drop_constraint(args.req); + } catch (NoSuchObjectException o1) { + result.o1 = o1; + } catch (MetaException o3) { + result.o3 = o3; + } + return result; + } + } + public static class drop_table extends org.apache.thrift.ProcessFunction { public drop_table() { super("drop_table"); @@ -13964,6 +14053,7 @@ protected AsyncProcessor(I iface, Map extends org.apache.thrift.AsyncProcessFunction { - public drop_table() { - super("drop_table"); + public static class drop_constraint extends org.apache.thrift.AsyncProcessFunction { + public drop_constraint() { + super("drop_constraint"); } - public drop_table_args getEmptyArgsInstance() { - return new drop_table_args(); + public drop_constraint_args getEmptyArgsInstance() { + return new drop_constraint_args(); } public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { final org.apache.thrift.AsyncProcessFunction fcall = this; return new AsyncMethodCallback() { public void onComplete(Void o) { - drop_table_result result = new drop_table_result(); + drop_constraint_result result = new drop_constraint_result(); try { fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); return; @@ -15332,7 +15422,7 @@ public void onComplete(Void o) { public void onError(Exception e) { byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; org.apache.thrift.TBase msg; - drop_table_result result = new drop_table_result(); + drop_constraint_result result = new drop_constraint_result(); if (e instanceof NoSuchObjectException) { result.o1 = (NoSuchObjectException) e; result.setO1IsSet(true); @@ -15363,25 +15453,25 @@ protected boolean isOneway() { return false; } - public void start(I iface, drop_table_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { - iface.drop_table(args.dbname, args.name, args.deleteData,resultHandler); + public void start(I iface, drop_constraint_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.drop_constraint(args.req,resultHandler); } } - public static class drop_table_with_environment_context extends org.apache.thrift.AsyncProcessFunction { - public drop_table_with_environment_context() { - super("drop_table_with_environment_context"); + public static class drop_table extends org.apache.thrift.AsyncProcessFunction { + public drop_table() { + super("drop_table"); } - public drop_table_with_environment_context_args getEmptyArgsInstance() { - return new drop_table_with_environment_context_args(); + public drop_table_args getEmptyArgsInstance() { + return new drop_table_args(); } public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { final org.apache.thrift.AsyncProcessFunction fcall = this; return new AsyncMethodCallback() { public void onComplete(Void o) { - drop_table_with_environment_context_result result = new drop_table_with_environment_context_result(); + drop_table_result result = new drop_table_result(); try { fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); return; @@ -15393,7 +15483,7 @@ public void onComplete(Void o) { public void onError(Exception e) { byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; org.apache.thrift.TBase msg; - drop_table_with_environment_context_result result = new drop_table_with_environment_context_result(); + drop_table_result result = new drop_table_result(); if (e instanceof NoSuchObjectException) { result.o1 = (NoSuchObjectException) e; result.setO1IsSet(true); @@ -15424,259 +15514,25 @@ protected boolean isOneway() { return false; } - public void start(I iface, drop_table_with_environment_context_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { - iface.drop_table_with_environment_context(args.dbname, args.name, args.deleteData, args.environment_context,resultHandler); - } - } - - public static class get_tables extends org.apache.thrift.AsyncProcessFunction> { - public get_tables() { - super("get_tables"); - } - - public get_tables_args getEmptyArgsInstance() { - return new get_tables_args(); - } - - public AsyncMethodCallback> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { - final org.apache.thrift.AsyncProcessFunction fcall = this; - return new AsyncMethodCallback>() { - public void onComplete(List o) { - get_tables_result result = new get_tables_result(); - result.success = o; - try { - fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); - return; - } catch (Exception e) { - LOGGER.error("Exception writing to internal frame buffer", e); - } - fb.close(); - } - public void onError(Exception e) { - byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; - org.apache.thrift.TBase msg; - get_tables_result result = new get_tables_result(); - if (e instanceof MetaException) { - result.o1 = (MetaException) e; - result.setO1IsSet(true); - msg = result; - } - else - { - msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; - msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); - } - try { - fcall.sendResponse(fb,msg,msgType,seqid); - return; - } catch (Exception ex) { - LOGGER.error("Exception writing to internal frame buffer", ex); - } - fb.close(); - } - }; - } - - protected boolean isOneway() { - return false; - } - - public void start(I iface, get_tables_args args, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws TException { - iface.get_tables(args.db_name, args.pattern,resultHandler); - } - } - - public static class get_table_meta extends org.apache.thrift.AsyncProcessFunction> { - public get_table_meta() { - super("get_table_meta"); - } - - public get_table_meta_args getEmptyArgsInstance() { - return new get_table_meta_args(); - } - - public AsyncMethodCallback> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { - final org.apache.thrift.AsyncProcessFunction fcall = this; - return new AsyncMethodCallback>() { - public void onComplete(List o) { - get_table_meta_result result = new get_table_meta_result(); - result.success = o; - try { - fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); - return; - } catch (Exception e) { - LOGGER.error("Exception writing to internal frame buffer", e); - } - fb.close(); - } - public void onError(Exception e) { - byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; - org.apache.thrift.TBase msg; - get_table_meta_result result = new get_table_meta_result(); - if (e instanceof MetaException) { - result.o1 = (MetaException) e; - result.setO1IsSet(true); - msg = result; - } - else - { - msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; - msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); - } - try { - fcall.sendResponse(fb,msg,msgType,seqid); - return; - } catch (Exception ex) { - LOGGER.error("Exception writing to internal frame buffer", ex); - } - fb.close(); - } - }; - } - - protected boolean isOneway() { - return false; - } - - public void start(I iface, get_table_meta_args args, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws TException { - iface.get_table_meta(args.db_patterns, args.tbl_patterns, args.tbl_types,resultHandler); - } - } - - public static class get_all_tables extends org.apache.thrift.AsyncProcessFunction> { - public get_all_tables() { - super("get_all_tables"); - } - - public get_all_tables_args getEmptyArgsInstance() { - return new get_all_tables_args(); - } - - public AsyncMethodCallback> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { - final org.apache.thrift.AsyncProcessFunction fcall = this; - return new AsyncMethodCallback>() { - public void onComplete(List o) { - get_all_tables_result result = new get_all_tables_result(); - result.success = o; - try { - fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); - return; - } catch (Exception e) { - LOGGER.error("Exception writing to internal frame buffer", e); - } - fb.close(); - } - public void onError(Exception e) { - byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; - org.apache.thrift.TBase msg; - get_all_tables_result result = new get_all_tables_result(); - if (e instanceof MetaException) { - result.o1 = (MetaException) e; - result.setO1IsSet(true); - msg = result; - } - else - { - msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; - msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); - } - try { - fcall.sendResponse(fb,msg,msgType,seqid); - return; - } catch (Exception ex) { - LOGGER.error("Exception writing to internal frame buffer", ex); - } - fb.close(); - } - }; - } - - protected boolean isOneway() { - return false; - } - - public void start(I iface, get_all_tables_args args, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws TException { - iface.get_all_tables(args.db_name,resultHandler); - } - } - - public static class get_table extends org.apache.thrift.AsyncProcessFunction { - public get_table() { - super("get_table"); - } - - public get_table_args getEmptyArgsInstance() { - return new get_table_args(); - } - - public AsyncMethodCallback
getResultHandler(final AsyncFrameBuffer fb, final int seqid) { - final org.apache.thrift.AsyncProcessFunction fcall = this; - return new AsyncMethodCallback
() { - public void onComplete(Table o) { - get_table_result result = new get_table_result(); - result.success = o; - try { - fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); - return; - } catch (Exception e) { - LOGGER.error("Exception writing to internal frame buffer", e); - } - fb.close(); - } - public void onError(Exception e) { - byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; - org.apache.thrift.TBase msg; - get_table_result result = new get_table_result(); - if (e instanceof MetaException) { - result.o1 = (MetaException) e; - result.setO1IsSet(true); - msg = result; - } - else if (e instanceof NoSuchObjectException) { - result.o2 = (NoSuchObjectException) e; - result.setO2IsSet(true); - msg = result; - } - else - { - msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; - msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); - } - try { - fcall.sendResponse(fb,msg,msgType,seqid); - return; - } catch (Exception ex) { - LOGGER.error("Exception writing to internal frame buffer", ex); - } - fb.close(); - } - }; - } - - protected boolean isOneway() { - return false; - } - - public void start(I iface, get_table_args args, org.apache.thrift.async.AsyncMethodCallback
resultHandler) throws TException { - iface.get_table(args.dbname, args.tbl_name,resultHandler); + public void start(I iface, drop_table_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.drop_table(args.dbname, args.name, args.deleteData,resultHandler); } } - public static class get_table_objects_by_name extends org.apache.thrift.AsyncProcessFunction> { - public get_table_objects_by_name() { - super("get_table_objects_by_name"); + public static class drop_table_with_environment_context extends org.apache.thrift.AsyncProcessFunction { + public drop_table_with_environment_context() { + super("drop_table_with_environment_context"); } - public get_table_objects_by_name_args getEmptyArgsInstance() { - return new get_table_objects_by_name_args(); + public drop_table_with_environment_context_args getEmptyArgsInstance() { + return new drop_table_with_environment_context_args(); } - public AsyncMethodCallback> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { final org.apache.thrift.AsyncProcessFunction fcall = this; - return new AsyncMethodCallback>() { - public void onComplete(List
o) { - get_table_objects_by_name_result result = new get_table_objects_by_name_result(); - result.success = o; + return new AsyncMethodCallback() { + public void onComplete(Void o) { + drop_table_with_environment_context_result result = new drop_table_with_environment_context_result(); try { fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); return; @@ -15688,19 +15544,14 @@ public void onComplete(List
o) { public void onError(Exception e) { byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; org.apache.thrift.TBase msg; - get_table_objects_by_name_result result = new get_table_objects_by_name_result(); - if (e instanceof MetaException) { - result.o1 = (MetaException) e; + drop_table_with_environment_context_result result = new drop_table_with_environment_context_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 UnknownDBException) { - result.o3 = (UnknownDBException) e; + else if (e instanceof MetaException) { + result.o3 = (MetaException) e; result.setO3IsSet(true); msg = result; } @@ -15724,25 +15575,25 @@ protected boolean isOneway() { return false; } - public void start(I iface, get_table_objects_by_name_args args, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws TException { - iface.get_table_objects_by_name(args.dbname, args.tbl_names,resultHandler); + public void start(I iface, drop_table_with_environment_context_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.drop_table_with_environment_context(args.dbname, args.name, args.deleteData, args.environment_context,resultHandler); } } - public static class get_table_names_by_filter extends org.apache.thrift.AsyncProcessFunction> { - public get_table_names_by_filter() { - super("get_table_names_by_filter"); + public static class get_tables extends org.apache.thrift.AsyncProcessFunction> { + public get_tables() { + super("get_tables"); } - public get_table_names_by_filter_args getEmptyArgsInstance() { - return new get_table_names_by_filter_args(); + public get_tables_args getEmptyArgsInstance() { + return new get_tables_args(); } public AsyncMethodCallback> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { final org.apache.thrift.AsyncProcessFunction fcall = this; return new AsyncMethodCallback>() { public void onComplete(List o) { - get_table_names_by_filter_result result = new get_table_names_by_filter_result(); + get_tables_result result = new get_tables_result(); result.success = o; try { fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); @@ -15755,22 +15606,12 @@ public void onComplete(List o) { public void onError(Exception e) { byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; org.apache.thrift.TBase msg; - get_table_names_by_filter_result result = new get_table_names_by_filter_result(); + get_tables_result result = new get_tables_result(); if (e instanceof MetaException) { result.o1 = (MetaException) e; result.setO1IsSet(true); msg = result; } - else if (e instanceof InvalidOperationException) { - result.o2 = (InvalidOperationException) e; - result.setO2IsSet(true); - msg = result; - } - else if (e instanceof UnknownDBException) { - result.o3 = (UnknownDBException) e; - result.setO3IsSet(true); - msg = result; - } else { msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; @@ -15791,25 +15632,26 @@ protected boolean isOneway() { return false; } - public void start(I iface, get_table_names_by_filter_args args, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws TException { - iface.get_table_names_by_filter(args.dbname, args.filter, args.max_tables,resultHandler); + public void start(I iface, get_tables_args args, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws TException { + iface.get_tables(args.db_name, args.pattern,resultHandler); } } - public static class alter_table extends org.apache.thrift.AsyncProcessFunction { - public alter_table() { - super("alter_table"); + public static class get_table_meta extends org.apache.thrift.AsyncProcessFunction> { + public get_table_meta() { + super("get_table_meta"); } - public alter_table_args getEmptyArgsInstance() { - return new alter_table_args(); + public get_table_meta_args getEmptyArgsInstance() { + return new get_table_meta_args(); } - public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + public AsyncMethodCallback> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { final org.apache.thrift.AsyncProcessFunction fcall = this; - return new AsyncMethodCallback() { - public void onComplete(Void o) { - alter_table_result result = new alter_table_result(); + return new AsyncMethodCallback>() { + public void onComplete(List o) { + get_table_meta_result result = new get_table_meta_result(); + result.success = o; try { fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); return; @@ -15821,17 +15663,12 @@ public void onComplete(Void o) { public void onError(Exception e) { byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; org.apache.thrift.TBase msg; - alter_table_result result = new alter_table_result(); - if (e instanceof InvalidOperationException) { - result.o1 = (InvalidOperationException) e; + get_table_meta_result result = new get_table_meta_result(); + if (e instanceof MetaException) { + result.o1 = (MetaException) e; result.setO1IsSet(true); msg = result; } - else if (e instanceof MetaException) { - result.o2 = (MetaException) e; - result.setO2IsSet(true); - msg = result; - } else { msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; @@ -15852,25 +15689,26 @@ protected boolean isOneway() { return false; } - public void start(I iface, alter_table_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { - iface.alter_table(args.dbname, args.tbl_name, args.new_tbl,resultHandler); + public void start(I iface, get_table_meta_args args, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws TException { + iface.get_table_meta(args.db_patterns, args.tbl_patterns, args.tbl_types,resultHandler); } } - public static class alter_table_with_environment_context extends org.apache.thrift.AsyncProcessFunction { - public alter_table_with_environment_context() { - super("alter_table_with_environment_context"); + public static class get_all_tables extends org.apache.thrift.AsyncProcessFunction> { + public get_all_tables() { + super("get_all_tables"); } - public alter_table_with_environment_context_args getEmptyArgsInstance() { - return new alter_table_with_environment_context_args(); + public get_all_tables_args getEmptyArgsInstance() { + return new get_all_tables_args(); } - public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + public AsyncMethodCallback> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { final org.apache.thrift.AsyncProcessFunction fcall = this; - return new AsyncMethodCallback() { - public void onComplete(Void o) { - alter_table_with_environment_context_result result = new alter_table_with_environment_context_result(); + return new AsyncMethodCallback>() { + public void onComplete(List o) { + get_all_tables_result result = new get_all_tables_result(); + result.success = o; try { fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); return; @@ -15882,17 +15720,12 @@ public void onComplete(Void o) { public void onError(Exception e) { byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; org.apache.thrift.TBase msg; - alter_table_with_environment_context_result result = new alter_table_with_environment_context_result(); - if (e instanceof InvalidOperationException) { - result.o1 = (InvalidOperationException) e; + get_all_tables_result result = new get_all_tables_result(); + if (e instanceof MetaException) { + result.o1 = (MetaException) e; result.setO1IsSet(true); msg = result; } - else if (e instanceof MetaException) { - result.o2 = (MetaException) e; - result.setO2IsSet(true); - msg = result; - } else { msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; @@ -15913,25 +15746,26 @@ protected boolean isOneway() { return false; } - public void start(I iface, alter_table_with_environment_context_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { - iface.alter_table_with_environment_context(args.dbname, args.tbl_name, args.new_tbl, args.environment_context,resultHandler); + public void start(I iface, get_all_tables_args args, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws TException { + iface.get_all_tables(args.db_name,resultHandler); } } - public static class alter_table_with_cascade extends org.apache.thrift.AsyncProcessFunction { - public alter_table_with_cascade() { - super("alter_table_with_cascade"); + public static class get_table extends org.apache.thrift.AsyncProcessFunction { + public get_table() { + super("get_table"); } - public alter_table_with_cascade_args getEmptyArgsInstance() { - return new alter_table_with_cascade_args(); + public get_table_args getEmptyArgsInstance() { + return new get_table_args(); } - public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + public AsyncMethodCallback
getResultHandler(final AsyncFrameBuffer fb, final int seqid) { final org.apache.thrift.AsyncProcessFunction fcall = this; - return new AsyncMethodCallback() { - public void onComplete(Void o) { - alter_table_with_cascade_result result = new alter_table_with_cascade_result(); + return new AsyncMethodCallback
() { + public void onComplete(Table o) { + get_table_result result = new get_table_result(); + result.success = o; try { fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); return; @@ -15943,14 +15777,14 @@ public void onComplete(Void o) { public void onError(Exception e) { byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; org.apache.thrift.TBase msg; - alter_table_with_cascade_result result = new alter_table_with_cascade_result(); - if (e instanceof InvalidOperationException) { - result.o1 = (InvalidOperationException) e; + get_table_result result = new get_table_result(); + if (e instanceof MetaException) { + result.o1 = (MetaException) e; result.setO1IsSet(true); msg = result; } - else if (e instanceof MetaException) { - result.o2 = (MetaException) e; + else if (e instanceof NoSuchObjectException) { + result.o2 = (NoSuchObjectException) e; result.setO2IsSet(true); msg = result; } @@ -15974,25 +15808,25 @@ protected boolean isOneway() { return false; } - public void start(I iface, alter_table_with_cascade_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { - iface.alter_table_with_cascade(args.dbname, args.tbl_name, args.new_tbl, args.cascade,resultHandler); + public void start(I iface, get_table_args args, org.apache.thrift.async.AsyncMethodCallback
resultHandler) throws TException { + iface.get_table(args.dbname, args.tbl_name,resultHandler); } } - public static class add_partition extends org.apache.thrift.AsyncProcessFunction { - public add_partition() { - super("add_partition"); + public static class get_table_objects_by_name extends org.apache.thrift.AsyncProcessFunction> { + public get_table_objects_by_name() { + super("get_table_objects_by_name"); } - public add_partition_args getEmptyArgsInstance() { - return new add_partition_args(); + public get_table_objects_by_name_args getEmptyArgsInstance() { + return new get_table_objects_by_name_args(); } - public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + public AsyncMethodCallback> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { final org.apache.thrift.AsyncProcessFunction fcall = this; - return new AsyncMethodCallback() { - public void onComplete(Partition o) { - add_partition_result result = new add_partition_result(); + return new AsyncMethodCallback>() { + public void onComplete(List
o) { + get_table_objects_by_name_result result = new get_table_objects_by_name_result(); result.success = o; try { fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); @@ -16005,19 +15839,19 @@ public void onComplete(Partition o) { public void onError(Exception e) { byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; org.apache.thrift.TBase msg; - add_partition_result result = new add_partition_result(); - if (e instanceof InvalidObjectException) { - result.o1 = (InvalidObjectException) e; + get_table_objects_by_name_result result = new get_table_objects_by_name_result(); + if (e instanceof MetaException) { + result.o1 = (MetaException) e; result.setO1IsSet(true); msg = result; } - else if (e instanceof AlreadyExistsException) { - result.o2 = (AlreadyExistsException) e; + else if (e instanceof InvalidOperationException) { + result.o2 = (InvalidOperationException) e; result.setO2IsSet(true); msg = result; } - else if (e instanceof MetaException) { - result.o3 = (MetaException) e; + else if (e instanceof UnknownDBException) { + result.o3 = (UnknownDBException) e; result.setO3IsSet(true); msg = result; } @@ -16041,25 +15875,25 @@ protected boolean isOneway() { return false; } - public void start(I iface, add_partition_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { - iface.add_partition(args.new_part,resultHandler); + public void start(I iface, get_table_objects_by_name_args args, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws TException { + iface.get_table_objects_by_name(args.dbname, args.tbl_names,resultHandler); } } - public static class add_partition_with_environment_context extends org.apache.thrift.AsyncProcessFunction { - public add_partition_with_environment_context() { - super("add_partition_with_environment_context"); + public static class get_table_names_by_filter extends org.apache.thrift.AsyncProcessFunction> { + public get_table_names_by_filter() { + super("get_table_names_by_filter"); } - public add_partition_with_environment_context_args getEmptyArgsInstance() { - return new add_partition_with_environment_context_args(); + public get_table_names_by_filter_args getEmptyArgsInstance() { + return new get_table_names_by_filter_args(); } - public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + public AsyncMethodCallback> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { final org.apache.thrift.AsyncProcessFunction fcall = this; - return new AsyncMethodCallback() { - public void onComplete(Partition o) { - add_partition_with_environment_context_result result = new add_partition_with_environment_context_result(); + return new AsyncMethodCallback>() { + public void onComplete(List o) { + get_table_names_by_filter_result result = new get_table_names_by_filter_result(); result.success = o; try { fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); @@ -16072,19 +15906,19 @@ public void onComplete(Partition o) { public void onError(Exception e) { byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; org.apache.thrift.TBase msg; - add_partition_with_environment_context_result result = new add_partition_with_environment_context_result(); - if (e instanceof InvalidObjectException) { - result.o1 = (InvalidObjectException) e; + get_table_names_by_filter_result result = new get_table_names_by_filter_result(); + if (e instanceof MetaException) { + result.o1 = (MetaException) e; result.setO1IsSet(true); msg = result; } - else if (e instanceof AlreadyExistsException) { - result.o2 = (AlreadyExistsException) e; + else if (e instanceof InvalidOperationException) { + result.o2 = (InvalidOperationException) e; result.setO2IsSet(true); msg = result; } - else if (e instanceof MetaException) { - result.o3 = (MetaException) e; + else if (e instanceof UnknownDBException) { + result.o3 = (UnknownDBException) e; result.setO3IsSet(true); msg = result; } @@ -16108,27 +15942,25 @@ protected boolean isOneway() { return false; } - public void start(I iface, add_partition_with_environment_context_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { - iface.add_partition_with_environment_context(args.new_part, args.environment_context,resultHandler); + public void start(I iface, get_table_names_by_filter_args args, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws TException { + iface.get_table_names_by_filter(args.dbname, args.filter, args.max_tables,resultHandler); } } - public static class add_partitions extends org.apache.thrift.AsyncProcessFunction { - public add_partitions() { - super("add_partitions"); + public static class alter_table extends org.apache.thrift.AsyncProcessFunction { + public alter_table() { + super("alter_table"); } - public add_partitions_args getEmptyArgsInstance() { - return new add_partitions_args(); + public alter_table_args getEmptyArgsInstance() { + return new alter_table_args(); } - public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { final org.apache.thrift.AsyncProcessFunction fcall = this; - return new AsyncMethodCallback() { - public void onComplete(Integer o) { - add_partitions_result result = new add_partitions_result(); - result.success = o; - result.setSuccessIsSet(true); + return new AsyncMethodCallback() { + public void onComplete(Void o) { + alter_table_result result = new alter_table_result(); try { fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); return; @@ -16140,20 +15972,15 @@ public void onComplete(Integer o) { public void onError(Exception e) { byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; org.apache.thrift.TBase msg; - add_partitions_result result = new add_partitions_result(); - if (e instanceof InvalidObjectException) { - result.o1 = (InvalidObjectException) e; + alter_table_result result = new alter_table_result(); + if (e instanceof InvalidOperationException) { + result.o1 = (InvalidOperationException) e; result.setO1IsSet(true); msg = result; } - else if (e instanceof AlreadyExistsException) { - result.o2 = (AlreadyExistsException) e; - result.setO2IsSet(true); - msg = result; - } else if (e instanceof MetaException) { - result.o3 = (MetaException) e; - result.setO3IsSet(true); + result.o2 = (MetaException) e; + result.setO2IsSet(true); msg = result; } else @@ -16176,27 +16003,25 @@ protected boolean isOneway() { return false; } - public void start(I iface, add_partitions_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { - iface.add_partitions(args.new_parts,resultHandler); + public void start(I iface, alter_table_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.alter_table(args.dbname, args.tbl_name, args.new_tbl,resultHandler); } } - public static class add_partitions_pspec extends org.apache.thrift.AsyncProcessFunction { - public add_partitions_pspec() { - super("add_partitions_pspec"); + public static class alter_table_with_environment_context extends org.apache.thrift.AsyncProcessFunction { + public alter_table_with_environment_context() { + super("alter_table_with_environment_context"); } - public add_partitions_pspec_args getEmptyArgsInstance() { - return new add_partitions_pspec_args(); + public alter_table_with_environment_context_args getEmptyArgsInstance() { + return new alter_table_with_environment_context_args(); } - public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { final org.apache.thrift.AsyncProcessFunction fcall = this; - return new AsyncMethodCallback() { - public void onComplete(Integer o) { - add_partitions_pspec_result result = new add_partitions_pspec_result(); - result.success = o; - result.setSuccessIsSet(true); + return new AsyncMethodCallback() { + public void onComplete(Void o) { + alter_table_with_environment_context_result result = new alter_table_with_environment_context_result(); try { fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); return; @@ -16208,20 +16033,15 @@ public void onComplete(Integer o) { public void onError(Exception e) { byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; org.apache.thrift.TBase msg; - add_partitions_pspec_result result = new add_partitions_pspec_result(); - if (e instanceof InvalidObjectException) { - result.o1 = (InvalidObjectException) e; + alter_table_with_environment_context_result result = new alter_table_with_environment_context_result(); + if (e instanceof InvalidOperationException) { + result.o1 = (InvalidOperationException) e; result.setO1IsSet(true); msg = result; } - else if (e instanceof AlreadyExistsException) { - result.o2 = (AlreadyExistsException) e; - result.setO2IsSet(true); - msg = result; - } else if (e instanceof MetaException) { - result.o3 = (MetaException) e; - result.setO3IsSet(true); + result.o2 = (MetaException) e; + result.setO2IsSet(true); msg = result; } else @@ -16244,26 +16064,25 @@ protected boolean isOneway() { return false; } - public void start(I iface, add_partitions_pspec_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { - iface.add_partitions_pspec(args.new_parts,resultHandler); + public void start(I iface, alter_table_with_environment_context_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.alter_table_with_environment_context(args.dbname, args.tbl_name, args.new_tbl, args.environment_context,resultHandler); } } - public static class append_partition extends org.apache.thrift.AsyncProcessFunction { - public append_partition() { - super("append_partition"); + public static class alter_table_with_cascade extends org.apache.thrift.AsyncProcessFunction { + public alter_table_with_cascade() { + super("alter_table_with_cascade"); } - public append_partition_args getEmptyArgsInstance() { - return new append_partition_args(); + public alter_table_with_cascade_args getEmptyArgsInstance() { + return new alter_table_with_cascade_args(); } - public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { final org.apache.thrift.AsyncProcessFunction fcall = this; - return new AsyncMethodCallback() { - public void onComplete(Partition o) { - append_partition_result result = new append_partition_result(); - result.success = o; + return new AsyncMethodCallback() { + public void onComplete(Void o) { + alter_table_with_cascade_result result = new alter_table_with_cascade_result(); try { fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); return; @@ -16275,20 +16094,15 @@ public void onComplete(Partition o) { public void onError(Exception e) { byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; org.apache.thrift.TBase msg; - append_partition_result result = new append_partition_result(); - if (e instanceof InvalidObjectException) { - result.o1 = (InvalidObjectException) e; + alter_table_with_cascade_result result = new alter_table_with_cascade_result(); + if (e instanceof InvalidOperationException) { + result.o1 = (InvalidOperationException) e; result.setO1IsSet(true); msg = result; } - else if (e instanceof AlreadyExistsException) { - result.o2 = (AlreadyExistsException) e; - result.setO2IsSet(true); - msg = result; - } else if (e instanceof MetaException) { - result.o3 = (MetaException) e; - result.setO3IsSet(true); + result.o2 = (MetaException) e; + result.setO2IsSet(true); msg = result; } else @@ -16311,25 +16125,25 @@ protected boolean isOneway() { return false; } - public void start(I iface, append_partition_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { - iface.append_partition(args.db_name, args.tbl_name, args.part_vals,resultHandler); + public void start(I iface, alter_table_with_cascade_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.alter_table_with_cascade(args.dbname, args.tbl_name, args.new_tbl, args.cascade,resultHandler); } } - public static class add_partitions_req extends org.apache.thrift.AsyncProcessFunction { - public add_partitions_req() { - super("add_partitions_req"); + public static class add_partition extends org.apache.thrift.AsyncProcessFunction { + public add_partition() { + super("add_partition"); } - public add_partitions_req_args getEmptyArgsInstance() { - return new add_partitions_req_args(); + public add_partition_args getEmptyArgsInstance() { + return new add_partition_args(); } - public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { final org.apache.thrift.AsyncProcessFunction fcall = this; - return new AsyncMethodCallback() { - public void onComplete(AddPartitionsResult o) { - add_partitions_req_result result = new add_partitions_req_result(); + return new AsyncMethodCallback() { + public void onComplete(Partition o) { + add_partition_result result = new add_partition_result(); result.success = o; try { fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); @@ -16342,7 +16156,7 @@ public void onComplete(AddPartitionsResult o) { public void onError(Exception e) { byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; org.apache.thrift.TBase msg; - add_partitions_req_result result = new add_partitions_req_result(); + add_partition_result result = new add_partition_result(); if (e instanceof InvalidObjectException) { result.o1 = (InvalidObjectException) e; result.setO1IsSet(true); @@ -16378,25 +16192,25 @@ protected boolean isOneway() { return false; } - public void start(I iface, add_partitions_req_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { - iface.add_partitions_req(args.request,resultHandler); + public void start(I iface, add_partition_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.add_partition(args.new_part,resultHandler); } } - public static class append_partition_with_environment_context extends org.apache.thrift.AsyncProcessFunction { - public append_partition_with_environment_context() { - super("append_partition_with_environment_context"); + public static class add_partition_with_environment_context extends org.apache.thrift.AsyncProcessFunction { + public add_partition_with_environment_context() { + super("add_partition_with_environment_context"); } - public append_partition_with_environment_context_args getEmptyArgsInstance() { - return new append_partition_with_environment_context_args(); + public add_partition_with_environment_context_args getEmptyArgsInstance() { + return new add_partition_with_environment_context_args(); } public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { final org.apache.thrift.AsyncProcessFunction fcall = this; return new AsyncMethodCallback() { public void onComplete(Partition o) { - append_partition_with_environment_context_result result = new append_partition_with_environment_context_result(); + add_partition_with_environment_context_result result = new add_partition_with_environment_context_result(); result.success = o; try { fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); @@ -16409,7 +16223,7 @@ public void onComplete(Partition o) { public void onError(Exception e) { byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; org.apache.thrift.TBase msg; - append_partition_with_environment_context_result result = new append_partition_with_environment_context_result(); + add_partition_with_environment_context_result result = new add_partition_with_environment_context_result(); if (e instanceof InvalidObjectException) { result.o1 = (InvalidObjectException) e; result.setO1IsSet(true); @@ -16445,26 +16259,27 @@ protected boolean isOneway() { return false; } - public void start(I iface, append_partition_with_environment_context_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { - iface.append_partition_with_environment_context(args.db_name, args.tbl_name, args.part_vals, args.environment_context,resultHandler); + public void start(I iface, add_partition_with_environment_context_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.add_partition_with_environment_context(args.new_part, args.environment_context,resultHandler); } } - public static class append_partition_by_name extends org.apache.thrift.AsyncProcessFunction { - public append_partition_by_name() { - super("append_partition_by_name"); + public static class add_partitions extends org.apache.thrift.AsyncProcessFunction { + public add_partitions() { + super("add_partitions"); } - public append_partition_by_name_args getEmptyArgsInstance() { - return new append_partition_by_name_args(); + public add_partitions_args getEmptyArgsInstance() { + return new add_partitions_args(); } - public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { final org.apache.thrift.AsyncProcessFunction fcall = this; - return new AsyncMethodCallback() { - public void onComplete(Partition o) { - append_partition_by_name_result result = new append_partition_by_name_result(); + return new AsyncMethodCallback() { + public void onComplete(Integer o) { + add_partitions_result result = new add_partitions_result(); result.success = o; + result.setSuccessIsSet(true); try { fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); return; @@ -16476,7 +16291,7 @@ public void onComplete(Partition o) { public void onError(Exception e) { byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; org.apache.thrift.TBase msg; - append_partition_by_name_result result = new append_partition_by_name_result(); + add_partitions_result result = new add_partitions_result(); if (e instanceof InvalidObjectException) { result.o1 = (InvalidObjectException) e; result.setO1IsSet(true); @@ -16512,26 +16327,27 @@ protected boolean isOneway() { return false; } - public void start(I iface, append_partition_by_name_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { - iface.append_partition_by_name(args.db_name, args.tbl_name, args.part_name,resultHandler); + public void start(I iface, add_partitions_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.add_partitions(args.new_parts,resultHandler); } } - public static class append_partition_by_name_with_environment_context extends org.apache.thrift.AsyncProcessFunction { - public append_partition_by_name_with_environment_context() { - super("append_partition_by_name_with_environment_context"); + public static class add_partitions_pspec extends org.apache.thrift.AsyncProcessFunction { + public add_partitions_pspec() { + super("add_partitions_pspec"); } - public append_partition_by_name_with_environment_context_args getEmptyArgsInstance() { - return new append_partition_by_name_with_environment_context_args(); + public add_partitions_pspec_args getEmptyArgsInstance() { + return new add_partitions_pspec_args(); } - public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { final org.apache.thrift.AsyncProcessFunction fcall = this; - return new AsyncMethodCallback() { - public void onComplete(Partition o) { - append_partition_by_name_with_environment_context_result result = new append_partition_by_name_with_environment_context_result(); + return new AsyncMethodCallback() { + public void onComplete(Integer o) { + add_partitions_pspec_result result = new add_partitions_pspec_result(); result.success = o; + result.setSuccessIsSet(true); try { fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); return; @@ -16543,7 +16359,342 @@ public void onComplete(Partition o) { public void onError(Exception e) { byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; org.apache.thrift.TBase msg; - append_partition_by_name_with_environment_context_result result = new append_partition_by_name_with_environment_context_result(); + add_partitions_pspec_result result = new add_partitions_pspec_result(); + if (e instanceof InvalidObjectException) { + result.o1 = (InvalidObjectException) e; + result.setO1IsSet(true); + msg = result; + } + else if (e instanceof AlreadyExistsException) { + result.o2 = (AlreadyExistsException) 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, add_partitions_pspec_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.add_partitions_pspec(args.new_parts,resultHandler); + } + } + + public static class append_partition extends org.apache.thrift.AsyncProcessFunction { + public append_partition() { + super("append_partition"); + } + + public append_partition_args getEmptyArgsInstance() { + return new append_partition_args(); + } + + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback() { + public void onComplete(Partition o) { + append_partition_result result = new append_partition_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; + append_partition_result result = new append_partition_result(); + if (e instanceof InvalidObjectException) { + result.o1 = (InvalidObjectException) e; + result.setO1IsSet(true); + msg = result; + } + else if (e instanceof AlreadyExistsException) { + result.o2 = (AlreadyExistsException) 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, append_partition_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.append_partition(args.db_name, args.tbl_name, args.part_vals,resultHandler); + } + } + + public static class add_partitions_req extends org.apache.thrift.AsyncProcessFunction { + public add_partitions_req() { + super("add_partitions_req"); + } + + public add_partitions_req_args getEmptyArgsInstance() { + return new add_partitions_req_args(); + } + + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback() { + public void onComplete(AddPartitionsResult o) { + add_partitions_req_result result = new add_partitions_req_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; + add_partitions_req_result result = new add_partitions_req_result(); + if (e instanceof InvalidObjectException) { + result.o1 = (InvalidObjectException) e; + result.setO1IsSet(true); + msg = result; + } + else if (e instanceof AlreadyExistsException) { + result.o2 = (AlreadyExistsException) 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, add_partitions_req_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.add_partitions_req(args.request,resultHandler); + } + } + + public static class append_partition_with_environment_context extends org.apache.thrift.AsyncProcessFunction { + public append_partition_with_environment_context() { + super("append_partition_with_environment_context"); + } + + public append_partition_with_environment_context_args getEmptyArgsInstance() { + return new append_partition_with_environment_context_args(); + } + + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback() { + public void onComplete(Partition o) { + append_partition_with_environment_context_result result = new append_partition_with_environment_context_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; + append_partition_with_environment_context_result result = new append_partition_with_environment_context_result(); + if (e instanceof InvalidObjectException) { + result.o1 = (InvalidObjectException) e; + result.setO1IsSet(true); + msg = result; + } + else if (e instanceof AlreadyExistsException) { + result.o2 = (AlreadyExistsException) 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, append_partition_with_environment_context_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.append_partition_with_environment_context(args.db_name, args.tbl_name, args.part_vals, args.environment_context,resultHandler); + } + } + + public static class append_partition_by_name extends org.apache.thrift.AsyncProcessFunction { + public append_partition_by_name() { + super("append_partition_by_name"); + } + + public append_partition_by_name_args getEmptyArgsInstance() { + return new append_partition_by_name_args(); + } + + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback() { + public void onComplete(Partition o) { + append_partition_by_name_result result = new append_partition_by_name_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; + append_partition_by_name_result result = new append_partition_by_name_result(); + if (e instanceof InvalidObjectException) { + result.o1 = (InvalidObjectException) e; + result.setO1IsSet(true); + msg = result; + } + else if (e instanceof AlreadyExistsException) { + result.o2 = (AlreadyExistsException) 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, append_partition_by_name_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.append_partition_by_name(args.db_name, args.tbl_name, args.part_name,resultHandler); + } + } + + public static class append_partition_by_name_with_environment_context extends org.apache.thrift.AsyncProcessFunction { + public append_partition_by_name_with_environment_context() { + super("append_partition_by_name_with_environment_context"); + } + + public append_partition_by_name_with_environment_context_args getEmptyArgsInstance() { + return new append_partition_by_name_with_environment_context_args(); + } + + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback() { + public void onComplete(Partition o) { + append_partition_by_name_with_environment_context_result result = new append_partition_by_name_with_environment_context_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; + append_partition_by_name_with_environment_context_result result = new append_partition_by_name_with_environment_context_result(); if (e instanceof InvalidObjectException) { result.o1 = (InvalidObjectException) e; result.setO1IsSet(true); @@ -42513,6 +42664,835 @@ public void read(org.apache.thrift.protocol.TProtocol prot, create_table_with_co } + public static class drop_constraint_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_constraint_args"); + + private static final org.apache.thrift.protocol.TField REQ_FIELD_DESC = new org.apache.thrift.protocol.TField("req", org.apache.thrift.protocol.TType.STRUCT, (short)1); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new drop_constraint_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new drop_constraint_argsTupleSchemeFactory()); + } + + private DropConstraintRequest req; // 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 { + REQ((short)1, "req"); + + 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: // REQ + return REQ; + 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.REQ, new org.apache.thrift.meta_data.FieldMetaData("req", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, DropConstraintRequest.class))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(drop_constraint_args.class, metaDataMap); + } + + public drop_constraint_args() { + } + + public drop_constraint_args( + DropConstraintRequest req) + { + this(); + this.req = req; + } + + /** + * Performs a deep copy on other. + */ + public drop_constraint_args(drop_constraint_args other) { + if (other.isSetReq()) { + this.req = new DropConstraintRequest(other.req); + } + } + + public drop_constraint_args deepCopy() { + return new drop_constraint_args(this); + } + + @Override + public void clear() { + this.req = null; + } + + public DropConstraintRequest getReq() { + return this.req; + } + + public void setReq(DropConstraintRequest req) { + this.req = req; + } + + public void unsetReq() { + this.req = null; + } + + /** Returns true if field req is set (has been assigned a value) and false otherwise */ + public boolean isSetReq() { + return this.req != null; + } + + public void setReqIsSet(boolean value) { + if (!value) { + this.req = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case REQ: + if (value == null) { + unsetReq(); + } else { + setReq((DropConstraintRequest)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case REQ: + return getReq(); + + } + 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 REQ: + return isSetReq(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof drop_constraint_args) + return this.equals((drop_constraint_args)that); + return false; + } + + public boolean equals(drop_constraint_args that) { + if (that == null) + return false; + + boolean this_present_req = true && this.isSetReq(); + boolean that_present_req = true && that.isSetReq(); + if (this_present_req || that_present_req) { + if (!(this_present_req && that_present_req)) + return false; + if (!this.req.equals(that.req)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + boolean present_req = true && (isSetReq()); + list.add(present_req); + if (present_req) + list.add(req); + + return list.hashCode(); + } + + @Override + public int compareTo(drop_constraint_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetReq()).compareTo(other.isSetReq()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetReq()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.req, other.req); + 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("drop_constraint_args("); + boolean first = true; + + sb.append("req:"); + if (this.req == null) { + sb.append("null"); + } else { + sb.append(this.req); + } + 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 (req != null) { + req.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 drop_constraint_argsStandardSchemeFactory implements SchemeFactory { + public drop_constraint_argsStandardScheme getScheme() { + return new drop_constraint_argsStandardScheme(); + } + } + + private static class drop_constraint_argsStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, drop_constraint_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: // REQ + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.req = new DropConstraintRequest(); + struct.req.read(iprot); + struct.setReqIsSet(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, drop_constraint_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.req != null) { + oprot.writeFieldBegin(REQ_FIELD_DESC); + struct.req.write(oprot); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class drop_constraint_argsTupleSchemeFactory implements SchemeFactory { + public drop_constraint_argsTupleScheme getScheme() { + return new drop_constraint_argsTupleScheme(); + } + } + + private static class drop_constraint_argsTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, drop_constraint_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetReq()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetReq()) { + struct.req.write(oprot); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, drop_constraint_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.req = new DropConstraintRequest(); + struct.req.read(iprot); + struct.setReqIsSet(true); + } + } + } + + } + + public static class drop_constraint_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_constraint_result"); + + 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 O3_FIELD_DESC = new org.apache.thrift.protocol.TField("o3", org.apache.thrift.protocol.TType.STRUCT, (short)2); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new drop_constraint_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new drop_constraint_resultTupleSchemeFactory()); + } + + private NoSuchObjectException o1; // 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 { + O1((short)1, "o1"), + O3((short)2, "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 1: // O1 + return O1; + case 2: // 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.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.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_constraint_result.class, metaDataMap); + } + + public drop_constraint_result() { + } + + public drop_constraint_result( + NoSuchObjectException o1, + MetaException o3) + { + this(); + this.o1 = o1; + this.o3 = o3; + } + + /** + * Performs a deep copy on other. + */ + public drop_constraint_result(drop_constraint_result other) { + if (other.isSetO1()) { + this.o1 = new NoSuchObjectException(other.o1); + } + if (other.isSetO3()) { + this.o3 = new MetaException(other.o3); + } + } + + public drop_constraint_result deepCopy() { + return new drop_constraint_result(this); + } + + @Override + public void clear() { + this.o1 = null; + this.o3 = 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 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 O1: + if (value == null) { + unsetO1(); + } else { + setO1((NoSuchObjectException)value); + } + break; + + case O3: + if (value == null) { + unsetO3(); + } else { + setO3((MetaException)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case O1: + return getO1(); + + 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 O1: + return isSetO1(); + case O3: + return isSetO3(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof drop_constraint_result) + return this.equals((drop_constraint_result)that); + return false; + } + + public boolean equals(drop_constraint_result that) { + if (that == null) + 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_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_o1 = true && (isSetO1()); + list.add(present_o1); + if (present_o1) + list.add(o1); + + boolean present_o3 = true && (isSetO3()); + list.add(present_o3); + if (present_o3) + list.add(o3); + + return list.hashCode(); + } + + @Override + public int compareTo(drop_constraint_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + 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(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("drop_constraint_result("); + boolean first = true; + + sb.append("o1:"); + if (this.o1 == null) { + sb.append("null"); + } else { + sb.append(this.o1); + } + 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 + } + + 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 drop_constraint_resultStandardSchemeFactory implements SchemeFactory { + public drop_constraint_resultStandardScheme getScheme() { + return new drop_constraint_resultStandardScheme(); + } + } + + private static class drop_constraint_resultStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, drop_constraint_result struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField schemeField; + iprot.readStructBegin(); + while (true) + { + schemeField = iprot.readFieldBegin(); + if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (schemeField.id) { + case 1: // O1 + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.o1 = new NoSuchObjectException(); + struct.o1.read(iprot); + struct.setO1IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // 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, drop_constraint_result struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.o1 != null) { + oprot.writeFieldBegin(O1_FIELD_DESC); + struct.o1.write(oprot); + oprot.writeFieldEnd(); + } + if (struct.o3 != null) { + oprot.writeFieldBegin(O3_FIELD_DESC); + struct.o3.write(oprot); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class drop_constraint_resultTupleSchemeFactory implements SchemeFactory { + public drop_constraint_resultTupleScheme getScheme() { + return new drop_constraint_resultTupleScheme(); + } + } + + private static class drop_constraint_resultTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, drop_constraint_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetO1()) { + optionals.set(0); + } + if (struct.isSetO3()) { + optionals.set(1); + } + oprot.writeBitSet(optionals, 2); + if (struct.isSetO1()) { + struct.o1.write(oprot); + } + if (struct.isSetO3()) { + struct.o3.write(oprot); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, drop_constraint_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(2); + if (incoming.get(0)) { + struct.o1 = new NoSuchObjectException(); + struct.o1.read(iprot); + struct.setO1IsSet(true); + } + if (incoming.get(1)) { + struct.o3 = new MetaException(); + struct.o3.read(iprot); + struct.setO3IsSet(true); + } + } + } + + } + public static class drop_table_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_table_args"); diff --git a/metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php b/metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php index 4f0c8fd..0e7b745 100644 --- a/metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php +++ b/metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php @@ -167,6 +167,12 @@ interface ThriftHiveMetastoreIf extends \FacebookServiceIf { */ public function create_table_with_constraints(\metastore\Table $tbl, array $primaryKeys, array $foreignKeys); /** + * @param \metastore\DropConstraintRequest $req + * @throws \metastore\NoSuchObjectException + * @throws \metastore\MetaException + */ + public function drop_constraint(\metastore\DropConstraintRequest $req); + /** * @param string $dbname * @param string $name * @param bool $deleteData @@ -2250,6 +2256,60 @@ class ThriftHiveMetastoreClient extends \FacebookServiceClient implements \metas return; } + public function drop_constraint(\metastore\DropConstraintRequest $req) + { + $this->send_drop_constraint($req); + $this->recv_drop_constraint(); + } + + public function send_drop_constraint(\metastore\DropConstraintRequest $req) + { + $args = new \metastore\ThriftHiveMetastore_drop_constraint_args(); + $args->req = $req; + $bin_accel = ($this->output_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_write_binary'); + if ($bin_accel) + { + thrift_protocol_write_binary($this->output_, 'drop_constraint', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite()); + } + else + { + $this->output_->writeMessageBegin('drop_constraint', TMessageType::CALL, $this->seqid_); + $args->write($this->output_); + $this->output_->writeMessageEnd(); + $this->output_->getTransport()->flush(); + } + } + + public function recv_drop_constraint() + { + $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_constraint_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_constraint_result(); + $result->read($this->input_); + $this->input_->readMessageEnd(); + } + if ($result->o1 !== null) { + throw $result->o1; + } + if ($result->o3 !== null) { + throw $result->o3; + } + return; + } + public function drop_table($dbname, $name, $deleteData) { $this->send_drop_table($dbname, $name, $deleteData); @@ -13889,6 +13949,188 @@ class ThriftHiveMetastore_create_table_with_constraints_result { } +class ThriftHiveMetastore_drop_constraint_args { + static $_TSPEC; + + /** + * @var \metastore\DropConstraintRequest + */ + public $req = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'req', + 'type' => TType::STRUCT, + 'class' => '\metastore\DropConstraintRequest', + ), + ); + } + if (is_array($vals)) { + if (isset($vals['req'])) { + $this->req = $vals['req']; + } + } + } + + public function getName() { + return 'ThriftHiveMetastore_drop_constraint_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->req = new \metastore\DropConstraintRequest(); + $xfer += $this->req->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_constraint_args'); + if ($this->req !== null) { + if (!is_object($this->req)) { + throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); + } + $xfer += $output->writeFieldBegin('req', TType::STRUCT, 1); + $xfer += $this->req->write($output); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class ThriftHiveMetastore_drop_constraint_result { + static $_TSPEC; + + /** + * @var \metastore\NoSuchObjectException + */ + public $o1 = null; + /** + * @var \metastore\MetaException + */ + public $o3 = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'o1', + 'type' => TType::STRUCT, + 'class' => '\metastore\NoSuchObjectException', + ), + 2 => array( + 'var' => 'o3', + 'type' => TType::STRUCT, + 'class' => '\metastore\MetaException', + ), + ); + } + if (is_array($vals)) { + if (isset($vals['o1'])) { + $this->o1 = $vals['o1']; + } + if (isset($vals['o3'])) { + $this->o3 = $vals['o3']; + } + } + } + + public function getName() { + return 'ThriftHiveMetastore_drop_constraint_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 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->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_constraint_result'); + if ($this->o1 !== null) { + $xfer += $output->writeFieldBegin('o1', TType::STRUCT, 1); + $xfer += $this->o1->write($output); + $xfer += $output->writeFieldEnd(); + } + if ($this->o3 !== null) { + $xfer += $output->writeFieldBegin('o3', TType::STRUCT, 2); + $xfer += $this->o3->write($output); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + class ThriftHiveMetastore_drop_table_args { static $_TSPEC; diff --git a/metastore/src/gen/thrift/gen-php/metastore/Types.php b/metastore/src/gen/thrift/gen-php/metastore/Types.php index e2fa963..a8a7db9 100644 --- a/metastore/src/gen/thrift/gen-php/metastore/Types.php +++ b/metastore/src/gen/thrift/gen-php/metastore/Types.php @@ -9153,6 +9153,127 @@ class ForeignKeysResponse { } +class DropConstraintRequest { + static $_TSPEC; + + /** + * @var string + */ + public $dbname = null; + /** + * @var string + */ + public $tablename = null; + /** + * @var string + */ + public $constraintname = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'dbname', + 'type' => TType::STRING, + ), + 2 => array( + 'var' => 'tablename', + 'type' => TType::STRING, + ), + 3 => array( + 'var' => 'constraintname', + 'type' => TType::STRING, + ), + ); + } + if (is_array($vals)) { + if (isset($vals['dbname'])) { + $this->dbname = $vals['dbname']; + } + if (isset($vals['tablename'])) { + $this->tablename = $vals['tablename']; + } + if (isset($vals['constraintname'])) { + $this->constraintname = $vals['constraintname']; + } + } + } + + public function getName() { + return 'DropConstraintRequest'; + } + + 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->dbname); + } else { + $xfer += $input->skip($ftype); + } + break; + case 2: + if ($ftype == TType::STRING) { + $xfer += $input->readString($this->tablename); + } else { + $xfer += $input->skip($ftype); + } + break; + case 3: + if ($ftype == TType::STRING) { + $xfer += $input->readString($this->constraintname); + } 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('DropConstraintRequest'); + if ($this->dbname !== null) { + $xfer += $output->writeFieldBegin('dbname', TType::STRING, 1); + $xfer += $output->writeString($this->dbname); + $xfer += $output->writeFieldEnd(); + } + if ($this->tablename !== null) { + $xfer += $output->writeFieldBegin('tablename', TType::STRING, 2); + $xfer += $output->writeString($this->tablename); + $xfer += $output->writeFieldEnd(); + } + if ($this->constraintname !== null) { + $xfer += $output->writeFieldBegin('constraintname', TType::STRING, 3); + $xfer += $output->writeString($this->constraintname); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + class PartitionsByExprResult { static $_TSPEC; diff --git a/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote b/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote index 3ec46f1..5323d9f 100755 --- a/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote +++ b/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote @@ -43,6 +43,7 @@ if len(sys.argv) <= 1 or sys.argv[1] == '--help': print(' void create_table(Table tbl)') print(' void create_table_with_environment_context(Table tbl, EnvironmentContext environment_context)') print(' void create_table_with_constraints(Table tbl, primaryKeys, foreignKeys)') + print(' void drop_constraint(DropConstraintRequest req)') print(' void drop_table(string dbname, string name, bool deleteData)') print(' void drop_table_with_environment_context(string dbname, string name, bool deleteData, EnvironmentContext environment_context)') print(' get_tables(string db_name, string pattern)') @@ -353,6 +354,12 @@ elif cmd == 'create_table_with_constraints': sys.exit(1) pp.pprint(client.create_table_with_constraints(eval(args[0]),eval(args[1]),eval(args[2]),)) +elif cmd == 'drop_constraint': + if len(args) != 1: + print('drop_constraint requires 1 args') + sys.exit(1) + pp.pprint(client.drop_constraint(eval(args[0]),)) + elif cmd == 'drop_table': if len(args) != 3: print('drop_table requires 3 args') diff --git a/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py b/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py index 119a5f1..bf8d383 100644 --- a/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py +++ b/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py @@ -165,6 +165,13 @@ def create_table_with_constraints(self, tbl, primaryKeys, foreignKeys): """ pass + def drop_constraint(self, req): + """ + Parameters: + - req + """ + pass + def drop_table(self, dbname, name, deleteData): """ Parameters: @@ -1875,6 +1882,39 @@ def recv_create_table_with_constraints(self): raise result.o4 return + def drop_constraint(self, req): + """ + Parameters: + - req + """ + self.send_drop_constraint(req) + self.recv_drop_constraint() + + def send_drop_constraint(self, req): + self._oprot.writeMessageBegin('drop_constraint', TMessageType.CALL, self._seqid) + args = drop_constraint_args() + args.req = req + args.write(self._oprot) + self._oprot.writeMessageEnd() + self._oprot.trans.flush() + + def recv_drop_constraint(self): + iprot = self._iprot + (fname, mtype, rseqid) = iprot.readMessageBegin() + if mtype == TMessageType.EXCEPTION: + x = TApplicationException() + x.read(iprot) + iprot.readMessageEnd() + raise x + result = drop_constraint_result() + result.read(iprot) + iprot.readMessageEnd() + if result.o1 is not None: + raise result.o1 + if result.o3 is not None: + raise result.o3 + return + def drop_table(self, dbname, name, deleteData): """ Parameters: @@ -6499,6 +6539,7 @@ def __init__(self, handler): self._processMap["create_table"] = Processor.process_create_table self._processMap["create_table_with_environment_context"] = Processor.process_create_table_with_environment_context self._processMap["create_table_with_constraints"] = Processor.process_create_table_with_constraints + self._processMap["drop_constraint"] = Processor.process_drop_constraint self._processMap["drop_table"] = Processor.process_drop_table self._processMap["drop_table_with_environment_context"] = Processor.process_drop_table_with_environment_context self._processMap["get_tables"] = Processor.process_get_tables @@ -7141,6 +7182,31 @@ def process_create_table_with_constraints(self, seqid, iprot, oprot): oprot.writeMessageEnd() oprot.trans.flush() + def process_drop_constraint(self, seqid, iprot, oprot): + args = drop_constraint_args() + args.read(iprot) + iprot.readMessageEnd() + result = drop_constraint_result() + try: + self._handler.drop_constraint(args.req) + msg_type = TMessageType.REPLY + except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): + raise + except NoSuchObjectException as o1: + msg_type = TMessageType.REPLY + result.o1 = o1 + 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_constraint", msg_type, seqid) + result.write(oprot) + oprot.writeMessageEnd() + oprot.trans.flush() + def process_drop_table(self, seqid, iprot, oprot): args = drop_table_args() args.read(iprot) @@ -13467,6 +13533,152 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) +class drop_constraint_args: + """ + Attributes: + - req + """ + + thrift_spec = ( + None, # 0 + (1, TType.STRUCT, 'req', (DropConstraintRequest, DropConstraintRequest.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)) + return + iprot.readStructBegin() + while True: + (fname, ftype, fid) = iprot.readFieldBegin() + if ftype == TType.STOP: + break + if fid == 1: + if ftype == TType.STRUCT: + self.req = DropConstraintRequest() + self.req.read(iprot) + else: + iprot.skip(ftype) + else: + iprot.skip(ftype) + iprot.readFieldEnd() + iprot.readStructEnd() + + def write(self, oprot): + if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: + oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) + return + oprot.writeStructBegin('drop_constraint_args') + if self.req is not None: + oprot.writeFieldBegin('req', TType.STRUCT, 1) + self.req.write(oprot) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.req) + return value + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + +class drop_constraint_result: + """ + Attributes: + - o1 + - o3 + """ + + thrift_spec = ( + None, # 0 + (1, TType.STRUCT, 'o1', (NoSuchObjectException, NoSuchObjectException.thrift_spec), None, ), # 1 + (2, TType.STRUCT, 'o3', (MetaException, MetaException.thrift_spec), None, ), # 2 + ) + + def __init__(self, o1=None, o3=None,): + self.o1 = o1 + self.o3 = o3 + + def read(self, iprot): + if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: + fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) + return + iprot.readStructBegin() + while True: + (fname, ftype, fid) = iprot.readFieldBegin() + if ftype == TType.STOP: + break + if fid == 1: + if ftype == TType.STRUCT: + self.o1 = NoSuchObjectException() + self.o1.read(iprot) + else: + iprot.skip(ftype) + elif fid == 2: + if ftype == TType.STRUCT: + self.o3 = MetaException() + self.o3.read(iprot) + else: + iprot.skip(ftype) + else: + iprot.skip(ftype) + iprot.readFieldEnd() + iprot.readStructEnd() + + def write(self, oprot): + if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: + oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) + return + oprot.writeStructBegin('drop_constraint_result') + if self.o1 is not None: + oprot.writeFieldBegin('o1', TType.STRUCT, 1) + self.o1.write(oprot) + oprot.writeFieldEnd() + if self.o3 is not None: + oprot.writeFieldBegin('o3', TType.STRUCT, 2) + self.o3.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.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 drop_table_args: """ Attributes: diff --git a/metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py b/metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py index f008788..8e0cb71 100644 --- a/metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py +++ b/metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py @@ -6264,6 +6264,103 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) +class DropConstraintRequest: + """ + Attributes: + - dbname + - tablename + - constraintname + """ + + thrift_spec = ( + None, # 0 + (1, TType.STRING, 'dbname', None, None, ), # 1 + (2, TType.STRING, 'tablename', None, None, ), # 2 + (3, TType.STRING, 'constraintname', None, None, ), # 3 + ) + + def __init__(self, dbname=None, tablename=None, constraintname=None,): + self.dbname = dbname + self.tablename = tablename + self.constraintname = constraintname + + 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.dbname = iprot.readString() + else: + iprot.skip(ftype) + elif fid == 2: + if ftype == TType.STRING: + self.tablename = iprot.readString() + else: + iprot.skip(ftype) + elif fid == 3: + if ftype == TType.STRING: + self.constraintname = 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('DropConstraintRequest') + if self.dbname is not None: + oprot.writeFieldBegin('dbname', TType.STRING, 1) + oprot.writeString(self.dbname) + oprot.writeFieldEnd() + if self.tablename is not None: + oprot.writeFieldBegin('tablename', TType.STRING, 2) + oprot.writeString(self.tablename) + oprot.writeFieldEnd() + if self.constraintname is not None: + oprot.writeFieldBegin('constraintname', TType.STRING, 3) + oprot.writeString(self.constraintname) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + if self.dbname is None: + raise TProtocol.TProtocolException(message='Required field dbname is unset!') + if self.tablename is None: + raise TProtocol.TProtocolException(message='Required field tablename is unset!') + if self.constraintname is None: + raise TProtocol.TProtocolException(message='Required field constraintname is unset!') + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.dbname) + value = (value * 31) ^ hash(self.tablename) + value = (value * 31) ^ hash(self.constraintname) + 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 PartitionsByExprResult: """ Attributes: diff --git a/metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb b/metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb index 4a24a19..4d3e49d 100644 --- a/metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb +++ b/metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb @@ -1390,6 +1390,29 @@ class ForeignKeysResponse ::Thrift::Struct.generate_accessors self end +class DropConstraintRequest + include ::Thrift::Struct, ::Thrift::Struct_Union + DBNAME = 1 + TABLENAME = 2 + CONSTRAINTNAME = 3 + + FIELDS = { + DBNAME => {:type => ::Thrift::Types::STRING, :name => 'dbname'}, + TABLENAME => {:type => ::Thrift::Types::STRING, :name => 'tablename'}, + CONSTRAINTNAME => {:type => ::Thrift::Types::STRING, :name => 'constraintname'} + } + + def struct_fields; FIELDS; end + + def validate + raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Required field dbname is unset!') unless @dbname + raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Required field tablename is unset!') unless @tablename + raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Required field constraintname is unset!') unless @constraintname + end + + ::Thrift::Struct.generate_accessors self +end + class PartitionsByExprResult include ::Thrift::Struct, ::Thrift::Struct_Union PARTITIONS = 1 diff --git a/metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb b/metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb index 99a764e..61d1832 100644 --- a/metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb +++ b/metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb @@ -336,6 +336,22 @@ module ThriftHiveMetastore return end + def drop_constraint(req) + send_drop_constraint(req) + recv_drop_constraint() + end + + def send_drop_constraint(req) + send_message('drop_constraint', Drop_constraint_args, :req => req) + end + + def recv_drop_constraint() + result = receive_message(Drop_constraint_result) + raise result.o1 unless result.o1.nil? + raise result.o3 unless result.o3.nil? + return + end + def drop_table(dbname, name, deleteData) send_drop_table(dbname, name, deleteData) recv_drop_table() @@ -2704,6 +2720,19 @@ module ThriftHiveMetastore write_result(result, oprot, 'create_table_with_constraints', seqid) end + def process_drop_constraint(seqid, iprot, oprot) + args = read_args(iprot, Drop_constraint_args) + result = Drop_constraint_result.new() + begin + @handler.drop_constraint(args.req) + rescue ::NoSuchObjectException => o1 + result.o1 = o1 + rescue ::MetaException => o3 + result.o3 = o3 + end + write_result(result, oprot, 'drop_constraint', seqid) + end + def process_drop_table(seqid, iprot, oprot) args = read_args(iprot, Drop_table_args) result = Drop_table_result.new() @@ -4954,6 +4983,40 @@ module ThriftHiveMetastore ::Thrift::Struct.generate_accessors self end + class Drop_constraint_args + include ::Thrift::Struct, ::Thrift::Struct_Union + REQ = 1 + + FIELDS = { + REQ => {:type => ::Thrift::Types::STRUCT, :name => 'req', :class => ::DropConstraintRequest} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Drop_constraint_result + include ::Thrift::Struct, ::Thrift::Struct_Union + O1 = 1 + O3 = 2 + + FIELDS = { + O1 => {:type => ::Thrift::Types::STRUCT, :name => 'o1', :class => ::NoSuchObjectException}, + O3 => {:type => ::Thrift::Types::STRUCT, :name => 'o3', :class => ::MetaException} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + class Drop_table_args include ::Thrift::Struct, ::Thrift::Struct_Union DBNAME = 1 diff --git a/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java b/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java index 4ada9c1..9a09e7a 100644 --- a/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java +++ b/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java @@ -1483,6 +1483,35 @@ public void create_table_with_constraints(final Table tbl, endFunction("create_table", success, ex, tbl.getTableName()); } } + + @Override + public void drop_constraint(DropConstraintRequest req) + throws MetaException, InvalidObjectException { + String dbName = req.getDbname(); + String tableName = req.getTablename(); + String constraintName = req.getConstraintname(); + startFunction("drop_constraint", ": " + constraintName.toString()); + boolean success = false; + Exception ex = null; + try { + getMS().dropConstraint(dbName, tableName, constraintName); + success = true; + } catch (NoSuchObjectException e) { + ex = e; + throw new InvalidObjectException(e.getMessage()); + } catch (Exception e) { + ex = e; + if (e instanceof MetaException) { + throw (MetaException) e; + } else if (e instanceof InvalidObjectException) { + throw (InvalidObjectException) e; + } else { + throw newMetaException(e); + } + } finally { + endFunction("drop_constraint", success, ex, constraintName); + } + } private boolean is_table_exists(RawStore ms, String dbname, String name) throws MetaException { return (ms.getTable(dbname, name) != null); diff --git a/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java b/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java index 7d37d07..75fea5b 100644 --- a/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java +++ b/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java @@ -44,6 +44,7 @@ import org.apache.hadoop.hive.metastore.api.ConfigValSecurityException; import org.apache.hadoop.hive.metastore.api.CurrentNotificationEventId; import org.apache.hadoop.hive.metastore.api.Database; +import org.apache.hadoop.hive.metastore.api.DropConstraintRequest; import org.apache.hadoop.hive.metastore.api.DropPartitionsExpr; import org.apache.hadoop.hive.metastore.api.DropPartitionsRequest; import org.apache.hadoop.hive.metastore.api.EnvironmentContext; @@ -765,6 +766,11 @@ public void createTableWithConstraints(Table tbl, } } + @Override + public void dropConstraint(String dbName, String tableName, String constraintName) throws + NoSuchObjectException, MetaException, TException { + client.drop_constraint(new DropConstraintRequest(dbName, tableName, constraintName)); + } /** * @param type diff --git a/metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java b/metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java index c900a2d..3965475 100644 --- a/metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java +++ b/metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java @@ -1570,4 +1570,7 @@ void createTableWithConstraints( List primaryKeys, List foreignKeys) throws AlreadyExistsException, InvalidObjectException, MetaException, NoSuchObjectException, TException; + void dropConstraint(String dbName, String tableName, String constraintName) throws + MetaException, NoSuchObjectException, TException; + } diff --git a/metastore/src/java/org/apache/hadoop/hive/metastore/ObjectStore.java b/metastore/src/java/org/apache/hadoop/hive/metastore/ObjectStore.java index f651a13..5c49be9 100644 --- a/metastore/src/java/org/apache/hadoop/hive/metastore/ObjectStore.java +++ b/metastore/src/java/org/apache/hadoop/hive/metastore/ObjectStore.java @@ -1025,7 +1025,8 @@ public boolean dropTable(String dbName, String tableName) throws MetaException, " table " + tableName + " record to delete"); } - List tabConstraints = listAllTableConstraints(dbName, tableName); + List tabConstraints = listAllTableConstraintsWithOptionalConstraintName( + dbName, tableName, null); if (tabConstraints != null && tabConstraints.size() > 0) { pm.deletePersistentAll(tabConstraints); } @@ -1043,19 +1044,27 @@ public boolean dropTable(String dbName, String tableName) throws MetaException, return success; } - private List listAllTableConstraints(String dbName, String tableName) { + private List listAllTableConstraintsWithOptionalConstraintName + (String dbName, String tableName, String constraintname) { List mConstraints = null; List constraintNames = new ArrayList(); Query query = null; try { query = pm.newQuery("select constraintName from org.apache.hadoop.hive.metastore.model.MConstraint where " - + "(parentTable.tableName == ptblname && parentTable.database.name == pdbname) || " - + "(childTable != null && childTable.tableName == ctblname && childTable.database.name == cdbname)"); + + "((parentTable.tableName == ptblname && parentTable.database.name == pdbname) || " + + "(childTable != null && childTable.tableName == ctblname && " + + "childTable.database.name == cdbname)) " + (constraintname != null ? + " && constraintName == constraintname" : "")); query.declareParameters("java.lang.String ptblname, java.lang.String pdbname," - + "java.lang.String ctblname, java.lang.String cdbname"); - Collection constraintNamesColl = (Collection) query. - executeWithArray(tableName, dbName, tableName, dbName); + + "java.lang.String ctblname, java.lang.String cdbname" + + (constraintname != null ? ", java.lang.String constraintname" : "")); + Collection constraintNamesColl = + constraintname != null ? + ((Collection) query. + executeWithArray(tableName, dbName, tableName, dbName, constraintname)): + ((Collection) query. + executeWithArray(tableName, dbName, tableName, dbName)); for (Iterator i = constraintNamesColl.iterator(); i.hasNext();) { String currName = (String) i.next(); constraintNames.add(currName); @@ -8389,4 +8398,27 @@ private String getPrimaryKeyConstraintName(String db_name, String tbl_name) thro return foreignKeys; } + @Override + public void dropConstraint(String dbName, String tableName, + String constraintName) throws NoSuchObjectException { + boolean success = false; + try { + openTransaction(); + + List tabConstraints = listAllTableConstraintsWithOptionalConstraintName( + dbName, tableName, constraintName); + if (tabConstraints != null && tabConstraints.size() > 0) { + pm.deletePersistentAll(tabConstraints); + } else { + throw new NoSuchObjectException("The constraint: " + constraintName + + " does not exist for the associated table: " + dbName + "." + tableName); + } + success = commitTransaction(); + } finally { + if (!success) { + rollbackTransaction(); + } + } + } + } diff --git a/metastore/src/java/org/apache/hadoop/hive/metastore/RawStore.java b/metastore/src/java/org/apache/hadoop/hive/metastore/RawStore.java index 100c396..06b8135 100644 --- a/metastore/src/java/org/apache/hadoop/hive/metastore/RawStore.java +++ b/metastore/src/java/org/apache/hadoop/hive/metastore/RawStore.java @@ -675,4 +675,6 @@ void getFileMetadataByExpr(List fileIds, FileMetadataExprType type, byte[] void createTableWithConstraints(Table tbl, List primaryKeys, List foreignKeys) throws InvalidObjectException, MetaException; + + void dropConstraint(String dbName, String tableName, String constraintName) throws NoSuchObjectException; } diff --git a/metastore/src/java/org/apache/hadoop/hive/metastore/hbase/HBaseStore.java b/metastore/src/java/org/apache/hadoop/hive/metastore/hbase/HBaseStore.java index d4e5da4..ec5b92c 100644 --- a/metastore/src/java/org/apache/hadoop/hive/metastore/hbase/HBaseStore.java +++ b/metastore/src/java/org/apache/hadoop/hive/metastore/hbase/HBaseStore.java @@ -2615,4 +2615,10 @@ public void createTableWithConstraints(Table tbl, throws InvalidObjectException, MetaException { // TODO Auto-generated method stub } + + @Override + public void dropConstraint(String dbName, String tableName, + String constraintName) throws NoSuchObjectException { + // TODO Auto-generated method stub + } } diff --git a/metastore/src/test/org/apache/hadoop/hive/metastore/DummyRawStoreControlledCommit.java b/metastore/src/test/org/apache/hadoop/hive/metastore/DummyRawStoreControlledCommit.java index 86e7bea..63fcb28 100644 --- a/metastore/src/test/org/apache/hadoop/hive/metastore/DummyRawStoreControlledCommit.java +++ b/metastore/src/test/org/apache/hadoop/hive/metastore/DummyRawStoreControlledCommit.java @@ -844,4 +844,10 @@ public void createTableWithConstraints(Table tbl, throws InvalidObjectException, MetaException { // TODO Auto-generated method stub } + + @Override + public void dropConstraint(String dbName, String tableName, + String constraintName) throws NoSuchObjectException { + // TODO Auto-generated method stub + } } diff --git a/metastore/src/test/org/apache/hadoop/hive/metastore/DummyRawStoreForJdoConnection.java b/metastore/src/test/org/apache/hadoop/hive/metastore/DummyRawStoreForJdoConnection.java index 5b32f00..386c70a 100644 --- a/metastore/src/test/org/apache/hadoop/hive/metastore/DummyRawStoreForJdoConnection.java +++ b/metastore/src/test/org/apache/hadoop/hive/metastore/DummyRawStoreForJdoConnection.java @@ -860,6 +860,12 @@ public void createTableWithConstraints(Table tbl, throws InvalidObjectException, MetaException { // TODO Auto-generated method stub } + + @Override + public void dropConstraint(String dbName, String tableName, + String constraintName) throws NoSuchObjectException { + // TODO Auto-generated method stub + } } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/exec/DDLTask.java b/ql/src/java/org/apache/hadoop/hive/ql/exec/DDLTask.java index 9887d77..c4d3bfb 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/exec/DDLTask.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/exec/DDLTask.java @@ -131,6 +131,7 @@ import org.apache.hadoop.hive.ql.parse.BaseSemanticAnalyzer; import org.apache.hadoop.hive.ql.parse.DDLSemanticAnalyzer; import org.apache.hadoop.hive.ql.parse.ReplicationSpec; +import org.apache.hadoop.hive.ql.parse.SemanticException; import org.apache.hadoop.hive.ql.plan.AddPartitionDesc; import org.apache.hadoop.hive.ql.plan.AlterDatabaseDesc; import org.apache.hadoop.hive.ql.plan.AlterIndexDesc; @@ -356,7 +357,11 @@ public int execute(DriverContext driverContext) { AlterTableDesc alterTbl = work.getAlterTblDesc(); if (alterTbl != null) { - return alterTable(db, alterTbl); + if (alterTbl.getOp() == AlterTableTypes.DROPCONSTRAINT ) { + return dropConstraint(db, alterTbl); + } else { + return alterTable(db, alterTbl); + } } CreateViewDesc crtView = work.getCreateViewDesc(); @@ -3596,7 +3601,19 @@ private int alterTableOrSinglePartition(AlterTableDesc alterTbl, Table tbl, Part return 0; } - /** + private int dropConstraint(Hive db, AlterTableDesc alterTbl) + throws SemanticException, HiveException { + try { + db.dropConstraint(Utilities.getDatabaseName(alterTbl.getOldName()), + Utilities.getTableName(alterTbl.getOldName()), + alterTbl.getConstraintName()); + } catch (NoSuchObjectException e) { + throw new HiveException(e); + } + return 0; + } + + /** * Drop a given table or some partitions. DropTableDesc is currently used for both. * * @param db diff --git a/ql/src/java/org/apache/hadoop/hive/ql/hooks/WriteEntity.java b/ql/src/java/org/apache/hadoop/hive/ql/hooks/WriteEntity.java index 515f8b2..2194a6d 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/hooks/WriteEntity.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/hooks/WriteEntity.java @@ -203,7 +203,8 @@ public static WriteType determineAlterTableWriteType(AlterTableDesc.AlterTableTy case ADDCOLS: case RENAME: case TRUNCATE: - case MERGEFILES: return WriteType.DDL_EXCLUSIVE; + case MERGEFILES: + case DROPCONSTRAINT: return WriteType.DDL_EXCLUSIVE; case ADDPARTITION: case ADDSERDEPROPS: diff --git a/ql/src/java/org/apache/hadoop/hive/ql/metadata/Hive.java b/ql/src/java/org/apache/hadoop/hive/ql/metadata/Hive.java index 26c458c..6862f70 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/metadata/Hive.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/metadata/Hive.java @@ -3593,4 +3593,13 @@ public long getPermanenFunctionsChangeVersion() throws HiveException { } } + public void dropConstraint(String dbName, String tableName, String constraintName) + throws HiveException, NoSuchObjectException { + try { + getMSC().dropConstraint(dbName, tableName, constraintName); + } catch (Exception e) { + throw new HiveException(e); + } + } + }; diff --git a/ql/src/java/org/apache/hadoop/hive/ql/parse/DDLSemanticAnalyzer.java b/ql/src/java/org/apache/hadoop/hive/ql/parse/DDLSemanticAnalyzer.java index 04e2a41..4a6617f 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/parse/DDLSemanticAnalyzer.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/parse/DDLSemanticAnalyzer.java @@ -26,7 +26,6 @@ import org.slf4j.LoggerFactory; import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.fs.Path; -import org.apache.hadoop.hive.common.FileUtils; import org.apache.hadoop.hive.common.JavaUtils; import org.apache.hadoop.hive.common.StatsSetupConst; import org.apache.hadoop.hive.conf.HiveConf; @@ -88,7 +87,6 @@ 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.DDLDesc; import org.apache.hadoop.hive.ql.plan.DDLWork; import org.apache.hadoop.hive.ql.plan.DescDatabaseDesc; import org.apache.hadoop.hive.ql.plan.DescFunctionDesc; @@ -321,6 +319,8 @@ public void analyzeInternal(ASTNode input) throws SemanticException { analyzeAlterTableCompact(ast, tableName, partSpec); } else if(ast.getToken().getType() == HiveParser.TOK_ALTERTABLE_UPDATECOLSTATS){ analyzeAlterTableUpdateStats(ast, tableName, partSpec); + } else if(ast.getToken().getType() == HiveParser.TOK_ALTERTABLE_DROPCONSTRAINT) { + analyzeAlterTableDropConstraint(ast, tableName); } break; } @@ -1740,6 +1740,15 @@ private void analyzeAlterTableCompact(ASTNode ast, String tableName, rootTasks.add(TaskFactory.get(new DDLWork(getInputs(), getOutputs(), desc), conf)); } + private void analyzeAlterTableDropConstraint(ASTNode ast, String tableName) + throws SemanticException { + String dropConstraintName = unescapeIdentifier(ast.getChild(0).getText()); + AlterTableDesc alterTblDesc = new AlterTableDesc(tableName, dropConstraintName); + + rootTasks.add(TaskFactory.get(new DDLWork(getInputs(), getOutputs(), + alterTblDesc), conf)); + } + static HashMap getProps(ASTNode prop) { // Must be deterministic order map for consistent q-test output across Java versions HashMap mapProp = new LinkedHashMap(); diff --git a/ql/src/java/org/apache/hadoop/hive/ql/parse/HiveParser.g b/ql/src/java/org/apache/hadoop/hive/ql/parse/HiveParser.g index 6531b03..2c66396 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/parse/HiveParser.g +++ b/ql/src/java/org/apache/hadoop/hive/ql/parse/HiveParser.g @@ -179,6 +179,7 @@ TOK_ALTERTABLE_SKEWED_LOCATION; TOK_ALTERTABLE_BUCKETS; TOK_ALTERTABLE_CLUSTER_SORT; TOK_ALTERTABLE_COMPACT; +TOK_ALTERTABLE_DROPCONSTRAINT; TOK_ALTERINDEX_REBUILD; TOK_ALTERINDEX_PROPERTIES; TOK_MSCK; @@ -1040,6 +1041,7 @@ alterTableStatementSuffix | alterStatementSuffixSkewedby | alterStatementSuffixExchangePartition | alterStatementPartitionKeyType + | alterStatementSuffixDropConstraint | partitionSpec? alterTblPartitionStatementSuffix -> alterTblPartitionStatementSuffix partitionSpec? ; @@ -1129,6 +1131,13 @@ alterStatementSuffixAddCol -> ^(TOK_ALTERTABLE_REPLACECOLS columnNameTypeList restrictOrCascade?) ; +alterStatementSuffixDropConstraint +@init { pushMsg("drop constraint statement", state); } +@after { popMsg(state); } + : KW_DROP KW_CONSTRAINT cName=identifier + ->^(TOK_ALTERTABLE_DROPCONSTRAINT $cName) + ; + alterStatementSuffixRenameCol @init { pushMsg("rename column name", state); } @after { popMsg(state); } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/parse/SemanticAnalyzerFactory.java b/ql/src/java/org/apache/hadoop/hive/ql/parse/SemanticAnalyzerFactory.java index fb8a33c..7b83381 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/parse/SemanticAnalyzerFactory.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/parse/SemanticAnalyzerFactory.java @@ -62,6 +62,7 @@ commandType.put(HiveParser.TOK_ALTERTABLE_PROPERTIES, HiveOperation.ALTERTABLE_PROPERTIES); commandType.put(HiveParser.TOK_ALTERTABLE_DROPPROPERTIES, HiveOperation.ALTERTABLE_PROPERTIES); commandType.put(HiveParser.TOK_ALTERTABLE_EXCHANGEPARTITION, HiveOperation.ALTERTABLE_EXCHANGEPARTITION); + commandType.put(HiveParser.TOK_ALTERTABLE_DROPCONSTRAINT, HiveOperation.ALTERTABLE_DROPCONSTRAINT); commandType.put(HiveParser.TOK_SHOWDATABASES, HiveOperation.SHOWDATABASES); commandType.put(HiveParser.TOK_SHOWTABLES, HiveOperation.SHOWTABLES); commandType.put(HiveParser.TOK_SHOWCOLUMNS, HiveOperation.SHOWCOLUMNS); @@ -195,6 +196,7 @@ public static BaseSemanticAnalyzer get(QueryState queryState, ASTNode tree) case HiveParser.TOK_ALTERTABLE_DROPPROPERTIES: case HiveParser.TOK_ALTERTABLE_EXCHANGEPARTITION: case HiveParser.TOK_ALTERTABLE_SKEWED: + case HiveParser.TOK_ALTERTABLE_DROPCONSTRAINT: queryState.setCommandType(commandType.get(child.getType())); return new DDLSemanticAnalyzer(queryState); } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/plan/AlterTableDesc.java b/ql/src/java/org/apache/hadoop/hive/ql/plan/AlterTableDesc.java index 4ba51ec..38d8d5a 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/plan/AlterTableDesc.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/plan/AlterTableDesc.java @@ -56,7 +56,7 @@ DROPPARTITION("drop partition"), RENAMEPARTITION("rename partition"), ADDSKEWEDBY("add skew column"), ALTERSKEWEDLOCATION("alter skew location"), ALTERBUCKETNUM("alter bucket number"), ALTERPARTITION("alter partition"), COMPACT("compact"), - TRUNCATE("truncate"), MERGEFILES("merge files"); + TRUNCATE("truncate"), MERGEFILES("merge files"), DROPCONSTRAINT("drop constraint"); ; private final String name; @@ -116,6 +116,7 @@ boolean isTurnOffSorting = false; boolean isCascade = false; EnvironmentContext environmentContext; + String dropConstraintName; public AlterTableDesc() { } @@ -263,6 +264,12 @@ public AlterTableDesc(String tableName, HashMap partSpec, int nu this.numberBuckets = numBuckets; } + public AlterTableDesc(String tableName, String dropConstraintName) { + this.oldName = tableName; + this.dropConstraintName = dropConstraintName; + op = AlterTableTypes.DROPCONSTRAINT; + } + @Explain(displayName = "new columns", explainLevels = { Level.USER, Level.DEFAULT, Level.EXTENDED }) public List getNewColsString() { return Utilities.getFieldSchemaString(getNewCols()); @@ -408,6 +415,22 @@ public String getStorageHandler() { } /** + * @return the drop constraint name of the table + */ + @Explain(displayName = "drop constraint name", explainLevels = { Level.USER, Level.DEFAULT, Level.EXTENDED }) + public String getConstraintName() { + return dropConstraintName; + } + + /** + * @param constraintName + * the dropConstraintName to set + */ + public void setDropConstraintName(String constraintName) { + this.dropConstraintName = constraintName; + } + + /** * @param storageHandler * the storage handler to set */ diff --git a/ql/src/java/org/apache/hadoop/hive/ql/plan/HiveOperation.java b/ql/src/java/org/apache/hadoop/hive/ql/plan/HiveOperation.java index 188cd6f..e651016 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/plan/HiveOperation.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/plan/HiveOperation.java @@ -115,6 +115,8 @@ new Privilege[] {Privilege.ALTER_DATA}, null), ALTERTABLE_PARTCOLTYPE("ALTERTABLE_PARTCOLTYPE", new Privilege[] { Privilege.SELECT }, new Privilege[] { Privilege.ALTER_DATA }), ALTERTABLE_EXCHANGEPARTITION("ALTERTABLE_EXCHANGEPARTITION", null, null), + ALTERTABLE_DROPCONSTRAINT("ALTERTABLE_DROPCONSTRAINT", + new Privilege[]{Privilege.ALTER_METADATA}, null), ALTERVIEW_RENAME("ALTERVIEW_RENAME", new Privilege[] {Privilege.ALTER_METADATA}, null), ALTERVIEW_AS("ALTERVIEW_AS", new Privilege[] {Privilege.ALTER_METADATA}, null), ALTERTABLE_COMPACT("ALTERTABLE_COMPACT", new Privilege[]{Privilege.SELECT}, new Privilege[]{Privilege.ALTER_DATA}), diff --git a/ql/src/test/queries/clientnegative/drop_invalid_constraint1.q b/ql/src/test/queries/clientnegative/drop_invalid_constraint1.q new file mode 100644 index 0000000..2055f9e --- /dev/null +++ b/ql/src/test/queries/clientnegative/drop_invalid_constraint1.q @@ -0,0 +1,3 @@ +CREATE TABLE table1 (a STRING, b STRING, constraint pk1 primary key (a) disable novalidate); +ALTER TABLE table1 DROP CONSTRAINT pk1; +ALTER TABLE table1 DROP CONSTRAINT pk1; diff --git a/ql/src/test/queries/clientnegative/drop_invalid_constraint2.q b/ql/src/test/queries/clientnegative/drop_invalid_constraint2.q new file mode 100644 index 0000000..d253617 --- /dev/null +++ b/ql/src/test/queries/clientnegative/drop_invalid_constraint2.q @@ -0,0 +1,2 @@ +CREATE TABLE table2 (a STRING, b STRING, constraint pk1 primary key (a) disable novalidate); +ALTER TABLE table1 DROP CONSTRAINT pk1; diff --git a/ql/src/test/queries/clientnegative/drop_invalid_constraint3.q b/ql/src/test/queries/clientnegative/drop_invalid_constraint3.q new file mode 100644 index 0000000..04eb1fb --- /dev/null +++ b/ql/src/test/queries/clientnegative/drop_invalid_constraint3.q @@ -0,0 +1,2 @@ +CREATE TABLE table2 (a STRING, b STRING, constraint pk1 primary key (a) disable novalidate); +ALTER TABLE table2 DROP CONSTRAINT pk2; diff --git a/ql/src/test/queries/clientnegative/drop_invalid_constraint4.q b/ql/src/test/queries/clientnegative/drop_invalid_constraint4.q new file mode 100644 index 0000000..3cf2d2a --- /dev/null +++ b/ql/src/test/queries/clientnegative/drop_invalid_constraint4.q @@ -0,0 +1,3 @@ +CREATE TABLE table1 (a STRING, b STRING, constraint pk1 primary key (a) disable novalidate); +CREATE TABLE table2 (a STRING, b STRING, constraint pk2 primary key (a) disable novalidate); +ALTER TABLE table1 DROP CONSTRAINT pk2; \ No newline at end of file diff --git a/ql/src/test/queries/clientpositive/create_with_constraints.q b/ql/src/test/queries/clientpositive/create_with_constraints.q index eef0c64..0bb92e4 100644 --- a/ql/src/test/queries/clientpositive/create_with_constraints.q +++ b/ql/src/test/queries/clientpositive/create_with_constraints.q @@ -8,5 +8,17 @@ CREATE TABLE table6 (x string, y string, PRIMARY KEY (x) disable novalidate, FOR CONSTRAINT fk4 FOREIGN KEY (y) REFERENCES table1(a) DISABLE NOVALIDATE); CREATE TABLE table7 (a STRING, b STRING, primary key (a) disable novalidate rely); CREATE TABLE table8 (a STRING, b STRING, constraint pk8 primary key (a) disable novalidate norely); +CREATE TABLE table9 (a STRING, b STRING, primary key (a, b) disable novalidate rely); +CREATE TABLE table10 (a STRING, b STRING, constraint pk10 primary key (a) disable novalidate norely, foreign key (a, b) references table9(a, b) disable novalidate); +CREATE TABLE table11 (a STRING, b STRING, c STRING, constraint pk11 primary key (a) disable novalidate rely, foreign key (a, b) references table9(a, b) disable novalidate, +foreign key (c) references table4(x) disable novalidate); +ALTER TABLE table2 DROP CONSTRAINT pk1; +ALTER TABLE table3 DROP CONSTRAINT fk1; +ALTER TABLE table6 DROP CONSTRAINT fk4; +CREATE DATABASE dbconstraint; +USE dbconstraint; +CREATE TABLE table2 (a STRING, b STRING, constraint pk1 primary key (a) disable novalidate); +USE default; +ALTER TABLE dbconstraint.table2 DROP CONSTRAINT pk1; diff --git a/ql/src/test/results/clientnegative/drop_invalid_constraint1.q.out b/ql/src/test/results/clientnegative/drop_invalid_constraint1.q.out new file mode 100644 index 0000000..042827f --- /dev/null +++ b/ql/src/test/results/clientnegative/drop_invalid_constraint1.q.out @@ -0,0 +1,17 @@ +PREHOOK: query: CREATE TABLE table1 (a STRING, b STRING, constraint pk1 primary key (a) disable novalidate) +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:default +PREHOOK: Output: default@table1 +POSTHOOK: query: CREATE TABLE table1 (a STRING, b STRING, constraint pk1 primary key (a) disable novalidate) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:default +POSTHOOK: Output: default@table1 +PREHOOK: query: ALTER TABLE table1 DROP CONSTRAINT pk1 +PREHOOK: type: ALTERTABLE_DROPCONSTRAINT +POSTHOOK: query: ALTER TABLE table1 DROP CONSTRAINT pk1 +POSTHOOK: type: ALTERTABLE_DROPCONSTRAINT +POSTHOOK: Input: default@table1 +POSTHOOK: Output: default@table1 +PREHOOK: query: ALTER TABLE table1 DROP CONSTRAINT pk1 +PREHOOK: type: ALTERTABLE_DROPCONSTRAINT +FAILED: Execution Error, return code 1 from org.apache.hadoop.hive.ql.exec.DDLTask. InvalidObjectException(message:The constraint: pk1 does not exist for the associated table: default.table1) diff --git a/ql/src/test/results/clientnegative/drop_invalid_constraint2.q.out b/ql/src/test/results/clientnegative/drop_invalid_constraint2.q.out new file mode 100644 index 0000000..5dae7c2 --- /dev/null +++ b/ql/src/test/results/clientnegative/drop_invalid_constraint2.q.out @@ -0,0 +1,11 @@ +PREHOOK: query: CREATE TABLE table2 (a STRING, b STRING, constraint pk1 primary key (a) disable novalidate) +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:default +PREHOOK: Output: default@table2 +POSTHOOK: query: CREATE TABLE table2 (a STRING, b STRING, constraint pk1 primary key (a) disable novalidate) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:default +POSTHOOK: Output: default@table2 +PREHOOK: query: ALTER TABLE table1 DROP CONSTRAINT pk1 +PREHOOK: type: ALTERTABLE_DROPCONSTRAINT +FAILED: Execution Error, return code 1 from org.apache.hadoop.hive.ql.exec.DDLTask. Table not found table1 diff --git a/ql/src/test/results/clientnegative/drop_invalid_constraint3.q.out b/ql/src/test/results/clientnegative/drop_invalid_constraint3.q.out new file mode 100644 index 0000000..9c60e94 --- /dev/null +++ b/ql/src/test/results/clientnegative/drop_invalid_constraint3.q.out @@ -0,0 +1,11 @@ +PREHOOK: query: CREATE TABLE table2 (a STRING, b STRING, constraint pk1 primary key (a) disable novalidate) +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:default +PREHOOK: Output: default@table2 +POSTHOOK: query: CREATE TABLE table2 (a STRING, b STRING, constraint pk1 primary key (a) disable novalidate) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:default +POSTHOOK: Output: default@table2 +PREHOOK: query: ALTER TABLE table2 DROP CONSTRAINT pk2 +PREHOOK: type: ALTERTABLE_DROPCONSTRAINT +FAILED: Execution Error, return code 1 from org.apache.hadoop.hive.ql.exec.DDLTask. InvalidObjectException(message:The constraint: pk2 does not exist for the associated table: default.table2) diff --git a/ql/src/test/results/clientnegative/drop_invalid_constraint4.q.out b/ql/src/test/results/clientnegative/drop_invalid_constraint4.q.out new file mode 100644 index 0000000..1d93c42 --- /dev/null +++ b/ql/src/test/results/clientnegative/drop_invalid_constraint4.q.out @@ -0,0 +1,19 @@ +PREHOOK: query: CREATE TABLE table1 (a STRING, b STRING, constraint pk1 primary key (a) disable novalidate) +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:default +PREHOOK: Output: default@table1 +POSTHOOK: query: CREATE TABLE table1 (a STRING, b STRING, constraint pk1 primary key (a) disable novalidate) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:default +POSTHOOK: Output: default@table1 +PREHOOK: query: CREATE TABLE table2 (a STRING, b STRING, constraint pk2 primary key (a) disable novalidate) +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:default +PREHOOK: Output: default@table2 +POSTHOOK: query: CREATE TABLE table2 (a STRING, b STRING, constraint pk2 primary key (a) disable novalidate) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:default +POSTHOOK: Output: default@table2 +PREHOOK: query: ALTER TABLE table1 DROP CONSTRAINT pk2 +PREHOOK: type: ALTERTABLE_DROPCONSTRAINT +FAILED: Execution Error, return code 1 from org.apache.hadoop.hive.ql.exec.DDLTask. InvalidObjectException(message:The constraint: pk2 does not exist for the associated table: default.table1) diff --git a/ql/src/test/results/clientpositive/create_with_constraints.q.out b/ql/src/test/results/clientpositive/create_with_constraints.q.out index 5cf8d83..351c71e 100644 --- a/ql/src/test/results/clientpositive/create_with_constraints.q.out +++ b/ql/src/test/results/clientpositive/create_with_constraints.q.out @@ -66,3 +66,79 @@ POSTHOOK: query: CREATE TABLE table8 (a STRING, b STRING, constraint pk8 primary POSTHOOK: type: CREATETABLE POSTHOOK: Output: database:default POSTHOOK: Output: default@table8 +PREHOOK: query: CREATE TABLE table9 (a STRING, b STRING, primary key (a, b) disable novalidate rely) +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:default +PREHOOK: Output: default@table9 +POSTHOOK: query: CREATE TABLE table9 (a STRING, b STRING, primary key (a, b) disable novalidate rely) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:default +POSTHOOK: Output: default@table9 +PREHOOK: query: CREATE TABLE table10 (a STRING, b STRING, constraint pk10 primary key (a) disable novalidate norely, foreign key (a, b) references table9(a, b) disable novalidate) +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:default +PREHOOK: Output: default@table10 +POSTHOOK: query: CREATE TABLE table10 (a STRING, b STRING, constraint pk10 primary key (a) disable novalidate norely, foreign key (a, b) references table9(a, b) disable novalidate) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:default +POSTHOOK: Output: default@table10 +PREHOOK: query: CREATE TABLE table11 (a STRING, b STRING, c STRING, constraint pk11 primary key (a) disable novalidate rely, foreign key (a, b) references table9(a, b) disable novalidate, +foreign key (c) references table4(x) disable novalidate) +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:default +PREHOOK: Output: default@table11 +POSTHOOK: query: CREATE TABLE table11 (a STRING, b STRING, c STRING, constraint pk11 primary key (a) disable novalidate rely, foreign key (a, b) references table9(a, b) disable novalidate, +foreign key (c) references table4(x) disable novalidate) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:default +POSTHOOK: Output: default@table11 +PREHOOK: query: ALTER TABLE table2 DROP CONSTRAINT pk1 +PREHOOK: type: ALTERTABLE_DROPCONSTRAINT +POSTHOOK: query: ALTER TABLE table2 DROP CONSTRAINT pk1 +POSTHOOK: type: ALTERTABLE_DROPCONSTRAINT +POSTHOOK: Input: default@table2 +POSTHOOK: Output: default@table2 +PREHOOK: query: ALTER TABLE table3 DROP CONSTRAINT fk1 +PREHOOK: type: ALTERTABLE_DROPCONSTRAINT +POSTHOOK: query: ALTER TABLE table3 DROP CONSTRAINT fk1 +POSTHOOK: type: ALTERTABLE_DROPCONSTRAINT +POSTHOOK: Input: default@table3 +POSTHOOK: Output: default@table3 +PREHOOK: query: ALTER TABLE table6 DROP CONSTRAINT fk4 +PREHOOK: type: ALTERTABLE_DROPCONSTRAINT +POSTHOOK: query: ALTER TABLE table6 DROP CONSTRAINT fk4 +POSTHOOK: type: ALTERTABLE_DROPCONSTRAINT +POSTHOOK: Input: default@table6 +POSTHOOK: Output: default@table6 +PREHOOK: query: CREATE DATABASE dbconstraint +PREHOOK: type: CREATEDATABASE +PREHOOK: Output: database:dbconstraint +POSTHOOK: query: CREATE DATABASE dbconstraint +POSTHOOK: type: CREATEDATABASE +POSTHOOK: Output: database:dbconstraint +PREHOOK: query: USE dbconstraint +PREHOOK: type: SWITCHDATABASE +PREHOOK: Input: database:dbconstraint +POSTHOOK: query: USE dbconstraint +POSTHOOK: type: SWITCHDATABASE +POSTHOOK: Input: database:dbconstraint +PREHOOK: query: CREATE TABLE table2 (a STRING, b STRING, constraint pk1 primary key (a) disable novalidate) +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:dbconstraint +PREHOOK: Output: dbconstraint@table2 +POSTHOOK: query: CREATE TABLE table2 (a STRING, b STRING, constraint pk1 primary key (a) disable novalidate) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:dbconstraint +POSTHOOK: Output: dbconstraint@table2 +PREHOOK: query: USE default +PREHOOK: type: SWITCHDATABASE +PREHOOK: Input: database:default +POSTHOOK: query: USE default +POSTHOOK: type: SWITCHDATABASE +POSTHOOK: Input: database:default +PREHOOK: query: ALTER TABLE dbconstraint.table2 DROP CONSTRAINT pk1 +PREHOOK: type: ALTERTABLE_DROPCONSTRAINT +POSTHOOK: query: ALTER TABLE dbconstraint.table2 DROP CONSTRAINT pk1 +POSTHOOK: type: ALTERTABLE_DROPCONSTRAINT +POSTHOOK: Input: dbconstraint@table2 +POSTHOOK: Output: dbconstraint@table2 diff --git a/service/src/gen/thrift/gen-py/__init__.py b/service/src/gen/thrift/gen-py/__init__.py deleted file mode 100644 index e69de29..0000000