commit 35663117937c7c753e3b5ae8f9088ba381c9d600 Author: Vihang Karajgaonkar Date: Mon May 1 15:56:19 2017 -0700 HIVE-16555 : Add a new thrift API call for get_metastore_uuid diff --git a/itests/hcatalog-unit/src/test/java/org/apache/hive/hcatalog/listener/DummyRawStoreFailEvent.java b/itests/hcatalog-unit/src/test/java/org/apache/hive/hcatalog/listener/DummyRawStoreFailEvent.java index 5282a5a4fb7687512f0fabd31f5cbadcfab93476..e166a8b58c544114bf4a5ff6f08e66d40dbe0faa 100644 --- a/itests/hcatalog-unit/src/test/java/org/apache/hive/hcatalog/listener/DummyRawStoreFailEvent.java +++ b/itests/hcatalog-unit/src/test/java/org/apache/hive/hcatalog/listener/DummyRawStoreFailEvent.java @@ -911,4 +911,9 @@ public void addPrimaryKeys(List pks) public void addForeignKeys(List fks) throws InvalidObjectException, MetaException { } + + @Override + public String getMetastoreUuid() throws MetaException { + return null; + } } \ No newline at end of file diff --git a/itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/TestEmbeddedHiveMetaStore.java b/itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/TestEmbeddedHiveMetaStore.java index bc00d11e2a1c9fd66b89f1ceca100aaafe43cfed..63b124a5b7a42797ab39539e0b4cc9cce459fcf3 100644 --- a/itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/TestEmbeddedHiveMetaStore.java +++ b/itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/TestEmbeddedHiveMetaStore.java @@ -21,28 +21,37 @@ import org.apache.hadoop.hive.conf.HiveConf; import org.apache.hadoop.util.StringUtils; +import java.util.ArrayList; +import java.util.List; +import java.util.concurrent.*; + public class TestEmbeddedHiveMetaStore extends TestHiveMetaStore { @Override protected void setUp() throws Exception { super.setUp(); warehouse = new Warehouse(hiveConf); + client = createClient(); + } + + @Override + protected void tearDown() throws Exception { try { - client = new HiveMetaStoreClient(hiveConf); + super.tearDown(); + client.close(); } catch (Throwable e) { - System.err.println("Unable to open the metastore"); + System.err.println("Unable to close metastore"); System.err.println(StringUtils.stringifyException(e)); throw new Exception(e); } } @Override - protected void tearDown() throws Exception { + protected HiveMetaStoreClient createClient() throws Exception { try { - super.tearDown(); - client.close(); + return new HiveMetaStoreClient(hiveConf); } catch (Throwable e) { - System.err.println("Unable to close metastore"); + System.err.println("Unable to open the metastore"); System.err.println(StringUtils.stringifyException(e)); throw new Exception(e); } diff --git a/itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/TestHiveMetaStore.java b/itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/TestHiveMetaStore.java index b95c25ca00751629577e014801c3fb9f1a99bd70..9d1e1dc306d72ced8580986688e070543971e3f8 100644 --- a/itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/TestHiveMetaStore.java +++ b/itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/TestHiveMetaStore.java @@ -31,6 +31,10 @@ import java.util.List; import java.util.Map; import java.util.Set; +import java.util.concurrent.Callable; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Future; import junit.framework.TestCase; @@ -99,6 +103,8 @@ private static final int DEFAULT_LIMIT_PARTITION_REQUEST = 100; + protected abstract HiveMetaStoreClient createClient() throws Exception; + @Override protected void setUp() throws Exception { hiveConf = new HiveConf(this.getClass()); @@ -110,6 +116,7 @@ protected void setUp() throws Exception { hiveConf.set("hive.key2", "http://www.example.com"); hiveConf.set("hive.key3", ""); hiveConf.set("hive.key4", "0"); + hiveConf.set("datanucleus.autoCreateTables", "false"); hiveConf.setIntVar(ConfVars.METASTORE_BATCH_RETRIEVE_MAX, 2); hiveConf.setIntVar(ConfVars.METASTORE_LIMIT_PARTITION_REQUEST, DEFAULT_LIMIT_PARTITION_REQUEST); @@ -3324,4 +3331,46 @@ public void testValidateTableCols() throws Throwable { throw e; } } + + public void testGetMetastoreUuid() throws Throwable { + String uuid = client.getMetastoreUuid(); + assertNotNull(uuid); + } + + public void testGetUUIDInParallel() throws Exception { + int numThreads = 5; + int parallelCalls = 10; + int numAPICallsPerThread = 10; + ExecutorService executorService = Executors.newFixedThreadPool(numThreads); + List>> futures = new ArrayList<>(); + for (int n = 0; n < parallelCalls; n++) { + futures.add(executorService.submit(new Callable>() { + @Override + public List call() throws Exception { + HiveMetaStoreClient testClient = new HiveMetaStoreClient(hiveConf); + List uuids = new ArrayList<>(10); + for (int i = 0; i < numAPICallsPerThread; i++) { + String uuid = testClient.getMetastoreUuid(); + uuids.add(uuid); + } + return uuids; + } + })); + } + + String firstUUID = null; + List allUuids = new ArrayList(); + for (Future> future : futures) { + for (String uuid : future.get()) { + if (firstUUID == null) { + firstUUID = uuid; + } else { + assertEquals(firstUUID.toLowerCase(), uuid.toLowerCase()); + } + allUuids.add(uuid); + } + } + int size = allUuids.size(); + assertEquals(numAPICallsPerThread * parallelCalls, size); + } } diff --git a/itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/TestRemoteHiveMetaStore.java b/itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/TestRemoteHiveMetaStore.java index ef02968e22363d537f58b6054266bf9bc87033ae..878f9131f7d206d497622af9e0eda219badbb1af 100644 --- a/itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/TestRemoteHiveMetaStore.java +++ b/itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/TestRemoteHiveMetaStore.java @@ -25,7 +25,7 @@ public class TestRemoteHiveMetaStore extends TestHiveMetaStore { private static boolean isServerStarted = false; - private static int port; + protected static int port; public TestRemoteHiveMetaStore() { super(); @@ -48,12 +48,13 @@ protected void setUp() throws Exception { isServerStarted = true; // This is default case with setugi off for both client and server - createClient(false); + client = createClient(); } - protected void createClient(boolean setugi) throws Exception { + @Override + protected HiveMetaStoreClient createClient() throws Exception { hiveConf.setVar(HiveConf.ConfVars.METASTOREURIS, "thrift://localhost:" + port); - hiveConf.setBoolVar(ConfVars.METASTORE_EXECUTE_SET_UGI,setugi); - client = new HiveMetaStoreClient(hiveConf); + hiveConf.setBoolVar(ConfVars.METASTORE_EXECUTE_SET_UGI, false); + return new HiveMetaStoreClient(hiveConf); } } \ No newline at end of file diff --git a/itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/TestSetUGIOnOnlyClient.java b/itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/TestSetUGIOnOnlyClient.java index 29768c1d660aac937c0cd1fa15fb70b571007d14..1a9abc9c8cfbcccb3aebb85fe7fab6f70a46d8cd 100644 --- a/itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/TestSetUGIOnOnlyClient.java +++ b/itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/TestSetUGIOnOnlyClient.java @@ -18,11 +18,14 @@ package org.apache.hadoop.hive.metastore; +import org.apache.hadoop.hive.conf.HiveConf; + public class TestSetUGIOnOnlyClient extends TestRemoteHiveMetaStore{ @Override - protected void createClient(boolean setugi) throws Exception { - // turn it on for client. - super.createClient(true); + protected HiveMetaStoreClient createClient() throws Exception { + hiveConf.setVar(HiveConf.ConfVars.METASTOREURIS, "thrift://localhost:" + port); + hiveConf.setBoolVar(HiveConf.ConfVars.METASTORE_EXECUTE_SET_UGI, true); + return new HiveMetaStoreClient(hiveConf); } } diff --git a/itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/TestSetUGIOnOnlyServer.java b/itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/TestSetUGIOnOnlyServer.java index 4a46f7537f3ceb16c45010b88786907109fd1090..b45fd011b96b704bfb9835c17961a429dc5ccf42 100644 --- a/itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/TestSetUGIOnOnlyServer.java +++ b/itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/TestSetUGIOnOnlyServer.java @@ -18,11 +18,14 @@ package org.apache.hadoop.hive.metastore; +import org.apache.hadoop.hive.conf.HiveConf; + public class TestSetUGIOnOnlyServer extends TestSetUGIOnBothClientServer { @Override - protected void createClient(boolean setugi) throws Exception { - // It is turned on for both client and server because of super class. Turn it off for client. - super.createClient(false); + protected HiveMetaStoreClient createClient() throws Exception { + hiveConf.setVar(HiveConf.ConfVars.METASTOREURIS, "thrift://localhost:" + port); + hiveConf.setBoolVar(HiveConf.ConfVars.METASTORE_EXECUTE_SET_UGI, false); + return new HiveMetaStoreClient(hiveConf); } } diff --git a/metastore/if/hive_metastore.thrift b/metastore/if/hive_metastore.thrift index a1bdc30bed81717346db1ad70603bcd991e9a2cb..88d00c8842678b0ce94818b150e68e2cc049287b 100755 --- a/metastore/if/hive_metastore.thrift +++ b/metastore/if/hive_metastore.thrift @@ -35,6 +35,12 @@ struct Version { 2: string comments } +struct MetastoreDBProperty { + 1: string propertyKey, + 2: string propertyValue, + 3: string description +} + struct FieldSchema { 1: string name, // name of the field 2: string type, // type of the field. primitive types defined above, specify list, map for lists & maps @@ -1488,6 +1494,8 @@ service ThriftHiveMetastore extends fb303.FacebookService ClearFileMetadataResult clear_file_metadata(1:ClearFileMetadataRequest req) CacheFileMetadataResult cache_file_metadata(1:CacheFileMetadataRequest req) + // Metastore DB properties + string get_metastore_uuid() throws (1:MetaException o1) } // * Note about the DDL_TIME: When creating or altering a table or a partition, diff --git a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp index 42de24e3ed731e90f14d72841ebfb5f9422dc38b..15656c3252cc0a1b15956d87ba95bb6697f156f5 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 _size818; - ::apache::thrift::protocol::TType _etype821; - xfer += iprot->readListBegin(_etype821, _size818); - this->success.resize(_size818); - uint32_t _i822; - for (_i822 = 0; _i822 < _size818; ++_i822) + uint32_t _size820; + ::apache::thrift::protocol::TType _etype823; + xfer += iprot->readListBegin(_etype823, _size820); + this->success.resize(_size820); + uint32_t _i824; + for (_i824 = 0; _i824 < _size820; ++_i824) { - xfer += iprot->readString(this->success[_i822]); + xfer += iprot->readString(this->success[_i824]); } 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 _iter823; - for (_iter823 = this->success.begin(); _iter823 != this->success.end(); ++_iter823) + std::vector ::const_iterator _iter825; + for (_iter825 = this->success.begin(); _iter825 != this->success.end(); ++_iter825) { - xfer += oprot->writeString((*_iter823)); + xfer += oprot->writeString((*_iter825)); } 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 _size824; - ::apache::thrift::protocol::TType _etype827; - xfer += iprot->readListBegin(_etype827, _size824); - (*(this->success)).resize(_size824); - uint32_t _i828; - for (_i828 = 0; _i828 < _size824; ++_i828) + uint32_t _size826; + ::apache::thrift::protocol::TType _etype829; + xfer += iprot->readListBegin(_etype829, _size826); + (*(this->success)).resize(_size826); + uint32_t _i830; + for (_i830 = 0; _i830 < _size826; ++_i830) { - xfer += iprot->readString((*(this->success))[_i828]); + xfer += iprot->readString((*(this->success))[_i830]); } 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 _size829; - ::apache::thrift::protocol::TType _etype832; - xfer += iprot->readListBegin(_etype832, _size829); - this->success.resize(_size829); - uint32_t _i833; - for (_i833 = 0; _i833 < _size829; ++_i833) + uint32_t _size831; + ::apache::thrift::protocol::TType _etype834; + xfer += iprot->readListBegin(_etype834, _size831); + this->success.resize(_size831); + uint32_t _i835; + for (_i835 = 0; _i835 < _size831; ++_i835) { - xfer += iprot->readString(this->success[_i833]); + xfer += iprot->readString(this->success[_i835]); } 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 _iter834; - for (_iter834 = this->success.begin(); _iter834 != this->success.end(); ++_iter834) + std::vector ::const_iterator _iter836; + for (_iter836 = this->success.begin(); _iter836 != this->success.end(); ++_iter836) { - xfer += oprot->writeString((*_iter834)); + xfer += oprot->writeString((*_iter836)); } 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 _size835; - ::apache::thrift::protocol::TType _etype838; - xfer += iprot->readListBegin(_etype838, _size835); - (*(this->success)).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->success)).resize(_size837); + uint32_t _i841; + for (_i841 = 0; _i841 < _size837; ++_i841) { - xfer += iprot->readString((*(this->success))[_i839]); + xfer += iprot->readString((*(this->success))[_i841]); } 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 _size840; - ::apache::thrift::protocol::TType _ktype841; - ::apache::thrift::protocol::TType _vtype842; - xfer += iprot->readMapBegin(_ktype841, _vtype842, _size840); - uint32_t _i844; - for (_i844 = 0; _i844 < _size840; ++_i844) + uint32_t _size842; + ::apache::thrift::protocol::TType _ktype843; + ::apache::thrift::protocol::TType _vtype844; + xfer += iprot->readMapBegin(_ktype843, _vtype844, _size842); + uint32_t _i846; + for (_i846 = 0; _i846 < _size842; ++_i846) { - std::string _key845; - xfer += iprot->readString(_key845); - Type& _val846 = this->success[_key845]; - xfer += _val846.read(iprot); + std::string _key847; + xfer += iprot->readString(_key847); + Type& _val848 = this->success[_key847]; + xfer += _val848.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 _iter847; - for (_iter847 = this->success.begin(); _iter847 != this->success.end(); ++_iter847) + std::map ::const_iterator _iter849; + for (_iter849 = this->success.begin(); _iter849 != this->success.end(); ++_iter849) { - xfer += oprot->writeString(_iter847->first); - xfer += _iter847->second.write(oprot); + xfer += oprot->writeString(_iter849->first); + xfer += _iter849->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 _size848; - ::apache::thrift::protocol::TType _ktype849; - ::apache::thrift::protocol::TType _vtype850; - xfer += iprot->readMapBegin(_ktype849, _vtype850, _size848); - uint32_t _i852; - for (_i852 = 0; _i852 < _size848; ++_i852) + uint32_t _size850; + ::apache::thrift::protocol::TType _ktype851; + ::apache::thrift::protocol::TType _vtype852; + xfer += iprot->readMapBegin(_ktype851, _vtype852, _size850); + uint32_t _i854; + for (_i854 = 0; _i854 < _size850; ++_i854) { - std::string _key853; - xfer += iprot->readString(_key853); - Type& _val854 = (*(this->success))[_key853]; - xfer += _val854.read(iprot); + std::string _key855; + xfer += iprot->readString(_key855); + Type& _val856 = (*(this->success))[_key855]; + xfer += _val856.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 _size855; - ::apache::thrift::protocol::TType _etype858; - xfer += iprot->readListBegin(_etype858, _size855); - this->success.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->success.resize(_size857); + uint32_t _i861; + for (_i861 = 0; _i861 < _size857; ++_i861) { - xfer += this->success[_i859].read(iprot); + xfer += this->success[_i861].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 _iter860; - for (_iter860 = this->success.begin(); _iter860 != this->success.end(); ++_iter860) + std::vector ::const_iterator _iter862; + for (_iter862 = this->success.begin(); _iter862 != this->success.end(); ++_iter862) { - xfer += (*_iter860).write(oprot); + xfer += (*_iter862).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 _size861; - ::apache::thrift::protocol::TType _etype864; - xfer += iprot->readListBegin(_etype864, _size861); - (*(this->success)).resize(_size861); - uint32_t _i865; - for (_i865 = 0; _i865 < _size861; ++_i865) + uint32_t _size863; + ::apache::thrift::protocol::TType _etype866; + xfer += iprot->readListBegin(_etype866, _size863); + (*(this->success)).resize(_size863); + uint32_t _i867; + for (_i867 = 0; _i867 < _size863; ++_i867) { - xfer += (*(this->success))[_i865].read(iprot); + xfer += (*(this->success))[_i867].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 _size866; - ::apache::thrift::protocol::TType _etype869; - xfer += iprot->readListBegin(_etype869, _size866); - this->success.resize(_size866); - uint32_t _i870; - for (_i870 = 0; _i870 < _size866; ++_i870) + 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) { - xfer += this->success[_i870].read(iprot); + xfer += this->success[_i872].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 _iter871; - for (_iter871 = this->success.begin(); _iter871 != this->success.end(); ++_iter871) + std::vector ::const_iterator _iter873; + for (_iter873 = this->success.begin(); _iter873 != this->success.end(); ++_iter873) { - xfer += (*_iter871).write(oprot); + xfer += (*_iter873).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 _size872; - ::apache::thrift::protocol::TType _etype875; - xfer += iprot->readListBegin(_etype875, _size872); - (*(this->success)).resize(_size872); - uint32_t _i876; - for (_i876 = 0; _i876 < _size872; ++_i876) + uint32_t _size874; + ::apache::thrift::protocol::TType _etype877; + xfer += iprot->readListBegin(_etype877, _size874); + (*(this->success)).resize(_size874); + uint32_t _i878; + for (_i878 = 0; _i878 < _size874; ++_i878) { - xfer += (*(this->success))[_i876].read(iprot); + xfer += (*(this->success))[_i878].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 _size877; - ::apache::thrift::protocol::TType _etype880; - xfer += iprot->readListBegin(_etype880, _size877); - this->success.resize(_size877); - uint32_t _i881; - for (_i881 = 0; _i881 < _size877; ++_i881) + 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) { - xfer += this->success[_i881].read(iprot); + xfer += this->success[_i883].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 _iter882; - for (_iter882 = this->success.begin(); _iter882 != this->success.end(); ++_iter882) + std::vector ::const_iterator _iter884; + for (_iter884 = this->success.begin(); _iter884 != this->success.end(); ++_iter884) { - xfer += (*_iter882).write(oprot); + xfer += (*_iter884).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 _size883; - ::apache::thrift::protocol::TType _etype886; - xfer += iprot->readListBegin(_etype886, _size883); - (*(this->success)).resize(_size883); - uint32_t _i887; - for (_i887 = 0; _i887 < _size883; ++_i887) + uint32_t _size885; + ::apache::thrift::protocol::TType _etype888; + xfer += iprot->readListBegin(_etype888, _size885); + (*(this->success)).resize(_size885); + uint32_t _i889; + for (_i889 = 0; _i889 < _size885; ++_i889) { - xfer += (*(this->success))[_i887].read(iprot); + xfer += (*(this->success))[_i889].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 _size888; - ::apache::thrift::protocol::TType _etype891; - xfer += iprot->readListBegin(_etype891, _size888); - this->success.resize(_size888); - uint32_t _i892; - for (_i892 = 0; _i892 < _size888; ++_i892) + uint32_t _size890; + ::apache::thrift::protocol::TType _etype893; + xfer += iprot->readListBegin(_etype893, _size890); + this->success.resize(_size890); + uint32_t _i894; + for (_i894 = 0; _i894 < _size890; ++_i894) { - xfer += this->success[_i892].read(iprot); + xfer += this->success[_i894].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 _iter893; - for (_iter893 = this->success.begin(); _iter893 != this->success.end(); ++_iter893) + std::vector ::const_iterator _iter895; + for (_iter895 = this->success.begin(); _iter895 != this->success.end(); ++_iter895) { - xfer += (*_iter893).write(oprot); + xfer += (*_iter895).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 _size894; - ::apache::thrift::protocol::TType _etype897; - xfer += iprot->readListBegin(_etype897, _size894); - (*(this->success)).resize(_size894); - uint32_t _i898; - for (_i898 = 0; _i898 < _size894; ++_i898) + uint32_t _size896; + ::apache::thrift::protocol::TType _etype899; + xfer += iprot->readListBegin(_etype899, _size896); + (*(this->success)).resize(_size896); + uint32_t _i900; + for (_i900 = 0; _i900 < _size896; ++_i900) { - xfer += (*(this->success))[_i898].read(iprot); + xfer += (*(this->success))[_i900].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 _size899; - ::apache::thrift::protocol::TType _etype902; - xfer += iprot->readListBegin(_etype902, _size899); - this->primaryKeys.resize(_size899); - uint32_t _i903; - for (_i903 = 0; _i903 < _size899; ++_i903) + uint32_t _size901; + ::apache::thrift::protocol::TType _etype904; + xfer += iprot->readListBegin(_etype904, _size901); + this->primaryKeys.resize(_size901); + uint32_t _i905; + for (_i905 = 0; _i905 < _size901; ++_i905) { - xfer += this->primaryKeys[_i903].read(iprot); + xfer += this->primaryKeys[_i905].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 _size904; - ::apache::thrift::protocol::TType _etype907; - xfer += iprot->readListBegin(_etype907, _size904); - this->foreignKeys.resize(_size904); - uint32_t _i908; - for (_i908 = 0; _i908 < _size904; ++_i908) + uint32_t _size906; + ::apache::thrift::protocol::TType _etype909; + xfer += iprot->readListBegin(_etype909, _size906); + this->foreignKeys.resize(_size906); + uint32_t _i910; + for (_i910 = 0; _i910 < _size906; ++_i910) { - xfer += this->foreignKeys[_i908].read(iprot); + xfer += this->foreignKeys[_i910].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 _iter909; - for (_iter909 = this->primaryKeys.begin(); _iter909 != this->primaryKeys.end(); ++_iter909) + std::vector ::const_iterator _iter911; + for (_iter911 = this->primaryKeys.begin(); _iter911 != this->primaryKeys.end(); ++_iter911) { - xfer += (*_iter909).write(oprot); + xfer += (*_iter911).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 _iter910; - for (_iter910 = this->foreignKeys.begin(); _iter910 != this->foreignKeys.end(); ++_iter910) + std::vector ::const_iterator _iter912; + for (_iter912 = this->foreignKeys.begin(); _iter912 != this->foreignKeys.end(); ++_iter912) { - xfer += (*_iter910).write(oprot); + xfer += (*_iter912).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 _iter911; - for (_iter911 = (*(this->primaryKeys)).begin(); _iter911 != (*(this->primaryKeys)).end(); ++_iter911) + std::vector ::const_iterator _iter913; + for (_iter913 = (*(this->primaryKeys)).begin(); _iter913 != (*(this->primaryKeys)).end(); ++_iter913) { - xfer += (*_iter911).write(oprot); + xfer += (*_iter913).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 _iter912; - for (_iter912 = (*(this->foreignKeys)).begin(); _iter912 != (*(this->foreignKeys)).end(); ++_iter912) + std::vector ::const_iterator _iter914; + for (_iter914 = (*(this->foreignKeys)).begin(); _iter914 != (*(this->foreignKeys)).end(); ++_iter914) { - xfer += (*_iter912).write(oprot); + xfer += (*_iter914).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6055,14 +6055,14 @@ uint32_t ThriftHiveMetastore_get_tables_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size913; - ::apache::thrift::protocol::TType _etype916; - xfer += iprot->readListBegin(_etype916, _size913); - this->success.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->success.resize(_size915); + uint32_t _i919; + for (_i919 = 0; _i919 < _size915; ++_i919) { - xfer += iprot->readString(this->success[_i917]); + xfer += iprot->readString(this->success[_i919]); } xfer += iprot->readListEnd(); } @@ -6101,10 +6101,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 _iter918; - for (_iter918 = this->success.begin(); _iter918 != this->success.end(); ++_iter918) + std::vector ::const_iterator _iter920; + for (_iter920 = this->success.begin(); _iter920 != this->success.end(); ++_iter920) { - xfer += oprot->writeString((*_iter918)); + xfer += oprot->writeString((*_iter920)); } xfer += oprot->writeListEnd(); } @@ -6149,14 +6149,14 @@ uint32_t ThriftHiveMetastore_get_tables_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size919; - ::apache::thrift::protocol::TType _etype922; - xfer += iprot->readListBegin(_etype922, _size919); - (*(this->success)).resize(_size919); - uint32_t _i923; - for (_i923 = 0; _i923 < _size919; ++_i923) + uint32_t _size921; + ::apache::thrift::protocol::TType _etype924; + xfer += iprot->readListBegin(_etype924, _size921); + (*(this->success)).resize(_size921); + uint32_t _i925; + for (_i925 = 0; _i925 < _size921; ++_i925) { - xfer += iprot->readString((*(this->success))[_i923]); + xfer += iprot->readString((*(this->success))[_i925]); } xfer += iprot->readListEnd(); } @@ -6326,14 +6326,14 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_result::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size924; - ::apache::thrift::protocol::TType _etype927; - xfer += iprot->readListBegin(_etype927, _size924); - this->success.resize(_size924); - uint32_t _i928; - for (_i928 = 0; _i928 < _size924; ++_i928) + uint32_t _size926; + ::apache::thrift::protocol::TType _etype929; + xfer += iprot->readListBegin(_etype929, _size926); + this->success.resize(_size926); + uint32_t _i930; + for (_i930 = 0; _i930 < _size926; ++_i930) { - xfer += iprot->readString(this->success[_i928]); + xfer += iprot->readString(this->success[_i930]); } xfer += iprot->readListEnd(); } @@ -6372,10 +6372,10 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_result::write(::apache::thrift:: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter929; - for (_iter929 = this->success.begin(); _iter929 != this->success.end(); ++_iter929) + std::vector ::const_iterator _iter931; + for (_iter931 = this->success.begin(); _iter931 != this->success.end(); ++_iter931) { - xfer += oprot->writeString((*_iter929)); + xfer += oprot->writeString((*_iter931)); } xfer += oprot->writeListEnd(); } @@ -6420,14 +6420,14 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_presult::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size930; - ::apache::thrift::protocol::TType _etype933; - xfer += iprot->readListBegin(_etype933, _size930); - (*(this->success)).resize(_size930); - uint32_t _i934; - for (_i934 = 0; _i934 < _size930; ++_i934) + uint32_t _size932; + ::apache::thrift::protocol::TType _etype935; + xfer += iprot->readListBegin(_etype935, _size932); + (*(this->success)).resize(_size932); + uint32_t _i936; + for (_i936 = 0; _i936 < _size932; ++_i936) { - xfer += iprot->readString((*(this->success))[_i934]); + xfer += iprot->readString((*(this->success))[_i936]); } xfer += iprot->readListEnd(); } @@ -6502,14 +6502,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 _size935; - ::apache::thrift::protocol::TType _etype938; - xfer += iprot->readListBegin(_etype938, _size935); - this->tbl_types.resize(_size935); - uint32_t _i939; - for (_i939 = 0; _i939 < _size935; ++_i939) + uint32_t _size937; + ::apache::thrift::protocol::TType _etype940; + xfer += iprot->readListBegin(_etype940, _size937); + this->tbl_types.resize(_size937); + uint32_t _i941; + for (_i941 = 0; _i941 < _size937; ++_i941) { - xfer += iprot->readString(this->tbl_types[_i939]); + xfer += iprot->readString(this->tbl_types[_i941]); } xfer += iprot->readListEnd(); } @@ -6546,10 +6546,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 _iter940; - for (_iter940 = this->tbl_types.begin(); _iter940 != this->tbl_types.end(); ++_iter940) + std::vector ::const_iterator _iter942; + for (_iter942 = this->tbl_types.begin(); _iter942 != this->tbl_types.end(); ++_iter942) { - xfer += oprot->writeString((*_iter940)); + xfer += oprot->writeString((*_iter942)); } xfer += oprot->writeListEnd(); } @@ -6581,10 +6581,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 _iter941; - for (_iter941 = (*(this->tbl_types)).begin(); _iter941 != (*(this->tbl_types)).end(); ++_iter941) + std::vector ::const_iterator _iter943; + for (_iter943 = (*(this->tbl_types)).begin(); _iter943 != (*(this->tbl_types)).end(); ++_iter943) { - xfer += oprot->writeString((*_iter941)); + xfer += oprot->writeString((*_iter943)); } xfer += oprot->writeListEnd(); } @@ -6625,14 +6625,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size942; - ::apache::thrift::protocol::TType _etype945; - xfer += iprot->readListBegin(_etype945, _size942); - this->success.resize(_size942); - uint32_t _i946; - for (_i946 = 0; _i946 < _size942; ++_i946) + uint32_t _size944; + ::apache::thrift::protocol::TType _etype947; + xfer += iprot->readListBegin(_etype947, _size944); + this->success.resize(_size944); + uint32_t _i948; + for (_i948 = 0; _i948 < _size944; ++_i948) { - xfer += this->success[_i946].read(iprot); + xfer += this->success[_i948].read(iprot); } xfer += iprot->readListEnd(); } @@ -6671,10 +6671,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 _iter947; - for (_iter947 = this->success.begin(); _iter947 != this->success.end(); ++_iter947) + std::vector ::const_iterator _iter949; + for (_iter949 = this->success.begin(); _iter949 != this->success.end(); ++_iter949) { - xfer += (*_iter947).write(oprot); + xfer += (*_iter949).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6719,14 +6719,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size948; - ::apache::thrift::protocol::TType _etype951; - xfer += iprot->readListBegin(_etype951, _size948); - (*(this->success)).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->success)).resize(_size950); + uint32_t _i954; + for (_i954 = 0; _i954 < _size950; ++_i954) { - xfer += (*(this->success))[_i952].read(iprot); + xfer += (*(this->success))[_i954].read(iprot); } xfer += iprot->readListEnd(); } @@ -6864,14 +6864,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size953; - ::apache::thrift::protocol::TType _etype956; - xfer += iprot->readListBegin(_etype956, _size953); - this->success.resize(_size953); - uint32_t _i957; - for (_i957 = 0; _i957 < _size953; ++_i957) + uint32_t _size955; + ::apache::thrift::protocol::TType _etype958; + xfer += iprot->readListBegin(_etype958, _size955); + this->success.resize(_size955); + uint32_t _i959; + for (_i959 = 0; _i959 < _size955; ++_i959) { - xfer += iprot->readString(this->success[_i957]); + xfer += iprot->readString(this->success[_i959]); } xfer += iprot->readListEnd(); } @@ -6910,10 +6910,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 _iter958; - for (_iter958 = this->success.begin(); _iter958 != this->success.end(); ++_iter958) + std::vector ::const_iterator _iter960; + for (_iter960 = this->success.begin(); _iter960 != this->success.end(); ++_iter960) { - xfer += oprot->writeString((*_iter958)); + xfer += oprot->writeString((*_iter960)); } xfer += oprot->writeListEnd(); } @@ -6958,14 +6958,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size959; - ::apache::thrift::protocol::TType _etype962; - xfer += iprot->readListBegin(_etype962, _size959); - (*(this->success)).resize(_size959); - uint32_t _i963; - for (_i963 = 0; _i963 < _size959; ++_i963) + uint32_t _size961; + ::apache::thrift::protocol::TType _etype964; + xfer += iprot->readListBegin(_etype964, _size961); + (*(this->success)).resize(_size961); + uint32_t _i965; + for (_i965 = 0; _i965 < _size961; ++_i965) { - xfer += iprot->readString((*(this->success))[_i963]); + xfer += iprot->readString((*(this->success))[_i965]); } xfer += iprot->readListEnd(); } @@ -7275,14 +7275,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 _size964; - ::apache::thrift::protocol::TType _etype967; - xfer += iprot->readListBegin(_etype967, _size964); - this->tbl_names.resize(_size964); - uint32_t _i968; - for (_i968 = 0; _i968 < _size964; ++_i968) + uint32_t _size966; + ::apache::thrift::protocol::TType _etype969; + xfer += iprot->readListBegin(_etype969, _size966); + this->tbl_names.resize(_size966); + uint32_t _i970; + for (_i970 = 0; _i970 < _size966; ++_i970) { - xfer += iprot->readString(this->tbl_names[_i968]); + xfer += iprot->readString(this->tbl_names[_i970]); } xfer += iprot->readListEnd(); } @@ -7315,10 +7315,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 _iter969; - for (_iter969 = this->tbl_names.begin(); _iter969 != this->tbl_names.end(); ++_iter969) + std::vector ::const_iterator _iter971; + for (_iter971 = this->tbl_names.begin(); _iter971 != this->tbl_names.end(); ++_iter971) { - xfer += oprot->writeString((*_iter969)); + xfer += oprot->writeString((*_iter971)); } xfer += oprot->writeListEnd(); } @@ -7346,10 +7346,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 _iter970; - for (_iter970 = (*(this->tbl_names)).begin(); _iter970 != (*(this->tbl_names)).end(); ++_iter970) + std::vector ::const_iterator _iter972; + for (_iter972 = (*(this->tbl_names)).begin(); _iter972 != (*(this->tbl_names)).end(); ++_iter972) { - xfer += oprot->writeString((*_iter970)); + xfer += oprot->writeString((*_iter972)); } xfer += oprot->writeListEnd(); } @@ -7390,14 +7390,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 _size971; - ::apache::thrift::protocol::TType _etype974; - xfer += iprot->readListBegin(_etype974, _size971); - this->success.resize(_size971); - uint32_t _i975; - for (_i975 = 0; _i975 < _size971; ++_i975) + uint32_t _size973; + ::apache::thrift::protocol::TType _etype976; + xfer += iprot->readListBegin(_etype976, _size973); + this->success.resize(_size973); + uint32_t _i977; + for (_i977 = 0; _i977 < _size973; ++_i977) { - xfer += this->success[_i975].read(iprot); + xfer += this->success[_i977].read(iprot); } xfer += iprot->readListEnd(); } @@ -7428,10 +7428,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 _iter976; - for (_iter976 = this->success.begin(); _iter976 != this->success.end(); ++_iter976) + std::vector
::const_iterator _iter978; + for (_iter978 = this->success.begin(); _iter978 != this->success.end(); ++_iter978) { - xfer += (*_iter976).write(oprot); + xfer += (*_iter978).write(oprot); } xfer += oprot->writeListEnd(); } @@ -7472,14 +7472,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 _size977; - ::apache::thrift::protocol::TType _etype980; - xfer += iprot->readListBegin(_etype980, _size977); - (*(this->success)).resize(_size977); - uint32_t _i981; - for (_i981 = 0; _i981 < _size977; ++_i981) + uint32_t _size979; + ::apache::thrift::protocol::TType _etype982; + xfer += iprot->readListBegin(_etype982, _size979); + (*(this->success)).resize(_size979); + uint32_t _i983; + for (_i983 = 0; _i983 < _size979; ++_i983) { - xfer += (*(this->success))[_i981].read(iprot); + xfer += (*(this->success))[_i983].read(iprot); } xfer += iprot->readListEnd(); } @@ -8115,14 +8115,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 _size982; - ::apache::thrift::protocol::TType _etype985; - xfer += iprot->readListBegin(_etype985, _size982); - this->success.resize(_size982); - uint32_t _i986; - for (_i986 = 0; _i986 < _size982; ++_i986) + uint32_t _size984; + ::apache::thrift::protocol::TType _etype987; + xfer += iprot->readListBegin(_etype987, _size984); + this->success.resize(_size984); + uint32_t _i988; + for (_i988 = 0; _i988 < _size984; ++_i988) { - xfer += iprot->readString(this->success[_i986]); + xfer += iprot->readString(this->success[_i988]); } xfer += iprot->readListEnd(); } @@ -8177,10 +8177,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 _iter987; - for (_iter987 = this->success.begin(); _iter987 != this->success.end(); ++_iter987) + std::vector ::const_iterator _iter989; + for (_iter989 = this->success.begin(); _iter989 != this->success.end(); ++_iter989) { - xfer += oprot->writeString((*_iter987)); + xfer += oprot->writeString((*_iter989)); } xfer += oprot->writeListEnd(); } @@ -8233,14 +8233,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 _size988; - ::apache::thrift::protocol::TType _etype991; - xfer += iprot->readListBegin(_etype991, _size988); - (*(this->success)).resize(_size988); - uint32_t _i992; - for (_i992 = 0; _i992 < _size988; ++_i992) + uint32_t _size990; + ::apache::thrift::protocol::TType _etype993; + xfer += iprot->readListBegin(_etype993, _size990); + (*(this->success)).resize(_size990); + uint32_t _i994; + for (_i994 = 0; _i994 < _size990; ++_i994) { - xfer += iprot->readString((*(this->success))[_i992]); + xfer += iprot->readString((*(this->success))[_i994]); } xfer += iprot->readListEnd(); } @@ -9574,14 +9574,14 @@ uint32_t ThriftHiveMetastore_add_partitions_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size993; - ::apache::thrift::protocol::TType _etype996; - xfer += iprot->readListBegin(_etype996, _size993); - this->new_parts.resize(_size993); - uint32_t _i997; - for (_i997 = 0; _i997 < _size993; ++_i997) + uint32_t _size995; + ::apache::thrift::protocol::TType _etype998; + xfer += iprot->readListBegin(_etype998, _size995); + this->new_parts.resize(_size995); + uint32_t _i999; + for (_i999 = 0; _i999 < _size995; ++_i999) { - xfer += this->new_parts[_i997].read(iprot); + xfer += this->new_parts[_i999].read(iprot); } xfer += iprot->readListEnd(); } @@ -9610,10 +9610,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 _iter998; - for (_iter998 = this->new_parts.begin(); _iter998 != this->new_parts.end(); ++_iter998) + std::vector ::const_iterator _iter1000; + for (_iter1000 = this->new_parts.begin(); _iter1000 != this->new_parts.end(); ++_iter1000) { - xfer += (*_iter998).write(oprot); + xfer += (*_iter1000).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9637,10 +9637,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 _iter999; - for (_iter999 = (*(this->new_parts)).begin(); _iter999 != (*(this->new_parts)).end(); ++_iter999) + std::vector ::const_iterator _iter1001; + for (_iter1001 = (*(this->new_parts)).begin(); _iter1001 != (*(this->new_parts)).end(); ++_iter1001) { - xfer += (*_iter999).write(oprot); + xfer += (*_iter1001).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9849,14 +9849,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 _size1000; - ::apache::thrift::protocol::TType _etype1003; - xfer += iprot->readListBegin(_etype1003, _size1000); - this->new_parts.resize(_size1000); - uint32_t _i1004; - for (_i1004 = 0; _i1004 < _size1000; ++_i1004) + uint32_t _size1002; + ::apache::thrift::protocol::TType _etype1005; + xfer += iprot->readListBegin(_etype1005, _size1002); + this->new_parts.resize(_size1002); + uint32_t _i1006; + for (_i1006 = 0; _i1006 < _size1002; ++_i1006) { - xfer += this->new_parts[_i1004].read(iprot); + xfer += this->new_parts[_i1006].read(iprot); } xfer += iprot->readListEnd(); } @@ -9885,10 +9885,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 _iter1005; - for (_iter1005 = this->new_parts.begin(); _iter1005 != this->new_parts.end(); ++_iter1005) + std::vector ::const_iterator _iter1007; + for (_iter1007 = this->new_parts.begin(); _iter1007 != this->new_parts.end(); ++_iter1007) { - xfer += (*_iter1005).write(oprot); + xfer += (*_iter1007).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9912,10 +9912,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 _iter1006; - for (_iter1006 = (*(this->new_parts)).begin(); _iter1006 != (*(this->new_parts)).end(); ++_iter1006) + std::vector ::const_iterator _iter1008; + for (_iter1008 = (*(this->new_parts)).begin(); _iter1008 != (*(this->new_parts)).end(); ++_iter1008) { - xfer += (*_iter1006).write(oprot); + xfer += (*_iter1008).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10140,14 +10140,14 @@ uint32_t ThriftHiveMetastore_append_partition_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1007; - ::apache::thrift::protocol::TType _etype1010; - xfer += iprot->readListBegin(_etype1010, _size1007); - this->part_vals.resize(_size1007); - uint32_t _i1011; - for (_i1011 = 0; _i1011 < _size1007; ++_i1011) + uint32_t _size1009; + ::apache::thrift::protocol::TType _etype1012; + xfer += iprot->readListBegin(_etype1012, _size1009); + this->part_vals.resize(_size1009); + uint32_t _i1013; + for (_i1013 = 0; _i1013 < _size1009; ++_i1013) { - xfer += iprot->readString(this->part_vals[_i1011]); + xfer += iprot->readString(this->part_vals[_i1013]); } xfer += iprot->readListEnd(); } @@ -10184,10 +10184,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 _iter1012; - for (_iter1012 = this->part_vals.begin(); _iter1012 != this->part_vals.end(); ++_iter1012) + std::vector ::const_iterator _iter1014; + for (_iter1014 = this->part_vals.begin(); _iter1014 != this->part_vals.end(); ++_iter1014) { - xfer += oprot->writeString((*_iter1012)); + xfer += oprot->writeString((*_iter1014)); } xfer += oprot->writeListEnd(); } @@ -10219,10 +10219,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 _iter1013; - for (_iter1013 = (*(this->part_vals)).begin(); _iter1013 != (*(this->part_vals)).end(); ++_iter1013) + std::vector ::const_iterator _iter1015; + for (_iter1015 = (*(this->part_vals)).begin(); _iter1015 != (*(this->part_vals)).end(); ++_iter1015) { - xfer += oprot->writeString((*_iter1013)); + xfer += oprot->writeString((*_iter1015)); } xfer += oprot->writeListEnd(); } @@ -10694,14 +10694,14 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::rea if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1014; - ::apache::thrift::protocol::TType _etype1017; - xfer += iprot->readListBegin(_etype1017, _size1014); - this->part_vals.resize(_size1014); - uint32_t _i1018; - for (_i1018 = 0; _i1018 < _size1014; ++_i1018) + uint32_t _size1016; + ::apache::thrift::protocol::TType _etype1019; + xfer += iprot->readListBegin(_etype1019, _size1016); + this->part_vals.resize(_size1016); + uint32_t _i1020; + for (_i1020 = 0; _i1020 < _size1016; ++_i1020) { - xfer += iprot->readString(this->part_vals[_i1018]); + xfer += iprot->readString(this->part_vals[_i1020]); } xfer += iprot->readListEnd(); } @@ -10746,10 +10746,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 _iter1019; - for (_iter1019 = this->part_vals.begin(); _iter1019 != this->part_vals.end(); ++_iter1019) + std::vector ::const_iterator _iter1021; + for (_iter1021 = this->part_vals.begin(); _iter1021 != this->part_vals.end(); ++_iter1021) { - xfer += oprot->writeString((*_iter1019)); + xfer += oprot->writeString((*_iter1021)); } xfer += oprot->writeListEnd(); } @@ -10785,10 +10785,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 _iter1020; - for (_iter1020 = (*(this->part_vals)).begin(); _iter1020 != (*(this->part_vals)).end(); ++_iter1020) + std::vector ::const_iterator _iter1022; + for (_iter1022 = (*(this->part_vals)).begin(); _iter1022 != (*(this->part_vals)).end(); ++_iter1022) { - xfer += oprot->writeString((*_iter1020)); + xfer += oprot->writeString((*_iter1022)); } xfer += oprot->writeListEnd(); } @@ -11591,14 +11591,14 @@ uint32_t ThriftHiveMetastore_drop_partition_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1021; - ::apache::thrift::protocol::TType _etype1024; - xfer += iprot->readListBegin(_etype1024, _size1021); - this->part_vals.resize(_size1021); - uint32_t _i1025; - for (_i1025 = 0; _i1025 < _size1021; ++_i1025) + uint32_t _size1023; + ::apache::thrift::protocol::TType _etype1026; + xfer += iprot->readListBegin(_etype1026, _size1023); + this->part_vals.resize(_size1023); + uint32_t _i1027; + for (_i1027 = 0; _i1027 < _size1023; ++_i1027) { - xfer += iprot->readString(this->part_vals[_i1025]); + xfer += iprot->readString(this->part_vals[_i1027]); } xfer += iprot->readListEnd(); } @@ -11643,10 +11643,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 _iter1026; - for (_iter1026 = this->part_vals.begin(); _iter1026 != this->part_vals.end(); ++_iter1026) + std::vector ::const_iterator _iter1028; + for (_iter1028 = this->part_vals.begin(); _iter1028 != this->part_vals.end(); ++_iter1028) { - xfer += oprot->writeString((*_iter1026)); + xfer += oprot->writeString((*_iter1028)); } xfer += oprot->writeListEnd(); } @@ -11682,10 +11682,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 _iter1027; - for (_iter1027 = (*(this->part_vals)).begin(); _iter1027 != (*(this->part_vals)).end(); ++_iter1027) + std::vector ::const_iterator _iter1029; + for (_iter1029 = (*(this->part_vals)).begin(); _iter1029 != (*(this->part_vals)).end(); ++_iter1029) { - xfer += oprot->writeString((*_iter1027)); + xfer += oprot->writeString((*_iter1029)); } xfer += oprot->writeListEnd(); } @@ -11894,14 +11894,14 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::read( if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1028; - ::apache::thrift::protocol::TType _etype1031; - xfer += iprot->readListBegin(_etype1031, _size1028); - this->part_vals.resize(_size1028); - uint32_t _i1032; - for (_i1032 = 0; _i1032 < _size1028; ++_i1032) + uint32_t _size1030; + ::apache::thrift::protocol::TType _etype1033; + xfer += iprot->readListBegin(_etype1033, _size1030); + this->part_vals.resize(_size1030); + uint32_t _i1034; + for (_i1034 = 0; _i1034 < _size1030; ++_i1034) { - xfer += iprot->readString(this->part_vals[_i1032]); + xfer += iprot->readString(this->part_vals[_i1034]); } xfer += iprot->readListEnd(); } @@ -11954,10 +11954,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 _iter1033; - for (_iter1033 = this->part_vals.begin(); _iter1033 != this->part_vals.end(); ++_iter1033) + std::vector ::const_iterator _iter1035; + for (_iter1035 = this->part_vals.begin(); _iter1035 != this->part_vals.end(); ++_iter1035) { - xfer += oprot->writeString((*_iter1033)); + xfer += oprot->writeString((*_iter1035)); } xfer += oprot->writeListEnd(); } @@ -11997,10 +11997,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 _iter1034; - for (_iter1034 = (*(this->part_vals)).begin(); _iter1034 != (*(this->part_vals)).end(); ++_iter1034) + std::vector ::const_iterator _iter1036; + for (_iter1036 = (*(this->part_vals)).begin(); _iter1036 != (*(this->part_vals)).end(); ++_iter1036) { - xfer += oprot->writeString((*_iter1034)); + xfer += oprot->writeString((*_iter1036)); } xfer += oprot->writeListEnd(); } @@ -13006,14 +13006,14 @@ uint32_t ThriftHiveMetastore_get_partition_args::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1035; - ::apache::thrift::protocol::TType _etype1038; - xfer += iprot->readListBegin(_etype1038, _size1035); - this->part_vals.resize(_size1035); - uint32_t _i1039; - for (_i1039 = 0; _i1039 < _size1035; ++_i1039) + uint32_t _size1037; + ::apache::thrift::protocol::TType _etype1040; + xfer += iprot->readListBegin(_etype1040, _size1037); + this->part_vals.resize(_size1037); + uint32_t _i1041; + for (_i1041 = 0; _i1041 < _size1037; ++_i1041) { - xfer += iprot->readString(this->part_vals[_i1039]); + xfer += iprot->readString(this->part_vals[_i1041]); } xfer += iprot->readListEnd(); } @@ -13050,10 +13050,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 _iter1040; - for (_iter1040 = this->part_vals.begin(); _iter1040 != this->part_vals.end(); ++_iter1040) + std::vector ::const_iterator _iter1042; + for (_iter1042 = this->part_vals.begin(); _iter1042 != this->part_vals.end(); ++_iter1042) { - xfer += oprot->writeString((*_iter1040)); + xfer += oprot->writeString((*_iter1042)); } xfer += oprot->writeListEnd(); } @@ -13085,10 +13085,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 _iter1041; - for (_iter1041 = (*(this->part_vals)).begin(); _iter1041 != (*(this->part_vals)).end(); ++_iter1041) + std::vector ::const_iterator _iter1043; + for (_iter1043 = (*(this->part_vals)).begin(); _iter1043 != (*(this->part_vals)).end(); ++_iter1043) { - xfer += oprot->writeString((*_iter1041)); + xfer += oprot->writeString((*_iter1043)); } xfer += oprot->writeListEnd(); } @@ -13277,17 +13277,17 @@ uint32_t ThriftHiveMetastore_exchange_partition_args::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size1042; - ::apache::thrift::protocol::TType _ktype1043; - ::apache::thrift::protocol::TType _vtype1044; - xfer += iprot->readMapBegin(_ktype1043, _vtype1044, _size1042); - uint32_t _i1046; - for (_i1046 = 0; _i1046 < _size1042; ++_i1046) + uint32_t _size1044; + ::apache::thrift::protocol::TType _ktype1045; + ::apache::thrift::protocol::TType _vtype1046; + xfer += iprot->readMapBegin(_ktype1045, _vtype1046, _size1044); + uint32_t _i1048; + for (_i1048 = 0; _i1048 < _size1044; ++_i1048) { - std::string _key1047; - xfer += iprot->readString(_key1047); - std::string& _val1048 = this->partitionSpecs[_key1047]; - xfer += iprot->readString(_val1048); + std::string _key1049; + xfer += iprot->readString(_key1049); + std::string& _val1050 = this->partitionSpecs[_key1049]; + xfer += iprot->readString(_val1050); } xfer += iprot->readMapEnd(); } @@ -13348,11 +13348,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 _iter1049; - for (_iter1049 = this->partitionSpecs.begin(); _iter1049 != this->partitionSpecs.end(); ++_iter1049) + std::map ::const_iterator _iter1051; + for (_iter1051 = this->partitionSpecs.begin(); _iter1051 != this->partitionSpecs.end(); ++_iter1051) { - xfer += oprot->writeString(_iter1049->first); - xfer += oprot->writeString(_iter1049->second); + xfer += oprot->writeString(_iter1051->first); + xfer += oprot->writeString(_iter1051->second); } xfer += oprot->writeMapEnd(); } @@ -13392,11 +13392,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 _iter1050; - for (_iter1050 = (*(this->partitionSpecs)).begin(); _iter1050 != (*(this->partitionSpecs)).end(); ++_iter1050) + std::map ::const_iterator _iter1052; + for (_iter1052 = (*(this->partitionSpecs)).begin(); _iter1052 != (*(this->partitionSpecs)).end(); ++_iter1052) { - xfer += oprot->writeString(_iter1050->first); - xfer += oprot->writeString(_iter1050->second); + xfer += oprot->writeString(_iter1052->first); + xfer += oprot->writeString(_iter1052->second); } xfer += oprot->writeMapEnd(); } @@ -13641,17 +13641,17 @@ uint32_t ThriftHiveMetastore_exchange_partitions_args::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size1051; - ::apache::thrift::protocol::TType _ktype1052; - ::apache::thrift::protocol::TType _vtype1053; - xfer += iprot->readMapBegin(_ktype1052, _vtype1053, _size1051); - uint32_t _i1055; - for (_i1055 = 0; _i1055 < _size1051; ++_i1055) + uint32_t _size1053; + ::apache::thrift::protocol::TType _ktype1054; + ::apache::thrift::protocol::TType _vtype1055; + xfer += iprot->readMapBegin(_ktype1054, _vtype1055, _size1053); + uint32_t _i1057; + for (_i1057 = 0; _i1057 < _size1053; ++_i1057) { - std::string _key1056; - xfer += iprot->readString(_key1056); - std::string& _val1057 = this->partitionSpecs[_key1056]; - xfer += iprot->readString(_val1057); + std::string _key1058; + xfer += iprot->readString(_key1058); + std::string& _val1059 = this->partitionSpecs[_key1058]; + xfer += iprot->readString(_val1059); } xfer += iprot->readMapEnd(); } @@ -13712,11 +13712,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 _iter1058; - for (_iter1058 = this->partitionSpecs.begin(); _iter1058 != this->partitionSpecs.end(); ++_iter1058) + std::map ::const_iterator _iter1060; + for (_iter1060 = this->partitionSpecs.begin(); _iter1060 != this->partitionSpecs.end(); ++_iter1060) { - xfer += oprot->writeString(_iter1058->first); - xfer += oprot->writeString(_iter1058->second); + xfer += oprot->writeString(_iter1060->first); + xfer += oprot->writeString(_iter1060->second); } xfer += oprot->writeMapEnd(); } @@ -13756,11 +13756,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 _iter1059; - for (_iter1059 = (*(this->partitionSpecs)).begin(); _iter1059 != (*(this->partitionSpecs)).end(); ++_iter1059) + std::map ::const_iterator _iter1061; + for (_iter1061 = (*(this->partitionSpecs)).begin(); _iter1061 != (*(this->partitionSpecs)).end(); ++_iter1061) { - xfer += oprot->writeString(_iter1059->first); - xfer += oprot->writeString(_iter1059->second); + xfer += oprot->writeString(_iter1061->first); + xfer += oprot->writeString(_iter1061->second); } xfer += oprot->writeMapEnd(); } @@ -13817,14 +13817,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1060; - ::apache::thrift::protocol::TType _etype1063; - xfer += iprot->readListBegin(_etype1063, _size1060); - this->success.resize(_size1060); - uint32_t _i1064; - for (_i1064 = 0; _i1064 < _size1060; ++_i1064) + uint32_t _size1062; + ::apache::thrift::protocol::TType _etype1065; + xfer += iprot->readListBegin(_etype1065, _size1062); + this->success.resize(_size1062); + uint32_t _i1066; + for (_i1066 = 0; _i1066 < _size1062; ++_i1066) { - xfer += this->success[_i1064].read(iprot); + xfer += this->success[_i1066].read(iprot); } xfer += iprot->readListEnd(); } @@ -13887,10 +13887,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 _iter1065; - for (_iter1065 = this->success.begin(); _iter1065 != this->success.end(); ++_iter1065) + std::vector ::const_iterator _iter1067; + for (_iter1067 = this->success.begin(); _iter1067 != this->success.end(); ++_iter1067) { - xfer += (*_iter1065).write(oprot); + xfer += (*_iter1067).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13947,14 +13947,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1066; - ::apache::thrift::protocol::TType _etype1069; - xfer += iprot->readListBegin(_etype1069, _size1066); - (*(this->success)).resize(_size1066); - uint32_t _i1070; - for (_i1070 = 0; _i1070 < _size1066; ++_i1070) + uint32_t _size1068; + ::apache::thrift::protocol::TType _etype1071; + xfer += iprot->readListBegin(_etype1071, _size1068); + (*(this->success)).resize(_size1068); + uint32_t _i1072; + for (_i1072 = 0; _i1072 < _size1068; ++_i1072) { - xfer += (*(this->success))[_i1070].read(iprot); + xfer += (*(this->success))[_i1072].read(iprot); } xfer += iprot->readListEnd(); } @@ -14053,14 +14053,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 _size1071; - ::apache::thrift::protocol::TType _etype1074; - xfer += iprot->readListBegin(_etype1074, _size1071); - this->part_vals.resize(_size1071); - uint32_t _i1075; - for (_i1075 = 0; _i1075 < _size1071; ++_i1075) + uint32_t _size1073; + ::apache::thrift::protocol::TType _etype1076; + xfer += iprot->readListBegin(_etype1076, _size1073); + this->part_vals.resize(_size1073); + uint32_t _i1077; + for (_i1077 = 0; _i1077 < _size1073; ++_i1077) { - xfer += iprot->readString(this->part_vals[_i1075]); + xfer += iprot->readString(this->part_vals[_i1077]); } xfer += iprot->readListEnd(); } @@ -14081,14 +14081,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 _size1076; - ::apache::thrift::protocol::TType _etype1079; - xfer += iprot->readListBegin(_etype1079, _size1076); - this->group_names.resize(_size1076); - uint32_t _i1080; - for (_i1080 = 0; _i1080 < _size1076; ++_i1080) + uint32_t _size1078; + ::apache::thrift::protocol::TType _etype1081; + xfer += iprot->readListBegin(_etype1081, _size1078); + this->group_names.resize(_size1078); + uint32_t _i1082; + for (_i1082 = 0; _i1082 < _size1078; ++_i1082) { - xfer += iprot->readString(this->group_names[_i1080]); + xfer += iprot->readString(this->group_names[_i1082]); } xfer += iprot->readListEnd(); } @@ -14125,10 +14125,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 _iter1081; - for (_iter1081 = this->part_vals.begin(); _iter1081 != this->part_vals.end(); ++_iter1081) + std::vector ::const_iterator _iter1083; + for (_iter1083 = this->part_vals.begin(); _iter1083 != this->part_vals.end(); ++_iter1083) { - xfer += oprot->writeString((*_iter1081)); + xfer += oprot->writeString((*_iter1083)); } xfer += oprot->writeListEnd(); } @@ -14141,10 +14141,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 _iter1082; - for (_iter1082 = this->group_names.begin(); _iter1082 != this->group_names.end(); ++_iter1082) + std::vector ::const_iterator _iter1084; + for (_iter1084 = this->group_names.begin(); _iter1084 != this->group_names.end(); ++_iter1084) { - xfer += oprot->writeString((*_iter1082)); + xfer += oprot->writeString((*_iter1084)); } xfer += oprot->writeListEnd(); } @@ -14176,10 +14176,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 _iter1083; - for (_iter1083 = (*(this->part_vals)).begin(); _iter1083 != (*(this->part_vals)).end(); ++_iter1083) + std::vector ::const_iterator _iter1085; + for (_iter1085 = (*(this->part_vals)).begin(); _iter1085 != (*(this->part_vals)).end(); ++_iter1085) { - xfer += oprot->writeString((*_iter1083)); + xfer += oprot->writeString((*_iter1085)); } xfer += oprot->writeListEnd(); } @@ -14192,10 +14192,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 _iter1084; - for (_iter1084 = (*(this->group_names)).begin(); _iter1084 != (*(this->group_names)).end(); ++_iter1084) + std::vector ::const_iterator _iter1086; + for (_iter1086 = (*(this->group_names)).begin(); _iter1086 != (*(this->group_names)).end(); ++_iter1086) { - xfer += oprot->writeString((*_iter1084)); + xfer += oprot->writeString((*_iter1086)); } xfer += oprot->writeListEnd(); } @@ -14754,14 +14754,14 @@ uint32_t ThriftHiveMetastore_get_partitions_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1085; - ::apache::thrift::protocol::TType _etype1088; - xfer += iprot->readListBegin(_etype1088, _size1085); - this->success.resize(_size1085); - uint32_t _i1089; - for (_i1089 = 0; _i1089 < _size1085; ++_i1089) + uint32_t _size1087; + ::apache::thrift::protocol::TType _etype1090; + xfer += iprot->readListBegin(_etype1090, _size1087); + this->success.resize(_size1087); + uint32_t _i1091; + for (_i1091 = 0; _i1091 < _size1087; ++_i1091) { - xfer += this->success[_i1089].read(iprot); + xfer += this->success[_i1091].read(iprot); } xfer += iprot->readListEnd(); } @@ -14808,10 +14808,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 _iter1090; - for (_iter1090 = this->success.begin(); _iter1090 != this->success.end(); ++_iter1090) + std::vector ::const_iterator _iter1092; + for (_iter1092 = this->success.begin(); _iter1092 != this->success.end(); ++_iter1092) { - xfer += (*_iter1090).write(oprot); + xfer += (*_iter1092).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14860,14 +14860,14 @@ uint32_t ThriftHiveMetastore_get_partitions_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1091; - ::apache::thrift::protocol::TType _etype1094; - xfer += iprot->readListBegin(_etype1094, _size1091); - (*(this->success)).resize(_size1091); - uint32_t _i1095; - for (_i1095 = 0; _i1095 < _size1091; ++_i1095) + uint32_t _size1093; + ::apache::thrift::protocol::TType _etype1096; + xfer += iprot->readListBegin(_etype1096, _size1093); + (*(this->success)).resize(_size1093); + uint32_t _i1097; + for (_i1097 = 0; _i1097 < _size1093; ++_i1097) { - xfer += (*(this->success))[_i1095].read(iprot); + xfer += (*(this->success))[_i1097].read(iprot); } xfer += iprot->readListEnd(); } @@ -14966,14 +14966,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 _size1096; - ::apache::thrift::protocol::TType _etype1099; - xfer += iprot->readListBegin(_etype1099, _size1096); - this->group_names.resize(_size1096); - uint32_t _i1100; - for (_i1100 = 0; _i1100 < _size1096; ++_i1100) + uint32_t _size1098; + ::apache::thrift::protocol::TType _etype1101; + xfer += iprot->readListBegin(_etype1101, _size1098); + this->group_names.resize(_size1098); + uint32_t _i1102; + for (_i1102 = 0; _i1102 < _size1098; ++_i1102) { - xfer += iprot->readString(this->group_names[_i1100]); + xfer += iprot->readString(this->group_names[_i1102]); } xfer += iprot->readListEnd(); } @@ -15018,10 +15018,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 _iter1101; - for (_iter1101 = this->group_names.begin(); _iter1101 != this->group_names.end(); ++_iter1101) + std::vector ::const_iterator _iter1103; + for (_iter1103 = this->group_names.begin(); _iter1103 != this->group_names.end(); ++_iter1103) { - xfer += oprot->writeString((*_iter1101)); + xfer += oprot->writeString((*_iter1103)); } xfer += oprot->writeListEnd(); } @@ -15061,10 +15061,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 _iter1102; - for (_iter1102 = (*(this->group_names)).begin(); _iter1102 != (*(this->group_names)).end(); ++_iter1102) + std::vector ::const_iterator _iter1104; + for (_iter1104 = (*(this->group_names)).begin(); _iter1104 != (*(this->group_names)).end(); ++_iter1104) { - xfer += oprot->writeString((*_iter1102)); + xfer += oprot->writeString((*_iter1104)); } xfer += oprot->writeListEnd(); } @@ -15105,14 +15105,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1103; - ::apache::thrift::protocol::TType _etype1106; - xfer += iprot->readListBegin(_etype1106, _size1103); - this->success.resize(_size1103); - uint32_t _i1107; - for (_i1107 = 0; _i1107 < _size1103; ++_i1107) + uint32_t _size1105; + ::apache::thrift::protocol::TType _etype1108; + xfer += iprot->readListBegin(_etype1108, _size1105); + this->success.resize(_size1105); + uint32_t _i1109; + for (_i1109 = 0; _i1109 < _size1105; ++_i1109) { - xfer += this->success[_i1107].read(iprot); + xfer += this->success[_i1109].read(iprot); } xfer += iprot->readListEnd(); } @@ -15159,10 +15159,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 _iter1108; - for (_iter1108 = this->success.begin(); _iter1108 != this->success.end(); ++_iter1108) + std::vector ::const_iterator _iter1110; + for (_iter1110 = this->success.begin(); _iter1110 != this->success.end(); ++_iter1110) { - xfer += (*_iter1108).write(oprot); + xfer += (*_iter1110).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15211,14 +15211,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1109; - ::apache::thrift::protocol::TType _etype1112; - xfer += iprot->readListBegin(_etype1112, _size1109); - (*(this->success)).resize(_size1109); - uint32_t _i1113; - for (_i1113 = 0; _i1113 < _size1109; ++_i1113) + uint32_t _size1111; + ::apache::thrift::protocol::TType _etype1114; + xfer += iprot->readListBegin(_etype1114, _size1111); + (*(this->success)).resize(_size1111); + uint32_t _i1115; + for (_i1115 = 0; _i1115 < _size1111; ++_i1115) { - xfer += (*(this->success))[_i1113].read(iprot); + xfer += (*(this->success))[_i1115].read(iprot); } xfer += iprot->readListEnd(); } @@ -15396,14 +15396,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_result::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1114; - ::apache::thrift::protocol::TType _etype1117; - xfer += iprot->readListBegin(_etype1117, _size1114); - this->success.resize(_size1114); - uint32_t _i1118; - for (_i1118 = 0; _i1118 < _size1114; ++_i1118) + uint32_t _size1116; + ::apache::thrift::protocol::TType _etype1119; + xfer += iprot->readListBegin(_etype1119, _size1116); + this->success.resize(_size1116); + uint32_t _i1120; + for (_i1120 = 0; _i1120 < _size1116; ++_i1120) { - xfer += this->success[_i1118].read(iprot); + xfer += this->success[_i1120].read(iprot); } xfer += iprot->readListEnd(); } @@ -15450,10 +15450,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 _iter1119; - for (_iter1119 = this->success.begin(); _iter1119 != this->success.end(); ++_iter1119) + std::vector ::const_iterator _iter1121; + for (_iter1121 = this->success.begin(); _iter1121 != this->success.end(); ++_iter1121) { - xfer += (*_iter1119).write(oprot); + xfer += (*_iter1121).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15502,14 +15502,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_presult::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1120; - ::apache::thrift::protocol::TType _etype1123; - xfer += iprot->readListBegin(_etype1123, _size1120); - (*(this->success)).resize(_size1120); - uint32_t _i1124; - for (_i1124 = 0; _i1124 < _size1120; ++_i1124) + uint32_t _size1122; + ::apache::thrift::protocol::TType _etype1125; + xfer += iprot->readListBegin(_etype1125, _size1122); + (*(this->success)).resize(_size1122); + uint32_t _i1126; + for (_i1126 = 0; _i1126 < _size1122; ++_i1126) { - xfer += (*(this->success))[_i1124].read(iprot); + xfer += (*(this->success))[_i1126].read(iprot); } xfer += iprot->readListEnd(); } @@ -15687,14 +15687,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1125; - ::apache::thrift::protocol::TType _etype1128; - xfer += iprot->readListBegin(_etype1128, _size1125); - this->success.resize(_size1125); - uint32_t _i1129; - for (_i1129 = 0; _i1129 < _size1125; ++_i1129) + uint32_t _size1127; + ::apache::thrift::protocol::TType _etype1130; + xfer += iprot->readListBegin(_etype1130, _size1127); + this->success.resize(_size1127); + uint32_t _i1131; + for (_i1131 = 0; _i1131 < _size1127; ++_i1131) { - xfer += iprot->readString(this->success[_i1129]); + xfer += iprot->readString(this->success[_i1131]); } xfer += iprot->readListEnd(); } @@ -15733,10 +15733,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 _iter1130; - for (_iter1130 = this->success.begin(); _iter1130 != this->success.end(); ++_iter1130) + std::vector ::const_iterator _iter1132; + for (_iter1132 = this->success.begin(); _iter1132 != this->success.end(); ++_iter1132) { - xfer += oprot->writeString((*_iter1130)); + xfer += oprot->writeString((*_iter1132)); } xfer += oprot->writeListEnd(); } @@ -15781,14 +15781,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1131; - ::apache::thrift::protocol::TType _etype1134; - xfer += iprot->readListBegin(_etype1134, _size1131); - (*(this->success)).resize(_size1131); - uint32_t _i1135; - for (_i1135 = 0; _i1135 < _size1131; ++_i1135) + uint32_t _size1133; + ::apache::thrift::protocol::TType _etype1136; + xfer += iprot->readListBegin(_etype1136, _size1133); + (*(this->success)).resize(_size1133); + uint32_t _i1137; + for (_i1137 = 0; _i1137 < _size1133; ++_i1137) { - xfer += iprot->readString((*(this->success))[_i1135]); + xfer += iprot->readString((*(this->success))[_i1137]); } xfer += iprot->readListEnd(); } @@ -15863,14 +15863,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 _size1136; - ::apache::thrift::protocol::TType _etype1139; - xfer += iprot->readListBegin(_etype1139, _size1136); - this->part_vals.resize(_size1136); - uint32_t _i1140; - for (_i1140 = 0; _i1140 < _size1136; ++_i1140) + uint32_t _size1138; + ::apache::thrift::protocol::TType _etype1141; + xfer += iprot->readListBegin(_etype1141, _size1138); + this->part_vals.resize(_size1138); + uint32_t _i1142; + for (_i1142 = 0; _i1142 < _size1138; ++_i1142) { - xfer += iprot->readString(this->part_vals[_i1140]); + xfer += iprot->readString(this->part_vals[_i1142]); } xfer += iprot->readListEnd(); } @@ -15915,10 +15915,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 _iter1141; - for (_iter1141 = this->part_vals.begin(); _iter1141 != this->part_vals.end(); ++_iter1141) + std::vector ::const_iterator _iter1143; + for (_iter1143 = this->part_vals.begin(); _iter1143 != this->part_vals.end(); ++_iter1143) { - xfer += oprot->writeString((*_iter1141)); + xfer += oprot->writeString((*_iter1143)); } xfer += oprot->writeListEnd(); } @@ -15954,10 +15954,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 _iter1142; - for (_iter1142 = (*(this->part_vals)).begin(); _iter1142 != (*(this->part_vals)).end(); ++_iter1142) + std::vector ::const_iterator _iter1144; + for (_iter1144 = (*(this->part_vals)).begin(); _iter1144 != (*(this->part_vals)).end(); ++_iter1144) { - xfer += oprot->writeString((*_iter1142)); + xfer += oprot->writeString((*_iter1144)); } xfer += oprot->writeListEnd(); } @@ -16002,14 +16002,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_result::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1143; - ::apache::thrift::protocol::TType _etype1146; - xfer += iprot->readListBegin(_etype1146, _size1143); - this->success.resize(_size1143); - uint32_t _i1147; - for (_i1147 = 0; _i1147 < _size1143; ++_i1147) + uint32_t _size1145; + ::apache::thrift::protocol::TType _etype1148; + xfer += iprot->readListBegin(_etype1148, _size1145); + this->success.resize(_size1145); + uint32_t _i1149; + for (_i1149 = 0; _i1149 < _size1145; ++_i1149) { - xfer += this->success[_i1147].read(iprot); + xfer += this->success[_i1149].read(iprot); } xfer += iprot->readListEnd(); } @@ -16056,10 +16056,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 _iter1148; - for (_iter1148 = this->success.begin(); _iter1148 != this->success.end(); ++_iter1148) + std::vector ::const_iterator _iter1150; + for (_iter1150 = this->success.begin(); _iter1150 != this->success.end(); ++_iter1150) { - xfer += (*_iter1148).write(oprot); + xfer += (*_iter1150).write(oprot); } xfer += oprot->writeListEnd(); } @@ -16108,14 +16108,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_presult::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1149; - ::apache::thrift::protocol::TType _etype1152; - xfer += iprot->readListBegin(_etype1152, _size1149); - (*(this->success)).resize(_size1149); - uint32_t _i1153; - for (_i1153 = 0; _i1153 < _size1149; ++_i1153) + uint32_t _size1151; + ::apache::thrift::protocol::TType _etype1154; + xfer += iprot->readListBegin(_etype1154, _size1151); + (*(this->success)).resize(_size1151); + uint32_t _i1155; + for (_i1155 = 0; _i1155 < _size1151; ++_i1155) { - xfer += (*(this->success))[_i1153].read(iprot); + xfer += (*(this->success))[_i1155].read(iprot); } xfer += iprot->readListEnd(); } @@ -16198,14 +16198,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 _size1154; - ::apache::thrift::protocol::TType _etype1157; - xfer += iprot->readListBegin(_etype1157, _size1154); - this->part_vals.resize(_size1154); - uint32_t _i1158; - for (_i1158 = 0; _i1158 < _size1154; ++_i1158) + uint32_t _size1156; + ::apache::thrift::protocol::TType _etype1159; + xfer += iprot->readListBegin(_etype1159, _size1156); + this->part_vals.resize(_size1156); + uint32_t _i1160; + for (_i1160 = 0; _i1160 < _size1156; ++_i1160) { - xfer += iprot->readString(this->part_vals[_i1158]); + xfer += iprot->readString(this->part_vals[_i1160]); } xfer += iprot->readListEnd(); } @@ -16234,14 +16234,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 _size1159; - ::apache::thrift::protocol::TType _etype1162; - xfer += iprot->readListBegin(_etype1162, _size1159); - this->group_names.resize(_size1159); - uint32_t _i1163; - for (_i1163 = 0; _i1163 < _size1159; ++_i1163) + uint32_t _size1161; + ::apache::thrift::protocol::TType _etype1164; + xfer += iprot->readListBegin(_etype1164, _size1161); + this->group_names.resize(_size1161); + uint32_t _i1165; + for (_i1165 = 0; _i1165 < _size1161; ++_i1165) { - xfer += iprot->readString(this->group_names[_i1163]); + xfer += iprot->readString(this->group_names[_i1165]); } xfer += iprot->readListEnd(); } @@ -16278,10 +16278,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 _iter1164; - for (_iter1164 = this->part_vals.begin(); _iter1164 != this->part_vals.end(); ++_iter1164) + std::vector ::const_iterator _iter1166; + for (_iter1166 = this->part_vals.begin(); _iter1166 != this->part_vals.end(); ++_iter1166) { - xfer += oprot->writeString((*_iter1164)); + xfer += oprot->writeString((*_iter1166)); } xfer += oprot->writeListEnd(); } @@ -16298,10 +16298,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 _iter1165; - for (_iter1165 = this->group_names.begin(); _iter1165 != this->group_names.end(); ++_iter1165) + std::vector ::const_iterator _iter1167; + for (_iter1167 = this->group_names.begin(); _iter1167 != this->group_names.end(); ++_iter1167) { - xfer += oprot->writeString((*_iter1165)); + xfer += oprot->writeString((*_iter1167)); } xfer += oprot->writeListEnd(); } @@ -16333,10 +16333,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 _iter1166; - for (_iter1166 = (*(this->part_vals)).begin(); _iter1166 != (*(this->part_vals)).end(); ++_iter1166) + std::vector ::const_iterator _iter1168; + for (_iter1168 = (*(this->part_vals)).begin(); _iter1168 != (*(this->part_vals)).end(); ++_iter1168) { - xfer += oprot->writeString((*_iter1166)); + xfer += oprot->writeString((*_iter1168)); } xfer += oprot->writeListEnd(); } @@ -16353,10 +16353,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 _iter1167; - for (_iter1167 = (*(this->group_names)).begin(); _iter1167 != (*(this->group_names)).end(); ++_iter1167) + std::vector ::const_iterator _iter1169; + for (_iter1169 = (*(this->group_names)).begin(); _iter1169 != (*(this->group_names)).end(); ++_iter1169) { - xfer += oprot->writeString((*_iter1167)); + xfer += oprot->writeString((*_iter1169)); } xfer += oprot->writeListEnd(); } @@ -16397,14 +16397,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_result::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1168; - ::apache::thrift::protocol::TType _etype1171; - xfer += iprot->readListBegin(_etype1171, _size1168); - this->success.resize(_size1168); - uint32_t _i1172; - for (_i1172 = 0; _i1172 < _size1168; ++_i1172) + uint32_t _size1170; + ::apache::thrift::protocol::TType _etype1173; + xfer += iprot->readListBegin(_etype1173, _size1170); + this->success.resize(_size1170); + uint32_t _i1174; + for (_i1174 = 0; _i1174 < _size1170; ++_i1174) { - xfer += this->success[_i1172].read(iprot); + xfer += this->success[_i1174].read(iprot); } xfer += iprot->readListEnd(); } @@ -16451,10 +16451,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 _iter1173; - for (_iter1173 = this->success.begin(); _iter1173 != this->success.end(); ++_iter1173) + std::vector ::const_iterator _iter1175; + for (_iter1175 = this->success.begin(); _iter1175 != this->success.end(); ++_iter1175) { - xfer += (*_iter1173).write(oprot); + xfer += (*_iter1175).write(oprot); } xfer += oprot->writeListEnd(); } @@ -16503,14 +16503,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_presult::read(::apache: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1174; - ::apache::thrift::protocol::TType _etype1177; - xfer += iprot->readListBegin(_etype1177, _size1174); - (*(this->success)).resize(_size1174); - uint32_t _i1178; - for (_i1178 = 0; _i1178 < _size1174; ++_i1178) + uint32_t _size1176; + ::apache::thrift::protocol::TType _etype1179; + xfer += iprot->readListBegin(_etype1179, _size1176); + (*(this->success)).resize(_size1176); + uint32_t _i1180; + for (_i1180 = 0; _i1180 < _size1176; ++_i1180) { - xfer += (*(this->success))[_i1178].read(iprot); + xfer += (*(this->success))[_i1180].read(iprot); } xfer += iprot->readListEnd(); } @@ -16593,14 +16593,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 _size1179; - ::apache::thrift::protocol::TType _etype1182; - xfer += iprot->readListBegin(_etype1182, _size1179); - this->part_vals.resize(_size1179); - uint32_t _i1183; - for (_i1183 = 0; _i1183 < _size1179; ++_i1183) + uint32_t _size1181; + ::apache::thrift::protocol::TType _etype1184; + xfer += iprot->readListBegin(_etype1184, _size1181); + this->part_vals.resize(_size1181); + uint32_t _i1185; + for (_i1185 = 0; _i1185 < _size1181; ++_i1185) { - xfer += iprot->readString(this->part_vals[_i1183]); + xfer += iprot->readString(this->part_vals[_i1185]); } xfer += iprot->readListEnd(); } @@ -16645,10 +16645,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 _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(); } @@ -16684,10 +16684,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 _iter1185; - for (_iter1185 = (*(this->part_vals)).begin(); _iter1185 != (*(this->part_vals)).end(); ++_iter1185) + std::vector ::const_iterator _iter1187; + for (_iter1187 = (*(this->part_vals)).begin(); _iter1187 != (*(this->part_vals)).end(); ++_iter1187) { - xfer += oprot->writeString((*_iter1185)); + xfer += oprot->writeString((*_iter1187)); } xfer += oprot->writeListEnd(); } @@ -16732,14 +16732,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1186; - ::apache::thrift::protocol::TType _etype1189; - xfer += iprot->readListBegin(_etype1189, _size1186); - this->success.resize(_size1186); - uint32_t _i1190; - for (_i1190 = 0; _i1190 < _size1186; ++_i1190) + uint32_t _size1188; + ::apache::thrift::protocol::TType _etype1191; + xfer += iprot->readListBegin(_etype1191, _size1188); + this->success.resize(_size1188); + uint32_t _i1192; + for (_i1192 = 0; _i1192 < _size1188; ++_i1192) { - xfer += iprot->readString(this->success[_i1190]); + xfer += iprot->readString(this->success[_i1192]); } xfer += iprot->readListEnd(); } @@ -16786,10 +16786,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 _iter1191; - for (_iter1191 = this->success.begin(); _iter1191 != this->success.end(); ++_iter1191) + std::vector ::const_iterator _iter1193; + for (_iter1193 = this->success.begin(); _iter1193 != this->success.end(); ++_iter1193) { - xfer += oprot->writeString((*_iter1191)); + xfer += oprot->writeString((*_iter1193)); } xfer += oprot->writeListEnd(); } @@ -16838,14 +16838,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1192; - ::apache::thrift::protocol::TType _etype1195; - xfer += iprot->readListBegin(_etype1195, _size1192); - (*(this->success)).resize(_size1192); - uint32_t _i1196; - for (_i1196 = 0; _i1196 < _size1192; ++_i1196) + uint32_t _size1194; + ::apache::thrift::protocol::TType _etype1197; + xfer += iprot->readListBegin(_etype1197, _size1194); + (*(this->success)).resize(_size1194); + uint32_t _i1198; + for (_i1198 = 0; _i1198 < _size1194; ++_i1198) { - xfer += iprot->readString((*(this->success))[_i1196]); + xfer += iprot->readString((*(this->success))[_i1198]); } xfer += iprot->readListEnd(); } @@ -17039,14 +17039,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1197; - ::apache::thrift::protocol::TType _etype1200; - xfer += iprot->readListBegin(_etype1200, _size1197); - this->success.resize(_size1197); - uint32_t _i1201; - for (_i1201 = 0; _i1201 < _size1197; ++_i1201) + uint32_t _size1199; + ::apache::thrift::protocol::TType _etype1202; + xfer += iprot->readListBegin(_etype1202, _size1199); + this->success.resize(_size1199); + uint32_t _i1203; + for (_i1203 = 0; _i1203 < _size1199; ++_i1203) { - xfer += this->success[_i1201].read(iprot); + xfer += this->success[_i1203].read(iprot); } xfer += iprot->readListEnd(); } @@ -17093,10 +17093,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 _iter1202; - for (_iter1202 = this->success.begin(); _iter1202 != this->success.end(); ++_iter1202) + std::vector ::const_iterator _iter1204; + for (_iter1204 = this->success.begin(); _iter1204 != this->success.end(); ++_iter1204) { - xfer += (*_iter1202).write(oprot); + xfer += (*_iter1204).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17145,14 +17145,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1203; - ::apache::thrift::protocol::TType _etype1206; - xfer += iprot->readListBegin(_etype1206, _size1203); - (*(this->success)).resize(_size1203); - uint32_t _i1207; - for (_i1207 = 0; _i1207 < _size1203; ++_i1207) + uint32_t _size1205; + ::apache::thrift::protocol::TType _etype1208; + xfer += iprot->readListBegin(_etype1208, _size1205); + (*(this->success)).resize(_size1205); + uint32_t _i1209; + for (_i1209 = 0; _i1209 < _size1205; ++_i1209) { - xfer += (*(this->success))[_i1207].read(iprot); + xfer += (*(this->success))[_i1209].read(iprot); } xfer += iprot->readListEnd(); } @@ -17346,14 +17346,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 _size1208; - ::apache::thrift::protocol::TType _etype1211; - xfer += iprot->readListBegin(_etype1211, _size1208); - this->success.resize(_size1208); - uint32_t _i1212; - for (_i1212 = 0; _i1212 < _size1208; ++_i1212) + uint32_t _size1210; + ::apache::thrift::protocol::TType _etype1213; + xfer += iprot->readListBegin(_etype1213, _size1210); + this->success.resize(_size1210); + uint32_t _i1214; + for (_i1214 = 0; _i1214 < _size1210; ++_i1214) { - xfer += this->success[_i1212].read(iprot); + xfer += this->success[_i1214].read(iprot); } xfer += iprot->readListEnd(); } @@ -17400,10 +17400,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 _iter1213; - for (_iter1213 = this->success.begin(); _iter1213 != this->success.end(); ++_iter1213) + std::vector ::const_iterator _iter1215; + for (_iter1215 = this->success.begin(); _iter1215 != this->success.end(); ++_iter1215) { - xfer += (*_iter1213).write(oprot); + xfer += (*_iter1215).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17452,14 +17452,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 _size1214; - ::apache::thrift::protocol::TType _etype1217; - xfer += iprot->readListBegin(_etype1217, _size1214); - (*(this->success)).resize(_size1214); - uint32_t _i1218; - for (_i1218 = 0; _i1218 < _size1214; ++_i1218) + uint32_t _size1216; + ::apache::thrift::protocol::TType _etype1219; + xfer += iprot->readListBegin(_etype1219, _size1216); + (*(this->success)).resize(_size1216); + uint32_t _i1220; + for (_i1220 = 0; _i1220 < _size1216; ++_i1220) { - xfer += (*(this->success))[_i1218].read(iprot); + xfer += (*(this->success))[_i1220].read(iprot); } xfer += iprot->readListEnd(); } @@ -18028,14 +18028,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_args::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { this->names.clear(); - uint32_t _size1219; - ::apache::thrift::protocol::TType _etype1222; - xfer += iprot->readListBegin(_etype1222, _size1219); - this->names.resize(_size1219); - uint32_t _i1223; - for (_i1223 = 0; _i1223 < _size1219; ++_i1223) + uint32_t _size1221; + ::apache::thrift::protocol::TType _etype1224; + xfer += iprot->readListBegin(_etype1224, _size1221); + this->names.resize(_size1221); + uint32_t _i1225; + for (_i1225 = 0; _i1225 < _size1221; ++_i1225) { - xfer += iprot->readString(this->names[_i1223]); + xfer += iprot->readString(this->names[_i1225]); } xfer += iprot->readListEnd(); } @@ -18072,10 +18072,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 _iter1224; - for (_iter1224 = this->names.begin(); _iter1224 != this->names.end(); ++_iter1224) + std::vector ::const_iterator _iter1226; + for (_iter1226 = this->names.begin(); _iter1226 != this->names.end(); ++_iter1226) { - xfer += oprot->writeString((*_iter1224)); + xfer += oprot->writeString((*_iter1226)); } xfer += oprot->writeListEnd(); } @@ -18107,10 +18107,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 _iter1225; - for (_iter1225 = (*(this->names)).begin(); _iter1225 != (*(this->names)).end(); ++_iter1225) + std::vector ::const_iterator _iter1227; + for (_iter1227 = (*(this->names)).begin(); _iter1227 != (*(this->names)).end(); ++_iter1227) { - xfer += oprot->writeString((*_iter1225)); + xfer += oprot->writeString((*_iter1227)); } xfer += oprot->writeListEnd(); } @@ -18151,14 +18151,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_result::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1226; - ::apache::thrift::protocol::TType _etype1229; - xfer += iprot->readListBegin(_etype1229, _size1226); - this->success.resize(_size1226); - uint32_t _i1230; - for (_i1230 = 0; _i1230 < _size1226; ++_i1230) + uint32_t _size1228; + ::apache::thrift::protocol::TType _etype1231; + xfer += iprot->readListBegin(_etype1231, _size1228); + this->success.resize(_size1228); + uint32_t _i1232; + for (_i1232 = 0; _i1232 < _size1228; ++_i1232) { - xfer += this->success[_i1230].read(iprot); + xfer += this->success[_i1232].read(iprot); } xfer += iprot->readListEnd(); } @@ -18205,10 +18205,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 _iter1231; - for (_iter1231 = this->success.begin(); _iter1231 != this->success.end(); ++_iter1231) + std::vector ::const_iterator _iter1233; + for (_iter1233 = this->success.begin(); _iter1233 != this->success.end(); ++_iter1233) { - xfer += (*_iter1231).write(oprot); + xfer += (*_iter1233).write(oprot); } xfer += oprot->writeListEnd(); } @@ -18257,14 +18257,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_presult::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1232; - ::apache::thrift::protocol::TType _etype1235; - xfer += iprot->readListBegin(_etype1235, _size1232); - (*(this->success)).resize(_size1232); - uint32_t _i1236; - for (_i1236 = 0; _i1236 < _size1232; ++_i1236) + uint32_t _size1234; + ::apache::thrift::protocol::TType _etype1237; + xfer += iprot->readListBegin(_etype1237, _size1234); + (*(this->success)).resize(_size1234); + uint32_t _i1238; + for (_i1238 = 0; _i1238 < _size1234; ++_i1238) { - xfer += (*(this->success))[_i1236].read(iprot); + xfer += (*(this->success))[_i1238].read(iprot); } xfer += iprot->readListEnd(); } @@ -18586,14 +18586,14 @@ uint32_t ThriftHiveMetastore_alter_partitions_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size1237; - ::apache::thrift::protocol::TType _etype1240; - xfer += iprot->readListBegin(_etype1240, _size1237); - this->new_parts.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->new_parts.resize(_size1239); + uint32_t _i1243; + for (_i1243 = 0; _i1243 < _size1239; ++_i1243) { - xfer += this->new_parts[_i1241].read(iprot); + xfer += this->new_parts[_i1243].read(iprot); } xfer += iprot->readListEnd(); } @@ -18630,10 +18630,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 _iter1242; - for (_iter1242 = this->new_parts.begin(); _iter1242 != this->new_parts.end(); ++_iter1242) + std::vector ::const_iterator _iter1244; + for (_iter1244 = this->new_parts.begin(); _iter1244 != this->new_parts.end(); ++_iter1244) { - xfer += (*_iter1242).write(oprot); + xfer += (*_iter1244).write(oprot); } xfer += oprot->writeListEnd(); } @@ -18665,10 +18665,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 _iter1243; - for (_iter1243 = (*(this->new_parts)).begin(); _iter1243 != (*(this->new_parts)).end(); ++_iter1243) + std::vector ::const_iterator _iter1245; + for (_iter1245 = (*(this->new_parts)).begin(); _iter1245 != (*(this->new_parts)).end(); ++_iter1245) { - xfer += (*_iter1243).write(oprot); + xfer += (*_iter1245).write(oprot); } xfer += oprot->writeListEnd(); } @@ -18853,14 +18853,14 @@ uint32_t ThriftHiveMetastore_alter_partitions_with_environment_context_args::rea if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size1244; - ::apache::thrift::protocol::TType _etype1247; - xfer += iprot->readListBegin(_etype1247, _size1244); - this->new_parts.resize(_size1244); - uint32_t _i1248; - for (_i1248 = 0; _i1248 < _size1244; ++_i1248) + uint32_t _size1246; + ::apache::thrift::protocol::TType _etype1249; + xfer += iprot->readListBegin(_etype1249, _size1246); + this->new_parts.resize(_size1246); + uint32_t _i1250; + for (_i1250 = 0; _i1250 < _size1246; ++_i1250) { - xfer += this->new_parts[_i1248].read(iprot); + xfer += this->new_parts[_i1250].read(iprot); } xfer += iprot->readListEnd(); } @@ -18905,10 +18905,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 _iter1249; - for (_iter1249 = this->new_parts.begin(); _iter1249 != this->new_parts.end(); ++_iter1249) + std::vector ::const_iterator _iter1251; + for (_iter1251 = this->new_parts.begin(); _iter1251 != this->new_parts.end(); ++_iter1251) { - xfer += (*_iter1249).write(oprot); + xfer += (*_iter1251).write(oprot); } xfer += oprot->writeListEnd(); } @@ -18944,10 +18944,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 _iter1250; - for (_iter1250 = (*(this->new_parts)).begin(); _iter1250 != (*(this->new_parts)).end(); ++_iter1250) + std::vector ::const_iterator _iter1252; + for (_iter1252 = (*(this->new_parts)).begin(); _iter1252 != (*(this->new_parts)).end(); ++_iter1252) { - xfer += (*_iter1250).write(oprot); + xfer += (*_iter1252).write(oprot); } xfer += oprot->writeListEnd(); } @@ -19391,14 +19391,14 @@ uint32_t ThriftHiveMetastore_rename_partition_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1251; - ::apache::thrift::protocol::TType _etype1254; - xfer += iprot->readListBegin(_etype1254, _size1251); - this->part_vals.resize(_size1251); - uint32_t _i1255; - for (_i1255 = 0; _i1255 < _size1251; ++_i1255) + uint32_t _size1253; + ::apache::thrift::protocol::TType _etype1256; + xfer += iprot->readListBegin(_etype1256, _size1253); + this->part_vals.resize(_size1253); + uint32_t _i1257; + for (_i1257 = 0; _i1257 < _size1253; ++_i1257) { - xfer += iprot->readString(this->part_vals[_i1255]); + xfer += iprot->readString(this->part_vals[_i1257]); } xfer += iprot->readListEnd(); } @@ -19443,10 +19443,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 _iter1256; - for (_iter1256 = this->part_vals.begin(); _iter1256 != this->part_vals.end(); ++_iter1256) + std::vector ::const_iterator _iter1258; + for (_iter1258 = this->part_vals.begin(); _iter1258 != this->part_vals.end(); ++_iter1258) { - xfer += oprot->writeString((*_iter1256)); + xfer += oprot->writeString((*_iter1258)); } xfer += oprot->writeListEnd(); } @@ -19482,10 +19482,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 _iter1257; - for (_iter1257 = (*(this->part_vals)).begin(); _iter1257 != (*(this->part_vals)).end(); ++_iter1257) + std::vector ::const_iterator _iter1259; + for (_iter1259 = (*(this->part_vals)).begin(); _iter1259 != (*(this->part_vals)).end(); ++_iter1259) { - xfer += oprot->writeString((*_iter1257)); + xfer += oprot->writeString((*_iter1259)); } xfer += oprot->writeListEnd(); } @@ -19658,14 +19658,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 _size1258; - ::apache::thrift::protocol::TType _etype1261; - xfer += iprot->readListBegin(_etype1261, _size1258); - this->part_vals.resize(_size1258); - uint32_t _i1262; - for (_i1262 = 0; _i1262 < _size1258; ++_i1262) + uint32_t _size1260; + ::apache::thrift::protocol::TType _etype1263; + xfer += iprot->readListBegin(_etype1263, _size1260); + this->part_vals.resize(_size1260); + uint32_t _i1264; + for (_i1264 = 0; _i1264 < _size1260; ++_i1264) { - xfer += iprot->readString(this->part_vals[_i1262]); + xfer += iprot->readString(this->part_vals[_i1264]); } xfer += iprot->readListEnd(); } @@ -19702,10 +19702,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 _iter1263; - for (_iter1263 = this->part_vals.begin(); _iter1263 != this->part_vals.end(); ++_iter1263) + std::vector ::const_iterator _iter1265; + for (_iter1265 = this->part_vals.begin(); _iter1265 != this->part_vals.end(); ++_iter1265) { - xfer += oprot->writeString((*_iter1263)); + xfer += oprot->writeString((*_iter1265)); } xfer += oprot->writeListEnd(); } @@ -19733,10 +19733,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 _iter1264; - for (_iter1264 = (*(this->part_vals)).begin(); _iter1264 != (*(this->part_vals)).end(); ++_iter1264) + std::vector ::const_iterator _iter1266; + for (_iter1266 = (*(this->part_vals)).begin(); _iter1266 != (*(this->part_vals)).end(); ++_iter1266) { - xfer += oprot->writeString((*_iter1264)); + xfer += oprot->writeString((*_iter1266)); } xfer += oprot->writeListEnd(); } @@ -20211,14 +20211,14 @@ uint32_t ThriftHiveMetastore_partition_name_to_vals_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1265; - ::apache::thrift::protocol::TType _etype1268; - xfer += iprot->readListBegin(_etype1268, _size1265); - this->success.resize(_size1265); - uint32_t _i1269; - for (_i1269 = 0; _i1269 < _size1265; ++_i1269) + uint32_t _size1267; + ::apache::thrift::protocol::TType _etype1270; + xfer += iprot->readListBegin(_etype1270, _size1267); + this->success.resize(_size1267); + uint32_t _i1271; + for (_i1271 = 0; _i1271 < _size1267; ++_i1271) { - xfer += iprot->readString(this->success[_i1269]); + xfer += iprot->readString(this->success[_i1271]); } xfer += iprot->readListEnd(); } @@ -20257,10 +20257,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 _iter1270; - for (_iter1270 = this->success.begin(); _iter1270 != this->success.end(); ++_iter1270) + std::vector ::const_iterator _iter1272; + for (_iter1272 = this->success.begin(); _iter1272 != this->success.end(); ++_iter1272) { - xfer += oprot->writeString((*_iter1270)); + xfer += oprot->writeString((*_iter1272)); } xfer += oprot->writeListEnd(); } @@ -20305,14 +20305,14 @@ uint32_t ThriftHiveMetastore_partition_name_to_vals_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1271; - ::apache::thrift::protocol::TType _etype1274; - xfer += iprot->readListBegin(_etype1274, _size1271); - (*(this->success)).resize(_size1271); - uint32_t _i1275; - for (_i1275 = 0; _i1275 < _size1271; ++_i1275) + uint32_t _size1273; + ::apache::thrift::protocol::TType _etype1276; + xfer += iprot->readListBegin(_etype1276, _size1273); + (*(this->success)).resize(_size1273); + uint32_t _i1277; + for (_i1277 = 0; _i1277 < _size1273; ++_i1277) { - xfer += iprot->readString((*(this->success))[_i1275]); + xfer += iprot->readString((*(this->success))[_i1277]); } xfer += iprot->readListEnd(); } @@ -20450,17 +20450,17 @@ uint32_t ThriftHiveMetastore_partition_name_to_spec_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_MAP) { { this->success.clear(); - uint32_t _size1276; - ::apache::thrift::protocol::TType _ktype1277; - ::apache::thrift::protocol::TType _vtype1278; - xfer += iprot->readMapBegin(_ktype1277, _vtype1278, _size1276); - uint32_t _i1280; - for (_i1280 = 0; _i1280 < _size1276; ++_i1280) + uint32_t _size1278; + ::apache::thrift::protocol::TType _ktype1279; + ::apache::thrift::protocol::TType _vtype1280; + xfer += iprot->readMapBegin(_ktype1279, _vtype1280, _size1278); + uint32_t _i1282; + for (_i1282 = 0; _i1282 < _size1278; ++_i1282) { - std::string _key1281; - xfer += iprot->readString(_key1281); - std::string& _val1282 = this->success[_key1281]; - xfer += iprot->readString(_val1282); + std::string _key1283; + xfer += iprot->readString(_key1283); + std::string& _val1284 = this->success[_key1283]; + xfer += iprot->readString(_val1284); } xfer += iprot->readMapEnd(); } @@ -20499,11 +20499,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 _iter1283; - for (_iter1283 = this->success.begin(); _iter1283 != this->success.end(); ++_iter1283) + std::map ::const_iterator _iter1285; + for (_iter1285 = this->success.begin(); _iter1285 != this->success.end(); ++_iter1285) { - xfer += oprot->writeString(_iter1283->first); - xfer += oprot->writeString(_iter1283->second); + xfer += oprot->writeString(_iter1285->first); + xfer += oprot->writeString(_iter1285->second); } xfer += oprot->writeMapEnd(); } @@ -20548,17 +20548,17 @@ uint32_t ThriftHiveMetastore_partition_name_to_spec_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_MAP) { { (*(this->success)).clear(); - uint32_t _size1284; - ::apache::thrift::protocol::TType _ktype1285; - ::apache::thrift::protocol::TType _vtype1286; - xfer += iprot->readMapBegin(_ktype1285, _vtype1286, _size1284); - uint32_t _i1288; - for (_i1288 = 0; _i1288 < _size1284; ++_i1288) + uint32_t _size1286; + ::apache::thrift::protocol::TType _ktype1287; + ::apache::thrift::protocol::TType _vtype1288; + xfer += iprot->readMapBegin(_ktype1287, _vtype1288, _size1286); + uint32_t _i1290; + for (_i1290 = 0; _i1290 < _size1286; ++_i1290) { - std::string _key1289; - xfer += iprot->readString(_key1289); - std::string& _val1290 = (*(this->success))[_key1289]; - xfer += iprot->readString(_val1290); + std::string _key1291; + xfer += iprot->readString(_key1291); + std::string& _val1292 = (*(this->success))[_key1291]; + xfer += iprot->readString(_val1292); } xfer += iprot->readMapEnd(); } @@ -20633,17 +20633,17 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_args::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_MAP) { { this->part_vals.clear(); - uint32_t _size1291; - ::apache::thrift::protocol::TType _ktype1292; - ::apache::thrift::protocol::TType _vtype1293; - xfer += iprot->readMapBegin(_ktype1292, _vtype1293, _size1291); - uint32_t _i1295; - for (_i1295 = 0; _i1295 < _size1291; ++_i1295) + uint32_t _size1293; + ::apache::thrift::protocol::TType _ktype1294; + ::apache::thrift::protocol::TType _vtype1295; + xfer += iprot->readMapBegin(_ktype1294, _vtype1295, _size1293); + uint32_t _i1297; + for (_i1297 = 0; _i1297 < _size1293; ++_i1297) { - std::string _key1296; - xfer += iprot->readString(_key1296); - std::string& _val1297 = this->part_vals[_key1296]; - xfer += iprot->readString(_val1297); + std::string _key1298; + xfer += iprot->readString(_key1298); + std::string& _val1299 = this->part_vals[_key1298]; + xfer += iprot->readString(_val1299); } xfer += iprot->readMapEnd(); } @@ -20654,9 +20654,9 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_args::read(::apache::thrift:: break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1298; - xfer += iprot->readI32(ecast1298); - this->eventType = (PartitionEventType::type)ecast1298; + int32_t ecast1300; + xfer += iprot->readI32(ecast1300); + this->eventType = (PartitionEventType::type)ecast1300; this->__isset.eventType = true; } else { xfer += iprot->skip(ftype); @@ -20690,11 +20690,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 _iter1299; - for (_iter1299 = this->part_vals.begin(); _iter1299 != this->part_vals.end(); ++_iter1299) + std::map ::const_iterator _iter1301; + for (_iter1301 = this->part_vals.begin(); _iter1301 != this->part_vals.end(); ++_iter1301) { - xfer += oprot->writeString(_iter1299->first); - xfer += oprot->writeString(_iter1299->second); + xfer += oprot->writeString(_iter1301->first); + xfer += oprot->writeString(_iter1301->second); } xfer += oprot->writeMapEnd(); } @@ -20730,11 +20730,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 _iter1300; - for (_iter1300 = (*(this->part_vals)).begin(); _iter1300 != (*(this->part_vals)).end(); ++_iter1300) + std::map ::const_iterator _iter1302; + for (_iter1302 = (*(this->part_vals)).begin(); _iter1302 != (*(this->part_vals)).end(); ++_iter1302) { - xfer += oprot->writeString(_iter1300->first); - xfer += oprot->writeString(_iter1300->second); + xfer += oprot->writeString(_iter1302->first); + xfer += oprot->writeString(_iter1302->second); } xfer += oprot->writeMapEnd(); } @@ -21003,17 +21003,17 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_MAP) { { this->part_vals.clear(); - uint32_t _size1301; - ::apache::thrift::protocol::TType _ktype1302; - ::apache::thrift::protocol::TType _vtype1303; - xfer += iprot->readMapBegin(_ktype1302, _vtype1303, _size1301); - uint32_t _i1305; - for (_i1305 = 0; _i1305 < _size1301; ++_i1305) + uint32_t _size1303; + ::apache::thrift::protocol::TType _ktype1304; + ::apache::thrift::protocol::TType _vtype1305; + xfer += iprot->readMapBegin(_ktype1304, _vtype1305, _size1303); + uint32_t _i1307; + for (_i1307 = 0; _i1307 < _size1303; ++_i1307) { - std::string _key1306; - xfer += iprot->readString(_key1306); - std::string& _val1307 = this->part_vals[_key1306]; - xfer += iprot->readString(_val1307); + std::string _key1308; + xfer += iprot->readString(_key1308); + std::string& _val1309 = this->part_vals[_key1308]; + xfer += iprot->readString(_val1309); } xfer += iprot->readMapEnd(); } @@ -21024,9 +21024,9 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::read(::apache::thri break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1308; - xfer += iprot->readI32(ecast1308); - this->eventType = (PartitionEventType::type)ecast1308; + int32_t ecast1310; + xfer += iprot->readI32(ecast1310); + this->eventType = (PartitionEventType::type)ecast1310; this->__isset.eventType = true; } else { xfer += iprot->skip(ftype); @@ -21060,11 +21060,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 _iter1309; - for (_iter1309 = this->part_vals.begin(); _iter1309 != this->part_vals.end(); ++_iter1309) + std::map ::const_iterator _iter1311; + for (_iter1311 = this->part_vals.begin(); _iter1311 != this->part_vals.end(); ++_iter1311) { - xfer += oprot->writeString(_iter1309->first); - xfer += oprot->writeString(_iter1309->second); + xfer += oprot->writeString(_iter1311->first); + xfer += oprot->writeString(_iter1311->second); } xfer += oprot->writeMapEnd(); } @@ -21100,11 +21100,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 _iter1310; - for (_iter1310 = (*(this->part_vals)).begin(); _iter1310 != (*(this->part_vals)).end(); ++_iter1310) + std::map ::const_iterator _iter1312; + for (_iter1312 = (*(this->part_vals)).begin(); _iter1312 != (*(this->part_vals)).end(); ++_iter1312) { - xfer += oprot->writeString(_iter1310->first); - xfer += oprot->writeString(_iter1310->second); + xfer += oprot->writeString(_iter1312->first); + xfer += oprot->writeString(_iter1312->second); } xfer += oprot->writeMapEnd(); } @@ -22540,14 +22540,14 @@ uint32_t ThriftHiveMetastore_get_indexes_result::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1311; - ::apache::thrift::protocol::TType _etype1314; - xfer += iprot->readListBegin(_etype1314, _size1311); - this->success.resize(_size1311); - uint32_t _i1315; - for (_i1315 = 0; _i1315 < _size1311; ++_i1315) + uint32_t _size1313; + ::apache::thrift::protocol::TType _etype1316; + xfer += iprot->readListBegin(_etype1316, _size1313); + this->success.resize(_size1313); + uint32_t _i1317; + for (_i1317 = 0; _i1317 < _size1313; ++_i1317) { - xfer += this->success[_i1315].read(iprot); + xfer += this->success[_i1317].read(iprot); } xfer += iprot->readListEnd(); } @@ -22594,10 +22594,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 _iter1316; - for (_iter1316 = this->success.begin(); _iter1316 != this->success.end(); ++_iter1316) + std::vector ::const_iterator _iter1318; + for (_iter1318 = this->success.begin(); _iter1318 != this->success.end(); ++_iter1318) { - xfer += (*_iter1316).write(oprot); + xfer += (*_iter1318).write(oprot); } xfer += oprot->writeListEnd(); } @@ -22646,14 +22646,14 @@ uint32_t ThriftHiveMetastore_get_indexes_presult::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1317; - ::apache::thrift::protocol::TType _etype1320; - xfer += iprot->readListBegin(_etype1320, _size1317); - (*(this->success)).resize(_size1317); - uint32_t _i1321; - for (_i1321 = 0; _i1321 < _size1317; ++_i1321) + uint32_t _size1319; + ::apache::thrift::protocol::TType _etype1322; + xfer += iprot->readListBegin(_etype1322, _size1319); + (*(this->success)).resize(_size1319); + uint32_t _i1323; + for (_i1323 = 0; _i1323 < _size1319; ++_i1323) { - xfer += (*(this->success))[_i1321].read(iprot); + xfer += (*(this->success))[_i1323].read(iprot); } xfer += iprot->readListEnd(); } @@ -22831,14 +22831,14 @@ uint32_t ThriftHiveMetastore_get_index_names_result::read(::apache::thrift::prot 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(); } @@ -22877,10 +22877,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 _iter1327; - for (_iter1327 = this->success.begin(); _iter1327 != this->success.end(); ++_iter1327) + std::vector ::const_iterator _iter1329; + for (_iter1329 = this->success.begin(); _iter1329 != this->success.end(); ++_iter1329) { - xfer += oprot->writeString((*_iter1327)); + xfer += oprot->writeString((*_iter1329)); } xfer += oprot->writeListEnd(); } @@ -22925,14 +22925,14 @@ uint32_t ThriftHiveMetastore_get_index_names_presult::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1328; - ::apache::thrift::protocol::TType _etype1331; - xfer += iprot->readListBegin(_etype1331, _size1328); - (*(this->success)).resize(_size1328); - uint32_t _i1332; - for (_i1332 = 0; _i1332 < _size1328; ++_i1332) + uint32_t _size1330; + ::apache::thrift::protocol::TType _etype1333; + xfer += iprot->readListBegin(_etype1333, _size1330); + (*(this->success)).resize(_size1330); + uint32_t _i1334; + for (_i1334 = 0; _i1334 < _size1330; ++_i1334) { - xfer += iprot->readString((*(this->success))[_i1332]); + xfer += iprot->readString((*(this->success))[_i1334]); } xfer += iprot->readListEnd(); } @@ -26959,14 +26959,14 @@ uint32_t ThriftHiveMetastore_get_functions_result::read(::apache::thrift::protoc 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(); } @@ -27005,10 +27005,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 _iter1338; - for (_iter1338 = this->success.begin(); _iter1338 != this->success.end(); ++_iter1338) + std::vector ::const_iterator _iter1340; + for (_iter1340 = this->success.begin(); _iter1340 != this->success.end(); ++_iter1340) { - xfer += oprot->writeString((*_iter1338)); + xfer += oprot->writeString((*_iter1340)); } xfer += oprot->writeListEnd(); } @@ -27053,14 +27053,14 @@ uint32_t ThriftHiveMetastore_get_functions_presult::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1339; - ::apache::thrift::protocol::TType _etype1342; - xfer += iprot->readListBegin(_etype1342, _size1339); - (*(this->success)).resize(_size1339); - uint32_t _i1343; - for (_i1343 = 0; _i1343 < _size1339; ++_i1343) + uint32_t _size1341; + ::apache::thrift::protocol::TType _etype1344; + xfer += iprot->readListBegin(_etype1344, _size1341); + (*(this->success)).resize(_size1341); + uint32_t _i1345; + for (_i1345 = 0; _i1345 < _size1341; ++_i1345) { - xfer += iprot->readString((*(this->success))[_i1343]); + xfer += iprot->readString((*(this->success))[_i1345]); } xfer += iprot->readListEnd(); } @@ -28020,14 +28020,14 @@ uint32_t ThriftHiveMetastore_get_role_names_result::read(::apache::thrift::proto 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(); } @@ -28066,10 +28066,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 _iter1349; - for (_iter1349 = this->success.begin(); _iter1349 != this->success.end(); ++_iter1349) + std::vector ::const_iterator _iter1351; + for (_iter1351 = this->success.begin(); _iter1351 != this->success.end(); ++_iter1351) { - xfer += oprot->writeString((*_iter1349)); + xfer += oprot->writeString((*_iter1351)); } xfer += oprot->writeListEnd(); } @@ -28114,14 +28114,14 @@ uint32_t ThriftHiveMetastore_get_role_names_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1350; - ::apache::thrift::protocol::TType _etype1353; - xfer += iprot->readListBegin(_etype1353, _size1350); - (*(this->success)).resize(_size1350); - uint32_t _i1354; - for (_i1354 = 0; _i1354 < _size1350; ++_i1354) + uint32_t _size1352; + ::apache::thrift::protocol::TType _etype1355; + xfer += iprot->readListBegin(_etype1355, _size1352); + (*(this->success)).resize(_size1352); + uint32_t _i1356; + for (_i1356 = 0; _i1356 < _size1352; ++_i1356) { - xfer += iprot->readString((*(this->success))[_i1354]); + xfer += iprot->readString((*(this->success))[_i1356]); } xfer += iprot->readListEnd(); } @@ -28194,9 +28194,9 @@ uint32_t ThriftHiveMetastore_grant_role_args::read(::apache::thrift::protocol::T break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1355; - xfer += iprot->readI32(ecast1355); - this->principal_type = (PrincipalType::type)ecast1355; + int32_t ecast1357; + xfer += iprot->readI32(ecast1357); + this->principal_type = (PrincipalType::type)ecast1357; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -28212,9 +28212,9 @@ uint32_t ThriftHiveMetastore_grant_role_args::read(::apache::thrift::protocol::T break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1356; - xfer += iprot->readI32(ecast1356); - this->grantorType = (PrincipalType::type)ecast1356; + int32_t ecast1358; + xfer += iprot->readI32(ecast1358); + this->grantorType = (PrincipalType::type)ecast1358; this->__isset.grantorType = true; } else { xfer += iprot->skip(ftype); @@ -28485,9 +28485,9 @@ uint32_t ThriftHiveMetastore_revoke_role_args::read(::apache::thrift::protocol:: break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1357; - xfer += iprot->readI32(ecast1357); - this->principal_type = (PrincipalType::type)ecast1357; + int32_t ecast1359; + xfer += iprot->readI32(ecast1359); + this->principal_type = (PrincipalType::type)ecast1359; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -28718,9 +28718,9 @@ uint32_t ThriftHiveMetastore_list_roles_args::read(::apache::thrift::protocol::T break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1358; - xfer += iprot->readI32(ecast1358); - this->principal_type = (PrincipalType::type)ecast1358; + int32_t ecast1360; + xfer += iprot->readI32(ecast1360); + this->principal_type = (PrincipalType::type)ecast1360; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -28809,14 +28809,14 @@ uint32_t ThriftHiveMetastore_list_roles_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1359; - ::apache::thrift::protocol::TType _etype1362; - xfer += iprot->readListBegin(_etype1362, _size1359); - this->success.resize(_size1359); - uint32_t _i1363; - for (_i1363 = 0; _i1363 < _size1359; ++_i1363) + uint32_t _size1361; + ::apache::thrift::protocol::TType _etype1364; + xfer += iprot->readListBegin(_etype1364, _size1361); + this->success.resize(_size1361); + uint32_t _i1365; + for (_i1365 = 0; _i1365 < _size1361; ++_i1365) { - xfer += this->success[_i1363].read(iprot); + xfer += this->success[_i1365].read(iprot); } xfer += iprot->readListEnd(); } @@ -28855,10 +28855,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 _iter1364; - for (_iter1364 = this->success.begin(); _iter1364 != this->success.end(); ++_iter1364) + std::vector ::const_iterator _iter1366; + for (_iter1366 = this->success.begin(); _iter1366 != this->success.end(); ++_iter1366) { - xfer += (*_iter1364).write(oprot); + xfer += (*_iter1366).write(oprot); } xfer += oprot->writeListEnd(); } @@ -28903,14 +28903,14 @@ uint32_t ThriftHiveMetastore_list_roles_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1365; - ::apache::thrift::protocol::TType _etype1368; - xfer += iprot->readListBegin(_etype1368, _size1365); - (*(this->success)).resize(_size1365); - uint32_t _i1369; - for (_i1369 = 0; _i1369 < _size1365; ++_i1369) + uint32_t _size1367; + ::apache::thrift::protocol::TType _etype1370; + xfer += iprot->readListBegin(_etype1370, _size1367); + (*(this->success)).resize(_size1367); + uint32_t _i1371; + for (_i1371 = 0; _i1371 < _size1367; ++_i1371) { - xfer += (*(this->success))[_i1369].read(iprot); + xfer += (*(this->success))[_i1371].read(iprot); } xfer += iprot->readListEnd(); } @@ -29606,14 +29606,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 _size1370; - ::apache::thrift::protocol::TType _etype1373; - xfer += iprot->readListBegin(_etype1373, _size1370); - this->group_names.resize(_size1370); - uint32_t _i1374; - for (_i1374 = 0; _i1374 < _size1370; ++_i1374) + uint32_t _size1372; + ::apache::thrift::protocol::TType _etype1375; + xfer += iprot->readListBegin(_etype1375, _size1372); + this->group_names.resize(_size1372); + uint32_t _i1376; + for (_i1376 = 0; _i1376 < _size1372; ++_i1376) { - xfer += iprot->readString(this->group_names[_i1374]); + xfer += iprot->readString(this->group_names[_i1376]); } xfer += iprot->readListEnd(); } @@ -29650,10 +29650,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 _iter1375; - for (_iter1375 = this->group_names.begin(); _iter1375 != this->group_names.end(); ++_iter1375) + std::vector ::const_iterator _iter1377; + for (_iter1377 = this->group_names.begin(); _iter1377 != this->group_names.end(); ++_iter1377) { - xfer += oprot->writeString((*_iter1375)); + xfer += oprot->writeString((*_iter1377)); } xfer += oprot->writeListEnd(); } @@ -29685,10 +29685,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 _iter1376; - for (_iter1376 = (*(this->group_names)).begin(); _iter1376 != (*(this->group_names)).end(); ++_iter1376) + std::vector ::const_iterator _iter1378; + for (_iter1378 = (*(this->group_names)).begin(); _iter1378 != (*(this->group_names)).end(); ++_iter1378) { - xfer += oprot->writeString((*_iter1376)); + xfer += oprot->writeString((*_iter1378)); } xfer += oprot->writeListEnd(); } @@ -29863,9 +29863,9 @@ uint32_t ThriftHiveMetastore_list_privileges_args::read(::apache::thrift::protoc break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1377; - xfer += iprot->readI32(ecast1377); - this->principal_type = (PrincipalType::type)ecast1377; + int32_t ecast1379; + xfer += iprot->readI32(ecast1379); + this->principal_type = (PrincipalType::type)ecast1379; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -29970,14 +29970,14 @@ uint32_t ThriftHiveMetastore_list_privileges_result::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1378; - ::apache::thrift::protocol::TType _etype1381; - xfer += iprot->readListBegin(_etype1381, _size1378); - this->success.resize(_size1378); - uint32_t _i1382; - for (_i1382 = 0; _i1382 < _size1378; ++_i1382) + uint32_t _size1380; + ::apache::thrift::protocol::TType _etype1383; + xfer += iprot->readListBegin(_etype1383, _size1380); + this->success.resize(_size1380); + uint32_t _i1384; + for (_i1384 = 0; _i1384 < _size1380; ++_i1384) { - xfer += this->success[_i1382].read(iprot); + xfer += this->success[_i1384].read(iprot); } xfer += iprot->readListEnd(); } @@ -30016,10 +30016,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 _iter1383; - for (_iter1383 = this->success.begin(); _iter1383 != this->success.end(); ++_iter1383) + std::vector ::const_iterator _iter1385; + for (_iter1385 = this->success.begin(); _iter1385 != this->success.end(); ++_iter1385) { - xfer += (*_iter1383).write(oprot); + xfer += (*_iter1385).write(oprot); } xfer += oprot->writeListEnd(); } @@ -30064,14 +30064,14 @@ uint32_t ThriftHiveMetastore_list_privileges_presult::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1384; - ::apache::thrift::protocol::TType _etype1387; - xfer += iprot->readListBegin(_etype1387, _size1384); - (*(this->success)).resize(_size1384); - uint32_t _i1388; - for (_i1388 = 0; _i1388 < _size1384; ++_i1388) + uint32_t _size1386; + ::apache::thrift::protocol::TType _etype1389; + xfer += iprot->readListBegin(_etype1389, _size1386); + (*(this->success)).resize(_size1386); + uint32_t _i1390; + for (_i1390 = 0; _i1390 < _size1386; ++_i1390) { - xfer += (*(this->success))[_i1388].read(iprot); + xfer += (*(this->success))[_i1390].read(iprot); } xfer += iprot->readListEnd(); } @@ -30759,14 +30759,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 _size1389; - ::apache::thrift::protocol::TType _etype1392; - xfer += iprot->readListBegin(_etype1392, _size1389); - this->group_names.resize(_size1389); - uint32_t _i1393; - for (_i1393 = 0; _i1393 < _size1389; ++_i1393) + uint32_t _size1391; + ::apache::thrift::protocol::TType _etype1394; + xfer += iprot->readListBegin(_etype1394, _size1391); + this->group_names.resize(_size1391); + uint32_t _i1395; + for (_i1395 = 0; _i1395 < _size1391; ++_i1395) { - xfer += iprot->readString(this->group_names[_i1393]); + xfer += iprot->readString(this->group_names[_i1395]); } xfer += iprot->readListEnd(); } @@ -30799,10 +30799,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 _iter1394; - for (_iter1394 = this->group_names.begin(); _iter1394 != this->group_names.end(); ++_iter1394) + std::vector ::const_iterator _iter1396; + for (_iter1396 = this->group_names.begin(); _iter1396 != this->group_names.end(); ++_iter1396) { - xfer += oprot->writeString((*_iter1394)); + xfer += oprot->writeString((*_iter1396)); } xfer += oprot->writeListEnd(); } @@ -30830,10 +30830,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 _iter1395; - for (_iter1395 = (*(this->group_names)).begin(); _iter1395 != (*(this->group_names)).end(); ++_iter1395) + std::vector ::const_iterator _iter1397; + for (_iter1397 = (*(this->group_names)).begin(); _iter1397 != (*(this->group_names)).end(); ++_iter1397) { - xfer += oprot->writeString((*_iter1395)); + xfer += oprot->writeString((*_iter1397)); } xfer += oprot->writeListEnd(); } @@ -30874,14 +30874,14 @@ uint32_t ThriftHiveMetastore_set_ugi_result::read(::apache::thrift::protocol::TP if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1396; - ::apache::thrift::protocol::TType _etype1399; - xfer += iprot->readListBegin(_etype1399, _size1396); - this->success.resize(_size1396); - uint32_t _i1400; - for (_i1400 = 0; _i1400 < _size1396; ++_i1400) + uint32_t _size1398; + ::apache::thrift::protocol::TType _etype1401; + xfer += iprot->readListBegin(_etype1401, _size1398); + this->success.resize(_size1398); + uint32_t _i1402; + for (_i1402 = 0; _i1402 < _size1398; ++_i1402) { - xfer += iprot->readString(this->success[_i1400]); + xfer += iprot->readString(this->success[_i1402]); } xfer += iprot->readListEnd(); } @@ -30920,10 +30920,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 _iter1401; - for (_iter1401 = this->success.begin(); _iter1401 != this->success.end(); ++_iter1401) + std::vector ::const_iterator _iter1403; + for (_iter1403 = this->success.begin(); _iter1403 != this->success.end(); ++_iter1403) { - xfer += oprot->writeString((*_iter1401)); + xfer += oprot->writeString((*_iter1403)); } xfer += oprot->writeListEnd(); } @@ -30968,14 +30968,14 @@ uint32_t ThriftHiveMetastore_set_ugi_presult::read(::apache::thrift::protocol::T if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1402; - ::apache::thrift::protocol::TType _etype1405; - xfer += iprot->readListBegin(_etype1405, _size1402); - (*(this->success)).resize(_size1402); - uint32_t _i1406; - for (_i1406 = 0; _i1406 < _size1402; ++_i1406) + uint32_t _size1404; + ::apache::thrift::protocol::TType _etype1407; + xfer += iprot->readListBegin(_etype1407, _size1404); + (*(this->success)).resize(_size1404); + uint32_t _i1408; + for (_i1408 = 0; _i1408 < _size1404; ++_i1408) { - xfer += iprot->readString((*(this->success))[_i1406]); + xfer += iprot->readString((*(this->success))[_i1408]); } xfer += iprot->readListEnd(); } @@ -32286,14 +32286,14 @@ uint32_t ThriftHiveMetastore_get_all_token_identifiers_result::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1407; - ::apache::thrift::protocol::TType _etype1410; - xfer += iprot->readListBegin(_etype1410, _size1407); - this->success.resize(_size1407); - uint32_t _i1411; - for (_i1411 = 0; _i1411 < _size1407; ++_i1411) + uint32_t _size1409; + ::apache::thrift::protocol::TType _etype1412; + xfer += iprot->readListBegin(_etype1412, _size1409); + this->success.resize(_size1409); + uint32_t _i1413; + for (_i1413 = 0; _i1413 < _size1409; ++_i1413) { - xfer += iprot->readString(this->success[_i1411]); + xfer += iprot->readString(this->success[_i1413]); } xfer += iprot->readListEnd(); } @@ -32324,10 +32324,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 _iter1412; - for (_iter1412 = this->success.begin(); _iter1412 != this->success.end(); ++_iter1412) + std::vector ::const_iterator _iter1414; + for (_iter1414 = this->success.begin(); _iter1414 != this->success.end(); ++_iter1414) { - xfer += oprot->writeString((*_iter1412)); + xfer += oprot->writeString((*_iter1414)); } xfer += oprot->writeListEnd(); } @@ -32368,14 +32368,14 @@ uint32_t ThriftHiveMetastore_get_all_token_identifiers_presult::read(::apache::t if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1413; - ::apache::thrift::protocol::TType _etype1416; - xfer += iprot->readListBegin(_etype1416, _size1413); - (*(this->success)).resize(_size1413); - uint32_t _i1417; - for (_i1417 = 0; _i1417 < _size1413; ++_i1417) + uint32_t _size1415; + ::apache::thrift::protocol::TType _etype1418; + xfer += iprot->readListBegin(_etype1418, _size1415); + (*(this->success)).resize(_size1415); + uint32_t _i1419; + for (_i1419 = 0; _i1419 < _size1415; ++_i1419) { - xfer += iprot->readString((*(this->success))[_i1417]); + xfer += iprot->readString((*(this->success))[_i1419]); } xfer += iprot->readListEnd(); } @@ -33101,14 +33101,14 @@ uint32_t ThriftHiveMetastore_get_master_keys_result::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1418; - ::apache::thrift::protocol::TType _etype1421; - xfer += iprot->readListBegin(_etype1421, _size1418); - this->success.resize(_size1418); - uint32_t _i1422; - for (_i1422 = 0; _i1422 < _size1418; ++_i1422) + uint32_t _size1420; + ::apache::thrift::protocol::TType _etype1423; + xfer += iprot->readListBegin(_etype1423, _size1420); + this->success.resize(_size1420); + uint32_t _i1424; + for (_i1424 = 0; _i1424 < _size1420; ++_i1424) { - xfer += iprot->readString(this->success[_i1422]); + xfer += iprot->readString(this->success[_i1424]); } xfer += iprot->readListEnd(); } @@ -33139,10 +33139,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 _iter1423; - for (_iter1423 = this->success.begin(); _iter1423 != this->success.end(); ++_iter1423) + std::vector ::const_iterator _iter1425; + for (_iter1425 = this->success.begin(); _iter1425 != this->success.end(); ++_iter1425) { - xfer += oprot->writeString((*_iter1423)); + xfer += oprot->writeString((*_iter1425)); } xfer += oprot->writeListEnd(); } @@ -33183,14 +33183,14 @@ uint32_t ThriftHiveMetastore_get_master_keys_presult::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1424; - ::apache::thrift::protocol::TType _etype1427; - xfer += iprot->readListBegin(_etype1427, _size1424); - (*(this->success)).resize(_size1424); - uint32_t _i1428; - for (_i1428 = 0; _i1428 < _size1424; ++_i1428) + uint32_t _size1426; + ::apache::thrift::protocol::TType _etype1429; + xfer += iprot->readListBegin(_etype1429, _size1426); + (*(this->success)).resize(_size1426); + uint32_t _i1430; + for (_i1430 = 0; _i1430 < _size1426; ++_i1430) { - xfer += iprot->readString((*(this->success))[_i1428]); + xfer += iprot->readString((*(this->success))[_i1430]); } xfer += iprot->readListEnd(); } @@ -37940,6 +37940,192 @@ uint32_t ThriftHiveMetastore_cache_file_metadata_presult::read(::apache::thrift: return xfer; } + +ThriftHiveMetastore_get_metastore_uuid_args::~ThriftHiveMetastore_get_metastore_uuid_args() throw() { +} + + +uint32_t ThriftHiveMetastore_get_metastore_uuid_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_metastore_uuid_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_metastore_uuid_args"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_metastore_uuid_pargs::~ThriftHiveMetastore_get_metastore_uuid_pargs() throw() { +} + + +uint32_t ThriftHiveMetastore_get_metastore_uuid_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_metastore_uuid_pargs"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_metastore_uuid_result::~ThriftHiveMetastore_get_metastore_uuid_result() throw() { +} + + +uint32_t ThriftHiveMetastore_get_metastore_uuid_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_metastore_uuid_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_metastore_uuid_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0); + xfer += oprot->writeString(this->success); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_metastore_uuid_presult::~ThriftHiveMetastore_get_metastore_uuid_presult() throw() { +} + + +uint32_t ThriftHiveMetastore_get_metastore_uuid_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + void ThriftHiveMetastoreClient::getMetaConf(std::string& _return, const std::string& key) { send_getMetaConf(key); @@ -47627,6 +47813,66 @@ void ThriftHiveMetastoreClient::recv_cache_file_metadata(CacheFileMetadataResult throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "cache_file_metadata failed: unknown result"); } +void ThriftHiveMetastoreClient::get_metastore_uuid(std::string& _return) +{ + send_get_metastore_uuid(); + recv_get_metastore_uuid(_return); +} + +void ThriftHiveMetastoreClient::send_get_metastore_uuid() +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_metastore_uuid", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_metastore_uuid_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_metastore_uuid(std::string& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_metastore_uuid") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_metastore_uuid_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_metastore_uuid failed: unknown result"); +} + bool ThriftHiveMetastoreProcessor::dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext) { ProcessMap::iterator pfn; pfn = processMap_.find(fname); @@ -56689,6 +56935,63 @@ void ThriftHiveMetastoreProcessor::process_cache_file_metadata(int32_t seqid, :: } } +void ThriftHiveMetastoreProcessor::process_get_metastore_uuid(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = NULL; + if (this->eventHandler_.get() != NULL) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.get_metastore_uuid", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_metastore_uuid"); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_metastore_uuid"); + } + + ThriftHiveMetastore_get_metastore_uuid_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.get_metastore_uuid", bytes); + } + + ThriftHiveMetastore_get_metastore_uuid_result result; + try { + iface_->get_metastore_uuid(result.success); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = o1; + result.__isset.o1 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.get_metastore_uuid"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_metastore_uuid", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.get_metastore_uuid"); + } + + oprot->writeMessageBegin("get_metastore_uuid", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.get_metastore_uuid", bytes); + } +} + ::boost::shared_ptr< ::apache::thrift::TProcessor > ThriftHiveMetastoreProcessorFactory::getProcessor(const ::apache::thrift::TConnectionInfo& connInfo) { ::apache::thrift::ReleaseHandler< ThriftHiveMetastoreIfFactory > cleanup(handlerFactory_); ::boost::shared_ptr< ThriftHiveMetastoreIf > handler(handlerFactory_->getHandler(connInfo), cleanup); @@ -70601,5 +70904,92 @@ void ThriftHiveMetastoreConcurrentClient::recv_cache_file_metadata(CacheFileMeta } // end while(true) } +void ThriftHiveMetastoreConcurrentClient::get_metastore_uuid(std::string& _return) +{ + int32_t seqid = send_get_metastore_uuid(); + recv_get_metastore_uuid(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_metastore_uuid() +{ + int32_t cseqid = this->sync_.generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); + oprot_->writeMessageBegin("get_metastore_uuid", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_metastore_uuid_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_metastore_uuid(std::string& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(&this->sync_, seqid); + + while(true) { + if(!this->sync_.getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("get_metastore_uuid") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_get_metastore_uuid_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_metastore_uuid failed: unknown result"); + } + // seqid != rseqid + this->sync_.updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_.waitForWork(seqid); + } // end while(true) +} + }}} // namespace diff --git a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h index fca5ae5cb5fb45215501438e7afd97dba1174cd0..8564a1b91103ef75da7c08179443287df0393c34 100644 --- a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h +++ b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h @@ -175,6 +175,7 @@ class ThriftHiveMetastoreIf : virtual public ::facebook::fb303::FacebookService virtual void put_file_metadata(PutFileMetadataResult& _return, const PutFileMetadataRequest& req) = 0; virtual void clear_file_metadata(ClearFileMetadataResult& _return, const ClearFileMetadataRequest& req) = 0; virtual void cache_file_metadata(CacheFileMetadataResult& _return, const CacheFileMetadataRequest& req) = 0; + virtual void get_metastore_uuid(std::string& _return) = 0; }; class ThriftHiveMetastoreIfFactory : virtual public ::facebook::fb303::FacebookServiceIfFactory { @@ -691,6 +692,9 @@ class ThriftHiveMetastoreNull : virtual public ThriftHiveMetastoreIf , virtual p void cache_file_metadata(CacheFileMetadataResult& /* _return */, const CacheFileMetadataRequest& /* req */) { return; } + void get_metastore_uuid(std::string& /* _return */) { + return; + } }; typedef struct _ThriftHiveMetastore_getMetaConf_args__isset { @@ -19601,6 +19605,106 @@ class ThriftHiveMetastore_cache_file_metadata_presult { }; + +class ThriftHiveMetastore_get_metastore_uuid_args { + public: + + ThriftHiveMetastore_get_metastore_uuid_args(const ThriftHiveMetastore_get_metastore_uuid_args&); + ThriftHiveMetastore_get_metastore_uuid_args& operator=(const ThriftHiveMetastore_get_metastore_uuid_args&); + ThriftHiveMetastore_get_metastore_uuid_args() { + } + + virtual ~ThriftHiveMetastore_get_metastore_uuid_args() throw(); + + bool operator == (const ThriftHiveMetastore_get_metastore_uuid_args & /* rhs */) const + { + return true; + } + bool operator != (const ThriftHiveMetastore_get_metastore_uuid_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_metastore_uuid_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_metastore_uuid_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_metastore_uuid_pargs() throw(); + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_metastore_uuid_result__isset { + _ThriftHiveMetastore_get_metastore_uuid_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_metastore_uuid_result__isset; + +class ThriftHiveMetastore_get_metastore_uuid_result { + public: + + ThriftHiveMetastore_get_metastore_uuid_result(const ThriftHiveMetastore_get_metastore_uuid_result&); + ThriftHiveMetastore_get_metastore_uuid_result& operator=(const ThriftHiveMetastore_get_metastore_uuid_result&); + ThriftHiveMetastore_get_metastore_uuid_result() : success() { + } + + virtual ~ThriftHiveMetastore_get_metastore_uuid_result() throw(); + std::string success; + MetaException o1; + + _ThriftHiveMetastore_get_metastore_uuid_result__isset __isset; + + void __set_success(const std::string& val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_metastore_uuid_result & rhs) const + { + if (!(success == rhs.success)) + return false; + if (!(o1 == rhs.o1)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_get_metastore_uuid_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_metastore_uuid_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_metastore_uuid_presult__isset { + _ThriftHiveMetastore_get_metastore_uuid_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_metastore_uuid_presult__isset; + +class ThriftHiveMetastore_get_metastore_uuid_presult { + public: + + + virtual ~ThriftHiveMetastore_get_metastore_uuid_presult() throw(); + std::string* success; + MetaException o1; + + _ThriftHiveMetastore_get_metastore_uuid_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + class ThriftHiveMetastoreClient : virtual public ThriftHiveMetastoreIf, public ::facebook::fb303::FacebookServiceClient { public: ThriftHiveMetastoreClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) : @@ -20071,6 +20175,9 @@ class ThriftHiveMetastoreClient : virtual public ThriftHiveMetastoreIf, public void cache_file_metadata(CacheFileMetadataResult& _return, const CacheFileMetadataRequest& req); void send_cache_file_metadata(const CacheFileMetadataRequest& req); void recv_cache_file_metadata(CacheFileMetadataResult& _return); + void get_metastore_uuid(std::string& _return); + void send_get_metastore_uuid(); + void recv_get_metastore_uuid(std::string& _return); }; class ThriftHiveMetastoreProcessor : public ::facebook::fb303::FacebookServiceProcessor { @@ -20234,6 +20341,7 @@ class ThriftHiveMetastoreProcessor : public ::facebook::fb303::FacebookServiceP void process_put_file_metadata(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_clear_file_metadata(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_cache_file_metadata(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_metastore_uuid(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); public: ThriftHiveMetastoreProcessor(boost::shared_ptr iface) : ::facebook::fb303::FacebookServiceProcessor(iface), @@ -20391,6 +20499,7 @@ class ThriftHiveMetastoreProcessor : public ::facebook::fb303::FacebookServiceP processMap_["put_file_metadata"] = &ThriftHiveMetastoreProcessor::process_put_file_metadata; processMap_["clear_file_metadata"] = &ThriftHiveMetastoreProcessor::process_clear_file_metadata; processMap_["cache_file_metadata"] = &ThriftHiveMetastoreProcessor::process_cache_file_metadata; + processMap_["get_metastore_uuid"] = &ThriftHiveMetastoreProcessor::process_get_metastore_uuid; } virtual ~ThriftHiveMetastoreProcessor() {} @@ -21891,6 +22000,16 @@ class ThriftHiveMetastoreMultiface : virtual public ThriftHiveMetastoreIf, publi return; } + void get_metastore_uuid(std::string& _return) { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_metastore_uuid(_return); + } + ifaces_[i]->get_metastore_uuid(_return); + return; + } + }; // The 'concurrent' client is a thread safe client that correctly handles @@ -22366,6 +22485,9 @@ class ThriftHiveMetastoreConcurrentClient : virtual public ThriftHiveMetastoreIf void cache_file_metadata(CacheFileMetadataResult& _return, const CacheFileMetadataRequest& req); int32_t send_cache_file_metadata(const CacheFileMetadataRequest& req); void recv_cache_file_metadata(CacheFileMetadataResult& _return, const int32_t seqid); + void get_metastore_uuid(std::string& _return); + int32_t send_get_metastore_uuid(); + void recv_get_metastore_uuid(std::string& _return, const int32_t seqid); }; #ifdef _WIN32 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 dfa462d6bbd99417f53b6705d0e84e016b72fb55..7ad0563038e6a621b6a27c7a6804b016e7bb8ee3 100644 --- a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp +++ b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp @@ -787,6 +787,11 @@ class ThriftHiveMetastoreHandler : virtual public ThriftHiveMetastoreIf { printf("cache_file_metadata\n"); } + void get_metastore_uuid(std::string& _return) { + // Your implementation goes here + printf("get_metastore_uuid\n"); + } + }; int main(int argc, char **argv) { 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 b38e1cb1b706a69aa1ae38da0e45f3dcbda35ee5..18bedd392a1143c2cfbf55696f93ed2e07899333 100644 --- a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp +++ b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp @@ -292,6 +292,132 @@ void Version::printTo(std::ostream& out) const { } +MetastoreDBProperty::~MetastoreDBProperty() throw() { +} + + +void MetastoreDBProperty::__set_propertyKey(const std::string& val) { + this->propertyKey = val; +} + +void MetastoreDBProperty::__set_propertyValue(const std::string& val) { + this->propertyValue = val; +} + +void MetastoreDBProperty::__set_description(const std::string& val) { + this->description = val; +} + +uint32_t MetastoreDBProperty::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->propertyKey); + this->__isset.propertyKey = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->propertyValue); + this->__isset.propertyValue = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->description); + this->__isset.description = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t MetastoreDBProperty::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("MetastoreDBProperty"); + + xfer += oprot->writeFieldBegin("propertyKey", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->propertyKey); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("propertyValue", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->propertyValue); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("description", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->description); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(MetastoreDBProperty &a, MetastoreDBProperty &b) { + using ::std::swap; + swap(a.propertyKey, b.propertyKey); + swap(a.propertyValue, b.propertyValue); + swap(a.description, b.description); + swap(a.__isset, b.__isset); +} + +MetastoreDBProperty::MetastoreDBProperty(const MetastoreDBProperty& other2) { + propertyKey = other2.propertyKey; + propertyValue = other2.propertyValue; + description = other2.description; + __isset = other2.__isset; +} +MetastoreDBProperty& MetastoreDBProperty::operator=(const MetastoreDBProperty& other3) { + propertyKey = other3.propertyKey; + propertyValue = other3.propertyValue; + description = other3.description; + __isset = other3.__isset; + return *this; +} +void MetastoreDBProperty::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "MetastoreDBProperty("; + out << "propertyKey=" << to_string(propertyKey); + out << ", " << "propertyValue=" << to_string(propertyValue); + out << ", " << "description=" << to_string(description); + out << ")"; +} + + FieldSchema::~FieldSchema() throw() { } @@ -395,17 +521,17 @@ void swap(FieldSchema &a, FieldSchema &b) { swap(a.__isset, b.__isset); } -FieldSchema::FieldSchema(const FieldSchema& other2) { - name = other2.name; - type = other2.type; - comment = other2.comment; - __isset = other2.__isset; +FieldSchema::FieldSchema(const FieldSchema& other4) { + name = other4.name; + type = other4.type; + comment = other4.comment; + __isset = other4.__isset; } -FieldSchema& FieldSchema::operator=(const FieldSchema& other3) { - name = other3.name; - type = other3.type; - comment = other3.comment; - __isset = other3.__isset; +FieldSchema& FieldSchema::operator=(const FieldSchema& other5) { + name = other5.name; + type = other5.type; + comment = other5.comment; + __isset = other5.__isset; return *this; } void FieldSchema::printTo(std::ostream& out) const { @@ -606,27 +732,27 @@ void swap(SQLPrimaryKey &a, SQLPrimaryKey &b) { swap(a.__isset, b.__isset); } -SQLPrimaryKey::SQLPrimaryKey(const SQLPrimaryKey& other4) { - table_db = other4.table_db; - table_name = other4.table_name; - column_name = other4.column_name; - key_seq = other4.key_seq; - pk_name = other4.pk_name; - enable_cstr = other4.enable_cstr; - validate_cstr = other4.validate_cstr; - rely_cstr = other4.rely_cstr; - __isset = other4.__isset; +SQLPrimaryKey::SQLPrimaryKey(const SQLPrimaryKey& other6) { + table_db = other6.table_db; + table_name = other6.table_name; + column_name = other6.column_name; + key_seq = other6.key_seq; + pk_name = other6.pk_name; + enable_cstr = other6.enable_cstr; + validate_cstr = other6.validate_cstr; + rely_cstr = other6.rely_cstr; + __isset = other6.__isset; } -SQLPrimaryKey& SQLPrimaryKey::operator=(const SQLPrimaryKey& other5) { - table_db = other5.table_db; - table_name = other5.table_name; - column_name = other5.column_name; - key_seq = other5.key_seq; - pk_name = other5.pk_name; - enable_cstr = other5.enable_cstr; - validate_cstr = other5.validate_cstr; - rely_cstr = other5.rely_cstr; - __isset = other5.__isset; +SQLPrimaryKey& SQLPrimaryKey::operator=(const SQLPrimaryKey& other7) { + table_db = other7.table_db; + table_name = other7.table_name; + column_name = other7.column_name; + key_seq = other7.key_seq; + pk_name = other7.pk_name; + enable_cstr = other7.enable_cstr; + validate_cstr = other7.validate_cstr; + rely_cstr = other7.rely_cstr; + __isset = other7.__isset; return *this; } void SQLPrimaryKey::printTo(std::ostream& out) const { @@ -934,39 +1060,39 @@ void swap(SQLForeignKey &a, SQLForeignKey &b) { swap(a.__isset, b.__isset); } -SQLForeignKey::SQLForeignKey(const SQLForeignKey& other6) { - pktable_db = other6.pktable_db; - pktable_name = other6.pktable_name; - pkcolumn_name = other6.pkcolumn_name; - fktable_db = other6.fktable_db; - fktable_name = other6.fktable_name; - fkcolumn_name = other6.fkcolumn_name; - key_seq = other6.key_seq; - update_rule = other6.update_rule; - delete_rule = other6.delete_rule; - fk_name = other6.fk_name; - pk_name = other6.pk_name; - enable_cstr = other6.enable_cstr; - validate_cstr = other6.validate_cstr; - rely_cstr = other6.rely_cstr; - __isset = other6.__isset; -} -SQLForeignKey& SQLForeignKey::operator=(const SQLForeignKey& other7) { - pktable_db = other7.pktable_db; - pktable_name = other7.pktable_name; - pkcolumn_name = other7.pkcolumn_name; - fktable_db = other7.fktable_db; - fktable_name = other7.fktable_name; - fkcolumn_name = other7.fkcolumn_name; - key_seq = other7.key_seq; - update_rule = other7.update_rule; - delete_rule = other7.delete_rule; - fk_name = other7.fk_name; - pk_name = other7.pk_name; - enable_cstr = other7.enable_cstr; - validate_cstr = other7.validate_cstr; - rely_cstr = other7.rely_cstr; - __isset = other7.__isset; +SQLForeignKey::SQLForeignKey(const SQLForeignKey& other8) { + pktable_db = other8.pktable_db; + pktable_name = other8.pktable_name; + pkcolumn_name = other8.pkcolumn_name; + fktable_db = other8.fktable_db; + fktable_name = other8.fktable_name; + fkcolumn_name = other8.fkcolumn_name; + key_seq = other8.key_seq; + update_rule = other8.update_rule; + delete_rule = other8.delete_rule; + fk_name = other8.fk_name; + pk_name = other8.pk_name; + enable_cstr = other8.enable_cstr; + validate_cstr = other8.validate_cstr; + rely_cstr = other8.rely_cstr; + __isset = other8.__isset; +} +SQLForeignKey& SQLForeignKey::operator=(const SQLForeignKey& other9) { + pktable_db = other9.pktable_db; + pktable_name = other9.pktable_name; + pkcolumn_name = other9.pkcolumn_name; + fktable_db = other9.fktable_db; + fktable_name = other9.fktable_name; + fkcolumn_name = other9.fkcolumn_name; + key_seq = other9.key_seq; + update_rule = other9.update_rule; + delete_rule = other9.delete_rule; + fk_name = other9.fk_name; + pk_name = other9.pk_name; + enable_cstr = other9.enable_cstr; + validate_cstr = other9.validate_cstr; + rely_cstr = other9.rely_cstr; + __isset = other9.__isset; return *this; } void SQLForeignKey::printTo(std::ostream& out) const { @@ -1062,14 +1188,14 @@ uint32_t Type::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fields.clear(); - uint32_t _size8; - ::apache::thrift::protocol::TType _etype11; - xfer += iprot->readListBegin(_etype11, _size8); - this->fields.resize(_size8); - uint32_t _i12; - for (_i12 = 0; _i12 < _size8; ++_i12) + uint32_t _size10; + ::apache::thrift::protocol::TType _etype13; + xfer += iprot->readListBegin(_etype13, _size10); + this->fields.resize(_size10); + uint32_t _i14; + for (_i14 = 0; _i14 < _size10; ++_i14) { - xfer += this->fields[_i12].read(iprot); + xfer += this->fields[_i14].read(iprot); } xfer += iprot->readListEnd(); } @@ -1113,10 +1239,10 @@ uint32_t Type::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("fields", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->fields.size())); - std::vector ::const_iterator _iter13; - for (_iter13 = this->fields.begin(); _iter13 != this->fields.end(); ++_iter13) + std::vector ::const_iterator _iter15; + for (_iter15 = this->fields.begin(); _iter15 != this->fields.end(); ++_iter15) { - xfer += (*_iter13).write(oprot); + xfer += (*_iter15).write(oprot); } xfer += oprot->writeListEnd(); } @@ -1136,19 +1262,19 @@ void swap(Type &a, Type &b) { swap(a.__isset, b.__isset); } -Type::Type(const Type& other14) { - name = other14.name; - type1 = other14.type1; - type2 = other14.type2; - fields = other14.fields; - __isset = other14.__isset; +Type::Type(const Type& other16) { + name = other16.name; + type1 = other16.type1; + type2 = other16.type2; + fields = other16.fields; + __isset = other16.__isset; } -Type& Type::operator=(const Type& other15) { - name = other15.name; - type1 = other15.type1; - type2 = other15.type2; - fields = other15.fields; - __isset = other15.__isset; +Type& Type::operator=(const Type& other17) { + name = other17.name; + type1 = other17.type1; + type2 = other17.type2; + fields = other17.fields; + __isset = other17.__isset; return *this; } void Type::printTo(std::ostream& out) const { @@ -1209,9 +1335,9 @@ uint32_t HiveObjectRef::read(::apache::thrift::protocol::TProtocol* iprot) { { case 1: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast16; - xfer += iprot->readI32(ecast16); - this->objectType = (HiveObjectType::type)ecast16; + int32_t ecast18; + xfer += iprot->readI32(ecast18); + this->objectType = (HiveObjectType::type)ecast18; this->__isset.objectType = true; } else { xfer += iprot->skip(ftype); @@ -1237,14 +1363,14 @@ uint32_t HiveObjectRef::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partValues.clear(); - uint32_t _size17; - ::apache::thrift::protocol::TType _etype20; - xfer += iprot->readListBegin(_etype20, _size17); - this->partValues.resize(_size17); - uint32_t _i21; - for (_i21 = 0; _i21 < _size17; ++_i21) + uint32_t _size19; + ::apache::thrift::protocol::TType _etype22; + xfer += iprot->readListBegin(_etype22, _size19); + this->partValues.resize(_size19); + uint32_t _i23; + for (_i23 = 0; _i23 < _size19; ++_i23) { - xfer += iprot->readString(this->partValues[_i21]); + xfer += iprot->readString(this->partValues[_i23]); } xfer += iprot->readListEnd(); } @@ -1293,10 +1419,10 @@ uint32_t HiveObjectRef::write(::apache::thrift::protocol::TProtocol* oprot) cons xfer += oprot->writeFieldBegin("partValues", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partValues.size())); - std::vector ::const_iterator _iter22; - for (_iter22 = this->partValues.begin(); _iter22 != this->partValues.end(); ++_iter22) + std::vector ::const_iterator _iter24; + for (_iter24 = this->partValues.begin(); _iter24 != this->partValues.end(); ++_iter24) { - xfer += oprot->writeString((*_iter22)); + xfer += oprot->writeString((*_iter24)); } xfer += oprot->writeListEnd(); } @@ -1321,21 +1447,21 @@ void swap(HiveObjectRef &a, HiveObjectRef &b) { swap(a.__isset, b.__isset); } -HiveObjectRef::HiveObjectRef(const HiveObjectRef& other23) { - objectType = other23.objectType; - dbName = other23.dbName; - objectName = other23.objectName; - partValues = other23.partValues; - columnName = other23.columnName; - __isset = other23.__isset; -} -HiveObjectRef& HiveObjectRef::operator=(const HiveObjectRef& other24) { - objectType = other24.objectType; - dbName = other24.dbName; - objectName = other24.objectName; - partValues = other24.partValues; - columnName = other24.columnName; - __isset = other24.__isset; +HiveObjectRef::HiveObjectRef(const HiveObjectRef& other25) { + objectType = other25.objectType; + dbName = other25.dbName; + objectName = other25.objectName; + partValues = other25.partValues; + columnName = other25.columnName; + __isset = other25.__isset; +} +HiveObjectRef& HiveObjectRef::operator=(const HiveObjectRef& other26) { + objectType = other26.objectType; + dbName = other26.dbName; + objectName = other26.objectName; + partValues = other26.partValues; + columnName = other26.columnName; + __isset = other26.__isset; return *this; } void HiveObjectRef::printTo(std::ostream& out) const { @@ -1421,9 +1547,9 @@ uint32_t PrivilegeGrantInfo::read(::apache::thrift::protocol::TProtocol* iprot) break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast25; - xfer += iprot->readI32(ecast25); - this->grantorType = (PrincipalType::type)ecast25; + int32_t ecast27; + xfer += iprot->readI32(ecast27); + this->grantorType = (PrincipalType::type)ecast27; this->__isset.grantorType = true; } else { xfer += iprot->skip(ftype); @@ -1489,21 +1615,21 @@ void swap(PrivilegeGrantInfo &a, PrivilegeGrantInfo &b) { swap(a.__isset, b.__isset); } -PrivilegeGrantInfo::PrivilegeGrantInfo(const PrivilegeGrantInfo& other26) { - privilege = other26.privilege; - createTime = other26.createTime; - grantor = other26.grantor; - grantorType = other26.grantorType; - grantOption = other26.grantOption; - __isset = other26.__isset; -} -PrivilegeGrantInfo& PrivilegeGrantInfo::operator=(const PrivilegeGrantInfo& other27) { - privilege = other27.privilege; - createTime = other27.createTime; - grantor = other27.grantor; - grantorType = other27.grantorType; - grantOption = other27.grantOption; - __isset = other27.__isset; +PrivilegeGrantInfo::PrivilegeGrantInfo(const PrivilegeGrantInfo& other28) { + privilege = other28.privilege; + createTime = other28.createTime; + grantor = other28.grantor; + grantorType = other28.grantorType; + grantOption = other28.grantOption; + __isset = other28.__isset; +} +PrivilegeGrantInfo& PrivilegeGrantInfo::operator=(const PrivilegeGrantInfo& other29) { + privilege = other29.privilege; + createTime = other29.createTime; + grantor = other29.grantor; + grantorType = other29.grantorType; + grantOption = other29.grantOption; + __isset = other29.__isset; return *this; } void PrivilegeGrantInfo::printTo(std::ostream& out) const { @@ -1577,9 +1703,9 @@ uint32_t HiveObjectPrivilege::read(::apache::thrift::protocol::TProtocol* iprot) break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast28; - xfer += iprot->readI32(ecast28); - this->principalType = (PrincipalType::type)ecast28; + int32_t ecast30; + xfer += iprot->readI32(ecast30); + this->principalType = (PrincipalType::type)ecast30; this->__isset.principalType = true; } else { xfer += iprot->skip(ftype); @@ -1640,19 +1766,19 @@ void swap(HiveObjectPrivilege &a, HiveObjectPrivilege &b) { swap(a.__isset, b.__isset); } -HiveObjectPrivilege::HiveObjectPrivilege(const HiveObjectPrivilege& other29) { - hiveObject = other29.hiveObject; - principalName = other29.principalName; - principalType = other29.principalType; - grantInfo = other29.grantInfo; - __isset = other29.__isset; +HiveObjectPrivilege::HiveObjectPrivilege(const HiveObjectPrivilege& other31) { + hiveObject = other31.hiveObject; + principalName = other31.principalName; + principalType = other31.principalType; + grantInfo = other31.grantInfo; + __isset = other31.__isset; } -HiveObjectPrivilege& HiveObjectPrivilege::operator=(const HiveObjectPrivilege& other30) { - hiveObject = other30.hiveObject; - principalName = other30.principalName; - principalType = other30.principalType; - grantInfo = other30.grantInfo; - __isset = other30.__isset; +HiveObjectPrivilege& HiveObjectPrivilege::operator=(const HiveObjectPrivilege& other32) { + hiveObject = other32.hiveObject; + principalName = other32.principalName; + principalType = other32.principalType; + grantInfo = other32.grantInfo; + __isset = other32.__isset; return *this; } void HiveObjectPrivilege::printTo(std::ostream& out) const { @@ -1699,14 +1825,14 @@ uint32_t PrivilegeBag::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->privileges.clear(); - uint32_t _size31; - ::apache::thrift::protocol::TType _etype34; - xfer += iprot->readListBegin(_etype34, _size31); - this->privileges.resize(_size31); - uint32_t _i35; - for (_i35 = 0; _i35 < _size31; ++_i35) + uint32_t _size33; + ::apache::thrift::protocol::TType _etype36; + xfer += iprot->readListBegin(_etype36, _size33); + this->privileges.resize(_size33); + uint32_t _i37; + for (_i37 = 0; _i37 < _size33; ++_i37) { - xfer += this->privileges[_i35].read(iprot); + xfer += this->privileges[_i37].read(iprot); } xfer += iprot->readListEnd(); } @@ -1735,10 +1861,10 @@ uint32_t PrivilegeBag::write(::apache::thrift::protocol::TProtocol* oprot) const xfer += oprot->writeFieldBegin("privileges", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->privileges.size())); - std::vector ::const_iterator _iter36; - for (_iter36 = this->privileges.begin(); _iter36 != this->privileges.end(); ++_iter36) + std::vector ::const_iterator _iter38; + for (_iter38 = this->privileges.begin(); _iter38 != this->privileges.end(); ++_iter38) { - xfer += (*_iter36).write(oprot); + xfer += (*_iter38).write(oprot); } xfer += oprot->writeListEnd(); } @@ -1755,13 +1881,13 @@ void swap(PrivilegeBag &a, PrivilegeBag &b) { swap(a.__isset, b.__isset); } -PrivilegeBag::PrivilegeBag(const PrivilegeBag& other37) { - privileges = other37.privileges; - __isset = other37.__isset; +PrivilegeBag::PrivilegeBag(const PrivilegeBag& other39) { + privileges = other39.privileges; + __isset = other39.__isset; } -PrivilegeBag& PrivilegeBag::operator=(const PrivilegeBag& other38) { - privileges = other38.privileges; - __isset = other38.__isset; +PrivilegeBag& PrivilegeBag::operator=(const PrivilegeBag& other40) { + privileges = other40.privileges; + __isset = other40.__isset; return *this; } void PrivilegeBag::printTo(std::ostream& out) const { @@ -1813,26 +1939,26 @@ uint32_t PrincipalPrivilegeSet::read(::apache::thrift::protocol::TProtocol* ipro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->userPrivileges.clear(); - uint32_t _size39; - ::apache::thrift::protocol::TType _ktype40; - ::apache::thrift::protocol::TType _vtype41; - xfer += iprot->readMapBegin(_ktype40, _vtype41, _size39); - uint32_t _i43; - for (_i43 = 0; _i43 < _size39; ++_i43) + uint32_t _size41; + ::apache::thrift::protocol::TType _ktype42; + ::apache::thrift::protocol::TType _vtype43; + xfer += iprot->readMapBegin(_ktype42, _vtype43, _size41); + uint32_t _i45; + for (_i45 = 0; _i45 < _size41; ++_i45) { - std::string _key44; - xfer += iprot->readString(_key44); - std::vector & _val45 = this->userPrivileges[_key44]; + std::string _key46; + xfer += iprot->readString(_key46); + std::vector & _val47 = this->userPrivileges[_key46]; { - _val45.clear(); - uint32_t _size46; - ::apache::thrift::protocol::TType _etype49; - xfer += iprot->readListBegin(_etype49, _size46); - _val45.resize(_size46); - uint32_t _i50; - for (_i50 = 0; _i50 < _size46; ++_i50) + _val47.clear(); + uint32_t _size48; + ::apache::thrift::protocol::TType _etype51; + xfer += iprot->readListBegin(_etype51, _size48); + _val47.resize(_size48); + uint32_t _i52; + for (_i52 = 0; _i52 < _size48; ++_i52) { - xfer += _val45[_i50].read(iprot); + xfer += _val47[_i52].read(iprot); } xfer += iprot->readListEnd(); } @@ -1848,26 +1974,26 @@ uint32_t PrincipalPrivilegeSet::read(::apache::thrift::protocol::TProtocol* ipro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->groupPrivileges.clear(); - uint32_t _size51; - ::apache::thrift::protocol::TType _ktype52; - ::apache::thrift::protocol::TType _vtype53; - xfer += iprot->readMapBegin(_ktype52, _vtype53, _size51); - uint32_t _i55; - for (_i55 = 0; _i55 < _size51; ++_i55) + uint32_t _size53; + ::apache::thrift::protocol::TType _ktype54; + ::apache::thrift::protocol::TType _vtype55; + xfer += iprot->readMapBegin(_ktype54, _vtype55, _size53); + uint32_t _i57; + for (_i57 = 0; _i57 < _size53; ++_i57) { - std::string _key56; - xfer += iprot->readString(_key56); - std::vector & _val57 = this->groupPrivileges[_key56]; + std::string _key58; + xfer += iprot->readString(_key58); + std::vector & _val59 = this->groupPrivileges[_key58]; { - _val57.clear(); - uint32_t _size58; - ::apache::thrift::protocol::TType _etype61; - xfer += iprot->readListBegin(_etype61, _size58); - _val57.resize(_size58); - uint32_t _i62; - for (_i62 = 0; _i62 < _size58; ++_i62) + _val59.clear(); + uint32_t _size60; + ::apache::thrift::protocol::TType _etype63; + xfer += iprot->readListBegin(_etype63, _size60); + _val59.resize(_size60); + uint32_t _i64; + for (_i64 = 0; _i64 < _size60; ++_i64) { - xfer += _val57[_i62].read(iprot); + xfer += _val59[_i64].read(iprot); } xfer += iprot->readListEnd(); } @@ -1883,26 +2009,26 @@ uint32_t PrincipalPrivilegeSet::read(::apache::thrift::protocol::TProtocol* ipro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->rolePrivileges.clear(); - uint32_t _size63; - ::apache::thrift::protocol::TType _ktype64; - ::apache::thrift::protocol::TType _vtype65; - xfer += iprot->readMapBegin(_ktype64, _vtype65, _size63); - uint32_t _i67; - for (_i67 = 0; _i67 < _size63; ++_i67) + uint32_t _size65; + ::apache::thrift::protocol::TType _ktype66; + ::apache::thrift::protocol::TType _vtype67; + xfer += iprot->readMapBegin(_ktype66, _vtype67, _size65); + uint32_t _i69; + for (_i69 = 0; _i69 < _size65; ++_i69) { - std::string _key68; - xfer += iprot->readString(_key68); - std::vector & _val69 = this->rolePrivileges[_key68]; + std::string _key70; + xfer += iprot->readString(_key70); + std::vector & _val71 = this->rolePrivileges[_key70]; { - _val69.clear(); - uint32_t _size70; - ::apache::thrift::protocol::TType _etype73; - xfer += iprot->readListBegin(_etype73, _size70); - _val69.resize(_size70); - uint32_t _i74; - for (_i74 = 0; _i74 < _size70; ++_i74) + _val71.clear(); + uint32_t _size72; + ::apache::thrift::protocol::TType _etype75; + xfer += iprot->readListBegin(_etype75, _size72); + _val71.resize(_size72); + uint32_t _i76; + for (_i76 = 0; _i76 < _size72; ++_i76) { - xfer += _val69[_i74].read(iprot); + xfer += _val71[_i76].read(iprot); } xfer += iprot->readListEnd(); } @@ -1934,16 +2060,16 @@ uint32_t PrincipalPrivilegeSet::write(::apache::thrift::protocol::TProtocol* opr xfer += oprot->writeFieldBegin("userPrivileges", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_LIST, static_cast(this->userPrivileges.size())); - std::map > ::const_iterator _iter75; - for (_iter75 = this->userPrivileges.begin(); _iter75 != this->userPrivileges.end(); ++_iter75) + std::map > ::const_iterator _iter77; + for (_iter77 = this->userPrivileges.begin(); _iter77 != this->userPrivileges.end(); ++_iter77) { - xfer += oprot->writeString(_iter75->first); + xfer += oprot->writeString(_iter77->first); { - xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(_iter75->second.size())); - std::vector ::const_iterator _iter76; - for (_iter76 = _iter75->second.begin(); _iter76 != _iter75->second.end(); ++_iter76) + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(_iter77->second.size())); + std::vector ::const_iterator _iter78; + for (_iter78 = _iter77->second.begin(); _iter78 != _iter77->second.end(); ++_iter78) { - xfer += (*_iter76).write(oprot); + xfer += (*_iter78).write(oprot); } xfer += oprot->writeListEnd(); } @@ -1955,16 +2081,16 @@ uint32_t PrincipalPrivilegeSet::write(::apache::thrift::protocol::TProtocol* opr xfer += oprot->writeFieldBegin("groupPrivileges", ::apache::thrift::protocol::T_MAP, 2); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_LIST, static_cast(this->groupPrivileges.size())); - std::map > ::const_iterator _iter77; - for (_iter77 = this->groupPrivileges.begin(); _iter77 != this->groupPrivileges.end(); ++_iter77) + std::map > ::const_iterator _iter79; + for (_iter79 = this->groupPrivileges.begin(); _iter79 != this->groupPrivileges.end(); ++_iter79) { - xfer += oprot->writeString(_iter77->first); + xfer += oprot->writeString(_iter79->first); { - xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(_iter77->second.size())); - std::vector ::const_iterator _iter78; - for (_iter78 = _iter77->second.begin(); _iter78 != _iter77->second.end(); ++_iter78) + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(_iter79->second.size())); + std::vector ::const_iterator _iter80; + for (_iter80 = _iter79->second.begin(); _iter80 != _iter79->second.end(); ++_iter80) { - xfer += (*_iter78).write(oprot); + xfer += (*_iter80).write(oprot); } xfer += oprot->writeListEnd(); } @@ -1976,16 +2102,16 @@ uint32_t PrincipalPrivilegeSet::write(::apache::thrift::protocol::TProtocol* opr xfer += oprot->writeFieldBegin("rolePrivileges", ::apache::thrift::protocol::T_MAP, 3); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_LIST, static_cast(this->rolePrivileges.size())); - std::map > ::const_iterator _iter79; - for (_iter79 = this->rolePrivileges.begin(); _iter79 != this->rolePrivileges.end(); ++_iter79) + std::map > ::const_iterator _iter81; + for (_iter81 = this->rolePrivileges.begin(); _iter81 != this->rolePrivileges.end(); ++_iter81) { - xfer += oprot->writeString(_iter79->first); + xfer += oprot->writeString(_iter81->first); { - xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(_iter79->second.size())); - std::vector ::const_iterator _iter80; - for (_iter80 = _iter79->second.begin(); _iter80 != _iter79->second.end(); ++_iter80) + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(_iter81->second.size())); + std::vector ::const_iterator _iter82; + for (_iter82 = _iter81->second.begin(); _iter82 != _iter81->second.end(); ++_iter82) { - xfer += (*_iter80).write(oprot); + xfer += (*_iter82).write(oprot); } xfer += oprot->writeListEnd(); } @@ -2007,17 +2133,17 @@ void swap(PrincipalPrivilegeSet &a, PrincipalPrivilegeSet &b) { swap(a.__isset, b.__isset); } -PrincipalPrivilegeSet::PrincipalPrivilegeSet(const PrincipalPrivilegeSet& other81) { - userPrivileges = other81.userPrivileges; - groupPrivileges = other81.groupPrivileges; - rolePrivileges = other81.rolePrivileges; - __isset = other81.__isset; +PrincipalPrivilegeSet::PrincipalPrivilegeSet(const PrincipalPrivilegeSet& other83) { + userPrivileges = other83.userPrivileges; + groupPrivileges = other83.groupPrivileges; + rolePrivileges = other83.rolePrivileges; + __isset = other83.__isset; } -PrincipalPrivilegeSet& PrincipalPrivilegeSet::operator=(const PrincipalPrivilegeSet& other82) { - userPrivileges = other82.userPrivileges; - groupPrivileges = other82.groupPrivileges; - rolePrivileges = other82.rolePrivileges; - __isset = other82.__isset; +PrincipalPrivilegeSet& PrincipalPrivilegeSet::operator=(const PrincipalPrivilegeSet& other84) { + userPrivileges = other84.userPrivileges; + groupPrivileges = other84.groupPrivileges; + rolePrivileges = other84.rolePrivileges; + __isset = other84.__isset; return *this; } void PrincipalPrivilegeSet::printTo(std::ostream& out) const { @@ -2070,9 +2196,9 @@ uint32_t GrantRevokePrivilegeRequest::read(::apache::thrift::protocol::TProtocol { case 1: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast83; - xfer += iprot->readI32(ecast83); - this->requestType = (GrantRevokeType::type)ecast83; + int32_t ecast85; + xfer += iprot->readI32(ecast85); + this->requestType = (GrantRevokeType::type)ecast85; this->__isset.requestType = true; } else { xfer += iprot->skip(ftype); @@ -2137,17 +2263,17 @@ void swap(GrantRevokePrivilegeRequest &a, GrantRevokePrivilegeRequest &b) { swap(a.__isset, b.__isset); } -GrantRevokePrivilegeRequest::GrantRevokePrivilegeRequest(const GrantRevokePrivilegeRequest& other84) { - requestType = other84.requestType; - privileges = other84.privileges; - revokeGrantOption = other84.revokeGrantOption; - __isset = other84.__isset; +GrantRevokePrivilegeRequest::GrantRevokePrivilegeRequest(const GrantRevokePrivilegeRequest& other86) { + requestType = other86.requestType; + privileges = other86.privileges; + revokeGrantOption = other86.revokeGrantOption; + __isset = other86.__isset; } -GrantRevokePrivilegeRequest& GrantRevokePrivilegeRequest::operator=(const GrantRevokePrivilegeRequest& other85) { - requestType = other85.requestType; - privileges = other85.privileges; - revokeGrantOption = other85.revokeGrantOption; - __isset = other85.__isset; +GrantRevokePrivilegeRequest& GrantRevokePrivilegeRequest::operator=(const GrantRevokePrivilegeRequest& other87) { + requestType = other87.requestType; + privileges = other87.privileges; + revokeGrantOption = other87.revokeGrantOption; + __isset = other87.__isset; return *this; } void GrantRevokePrivilegeRequest::printTo(std::ostream& out) const { @@ -2231,13 +2357,13 @@ void swap(GrantRevokePrivilegeResponse &a, GrantRevokePrivilegeResponse &b) { swap(a.__isset, b.__isset); } -GrantRevokePrivilegeResponse::GrantRevokePrivilegeResponse(const GrantRevokePrivilegeResponse& other86) { - success = other86.success; - __isset = other86.__isset; +GrantRevokePrivilegeResponse::GrantRevokePrivilegeResponse(const GrantRevokePrivilegeResponse& other88) { + success = other88.success; + __isset = other88.__isset; } -GrantRevokePrivilegeResponse& GrantRevokePrivilegeResponse::operator=(const GrantRevokePrivilegeResponse& other87) { - success = other87.success; - __isset = other87.__isset; +GrantRevokePrivilegeResponse& GrantRevokePrivilegeResponse::operator=(const GrantRevokePrivilegeResponse& other89) { + success = other89.success; + __isset = other89.__isset; return *this; } void GrantRevokePrivilegeResponse::printTo(std::ostream& out) const { @@ -2351,17 +2477,17 @@ void swap(Role &a, Role &b) { swap(a.__isset, b.__isset); } -Role::Role(const Role& other88) { - roleName = other88.roleName; - createTime = other88.createTime; - ownerName = other88.ownerName; - __isset = other88.__isset; +Role::Role(const Role& other90) { + roleName = other90.roleName; + createTime = other90.createTime; + ownerName = other90.ownerName; + __isset = other90.__isset; } -Role& Role::operator=(const Role& other89) { - roleName = other89.roleName; - createTime = other89.createTime; - ownerName = other89.ownerName; - __isset = other89.__isset; +Role& Role::operator=(const Role& other91) { + roleName = other91.roleName; + createTime = other91.createTime; + ownerName = other91.ownerName; + __isset = other91.__isset; return *this; } void Role::printTo(std::ostream& out) const { @@ -2445,9 +2571,9 @@ uint32_t RolePrincipalGrant::read(::apache::thrift::protocol::TProtocol* iprot) break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast90; - xfer += iprot->readI32(ecast90); - this->principalType = (PrincipalType::type)ecast90; + int32_t ecast92; + xfer += iprot->readI32(ecast92); + this->principalType = (PrincipalType::type)ecast92; this->__isset.principalType = true; } else { xfer += iprot->skip(ftype); @@ -2479,9 +2605,9 @@ uint32_t RolePrincipalGrant::read(::apache::thrift::protocol::TProtocol* iprot) break; case 7: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast91; - xfer += iprot->readI32(ecast91); - this->grantorPrincipalType = (PrincipalType::type)ecast91; + int32_t ecast93; + xfer += iprot->readI32(ecast93); + this->grantorPrincipalType = (PrincipalType::type)ecast93; this->__isset.grantorPrincipalType = true; } else { xfer += iprot->skip(ftype); @@ -2549,25 +2675,25 @@ void swap(RolePrincipalGrant &a, RolePrincipalGrant &b) { swap(a.__isset, b.__isset); } -RolePrincipalGrant::RolePrincipalGrant(const RolePrincipalGrant& other92) { - roleName = other92.roleName; - principalName = other92.principalName; - principalType = other92.principalType; - grantOption = other92.grantOption; - grantTime = other92.grantTime; - grantorName = other92.grantorName; - grantorPrincipalType = other92.grantorPrincipalType; - __isset = other92.__isset; -} -RolePrincipalGrant& RolePrincipalGrant::operator=(const RolePrincipalGrant& other93) { - roleName = other93.roleName; - principalName = other93.principalName; - principalType = other93.principalType; - grantOption = other93.grantOption; - grantTime = other93.grantTime; - grantorName = other93.grantorName; - grantorPrincipalType = other93.grantorPrincipalType; - __isset = other93.__isset; +RolePrincipalGrant::RolePrincipalGrant(const RolePrincipalGrant& other94) { + roleName = other94.roleName; + principalName = other94.principalName; + principalType = other94.principalType; + grantOption = other94.grantOption; + grantTime = other94.grantTime; + grantorName = other94.grantorName; + grantorPrincipalType = other94.grantorPrincipalType; + __isset = other94.__isset; +} +RolePrincipalGrant& RolePrincipalGrant::operator=(const RolePrincipalGrant& other95) { + roleName = other95.roleName; + principalName = other95.principalName; + principalType = other95.principalType; + grantOption = other95.grantOption; + grantTime = other95.grantTime; + grantorName = other95.grantorName; + grantorPrincipalType = other95.grantorPrincipalType; + __isset = other95.__isset; return *this; } void RolePrincipalGrant::printTo(std::ostream& out) const { @@ -2629,9 +2755,9 @@ uint32_t GetRoleGrantsForPrincipalRequest::read(::apache::thrift::protocol::TPro break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast94; - xfer += iprot->readI32(ecast94); - this->principal_type = (PrincipalType::type)ecast94; + int32_t ecast96; + xfer += iprot->readI32(ecast96); + this->principal_type = (PrincipalType::type)ecast96; isset_principal_type = true; } else { xfer += iprot->skip(ftype); @@ -2677,13 +2803,13 @@ void swap(GetRoleGrantsForPrincipalRequest &a, GetRoleGrantsForPrincipalRequest swap(a.principal_type, b.principal_type); } -GetRoleGrantsForPrincipalRequest::GetRoleGrantsForPrincipalRequest(const GetRoleGrantsForPrincipalRequest& other95) { - principal_name = other95.principal_name; - principal_type = other95.principal_type; +GetRoleGrantsForPrincipalRequest::GetRoleGrantsForPrincipalRequest(const GetRoleGrantsForPrincipalRequest& other97) { + principal_name = other97.principal_name; + principal_type = other97.principal_type; } -GetRoleGrantsForPrincipalRequest& GetRoleGrantsForPrincipalRequest::operator=(const GetRoleGrantsForPrincipalRequest& other96) { - principal_name = other96.principal_name; - principal_type = other96.principal_type; +GetRoleGrantsForPrincipalRequest& GetRoleGrantsForPrincipalRequest::operator=(const GetRoleGrantsForPrincipalRequest& other98) { + principal_name = other98.principal_name; + principal_type = other98.principal_type; return *this; } void GetRoleGrantsForPrincipalRequest::printTo(std::ostream& out) const { @@ -2729,14 +2855,14 @@ uint32_t GetRoleGrantsForPrincipalResponse::read(::apache::thrift::protocol::TPr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->principalGrants.clear(); - uint32_t _size97; - ::apache::thrift::protocol::TType _etype100; - xfer += iprot->readListBegin(_etype100, _size97); - this->principalGrants.resize(_size97); - uint32_t _i101; - for (_i101 = 0; _i101 < _size97; ++_i101) + uint32_t _size99; + ::apache::thrift::protocol::TType _etype102; + xfer += iprot->readListBegin(_etype102, _size99); + this->principalGrants.resize(_size99); + uint32_t _i103; + for (_i103 = 0; _i103 < _size99; ++_i103) { - xfer += this->principalGrants[_i101].read(iprot); + xfer += this->principalGrants[_i103].read(iprot); } xfer += iprot->readListEnd(); } @@ -2767,10 +2893,10 @@ uint32_t GetRoleGrantsForPrincipalResponse::write(::apache::thrift::protocol::TP xfer += oprot->writeFieldBegin("principalGrants", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->principalGrants.size())); - std::vector ::const_iterator _iter102; - for (_iter102 = this->principalGrants.begin(); _iter102 != this->principalGrants.end(); ++_iter102) + std::vector ::const_iterator _iter104; + for (_iter104 = this->principalGrants.begin(); _iter104 != this->principalGrants.end(); ++_iter104) { - xfer += (*_iter102).write(oprot); + xfer += (*_iter104).write(oprot); } xfer += oprot->writeListEnd(); } @@ -2786,11 +2912,11 @@ void swap(GetRoleGrantsForPrincipalResponse &a, GetRoleGrantsForPrincipalRespons swap(a.principalGrants, b.principalGrants); } -GetRoleGrantsForPrincipalResponse::GetRoleGrantsForPrincipalResponse(const GetRoleGrantsForPrincipalResponse& other103) { - principalGrants = other103.principalGrants; +GetRoleGrantsForPrincipalResponse::GetRoleGrantsForPrincipalResponse(const GetRoleGrantsForPrincipalResponse& other105) { + principalGrants = other105.principalGrants; } -GetRoleGrantsForPrincipalResponse& GetRoleGrantsForPrincipalResponse::operator=(const GetRoleGrantsForPrincipalResponse& other104) { - principalGrants = other104.principalGrants; +GetRoleGrantsForPrincipalResponse& GetRoleGrantsForPrincipalResponse::operator=(const GetRoleGrantsForPrincipalResponse& other106) { + principalGrants = other106.principalGrants; return *this; } void GetRoleGrantsForPrincipalResponse::printTo(std::ostream& out) const { @@ -2872,11 +2998,11 @@ void swap(GetPrincipalsInRoleRequest &a, GetPrincipalsInRoleRequest &b) { swap(a.roleName, b.roleName); } -GetPrincipalsInRoleRequest::GetPrincipalsInRoleRequest(const GetPrincipalsInRoleRequest& other105) { - roleName = other105.roleName; +GetPrincipalsInRoleRequest::GetPrincipalsInRoleRequest(const GetPrincipalsInRoleRequest& other107) { + roleName = other107.roleName; } -GetPrincipalsInRoleRequest& GetPrincipalsInRoleRequest::operator=(const GetPrincipalsInRoleRequest& other106) { - roleName = other106.roleName; +GetPrincipalsInRoleRequest& GetPrincipalsInRoleRequest::operator=(const GetPrincipalsInRoleRequest& other108) { + roleName = other108.roleName; return *this; } void GetPrincipalsInRoleRequest::printTo(std::ostream& out) const { @@ -2921,14 +3047,14 @@ uint32_t GetPrincipalsInRoleResponse::read(::apache::thrift::protocol::TProtocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->principalGrants.clear(); - uint32_t _size107; - ::apache::thrift::protocol::TType _etype110; - xfer += iprot->readListBegin(_etype110, _size107); - this->principalGrants.resize(_size107); - uint32_t _i111; - for (_i111 = 0; _i111 < _size107; ++_i111) + uint32_t _size109; + ::apache::thrift::protocol::TType _etype112; + xfer += iprot->readListBegin(_etype112, _size109); + this->principalGrants.resize(_size109); + uint32_t _i113; + for (_i113 = 0; _i113 < _size109; ++_i113) { - xfer += this->principalGrants[_i111].read(iprot); + xfer += this->principalGrants[_i113].read(iprot); } xfer += iprot->readListEnd(); } @@ -2959,10 +3085,10 @@ uint32_t GetPrincipalsInRoleResponse::write(::apache::thrift::protocol::TProtoco xfer += oprot->writeFieldBegin("principalGrants", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->principalGrants.size())); - std::vector ::const_iterator _iter112; - for (_iter112 = this->principalGrants.begin(); _iter112 != this->principalGrants.end(); ++_iter112) + std::vector ::const_iterator _iter114; + for (_iter114 = this->principalGrants.begin(); _iter114 != this->principalGrants.end(); ++_iter114) { - xfer += (*_iter112).write(oprot); + xfer += (*_iter114).write(oprot); } xfer += oprot->writeListEnd(); } @@ -2978,11 +3104,11 @@ void swap(GetPrincipalsInRoleResponse &a, GetPrincipalsInRoleResponse &b) { swap(a.principalGrants, b.principalGrants); } -GetPrincipalsInRoleResponse::GetPrincipalsInRoleResponse(const GetPrincipalsInRoleResponse& other113) { - principalGrants = other113.principalGrants; +GetPrincipalsInRoleResponse::GetPrincipalsInRoleResponse(const GetPrincipalsInRoleResponse& other115) { + principalGrants = other115.principalGrants; } -GetPrincipalsInRoleResponse& GetPrincipalsInRoleResponse::operator=(const GetPrincipalsInRoleResponse& other114) { - principalGrants = other114.principalGrants; +GetPrincipalsInRoleResponse& GetPrincipalsInRoleResponse::operator=(const GetPrincipalsInRoleResponse& other116) { + principalGrants = other116.principalGrants; return *this; } void GetPrincipalsInRoleResponse::printTo(std::ostream& out) const { @@ -3051,9 +3177,9 @@ uint32_t GrantRevokeRoleRequest::read(::apache::thrift::protocol::TProtocol* ipr { case 1: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast115; - xfer += iprot->readI32(ecast115); - this->requestType = (GrantRevokeType::type)ecast115; + int32_t ecast117; + xfer += iprot->readI32(ecast117); + this->requestType = (GrantRevokeType::type)ecast117; this->__isset.requestType = true; } else { xfer += iprot->skip(ftype); @@ -3077,9 +3203,9 @@ uint32_t GrantRevokeRoleRequest::read(::apache::thrift::protocol::TProtocol* ipr break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast116; - xfer += iprot->readI32(ecast116); - this->principalType = (PrincipalType::type)ecast116; + int32_t ecast118; + xfer += iprot->readI32(ecast118); + this->principalType = (PrincipalType::type)ecast118; this->__isset.principalType = true; } else { xfer += iprot->skip(ftype); @@ -3095,9 +3221,9 @@ uint32_t GrantRevokeRoleRequest::read(::apache::thrift::protocol::TProtocol* ipr break; case 6: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast117; - xfer += iprot->readI32(ecast117); - this->grantorType = (PrincipalType::type)ecast117; + int32_t ecast119; + xfer += iprot->readI32(ecast119); + this->grantorType = (PrincipalType::type)ecast119; this->__isset.grantorType = true; } else { xfer += iprot->skip(ftype); @@ -3176,25 +3302,25 @@ void swap(GrantRevokeRoleRequest &a, GrantRevokeRoleRequest &b) { swap(a.__isset, b.__isset); } -GrantRevokeRoleRequest::GrantRevokeRoleRequest(const GrantRevokeRoleRequest& other118) { - requestType = other118.requestType; - roleName = other118.roleName; - principalName = other118.principalName; - principalType = other118.principalType; - grantor = other118.grantor; - grantorType = other118.grantorType; - grantOption = other118.grantOption; - __isset = other118.__isset; -} -GrantRevokeRoleRequest& GrantRevokeRoleRequest::operator=(const GrantRevokeRoleRequest& other119) { - requestType = other119.requestType; - roleName = other119.roleName; - principalName = other119.principalName; - principalType = other119.principalType; - grantor = other119.grantor; - grantorType = other119.grantorType; - grantOption = other119.grantOption; - __isset = other119.__isset; +GrantRevokeRoleRequest::GrantRevokeRoleRequest(const GrantRevokeRoleRequest& other120) { + requestType = other120.requestType; + roleName = other120.roleName; + principalName = other120.principalName; + principalType = other120.principalType; + grantor = other120.grantor; + grantorType = other120.grantorType; + grantOption = other120.grantOption; + __isset = other120.__isset; +} +GrantRevokeRoleRequest& GrantRevokeRoleRequest::operator=(const GrantRevokeRoleRequest& other121) { + requestType = other121.requestType; + roleName = other121.roleName; + principalName = other121.principalName; + principalType = other121.principalType; + grantor = other121.grantor; + grantorType = other121.grantorType; + grantOption = other121.grantOption; + __isset = other121.__isset; return *this; } void GrantRevokeRoleRequest::printTo(std::ostream& out) const { @@ -3282,13 +3408,13 @@ void swap(GrantRevokeRoleResponse &a, GrantRevokeRoleResponse &b) { swap(a.__isset, b.__isset); } -GrantRevokeRoleResponse::GrantRevokeRoleResponse(const GrantRevokeRoleResponse& other120) { - success = other120.success; - __isset = other120.__isset; +GrantRevokeRoleResponse::GrantRevokeRoleResponse(const GrantRevokeRoleResponse& other122) { + success = other122.success; + __isset = other122.__isset; } -GrantRevokeRoleResponse& GrantRevokeRoleResponse::operator=(const GrantRevokeRoleResponse& other121) { - success = other121.success; - __isset = other121.__isset; +GrantRevokeRoleResponse& GrantRevokeRoleResponse::operator=(const GrantRevokeRoleResponse& other123) { + success = other123.success; + __isset = other123.__isset; return *this; } void GrantRevokeRoleResponse::printTo(std::ostream& out) const { @@ -3383,17 +3509,17 @@ uint32_t Database::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size122; - ::apache::thrift::protocol::TType _ktype123; - ::apache::thrift::protocol::TType _vtype124; - xfer += iprot->readMapBegin(_ktype123, _vtype124, _size122); - uint32_t _i126; - for (_i126 = 0; _i126 < _size122; ++_i126) + uint32_t _size124; + ::apache::thrift::protocol::TType _ktype125; + ::apache::thrift::protocol::TType _vtype126; + xfer += iprot->readMapBegin(_ktype125, _vtype126, _size124); + uint32_t _i128; + for (_i128 = 0; _i128 < _size124; ++_i128) { - std::string _key127; - xfer += iprot->readString(_key127); - std::string& _val128 = this->parameters[_key127]; - xfer += iprot->readString(_val128); + std::string _key129; + xfer += iprot->readString(_key129); + std::string& _val130 = this->parameters[_key129]; + xfer += iprot->readString(_val130); } xfer += iprot->readMapEnd(); } @@ -3420,9 +3546,9 @@ uint32_t Database::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 7: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast129; - xfer += iprot->readI32(ecast129); - this->ownerType = (PrincipalType::type)ecast129; + int32_t ecast131; + xfer += iprot->readI32(ecast131); + this->ownerType = (PrincipalType::type)ecast131; this->__isset.ownerType = true; } else { xfer += iprot->skip(ftype); @@ -3460,11 +3586,11 @@ uint32_t Database::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 4); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->parameters.size())); - std::map ::const_iterator _iter130; - for (_iter130 = this->parameters.begin(); _iter130 != this->parameters.end(); ++_iter130) + std::map ::const_iterator _iter132; + for (_iter132 = this->parameters.begin(); _iter132 != this->parameters.end(); ++_iter132) { - xfer += oprot->writeString(_iter130->first); - xfer += oprot->writeString(_iter130->second); + xfer += oprot->writeString(_iter132->first); + xfer += oprot->writeString(_iter132->second); } xfer += oprot->writeMapEnd(); } @@ -3502,25 +3628,25 @@ void swap(Database &a, Database &b) { swap(a.__isset, b.__isset); } -Database::Database(const Database& other131) { - name = other131.name; - description = other131.description; - locationUri = other131.locationUri; - parameters = other131.parameters; - privileges = other131.privileges; - ownerName = other131.ownerName; - ownerType = other131.ownerType; - __isset = other131.__isset; -} -Database& Database::operator=(const Database& other132) { - name = other132.name; - description = other132.description; - locationUri = other132.locationUri; - parameters = other132.parameters; - privileges = other132.privileges; - ownerName = other132.ownerName; - ownerType = other132.ownerType; - __isset = other132.__isset; +Database::Database(const Database& other133) { + name = other133.name; + description = other133.description; + locationUri = other133.locationUri; + parameters = other133.parameters; + privileges = other133.privileges; + ownerName = other133.ownerName; + ownerType = other133.ownerType; + __isset = other133.__isset; +} +Database& Database::operator=(const Database& other134) { + name = other134.name; + description = other134.description; + locationUri = other134.locationUri; + parameters = other134.parameters; + privileges = other134.privileges; + ownerName = other134.ownerName; + ownerType = other134.ownerType; + __isset = other134.__isset; return *this; } void Database::printTo(std::ostream& out) const { @@ -3594,17 +3720,17 @@ uint32_t SerDeInfo::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size133; - ::apache::thrift::protocol::TType _ktype134; - ::apache::thrift::protocol::TType _vtype135; - xfer += iprot->readMapBegin(_ktype134, _vtype135, _size133); - uint32_t _i137; - for (_i137 = 0; _i137 < _size133; ++_i137) + uint32_t _size135; + ::apache::thrift::protocol::TType _ktype136; + ::apache::thrift::protocol::TType _vtype137; + xfer += iprot->readMapBegin(_ktype136, _vtype137, _size135); + uint32_t _i139; + for (_i139 = 0; _i139 < _size135; ++_i139) { - std::string _key138; - xfer += iprot->readString(_key138); - std::string& _val139 = this->parameters[_key138]; - xfer += iprot->readString(_val139); + std::string _key140; + xfer += iprot->readString(_key140); + std::string& _val141 = this->parameters[_key140]; + xfer += iprot->readString(_val141); } xfer += iprot->readMapEnd(); } @@ -3641,11 +3767,11 @@ uint32_t SerDeInfo::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 3); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->parameters.size())); - std::map ::const_iterator _iter140; - for (_iter140 = this->parameters.begin(); _iter140 != this->parameters.end(); ++_iter140) + std::map ::const_iterator _iter142; + for (_iter142 = this->parameters.begin(); _iter142 != this->parameters.end(); ++_iter142) { - xfer += oprot->writeString(_iter140->first); - xfer += oprot->writeString(_iter140->second); + xfer += oprot->writeString(_iter142->first); + xfer += oprot->writeString(_iter142->second); } xfer += oprot->writeMapEnd(); } @@ -3664,17 +3790,17 @@ void swap(SerDeInfo &a, SerDeInfo &b) { swap(a.__isset, b.__isset); } -SerDeInfo::SerDeInfo(const SerDeInfo& other141) { - name = other141.name; - serializationLib = other141.serializationLib; - parameters = other141.parameters; - __isset = other141.__isset; +SerDeInfo::SerDeInfo(const SerDeInfo& other143) { + name = other143.name; + serializationLib = other143.serializationLib; + parameters = other143.parameters; + __isset = other143.__isset; } -SerDeInfo& SerDeInfo::operator=(const SerDeInfo& other142) { - name = other142.name; - serializationLib = other142.serializationLib; - parameters = other142.parameters; - __isset = other142.__isset; +SerDeInfo& SerDeInfo::operator=(const SerDeInfo& other144) { + name = other144.name; + serializationLib = other144.serializationLib; + parameters = other144.parameters; + __isset = other144.__isset; return *this; } void SerDeInfo::printTo(std::ostream& out) const { @@ -3773,15 +3899,15 @@ void swap(Order &a, Order &b) { swap(a.__isset, b.__isset); } -Order::Order(const Order& other143) { - col = other143.col; - order = other143.order; - __isset = other143.__isset; +Order::Order(const Order& other145) { + col = other145.col; + order = other145.order; + __isset = other145.__isset; } -Order& Order::operator=(const Order& other144) { - col = other144.col; - order = other144.order; - __isset = other144.__isset; +Order& Order::operator=(const Order& other146) { + col = other146.col; + order = other146.order; + __isset = other146.__isset; return *this; } void Order::printTo(std::ostream& out) const { @@ -3834,14 +3960,14 @@ uint32_t SkewedInfo::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->skewedColNames.clear(); - uint32_t _size145; - ::apache::thrift::protocol::TType _etype148; - xfer += iprot->readListBegin(_etype148, _size145); - this->skewedColNames.resize(_size145); - uint32_t _i149; - for (_i149 = 0; _i149 < _size145; ++_i149) + uint32_t _size147; + ::apache::thrift::protocol::TType _etype150; + xfer += iprot->readListBegin(_etype150, _size147); + this->skewedColNames.resize(_size147); + uint32_t _i151; + for (_i151 = 0; _i151 < _size147; ++_i151) { - xfer += iprot->readString(this->skewedColNames[_i149]); + xfer += iprot->readString(this->skewedColNames[_i151]); } xfer += iprot->readListEnd(); } @@ -3854,23 +3980,23 @@ uint32_t SkewedInfo::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->skewedColValues.clear(); - uint32_t _size150; - ::apache::thrift::protocol::TType _etype153; - xfer += iprot->readListBegin(_etype153, _size150); - this->skewedColValues.resize(_size150); - uint32_t _i154; - for (_i154 = 0; _i154 < _size150; ++_i154) + uint32_t _size152; + ::apache::thrift::protocol::TType _etype155; + xfer += iprot->readListBegin(_etype155, _size152); + this->skewedColValues.resize(_size152); + uint32_t _i156; + for (_i156 = 0; _i156 < _size152; ++_i156) { { - this->skewedColValues[_i154].clear(); - uint32_t _size155; - ::apache::thrift::protocol::TType _etype158; - xfer += iprot->readListBegin(_etype158, _size155); - this->skewedColValues[_i154].resize(_size155); - uint32_t _i159; - for (_i159 = 0; _i159 < _size155; ++_i159) + this->skewedColValues[_i156].clear(); + uint32_t _size157; + ::apache::thrift::protocol::TType _etype160; + xfer += iprot->readListBegin(_etype160, _size157); + this->skewedColValues[_i156].resize(_size157); + uint32_t _i161; + for (_i161 = 0; _i161 < _size157; ++_i161) { - xfer += iprot->readString(this->skewedColValues[_i154][_i159]); + xfer += iprot->readString(this->skewedColValues[_i156][_i161]); } xfer += iprot->readListEnd(); } @@ -3886,29 +4012,29 @@ uint32_t SkewedInfo::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->skewedColValueLocationMaps.clear(); - uint32_t _size160; - ::apache::thrift::protocol::TType _ktype161; - ::apache::thrift::protocol::TType _vtype162; - xfer += iprot->readMapBegin(_ktype161, _vtype162, _size160); - uint32_t _i164; - for (_i164 = 0; _i164 < _size160; ++_i164) + uint32_t _size162; + ::apache::thrift::protocol::TType _ktype163; + ::apache::thrift::protocol::TType _vtype164; + xfer += iprot->readMapBegin(_ktype163, _vtype164, _size162); + uint32_t _i166; + for (_i166 = 0; _i166 < _size162; ++_i166) { - std::vector _key165; + std::vector _key167; { - _key165.clear(); - uint32_t _size167; - ::apache::thrift::protocol::TType _etype170; - xfer += iprot->readListBegin(_etype170, _size167); - _key165.resize(_size167); - uint32_t _i171; - for (_i171 = 0; _i171 < _size167; ++_i171) + _key167.clear(); + uint32_t _size169; + ::apache::thrift::protocol::TType _etype172; + xfer += iprot->readListBegin(_etype172, _size169); + _key167.resize(_size169); + uint32_t _i173; + for (_i173 = 0; _i173 < _size169; ++_i173) { - xfer += iprot->readString(_key165[_i171]); + xfer += iprot->readString(_key167[_i173]); } xfer += iprot->readListEnd(); } - std::string& _val166 = this->skewedColValueLocationMaps[_key165]; - xfer += iprot->readString(_val166); + std::string& _val168 = this->skewedColValueLocationMaps[_key167]; + xfer += iprot->readString(_val168); } xfer += iprot->readMapEnd(); } @@ -3937,10 +4063,10 @@ uint32_t SkewedInfo::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("skewedColNames", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->skewedColNames.size())); - std::vector ::const_iterator _iter172; - for (_iter172 = this->skewedColNames.begin(); _iter172 != this->skewedColNames.end(); ++_iter172) + std::vector ::const_iterator _iter174; + for (_iter174 = this->skewedColNames.begin(); _iter174 != this->skewedColNames.end(); ++_iter174) { - xfer += oprot->writeString((*_iter172)); + xfer += oprot->writeString((*_iter174)); } xfer += oprot->writeListEnd(); } @@ -3949,15 +4075,15 @@ uint32_t SkewedInfo::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("skewedColValues", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_LIST, static_cast(this->skewedColValues.size())); - std::vector > ::const_iterator _iter173; - for (_iter173 = this->skewedColValues.begin(); _iter173 != this->skewedColValues.end(); ++_iter173) + std::vector > ::const_iterator _iter175; + for (_iter175 = this->skewedColValues.begin(); _iter175 != this->skewedColValues.end(); ++_iter175) { { - xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*_iter173).size())); - std::vector ::const_iterator _iter174; - for (_iter174 = (*_iter173).begin(); _iter174 != (*_iter173).end(); ++_iter174) + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*_iter175).size())); + std::vector ::const_iterator _iter176; + for (_iter176 = (*_iter175).begin(); _iter176 != (*_iter175).end(); ++_iter176) { - xfer += oprot->writeString((*_iter174)); + xfer += oprot->writeString((*_iter176)); } xfer += oprot->writeListEnd(); } @@ -3969,19 +4095,19 @@ uint32_t SkewedInfo::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("skewedColValueLocationMaps", ::apache::thrift::protocol::T_MAP, 3); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_LIST, ::apache::thrift::protocol::T_STRING, static_cast(this->skewedColValueLocationMaps.size())); - std::map , std::string> ::const_iterator _iter175; - for (_iter175 = this->skewedColValueLocationMaps.begin(); _iter175 != this->skewedColValueLocationMaps.end(); ++_iter175) + std::map , std::string> ::const_iterator _iter177; + for (_iter177 = this->skewedColValueLocationMaps.begin(); _iter177 != this->skewedColValueLocationMaps.end(); ++_iter177) { { - xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(_iter175->first.size())); - std::vector ::const_iterator _iter176; - for (_iter176 = _iter175->first.begin(); _iter176 != _iter175->first.end(); ++_iter176) + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(_iter177->first.size())); + std::vector ::const_iterator _iter178; + for (_iter178 = _iter177->first.begin(); _iter178 != _iter177->first.end(); ++_iter178) { - xfer += oprot->writeString((*_iter176)); + xfer += oprot->writeString((*_iter178)); } xfer += oprot->writeListEnd(); } - xfer += oprot->writeString(_iter175->second); + xfer += oprot->writeString(_iter177->second); } xfer += oprot->writeMapEnd(); } @@ -4000,17 +4126,17 @@ void swap(SkewedInfo &a, SkewedInfo &b) { swap(a.__isset, b.__isset); } -SkewedInfo::SkewedInfo(const SkewedInfo& other177) { - skewedColNames = other177.skewedColNames; - skewedColValues = other177.skewedColValues; - skewedColValueLocationMaps = other177.skewedColValueLocationMaps; - __isset = other177.__isset; +SkewedInfo::SkewedInfo(const SkewedInfo& other179) { + skewedColNames = other179.skewedColNames; + skewedColValues = other179.skewedColValues; + skewedColValueLocationMaps = other179.skewedColValueLocationMaps; + __isset = other179.__isset; } -SkewedInfo& SkewedInfo::operator=(const SkewedInfo& other178) { - skewedColNames = other178.skewedColNames; - skewedColValues = other178.skewedColValues; - skewedColValueLocationMaps = other178.skewedColValueLocationMaps; - __isset = other178.__isset; +SkewedInfo& SkewedInfo::operator=(const SkewedInfo& other180) { + skewedColNames = other180.skewedColNames; + skewedColValues = other180.skewedColValues; + skewedColValueLocationMaps = other180.skewedColValueLocationMaps; + __isset = other180.__isset; return *this; } void SkewedInfo::printTo(std::ostream& out) const { @@ -4102,14 +4228,14 @@ uint32_t StorageDescriptor::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->cols.clear(); - uint32_t _size179; - ::apache::thrift::protocol::TType _etype182; - xfer += iprot->readListBegin(_etype182, _size179); - this->cols.resize(_size179); - uint32_t _i183; - for (_i183 = 0; _i183 < _size179; ++_i183) + uint32_t _size181; + ::apache::thrift::protocol::TType _etype184; + xfer += iprot->readListBegin(_etype184, _size181); + this->cols.resize(_size181); + uint32_t _i185; + for (_i185 = 0; _i185 < _size181; ++_i185) { - xfer += this->cols[_i183].read(iprot); + xfer += this->cols[_i185].read(iprot); } xfer += iprot->readListEnd(); } @@ -4170,14 +4296,14 @@ uint32_t StorageDescriptor::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->bucketCols.clear(); - uint32_t _size184; - ::apache::thrift::protocol::TType _etype187; - xfer += iprot->readListBegin(_etype187, _size184); - this->bucketCols.resize(_size184); - uint32_t _i188; - for (_i188 = 0; _i188 < _size184; ++_i188) + uint32_t _size186; + ::apache::thrift::protocol::TType _etype189; + xfer += iprot->readListBegin(_etype189, _size186); + this->bucketCols.resize(_size186); + uint32_t _i190; + for (_i190 = 0; _i190 < _size186; ++_i190) { - xfer += iprot->readString(this->bucketCols[_i188]); + xfer += iprot->readString(this->bucketCols[_i190]); } xfer += iprot->readListEnd(); } @@ -4190,14 +4316,14 @@ uint32_t StorageDescriptor::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->sortCols.clear(); - uint32_t _size189; - ::apache::thrift::protocol::TType _etype192; - xfer += iprot->readListBegin(_etype192, _size189); - this->sortCols.resize(_size189); - uint32_t _i193; - for (_i193 = 0; _i193 < _size189; ++_i193) + uint32_t _size191; + ::apache::thrift::protocol::TType _etype194; + xfer += iprot->readListBegin(_etype194, _size191); + this->sortCols.resize(_size191); + uint32_t _i195; + for (_i195 = 0; _i195 < _size191; ++_i195) { - xfer += this->sortCols[_i193].read(iprot); + xfer += this->sortCols[_i195].read(iprot); } xfer += iprot->readListEnd(); } @@ -4210,17 +4336,17 @@ uint32_t StorageDescriptor::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size194; - ::apache::thrift::protocol::TType _ktype195; - ::apache::thrift::protocol::TType _vtype196; - xfer += iprot->readMapBegin(_ktype195, _vtype196, _size194); - uint32_t _i198; - for (_i198 = 0; _i198 < _size194; ++_i198) + uint32_t _size196; + ::apache::thrift::protocol::TType _ktype197; + ::apache::thrift::protocol::TType _vtype198; + xfer += iprot->readMapBegin(_ktype197, _vtype198, _size196); + uint32_t _i200; + for (_i200 = 0; _i200 < _size196; ++_i200) { - std::string _key199; - xfer += iprot->readString(_key199); - std::string& _val200 = this->parameters[_key199]; - xfer += iprot->readString(_val200); + std::string _key201; + xfer += iprot->readString(_key201); + std::string& _val202 = this->parameters[_key201]; + xfer += iprot->readString(_val202); } xfer += iprot->readMapEnd(); } @@ -4265,10 +4391,10 @@ uint32_t StorageDescriptor::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("cols", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->cols.size())); - std::vector ::const_iterator _iter201; - for (_iter201 = this->cols.begin(); _iter201 != this->cols.end(); ++_iter201) + std::vector ::const_iterator _iter203; + for (_iter203 = this->cols.begin(); _iter203 != this->cols.end(); ++_iter203) { - xfer += (*_iter201).write(oprot); + xfer += (*_iter203).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4301,10 +4427,10 @@ uint32_t StorageDescriptor::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("bucketCols", ::apache::thrift::protocol::T_LIST, 8); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->bucketCols.size())); - std::vector ::const_iterator _iter202; - for (_iter202 = this->bucketCols.begin(); _iter202 != this->bucketCols.end(); ++_iter202) + std::vector ::const_iterator _iter204; + for (_iter204 = this->bucketCols.begin(); _iter204 != this->bucketCols.end(); ++_iter204) { - xfer += oprot->writeString((*_iter202)); + xfer += oprot->writeString((*_iter204)); } xfer += oprot->writeListEnd(); } @@ -4313,10 +4439,10 @@ uint32_t StorageDescriptor::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("sortCols", ::apache::thrift::protocol::T_LIST, 9); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->sortCols.size())); - std::vector ::const_iterator _iter203; - for (_iter203 = this->sortCols.begin(); _iter203 != this->sortCols.end(); ++_iter203) + std::vector ::const_iterator _iter205; + for (_iter205 = this->sortCols.begin(); _iter205 != this->sortCols.end(); ++_iter205) { - xfer += (*_iter203).write(oprot); + xfer += (*_iter205).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4325,11 +4451,11 @@ uint32_t StorageDescriptor::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 10); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->parameters.size())); - std::map ::const_iterator _iter204; - for (_iter204 = this->parameters.begin(); _iter204 != this->parameters.end(); ++_iter204) + std::map ::const_iterator _iter206; + for (_iter206 = this->parameters.begin(); _iter206 != this->parameters.end(); ++_iter206) { - xfer += oprot->writeString(_iter204->first); - xfer += oprot->writeString(_iter204->second); + xfer += oprot->writeString(_iter206->first); + xfer += oprot->writeString(_iter206->second); } xfer += oprot->writeMapEnd(); } @@ -4367,35 +4493,35 @@ void swap(StorageDescriptor &a, StorageDescriptor &b) { swap(a.__isset, b.__isset); } -StorageDescriptor::StorageDescriptor(const StorageDescriptor& other205) { - cols = other205.cols; - location = other205.location; - inputFormat = other205.inputFormat; - outputFormat = other205.outputFormat; - compressed = other205.compressed; - numBuckets = other205.numBuckets; - serdeInfo = other205.serdeInfo; - bucketCols = other205.bucketCols; - sortCols = other205.sortCols; - parameters = other205.parameters; - skewedInfo = other205.skewedInfo; - storedAsSubDirectories = other205.storedAsSubDirectories; - __isset = other205.__isset; -} -StorageDescriptor& StorageDescriptor::operator=(const StorageDescriptor& other206) { - cols = other206.cols; - location = other206.location; - inputFormat = other206.inputFormat; - outputFormat = other206.outputFormat; - compressed = other206.compressed; - numBuckets = other206.numBuckets; - serdeInfo = other206.serdeInfo; - bucketCols = other206.bucketCols; - sortCols = other206.sortCols; - parameters = other206.parameters; - skewedInfo = other206.skewedInfo; - storedAsSubDirectories = other206.storedAsSubDirectories; - __isset = other206.__isset; +StorageDescriptor::StorageDescriptor(const StorageDescriptor& other207) { + cols = other207.cols; + location = other207.location; + inputFormat = other207.inputFormat; + outputFormat = other207.outputFormat; + compressed = other207.compressed; + numBuckets = other207.numBuckets; + serdeInfo = other207.serdeInfo; + bucketCols = other207.bucketCols; + sortCols = other207.sortCols; + parameters = other207.parameters; + skewedInfo = other207.skewedInfo; + storedAsSubDirectories = other207.storedAsSubDirectories; + __isset = other207.__isset; +} +StorageDescriptor& StorageDescriptor::operator=(const StorageDescriptor& other208) { + cols = other208.cols; + location = other208.location; + inputFormat = other208.inputFormat; + outputFormat = other208.outputFormat; + compressed = other208.compressed; + numBuckets = other208.numBuckets; + serdeInfo = other208.serdeInfo; + bucketCols = other208.bucketCols; + sortCols = other208.sortCols; + parameters = other208.parameters; + skewedInfo = other208.skewedInfo; + storedAsSubDirectories = other208.storedAsSubDirectories; + __isset = other208.__isset; return *this; } void StorageDescriptor::printTo(std::ostream& out) const { @@ -4565,14 +4691,14 @@ uint32_t Table::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionKeys.clear(); - uint32_t _size207; - ::apache::thrift::protocol::TType _etype210; - xfer += iprot->readListBegin(_etype210, _size207); - this->partitionKeys.resize(_size207); - uint32_t _i211; - for (_i211 = 0; _i211 < _size207; ++_i211) + uint32_t _size209; + ::apache::thrift::protocol::TType _etype212; + xfer += iprot->readListBegin(_etype212, _size209); + this->partitionKeys.resize(_size209); + uint32_t _i213; + for (_i213 = 0; _i213 < _size209; ++_i213) { - xfer += this->partitionKeys[_i211].read(iprot); + xfer += this->partitionKeys[_i213].read(iprot); } xfer += iprot->readListEnd(); } @@ -4585,17 +4711,17 @@ uint32_t Table::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size212; - ::apache::thrift::protocol::TType _ktype213; - ::apache::thrift::protocol::TType _vtype214; - xfer += iprot->readMapBegin(_ktype213, _vtype214, _size212); - uint32_t _i216; - for (_i216 = 0; _i216 < _size212; ++_i216) + uint32_t _size214; + ::apache::thrift::protocol::TType _ktype215; + ::apache::thrift::protocol::TType _vtype216; + xfer += iprot->readMapBegin(_ktype215, _vtype216, _size214); + uint32_t _i218; + for (_i218 = 0; _i218 < _size214; ++_i218) { - std::string _key217; - xfer += iprot->readString(_key217); - std::string& _val218 = this->parameters[_key217]; - xfer += iprot->readString(_val218); + std::string _key219; + xfer += iprot->readString(_key219); + std::string& _val220 = this->parameters[_key219]; + xfer += iprot->readString(_val220); } xfer += iprot->readMapEnd(); } @@ -4700,10 +4826,10 @@ uint32_t Table::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("partitionKeys", ::apache::thrift::protocol::T_LIST, 8); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitionKeys.size())); - std::vector ::const_iterator _iter219; - for (_iter219 = this->partitionKeys.begin(); _iter219 != this->partitionKeys.end(); ++_iter219) + std::vector ::const_iterator _iter221; + for (_iter221 = this->partitionKeys.begin(); _iter221 != this->partitionKeys.end(); ++_iter221) { - xfer += (*_iter219).write(oprot); + xfer += (*_iter221).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4712,11 +4838,11 @@ uint32_t Table::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 9); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->parameters.size())); - std::map ::const_iterator _iter220; - for (_iter220 = this->parameters.begin(); _iter220 != this->parameters.end(); ++_iter220) + std::map ::const_iterator _iter222; + for (_iter222 = this->parameters.begin(); _iter222 != this->parameters.end(); ++_iter222) { - xfer += oprot->writeString(_iter220->first); - xfer += oprot->writeString(_iter220->second); + xfer += oprot->writeString(_iter222->first); + xfer += oprot->writeString(_iter222->second); } xfer += oprot->writeMapEnd(); } @@ -4774,41 +4900,41 @@ void swap(Table &a, Table &b) { swap(a.__isset, b.__isset); } -Table::Table(const Table& other221) { - tableName = other221.tableName; - dbName = other221.dbName; - owner = other221.owner; - createTime = other221.createTime; - lastAccessTime = other221.lastAccessTime; - retention = other221.retention; - sd = other221.sd; - partitionKeys = other221.partitionKeys; - parameters = other221.parameters; - viewOriginalText = other221.viewOriginalText; - viewExpandedText = other221.viewExpandedText; - tableType = other221.tableType; - privileges = other221.privileges; - temporary = other221.temporary; - rewriteEnabled = other221.rewriteEnabled; - __isset = other221.__isset; -} -Table& Table::operator=(const Table& other222) { - tableName = other222.tableName; - dbName = other222.dbName; - owner = other222.owner; - createTime = other222.createTime; - lastAccessTime = other222.lastAccessTime; - retention = other222.retention; - sd = other222.sd; - partitionKeys = other222.partitionKeys; - parameters = other222.parameters; - viewOriginalText = other222.viewOriginalText; - viewExpandedText = other222.viewExpandedText; - tableType = other222.tableType; - privileges = other222.privileges; - temporary = other222.temporary; - rewriteEnabled = other222.rewriteEnabled; - __isset = other222.__isset; +Table::Table(const Table& other223) { + tableName = other223.tableName; + dbName = other223.dbName; + owner = other223.owner; + createTime = other223.createTime; + lastAccessTime = other223.lastAccessTime; + retention = other223.retention; + sd = other223.sd; + partitionKeys = other223.partitionKeys; + parameters = other223.parameters; + viewOriginalText = other223.viewOriginalText; + viewExpandedText = other223.viewExpandedText; + tableType = other223.tableType; + privileges = other223.privileges; + temporary = other223.temporary; + rewriteEnabled = other223.rewriteEnabled; + __isset = other223.__isset; +} +Table& Table::operator=(const Table& other224) { + tableName = other224.tableName; + dbName = other224.dbName; + owner = other224.owner; + createTime = other224.createTime; + lastAccessTime = other224.lastAccessTime; + retention = other224.retention; + sd = other224.sd; + partitionKeys = other224.partitionKeys; + parameters = other224.parameters; + viewOriginalText = other224.viewOriginalText; + viewExpandedText = other224.viewExpandedText; + tableType = other224.tableType; + privileges = other224.privileges; + temporary = other224.temporary; + rewriteEnabled = other224.rewriteEnabled; + __isset = other224.__isset; return *this; } void Table::printTo(std::ostream& out) const { @@ -4895,14 +5021,14 @@ uint32_t Partition::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->values.clear(); - uint32_t _size223; - ::apache::thrift::protocol::TType _etype226; - xfer += iprot->readListBegin(_etype226, _size223); - this->values.resize(_size223); - uint32_t _i227; - for (_i227 = 0; _i227 < _size223; ++_i227) + uint32_t _size225; + ::apache::thrift::protocol::TType _etype228; + xfer += iprot->readListBegin(_etype228, _size225); + this->values.resize(_size225); + uint32_t _i229; + for (_i229 = 0; _i229 < _size225; ++_i229) { - xfer += iprot->readString(this->values[_i227]); + xfer += iprot->readString(this->values[_i229]); } xfer += iprot->readListEnd(); } @@ -4955,17 +5081,17 @@ uint32_t Partition::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size228; - ::apache::thrift::protocol::TType _ktype229; - ::apache::thrift::protocol::TType _vtype230; - xfer += iprot->readMapBegin(_ktype229, _vtype230, _size228); - uint32_t _i232; - for (_i232 = 0; _i232 < _size228; ++_i232) + uint32_t _size230; + ::apache::thrift::protocol::TType _ktype231; + ::apache::thrift::protocol::TType _vtype232; + xfer += iprot->readMapBegin(_ktype231, _vtype232, _size230); + uint32_t _i234; + for (_i234 = 0; _i234 < _size230; ++_i234) { - std::string _key233; - xfer += iprot->readString(_key233); - std::string& _val234 = this->parameters[_key233]; - xfer += iprot->readString(_val234); + std::string _key235; + xfer += iprot->readString(_key235); + std::string& _val236 = this->parameters[_key235]; + xfer += iprot->readString(_val236); } xfer += iprot->readMapEnd(); } @@ -5002,10 +5128,10 @@ uint32_t Partition::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->values.size())); - std::vector ::const_iterator _iter235; - for (_iter235 = this->values.begin(); _iter235 != this->values.end(); ++_iter235) + std::vector ::const_iterator _iter237; + for (_iter237 = this->values.begin(); _iter237 != this->values.end(); ++_iter237) { - xfer += oprot->writeString((*_iter235)); + xfer += oprot->writeString((*_iter237)); } xfer += oprot->writeListEnd(); } @@ -5034,11 +5160,11 @@ uint32_t Partition::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 7); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->parameters.size())); - std::map ::const_iterator _iter236; - for (_iter236 = this->parameters.begin(); _iter236 != this->parameters.end(); ++_iter236) + std::map ::const_iterator _iter238; + for (_iter238 = this->parameters.begin(); _iter238 != this->parameters.end(); ++_iter238) { - xfer += oprot->writeString(_iter236->first); - xfer += oprot->writeString(_iter236->second); + xfer += oprot->writeString(_iter238->first); + xfer += oprot->writeString(_iter238->second); } xfer += oprot->writeMapEnd(); } @@ -5067,27 +5193,27 @@ void swap(Partition &a, Partition &b) { swap(a.__isset, b.__isset); } -Partition::Partition(const Partition& other237) { - values = other237.values; - dbName = other237.dbName; - tableName = other237.tableName; - createTime = other237.createTime; - lastAccessTime = other237.lastAccessTime; - sd = other237.sd; - parameters = other237.parameters; - privileges = other237.privileges; - __isset = other237.__isset; -} -Partition& Partition::operator=(const Partition& other238) { - values = other238.values; - dbName = other238.dbName; - tableName = other238.tableName; - createTime = other238.createTime; - lastAccessTime = other238.lastAccessTime; - sd = other238.sd; - parameters = other238.parameters; - privileges = other238.privileges; - __isset = other238.__isset; +Partition::Partition(const Partition& other239) { + values = other239.values; + dbName = other239.dbName; + tableName = other239.tableName; + createTime = other239.createTime; + lastAccessTime = other239.lastAccessTime; + sd = other239.sd; + parameters = other239.parameters; + privileges = other239.privileges; + __isset = other239.__isset; +} +Partition& Partition::operator=(const Partition& other240) { + values = other240.values; + dbName = other240.dbName; + tableName = other240.tableName; + createTime = other240.createTime; + lastAccessTime = other240.lastAccessTime; + sd = other240.sd; + parameters = other240.parameters; + privileges = other240.privileges; + __isset = other240.__isset; return *this; } void Partition::printTo(std::ostream& out) const { @@ -5159,14 +5285,14 @@ uint32_t PartitionWithoutSD::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->values.clear(); - uint32_t _size239; - ::apache::thrift::protocol::TType _etype242; - xfer += iprot->readListBegin(_etype242, _size239); - this->values.resize(_size239); - uint32_t _i243; - for (_i243 = 0; _i243 < _size239; ++_i243) + uint32_t _size241; + ::apache::thrift::protocol::TType _etype244; + xfer += iprot->readListBegin(_etype244, _size241); + this->values.resize(_size241); + uint32_t _i245; + for (_i245 = 0; _i245 < _size241; ++_i245) { - xfer += iprot->readString(this->values[_i243]); + xfer += iprot->readString(this->values[_i245]); } xfer += iprot->readListEnd(); } @@ -5203,17 +5329,17 @@ uint32_t PartitionWithoutSD::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size244; - ::apache::thrift::protocol::TType _ktype245; - ::apache::thrift::protocol::TType _vtype246; - xfer += iprot->readMapBegin(_ktype245, _vtype246, _size244); - uint32_t _i248; - for (_i248 = 0; _i248 < _size244; ++_i248) + uint32_t _size246; + ::apache::thrift::protocol::TType _ktype247; + ::apache::thrift::protocol::TType _vtype248; + xfer += iprot->readMapBegin(_ktype247, _vtype248, _size246); + uint32_t _i250; + for (_i250 = 0; _i250 < _size246; ++_i250) { - std::string _key249; - xfer += iprot->readString(_key249); - std::string& _val250 = this->parameters[_key249]; - xfer += iprot->readString(_val250); + std::string _key251; + xfer += iprot->readString(_key251); + std::string& _val252 = this->parameters[_key251]; + xfer += iprot->readString(_val252); } xfer += iprot->readMapEnd(); } @@ -5250,10 +5376,10 @@ uint32_t PartitionWithoutSD::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->values.size())); - std::vector ::const_iterator _iter251; - for (_iter251 = this->values.begin(); _iter251 != this->values.end(); ++_iter251) + std::vector ::const_iterator _iter253; + for (_iter253 = this->values.begin(); _iter253 != this->values.end(); ++_iter253) { - xfer += oprot->writeString((*_iter251)); + xfer += oprot->writeString((*_iter253)); } xfer += oprot->writeListEnd(); } @@ -5274,11 +5400,11 @@ uint32_t PartitionWithoutSD::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 5); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->parameters.size())); - std::map ::const_iterator _iter252; - for (_iter252 = this->parameters.begin(); _iter252 != this->parameters.end(); ++_iter252) + std::map ::const_iterator _iter254; + for (_iter254 = this->parameters.begin(); _iter254 != this->parameters.end(); ++_iter254) { - xfer += oprot->writeString(_iter252->first); - xfer += oprot->writeString(_iter252->second); + xfer += oprot->writeString(_iter254->first); + xfer += oprot->writeString(_iter254->second); } xfer += oprot->writeMapEnd(); } @@ -5305,23 +5431,23 @@ void swap(PartitionWithoutSD &a, PartitionWithoutSD &b) { swap(a.__isset, b.__isset); } -PartitionWithoutSD::PartitionWithoutSD(const PartitionWithoutSD& other253) { - values = other253.values; - createTime = other253.createTime; - lastAccessTime = other253.lastAccessTime; - relativePath = other253.relativePath; - parameters = other253.parameters; - privileges = other253.privileges; - __isset = other253.__isset; -} -PartitionWithoutSD& PartitionWithoutSD::operator=(const PartitionWithoutSD& other254) { - values = other254.values; - createTime = other254.createTime; - lastAccessTime = other254.lastAccessTime; - relativePath = other254.relativePath; - parameters = other254.parameters; - privileges = other254.privileges; - __isset = other254.__isset; +PartitionWithoutSD::PartitionWithoutSD(const PartitionWithoutSD& other255) { + values = other255.values; + createTime = other255.createTime; + lastAccessTime = other255.lastAccessTime; + relativePath = other255.relativePath; + parameters = other255.parameters; + privileges = other255.privileges; + __isset = other255.__isset; +} +PartitionWithoutSD& PartitionWithoutSD::operator=(const PartitionWithoutSD& other256) { + values = other256.values; + createTime = other256.createTime; + lastAccessTime = other256.lastAccessTime; + relativePath = other256.relativePath; + parameters = other256.parameters; + privileges = other256.privileges; + __isset = other256.__isset; return *this; } void PartitionWithoutSD::printTo(std::ostream& out) const { @@ -5374,14 +5500,14 @@ uint32_t PartitionSpecWithSharedSD::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size255; - ::apache::thrift::protocol::TType _etype258; - xfer += iprot->readListBegin(_etype258, _size255); - this->partitions.resize(_size255); - uint32_t _i259; - for (_i259 = 0; _i259 < _size255; ++_i259) + uint32_t _size257; + ::apache::thrift::protocol::TType _etype260; + xfer += iprot->readListBegin(_etype260, _size257); + this->partitions.resize(_size257); + uint32_t _i261; + for (_i261 = 0; _i261 < _size257; ++_i261) { - xfer += this->partitions[_i259].read(iprot); + xfer += this->partitions[_i261].read(iprot); } xfer += iprot->readListEnd(); } @@ -5418,10 +5544,10 @@ uint32_t PartitionSpecWithSharedSD::write(::apache::thrift::protocol::TProtocol* 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 _iter260; - for (_iter260 = this->partitions.begin(); _iter260 != this->partitions.end(); ++_iter260) + std::vector ::const_iterator _iter262; + for (_iter262 = this->partitions.begin(); _iter262 != this->partitions.end(); ++_iter262) { - xfer += (*_iter260).write(oprot); + xfer += (*_iter262).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5443,15 +5569,15 @@ void swap(PartitionSpecWithSharedSD &a, PartitionSpecWithSharedSD &b) { swap(a.__isset, b.__isset); } -PartitionSpecWithSharedSD::PartitionSpecWithSharedSD(const PartitionSpecWithSharedSD& other261) { - partitions = other261.partitions; - sd = other261.sd; - __isset = other261.__isset; +PartitionSpecWithSharedSD::PartitionSpecWithSharedSD(const PartitionSpecWithSharedSD& other263) { + partitions = other263.partitions; + sd = other263.sd; + __isset = other263.__isset; } -PartitionSpecWithSharedSD& PartitionSpecWithSharedSD::operator=(const PartitionSpecWithSharedSD& other262) { - partitions = other262.partitions; - sd = other262.sd; - __isset = other262.__isset; +PartitionSpecWithSharedSD& PartitionSpecWithSharedSD::operator=(const PartitionSpecWithSharedSD& other264) { + partitions = other264.partitions; + sd = other264.sd; + __isset = other264.__isset; return *this; } void PartitionSpecWithSharedSD::printTo(std::ostream& out) const { @@ -5496,14 +5622,14 @@ uint32_t PartitionListComposingSpec::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size263; - ::apache::thrift::protocol::TType _etype266; - xfer += iprot->readListBegin(_etype266, _size263); - this->partitions.resize(_size263); - uint32_t _i267; - for (_i267 = 0; _i267 < _size263; ++_i267) + uint32_t _size265; + ::apache::thrift::protocol::TType _etype268; + xfer += iprot->readListBegin(_etype268, _size265); + this->partitions.resize(_size265); + uint32_t _i269; + for (_i269 = 0; _i269 < _size265; ++_i269) { - xfer += this->partitions[_i267].read(iprot); + xfer += this->partitions[_i269].read(iprot); } xfer += iprot->readListEnd(); } @@ -5532,10 +5658,10 @@ uint32_t PartitionListComposingSpec::write(::apache::thrift::protocol::TProtocol 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 _iter268; - for (_iter268 = this->partitions.begin(); _iter268 != this->partitions.end(); ++_iter268) + std::vector ::const_iterator _iter270; + for (_iter270 = this->partitions.begin(); _iter270 != this->partitions.end(); ++_iter270) { - xfer += (*_iter268).write(oprot); + xfer += (*_iter270).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5552,13 +5678,13 @@ void swap(PartitionListComposingSpec &a, PartitionListComposingSpec &b) { swap(a.__isset, b.__isset); } -PartitionListComposingSpec::PartitionListComposingSpec(const PartitionListComposingSpec& other269) { - partitions = other269.partitions; - __isset = other269.__isset; +PartitionListComposingSpec::PartitionListComposingSpec(const PartitionListComposingSpec& other271) { + partitions = other271.partitions; + __isset = other271.__isset; } -PartitionListComposingSpec& PartitionListComposingSpec::operator=(const PartitionListComposingSpec& other270) { - partitions = other270.partitions; - __isset = other270.__isset; +PartitionListComposingSpec& PartitionListComposingSpec::operator=(const PartitionListComposingSpec& other272) { + partitions = other272.partitions; + __isset = other272.__isset; return *this; } void PartitionListComposingSpec::printTo(std::ostream& out) const { @@ -5710,21 +5836,21 @@ void swap(PartitionSpec &a, PartitionSpec &b) { swap(a.__isset, b.__isset); } -PartitionSpec::PartitionSpec(const PartitionSpec& other271) { - dbName = other271.dbName; - tableName = other271.tableName; - rootPath = other271.rootPath; - sharedSDPartitionSpec = other271.sharedSDPartitionSpec; - partitionList = other271.partitionList; - __isset = other271.__isset; -} -PartitionSpec& PartitionSpec::operator=(const PartitionSpec& other272) { - dbName = other272.dbName; - tableName = other272.tableName; - rootPath = other272.rootPath; - sharedSDPartitionSpec = other272.sharedSDPartitionSpec; - partitionList = other272.partitionList; - __isset = other272.__isset; +PartitionSpec::PartitionSpec(const PartitionSpec& other273) { + dbName = other273.dbName; + tableName = other273.tableName; + rootPath = other273.rootPath; + sharedSDPartitionSpec = other273.sharedSDPartitionSpec; + partitionList = other273.partitionList; + __isset = other273.__isset; +} +PartitionSpec& PartitionSpec::operator=(const PartitionSpec& other274) { + dbName = other274.dbName; + tableName = other274.tableName; + rootPath = other274.rootPath; + sharedSDPartitionSpec = other274.sharedSDPartitionSpec; + partitionList = other274.partitionList; + __isset = other274.__isset; return *this; } void PartitionSpec::printTo(std::ostream& out) const { @@ -5872,17 +5998,17 @@ uint32_t Index::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size273; - ::apache::thrift::protocol::TType _ktype274; - ::apache::thrift::protocol::TType _vtype275; - xfer += iprot->readMapBegin(_ktype274, _vtype275, _size273); - uint32_t _i277; - for (_i277 = 0; _i277 < _size273; ++_i277) + uint32_t _size275; + ::apache::thrift::protocol::TType _ktype276; + ::apache::thrift::protocol::TType _vtype277; + xfer += iprot->readMapBegin(_ktype276, _vtype277, _size275); + uint32_t _i279; + for (_i279 = 0; _i279 < _size275; ++_i279) { - std::string _key278; - xfer += iprot->readString(_key278); - std::string& _val279 = this->parameters[_key278]; - xfer += iprot->readString(_val279); + std::string _key280; + xfer += iprot->readString(_key280); + std::string& _val281 = this->parameters[_key280]; + xfer += iprot->readString(_val281); } xfer += iprot->readMapEnd(); } @@ -5951,11 +6077,11 @@ uint32_t Index::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 9); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->parameters.size())); - std::map ::const_iterator _iter280; - for (_iter280 = this->parameters.begin(); _iter280 != this->parameters.end(); ++_iter280) + std::map ::const_iterator _iter282; + for (_iter282 = this->parameters.begin(); _iter282 != this->parameters.end(); ++_iter282) { - xfer += oprot->writeString(_iter280->first); - xfer += oprot->writeString(_iter280->second); + xfer += oprot->writeString(_iter282->first); + xfer += oprot->writeString(_iter282->second); } xfer += oprot->writeMapEnd(); } @@ -5985,31 +6111,31 @@ void swap(Index &a, Index &b) { swap(a.__isset, b.__isset); } -Index::Index(const Index& other281) { - indexName = other281.indexName; - indexHandlerClass = other281.indexHandlerClass; - dbName = other281.dbName; - origTableName = other281.origTableName; - createTime = other281.createTime; - lastAccessTime = other281.lastAccessTime; - indexTableName = other281.indexTableName; - sd = other281.sd; - parameters = other281.parameters; - deferredRebuild = other281.deferredRebuild; - __isset = other281.__isset; -} -Index& Index::operator=(const Index& other282) { - indexName = other282.indexName; - indexHandlerClass = other282.indexHandlerClass; - dbName = other282.dbName; - origTableName = other282.origTableName; - createTime = other282.createTime; - lastAccessTime = other282.lastAccessTime; - indexTableName = other282.indexTableName; - sd = other282.sd; - parameters = other282.parameters; - deferredRebuild = other282.deferredRebuild; - __isset = other282.__isset; +Index::Index(const Index& other283) { + indexName = other283.indexName; + indexHandlerClass = other283.indexHandlerClass; + dbName = other283.dbName; + origTableName = other283.origTableName; + createTime = other283.createTime; + lastAccessTime = other283.lastAccessTime; + indexTableName = other283.indexTableName; + sd = other283.sd; + parameters = other283.parameters; + deferredRebuild = other283.deferredRebuild; + __isset = other283.__isset; +} +Index& Index::operator=(const Index& other284) { + indexName = other284.indexName; + indexHandlerClass = other284.indexHandlerClass; + dbName = other284.dbName; + origTableName = other284.origTableName; + createTime = other284.createTime; + lastAccessTime = other284.lastAccessTime; + indexTableName = other284.indexTableName; + sd = other284.sd; + parameters = other284.parameters; + deferredRebuild = other284.deferredRebuild; + __isset = other284.__isset; return *this; } void Index::printTo(std::ostream& out) const { @@ -6160,19 +6286,19 @@ void swap(BooleanColumnStatsData &a, BooleanColumnStatsData &b) { swap(a.__isset, b.__isset); } -BooleanColumnStatsData::BooleanColumnStatsData(const BooleanColumnStatsData& other283) { - numTrues = other283.numTrues; - numFalses = other283.numFalses; - numNulls = other283.numNulls; - bitVectors = other283.bitVectors; - __isset = other283.__isset; +BooleanColumnStatsData::BooleanColumnStatsData(const BooleanColumnStatsData& other285) { + numTrues = other285.numTrues; + numFalses = other285.numFalses; + numNulls = other285.numNulls; + bitVectors = other285.bitVectors; + __isset = other285.__isset; } -BooleanColumnStatsData& BooleanColumnStatsData::operator=(const BooleanColumnStatsData& other284) { - numTrues = other284.numTrues; - numFalses = other284.numFalses; - numNulls = other284.numNulls; - bitVectors = other284.bitVectors; - __isset = other284.__isset; +BooleanColumnStatsData& BooleanColumnStatsData::operator=(const BooleanColumnStatsData& other286) { + numTrues = other286.numTrues; + numFalses = other286.numFalses; + numNulls = other286.numNulls; + bitVectors = other286.bitVectors; + __isset = other286.__isset; return *this; } void BooleanColumnStatsData::printTo(std::ostream& out) const { @@ -6335,21 +6461,21 @@ void swap(DoubleColumnStatsData &a, DoubleColumnStatsData &b) { swap(a.__isset, b.__isset); } -DoubleColumnStatsData::DoubleColumnStatsData(const DoubleColumnStatsData& other285) { - lowValue = other285.lowValue; - highValue = other285.highValue; - numNulls = other285.numNulls; - numDVs = other285.numDVs; - bitVectors = other285.bitVectors; - __isset = other285.__isset; +DoubleColumnStatsData::DoubleColumnStatsData(const DoubleColumnStatsData& other287) { + lowValue = other287.lowValue; + highValue = other287.highValue; + numNulls = other287.numNulls; + numDVs = other287.numDVs; + bitVectors = other287.bitVectors; + __isset = other287.__isset; } -DoubleColumnStatsData& DoubleColumnStatsData::operator=(const DoubleColumnStatsData& other286) { - lowValue = other286.lowValue; - highValue = other286.highValue; - numNulls = other286.numNulls; - numDVs = other286.numDVs; - bitVectors = other286.bitVectors; - __isset = other286.__isset; +DoubleColumnStatsData& DoubleColumnStatsData::operator=(const DoubleColumnStatsData& other288) { + lowValue = other288.lowValue; + highValue = other288.highValue; + numNulls = other288.numNulls; + numDVs = other288.numDVs; + bitVectors = other288.bitVectors; + __isset = other288.__isset; return *this; } void DoubleColumnStatsData::printTo(std::ostream& out) const { @@ -6513,21 +6639,21 @@ void swap(LongColumnStatsData &a, LongColumnStatsData &b) { swap(a.__isset, b.__isset); } -LongColumnStatsData::LongColumnStatsData(const LongColumnStatsData& other287) { - lowValue = other287.lowValue; - highValue = other287.highValue; - numNulls = other287.numNulls; - numDVs = other287.numDVs; - bitVectors = other287.bitVectors; - __isset = other287.__isset; +LongColumnStatsData::LongColumnStatsData(const LongColumnStatsData& other289) { + lowValue = other289.lowValue; + highValue = other289.highValue; + numNulls = other289.numNulls; + numDVs = other289.numDVs; + bitVectors = other289.bitVectors; + __isset = other289.__isset; } -LongColumnStatsData& LongColumnStatsData::operator=(const LongColumnStatsData& other288) { - lowValue = other288.lowValue; - highValue = other288.highValue; - numNulls = other288.numNulls; - numDVs = other288.numDVs; - bitVectors = other288.bitVectors; - __isset = other288.__isset; +LongColumnStatsData& LongColumnStatsData::operator=(const LongColumnStatsData& other290) { + lowValue = other290.lowValue; + highValue = other290.highValue; + numNulls = other290.numNulls; + numDVs = other290.numDVs; + bitVectors = other290.bitVectors; + __isset = other290.__isset; return *this; } void LongColumnStatsData::printTo(std::ostream& out) const { @@ -6693,21 +6819,21 @@ void swap(StringColumnStatsData &a, StringColumnStatsData &b) { swap(a.__isset, b.__isset); } -StringColumnStatsData::StringColumnStatsData(const StringColumnStatsData& other289) { - maxColLen = other289.maxColLen; - avgColLen = other289.avgColLen; - numNulls = other289.numNulls; - numDVs = other289.numDVs; - bitVectors = other289.bitVectors; - __isset = other289.__isset; +StringColumnStatsData::StringColumnStatsData(const StringColumnStatsData& other291) { + maxColLen = other291.maxColLen; + avgColLen = other291.avgColLen; + numNulls = other291.numNulls; + numDVs = other291.numDVs; + bitVectors = other291.bitVectors; + __isset = other291.__isset; } -StringColumnStatsData& StringColumnStatsData::operator=(const StringColumnStatsData& other290) { - maxColLen = other290.maxColLen; - avgColLen = other290.avgColLen; - numNulls = other290.numNulls; - numDVs = other290.numDVs; - bitVectors = other290.bitVectors; - __isset = other290.__isset; +StringColumnStatsData& StringColumnStatsData::operator=(const StringColumnStatsData& other292) { + maxColLen = other292.maxColLen; + avgColLen = other292.avgColLen; + numNulls = other292.numNulls; + numDVs = other292.numDVs; + bitVectors = other292.bitVectors; + __isset = other292.__isset; return *this; } void StringColumnStatsData::printTo(std::ostream& out) const { @@ -6853,19 +6979,19 @@ void swap(BinaryColumnStatsData &a, BinaryColumnStatsData &b) { swap(a.__isset, b.__isset); } -BinaryColumnStatsData::BinaryColumnStatsData(const BinaryColumnStatsData& other291) { - maxColLen = other291.maxColLen; - avgColLen = other291.avgColLen; - numNulls = other291.numNulls; - bitVectors = other291.bitVectors; - __isset = other291.__isset; +BinaryColumnStatsData::BinaryColumnStatsData(const BinaryColumnStatsData& other293) { + maxColLen = other293.maxColLen; + avgColLen = other293.avgColLen; + numNulls = other293.numNulls; + bitVectors = other293.bitVectors; + __isset = other293.__isset; } -BinaryColumnStatsData& BinaryColumnStatsData::operator=(const BinaryColumnStatsData& other292) { - maxColLen = other292.maxColLen; - avgColLen = other292.avgColLen; - numNulls = other292.numNulls; - bitVectors = other292.bitVectors; - __isset = other292.__isset; +BinaryColumnStatsData& BinaryColumnStatsData::operator=(const BinaryColumnStatsData& other294) { + maxColLen = other294.maxColLen; + avgColLen = other294.avgColLen; + numNulls = other294.numNulls; + bitVectors = other294.bitVectors; + __isset = other294.__isset; return *this; } void BinaryColumnStatsData::printTo(std::ostream& out) const { @@ -6970,13 +7096,13 @@ void swap(Decimal &a, Decimal &b) { swap(a.scale, b.scale); } -Decimal::Decimal(const Decimal& other293) { - unscaled = other293.unscaled; - scale = other293.scale; +Decimal::Decimal(const Decimal& other295) { + unscaled = other295.unscaled; + scale = other295.scale; } -Decimal& Decimal::operator=(const Decimal& other294) { - unscaled = other294.unscaled; - scale = other294.scale; +Decimal& Decimal::operator=(const Decimal& other296) { + unscaled = other296.unscaled; + scale = other296.scale; return *this; } void Decimal::printTo(std::ostream& out) const { @@ -7137,21 +7263,21 @@ void swap(DecimalColumnStatsData &a, DecimalColumnStatsData &b) { swap(a.__isset, b.__isset); } -DecimalColumnStatsData::DecimalColumnStatsData(const DecimalColumnStatsData& other295) { - lowValue = other295.lowValue; - highValue = other295.highValue; - numNulls = other295.numNulls; - numDVs = other295.numDVs; - bitVectors = other295.bitVectors; - __isset = other295.__isset; -} -DecimalColumnStatsData& DecimalColumnStatsData::operator=(const DecimalColumnStatsData& other296) { - lowValue = other296.lowValue; - highValue = other296.highValue; - numNulls = other296.numNulls; - numDVs = other296.numDVs; - bitVectors = other296.bitVectors; - __isset = other296.__isset; +DecimalColumnStatsData::DecimalColumnStatsData(const DecimalColumnStatsData& other297) { + lowValue = other297.lowValue; + highValue = other297.highValue; + numNulls = other297.numNulls; + numDVs = other297.numDVs; + bitVectors = other297.bitVectors; + __isset = other297.__isset; +} +DecimalColumnStatsData& DecimalColumnStatsData::operator=(const DecimalColumnStatsData& other298) { + lowValue = other298.lowValue; + highValue = other298.highValue; + numNulls = other298.numNulls; + numDVs = other298.numDVs; + bitVectors = other298.bitVectors; + __isset = other298.__isset; return *this; } void DecimalColumnStatsData::printTo(std::ostream& out) const { @@ -7237,11 +7363,11 @@ void swap(Date &a, Date &b) { swap(a.daysSinceEpoch, b.daysSinceEpoch); } -Date::Date(const Date& other297) { - daysSinceEpoch = other297.daysSinceEpoch; +Date::Date(const Date& other299) { + daysSinceEpoch = other299.daysSinceEpoch; } -Date& Date::operator=(const Date& other298) { - daysSinceEpoch = other298.daysSinceEpoch; +Date& Date::operator=(const Date& other300) { + daysSinceEpoch = other300.daysSinceEpoch; return *this; } void Date::printTo(std::ostream& out) const { @@ -7401,21 +7527,21 @@ void swap(DateColumnStatsData &a, DateColumnStatsData &b) { swap(a.__isset, b.__isset); } -DateColumnStatsData::DateColumnStatsData(const DateColumnStatsData& other299) { - lowValue = other299.lowValue; - highValue = other299.highValue; - numNulls = other299.numNulls; - numDVs = other299.numDVs; - bitVectors = other299.bitVectors; - __isset = other299.__isset; -} -DateColumnStatsData& DateColumnStatsData::operator=(const DateColumnStatsData& other300) { - lowValue = other300.lowValue; - highValue = other300.highValue; - numNulls = other300.numNulls; - numDVs = other300.numDVs; - bitVectors = other300.bitVectors; - __isset = other300.__isset; +DateColumnStatsData::DateColumnStatsData(const DateColumnStatsData& other301) { + lowValue = other301.lowValue; + highValue = other301.highValue; + numNulls = other301.numNulls; + numDVs = other301.numDVs; + bitVectors = other301.bitVectors; + __isset = other301.__isset; +} +DateColumnStatsData& DateColumnStatsData::operator=(const DateColumnStatsData& other302) { + lowValue = other302.lowValue; + highValue = other302.highValue; + numNulls = other302.numNulls; + numDVs = other302.numDVs; + bitVectors = other302.bitVectors; + __isset = other302.__isset; return *this; } void DateColumnStatsData::printTo(std::ostream& out) const { @@ -7601,25 +7727,25 @@ void swap(ColumnStatisticsData &a, ColumnStatisticsData &b) { swap(a.__isset, b.__isset); } -ColumnStatisticsData::ColumnStatisticsData(const ColumnStatisticsData& other301) { - booleanStats = other301.booleanStats; - longStats = other301.longStats; - doubleStats = other301.doubleStats; - stringStats = other301.stringStats; - binaryStats = other301.binaryStats; - decimalStats = other301.decimalStats; - dateStats = other301.dateStats; - __isset = other301.__isset; -} -ColumnStatisticsData& ColumnStatisticsData::operator=(const ColumnStatisticsData& other302) { - booleanStats = other302.booleanStats; - longStats = other302.longStats; - doubleStats = other302.doubleStats; - stringStats = other302.stringStats; - binaryStats = other302.binaryStats; - decimalStats = other302.decimalStats; - dateStats = other302.dateStats; - __isset = other302.__isset; +ColumnStatisticsData::ColumnStatisticsData(const ColumnStatisticsData& other303) { + booleanStats = other303.booleanStats; + longStats = other303.longStats; + doubleStats = other303.doubleStats; + stringStats = other303.stringStats; + binaryStats = other303.binaryStats; + decimalStats = other303.decimalStats; + dateStats = other303.dateStats; + __isset = other303.__isset; +} +ColumnStatisticsData& ColumnStatisticsData::operator=(const ColumnStatisticsData& other304) { + booleanStats = other304.booleanStats; + longStats = other304.longStats; + doubleStats = other304.doubleStats; + stringStats = other304.stringStats; + binaryStats = other304.binaryStats; + decimalStats = other304.decimalStats; + dateStats = other304.dateStats; + __isset = other304.__isset; return *this; } void ColumnStatisticsData::printTo(std::ostream& out) const { @@ -7747,15 +7873,15 @@ void swap(ColumnStatisticsObj &a, ColumnStatisticsObj &b) { swap(a.statsData, b.statsData); } -ColumnStatisticsObj::ColumnStatisticsObj(const ColumnStatisticsObj& other303) { - colName = other303.colName; - colType = other303.colType; - statsData = other303.statsData; +ColumnStatisticsObj::ColumnStatisticsObj(const ColumnStatisticsObj& other305) { + colName = other305.colName; + colType = other305.colType; + statsData = other305.statsData; } -ColumnStatisticsObj& ColumnStatisticsObj::operator=(const ColumnStatisticsObj& other304) { - colName = other304.colName; - colType = other304.colType; - statsData = other304.statsData; +ColumnStatisticsObj& ColumnStatisticsObj::operator=(const ColumnStatisticsObj& other306) { + colName = other306.colName; + colType = other306.colType; + statsData = other306.statsData; return *this; } void ColumnStatisticsObj::printTo(std::ostream& out) const { @@ -7918,21 +8044,21 @@ void swap(ColumnStatisticsDesc &a, ColumnStatisticsDesc &b) { swap(a.__isset, b.__isset); } -ColumnStatisticsDesc::ColumnStatisticsDesc(const ColumnStatisticsDesc& other305) { - isTblLevel = other305.isTblLevel; - dbName = other305.dbName; - tableName = other305.tableName; - partName = other305.partName; - lastAnalyzed = other305.lastAnalyzed; - __isset = other305.__isset; -} -ColumnStatisticsDesc& ColumnStatisticsDesc::operator=(const ColumnStatisticsDesc& other306) { - isTblLevel = other306.isTblLevel; - dbName = other306.dbName; - tableName = other306.tableName; - partName = other306.partName; - lastAnalyzed = other306.lastAnalyzed; - __isset = other306.__isset; +ColumnStatisticsDesc::ColumnStatisticsDesc(const ColumnStatisticsDesc& other307) { + isTblLevel = other307.isTblLevel; + dbName = other307.dbName; + tableName = other307.tableName; + partName = other307.partName; + lastAnalyzed = other307.lastAnalyzed; + __isset = other307.__isset; +} +ColumnStatisticsDesc& ColumnStatisticsDesc::operator=(const ColumnStatisticsDesc& other308) { + isTblLevel = other308.isTblLevel; + dbName = other308.dbName; + tableName = other308.tableName; + partName = other308.partName; + lastAnalyzed = other308.lastAnalyzed; + __isset = other308.__isset; return *this; } void ColumnStatisticsDesc::printTo(std::ostream& out) const { @@ -7994,14 +8120,14 @@ uint32_t ColumnStatistics::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->statsObj.clear(); - uint32_t _size307; - ::apache::thrift::protocol::TType _etype310; - xfer += iprot->readListBegin(_etype310, _size307); - this->statsObj.resize(_size307); - uint32_t _i311; - for (_i311 = 0; _i311 < _size307; ++_i311) + uint32_t _size309; + ::apache::thrift::protocol::TType _etype312; + xfer += iprot->readListBegin(_etype312, _size309); + this->statsObj.resize(_size309); + uint32_t _i313; + for (_i313 = 0; _i313 < _size309; ++_i313) { - xfer += this->statsObj[_i311].read(iprot); + xfer += this->statsObj[_i313].read(iprot); } xfer += iprot->readListEnd(); } @@ -8038,10 +8164,10 @@ uint32_t ColumnStatistics::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("statsObj", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->statsObj.size())); - std::vector ::const_iterator _iter312; - for (_iter312 = this->statsObj.begin(); _iter312 != this->statsObj.end(); ++_iter312) + std::vector ::const_iterator _iter314; + for (_iter314 = this->statsObj.begin(); _iter314 != this->statsObj.end(); ++_iter314) { - xfer += (*_iter312).write(oprot); + xfer += (*_iter314).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8058,13 +8184,13 @@ void swap(ColumnStatistics &a, ColumnStatistics &b) { swap(a.statsObj, b.statsObj); } -ColumnStatistics::ColumnStatistics(const ColumnStatistics& other313) { - statsDesc = other313.statsDesc; - statsObj = other313.statsObj; +ColumnStatistics::ColumnStatistics(const ColumnStatistics& other315) { + statsDesc = other315.statsDesc; + statsObj = other315.statsObj; } -ColumnStatistics& ColumnStatistics::operator=(const ColumnStatistics& other314) { - statsDesc = other314.statsDesc; - statsObj = other314.statsObj; +ColumnStatistics& ColumnStatistics::operator=(const ColumnStatistics& other316) { + statsDesc = other316.statsDesc; + statsObj = other316.statsObj; return *this; } void ColumnStatistics::printTo(std::ostream& out) const { @@ -8115,14 +8241,14 @@ uint32_t AggrStats::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->colStats.clear(); - uint32_t _size315; - ::apache::thrift::protocol::TType _etype318; - xfer += iprot->readListBegin(_etype318, _size315); - this->colStats.resize(_size315); - uint32_t _i319; - for (_i319 = 0; _i319 < _size315; ++_i319) + uint32_t _size317; + ::apache::thrift::protocol::TType _etype320; + xfer += iprot->readListBegin(_etype320, _size317); + this->colStats.resize(_size317); + uint32_t _i321; + for (_i321 = 0; _i321 < _size317; ++_i321) { - xfer += this->colStats[_i319].read(iprot); + xfer += this->colStats[_i321].read(iprot); } xfer += iprot->readListEnd(); } @@ -8163,10 +8289,10 @@ uint32_t AggrStats::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("colStats", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->colStats.size())); - std::vector ::const_iterator _iter320; - for (_iter320 = this->colStats.begin(); _iter320 != this->colStats.end(); ++_iter320) + std::vector ::const_iterator _iter322; + for (_iter322 = this->colStats.begin(); _iter322 != this->colStats.end(); ++_iter322) { - xfer += (*_iter320).write(oprot); + xfer += (*_iter322).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8187,13 +8313,13 @@ void swap(AggrStats &a, AggrStats &b) { swap(a.partsFound, b.partsFound); } -AggrStats::AggrStats(const AggrStats& other321) { - colStats = other321.colStats; - partsFound = other321.partsFound; +AggrStats::AggrStats(const AggrStats& other323) { + colStats = other323.colStats; + partsFound = other323.partsFound; } -AggrStats& AggrStats::operator=(const AggrStats& other322) { - colStats = other322.colStats; - partsFound = other322.partsFound; +AggrStats& AggrStats::operator=(const AggrStats& other324) { + colStats = other324.colStats; + partsFound = other324.partsFound; return *this; } void AggrStats::printTo(std::ostream& out) const { @@ -8244,14 +8370,14 @@ uint32_t SetPartitionsStatsRequest::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->colStats.clear(); - uint32_t _size323; - ::apache::thrift::protocol::TType _etype326; - xfer += iprot->readListBegin(_etype326, _size323); - this->colStats.resize(_size323); - uint32_t _i327; - for (_i327 = 0; _i327 < _size323; ++_i327) + uint32_t _size325; + ::apache::thrift::protocol::TType _etype328; + xfer += iprot->readListBegin(_etype328, _size325); + this->colStats.resize(_size325); + uint32_t _i329; + for (_i329 = 0; _i329 < _size325; ++_i329) { - xfer += this->colStats[_i327].read(iprot); + xfer += this->colStats[_i329].read(iprot); } xfer += iprot->readListEnd(); } @@ -8290,10 +8416,10 @@ uint32_t SetPartitionsStatsRequest::write(::apache::thrift::protocol::TProtocol* xfer += oprot->writeFieldBegin("colStats", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->colStats.size())); - std::vector ::const_iterator _iter328; - for (_iter328 = this->colStats.begin(); _iter328 != this->colStats.end(); ++_iter328) + std::vector ::const_iterator _iter330; + for (_iter330 = this->colStats.begin(); _iter330 != this->colStats.end(); ++_iter330) { - xfer += (*_iter328).write(oprot); + xfer += (*_iter330).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8316,15 +8442,15 @@ void swap(SetPartitionsStatsRequest &a, SetPartitionsStatsRequest &b) { swap(a.__isset, b.__isset); } -SetPartitionsStatsRequest::SetPartitionsStatsRequest(const SetPartitionsStatsRequest& other329) { - colStats = other329.colStats; - needMerge = other329.needMerge; - __isset = other329.__isset; +SetPartitionsStatsRequest::SetPartitionsStatsRequest(const SetPartitionsStatsRequest& other331) { + colStats = other331.colStats; + needMerge = other331.needMerge; + __isset = other331.__isset; } -SetPartitionsStatsRequest& SetPartitionsStatsRequest::operator=(const SetPartitionsStatsRequest& other330) { - colStats = other330.colStats; - needMerge = other330.needMerge; - __isset = other330.__isset; +SetPartitionsStatsRequest& SetPartitionsStatsRequest::operator=(const SetPartitionsStatsRequest& other332) { + colStats = other332.colStats; + needMerge = other332.needMerge; + __isset = other332.__isset; return *this; } void SetPartitionsStatsRequest::printTo(std::ostream& out) const { @@ -8373,14 +8499,14 @@ uint32_t Schema::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fieldSchemas.clear(); - uint32_t _size331; - ::apache::thrift::protocol::TType _etype334; - xfer += iprot->readListBegin(_etype334, _size331); - this->fieldSchemas.resize(_size331); - uint32_t _i335; - for (_i335 = 0; _i335 < _size331; ++_i335) + uint32_t _size333; + ::apache::thrift::protocol::TType _etype336; + xfer += iprot->readListBegin(_etype336, _size333); + this->fieldSchemas.resize(_size333); + uint32_t _i337; + for (_i337 = 0; _i337 < _size333; ++_i337) { - xfer += this->fieldSchemas[_i335].read(iprot); + xfer += this->fieldSchemas[_i337].read(iprot); } xfer += iprot->readListEnd(); } @@ -8393,17 +8519,17 @@ uint32_t Schema::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->properties.clear(); - uint32_t _size336; - ::apache::thrift::protocol::TType _ktype337; - ::apache::thrift::protocol::TType _vtype338; - xfer += iprot->readMapBegin(_ktype337, _vtype338, _size336); - uint32_t _i340; - for (_i340 = 0; _i340 < _size336; ++_i340) + uint32_t _size338; + ::apache::thrift::protocol::TType _ktype339; + ::apache::thrift::protocol::TType _vtype340; + xfer += iprot->readMapBegin(_ktype339, _vtype340, _size338); + uint32_t _i342; + for (_i342 = 0; _i342 < _size338; ++_i342) { - std::string _key341; - xfer += iprot->readString(_key341); - std::string& _val342 = this->properties[_key341]; - xfer += iprot->readString(_val342); + std::string _key343; + xfer += iprot->readString(_key343); + std::string& _val344 = this->properties[_key343]; + xfer += iprot->readString(_val344); } xfer += iprot->readMapEnd(); } @@ -8432,10 +8558,10 @@ uint32_t Schema::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("fieldSchemas", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->fieldSchemas.size())); - std::vector ::const_iterator _iter343; - for (_iter343 = this->fieldSchemas.begin(); _iter343 != this->fieldSchemas.end(); ++_iter343) + std::vector ::const_iterator _iter345; + for (_iter345 = this->fieldSchemas.begin(); _iter345 != this->fieldSchemas.end(); ++_iter345) { - xfer += (*_iter343).write(oprot); + xfer += (*_iter345).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8444,11 +8570,11 @@ uint32_t Schema::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("properties", ::apache::thrift::protocol::T_MAP, 2); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->properties.size())); - std::map ::const_iterator _iter344; - for (_iter344 = this->properties.begin(); _iter344 != this->properties.end(); ++_iter344) + std::map ::const_iterator _iter346; + for (_iter346 = this->properties.begin(); _iter346 != this->properties.end(); ++_iter346) { - xfer += oprot->writeString(_iter344->first); - xfer += oprot->writeString(_iter344->second); + xfer += oprot->writeString(_iter346->first); + xfer += oprot->writeString(_iter346->second); } xfer += oprot->writeMapEnd(); } @@ -8466,15 +8592,15 @@ void swap(Schema &a, Schema &b) { swap(a.__isset, b.__isset); } -Schema::Schema(const Schema& other345) { - fieldSchemas = other345.fieldSchemas; - properties = other345.properties; - __isset = other345.__isset; +Schema::Schema(const Schema& other347) { + fieldSchemas = other347.fieldSchemas; + properties = other347.properties; + __isset = other347.__isset; } -Schema& Schema::operator=(const Schema& other346) { - fieldSchemas = other346.fieldSchemas; - properties = other346.properties; - __isset = other346.__isset; +Schema& Schema::operator=(const Schema& other348) { + fieldSchemas = other348.fieldSchemas; + properties = other348.properties; + __isset = other348.__isset; return *this; } void Schema::printTo(std::ostream& out) const { @@ -8519,17 +8645,17 @@ uint32_t EnvironmentContext::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_MAP) { { this->properties.clear(); - uint32_t _size347; - ::apache::thrift::protocol::TType _ktype348; - ::apache::thrift::protocol::TType _vtype349; - xfer += iprot->readMapBegin(_ktype348, _vtype349, _size347); - uint32_t _i351; - for (_i351 = 0; _i351 < _size347; ++_i351) + uint32_t _size349; + ::apache::thrift::protocol::TType _ktype350; + ::apache::thrift::protocol::TType _vtype351; + xfer += iprot->readMapBegin(_ktype350, _vtype351, _size349); + uint32_t _i353; + for (_i353 = 0; _i353 < _size349; ++_i353) { - std::string _key352; - xfer += iprot->readString(_key352); - std::string& _val353 = this->properties[_key352]; - xfer += iprot->readString(_val353); + std::string _key354; + xfer += iprot->readString(_key354); + std::string& _val355 = this->properties[_key354]; + xfer += iprot->readString(_val355); } xfer += iprot->readMapEnd(); } @@ -8558,11 +8684,11 @@ uint32_t EnvironmentContext::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("properties", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->properties.size())); - std::map ::const_iterator _iter354; - for (_iter354 = this->properties.begin(); _iter354 != this->properties.end(); ++_iter354) + std::map ::const_iterator _iter356; + for (_iter356 = this->properties.begin(); _iter356 != this->properties.end(); ++_iter356) { - xfer += oprot->writeString(_iter354->first); - xfer += oprot->writeString(_iter354->second); + xfer += oprot->writeString(_iter356->first); + xfer += oprot->writeString(_iter356->second); } xfer += oprot->writeMapEnd(); } @@ -8579,13 +8705,13 @@ void swap(EnvironmentContext &a, EnvironmentContext &b) { swap(a.__isset, b.__isset); } -EnvironmentContext::EnvironmentContext(const EnvironmentContext& other355) { - properties = other355.properties; - __isset = other355.__isset; +EnvironmentContext::EnvironmentContext(const EnvironmentContext& other357) { + properties = other357.properties; + __isset = other357.__isset; } -EnvironmentContext& EnvironmentContext::operator=(const EnvironmentContext& other356) { - properties = other356.properties; - __isset = other356.__isset; +EnvironmentContext& EnvironmentContext::operator=(const EnvironmentContext& other358) { + properties = other358.properties; + __isset = other358.__isset; return *this; } void EnvironmentContext::printTo(std::ostream& out) const { @@ -8687,13 +8813,13 @@ void swap(PrimaryKeysRequest &a, PrimaryKeysRequest &b) { swap(a.tbl_name, b.tbl_name); } -PrimaryKeysRequest::PrimaryKeysRequest(const PrimaryKeysRequest& other357) { - db_name = other357.db_name; - tbl_name = other357.tbl_name; +PrimaryKeysRequest::PrimaryKeysRequest(const PrimaryKeysRequest& other359) { + db_name = other359.db_name; + tbl_name = other359.tbl_name; } -PrimaryKeysRequest& PrimaryKeysRequest::operator=(const PrimaryKeysRequest& other358) { - db_name = other358.db_name; - tbl_name = other358.tbl_name; +PrimaryKeysRequest& PrimaryKeysRequest::operator=(const PrimaryKeysRequest& other360) { + db_name = other360.db_name; + tbl_name = other360.tbl_name; return *this; } void PrimaryKeysRequest::printTo(std::ostream& out) const { @@ -8739,14 +8865,14 @@ uint32_t PrimaryKeysResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->primaryKeys.clear(); - uint32_t _size359; - ::apache::thrift::protocol::TType _etype362; - xfer += iprot->readListBegin(_etype362, _size359); - this->primaryKeys.resize(_size359); - uint32_t _i363; - for (_i363 = 0; _i363 < _size359; ++_i363) + uint32_t _size361; + ::apache::thrift::protocol::TType _etype364; + xfer += iprot->readListBegin(_etype364, _size361); + this->primaryKeys.resize(_size361); + uint32_t _i365; + for (_i365 = 0; _i365 < _size361; ++_i365) { - xfer += this->primaryKeys[_i363].read(iprot); + xfer += this->primaryKeys[_i365].read(iprot); } xfer += iprot->readListEnd(); } @@ -8777,10 +8903,10 @@ uint32_t PrimaryKeysResponse::write(::apache::thrift::protocol::TProtocol* oprot xfer += oprot->writeFieldBegin("primaryKeys", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->primaryKeys.size())); - std::vector ::const_iterator _iter364; - for (_iter364 = this->primaryKeys.begin(); _iter364 != this->primaryKeys.end(); ++_iter364) + std::vector ::const_iterator _iter366; + for (_iter366 = this->primaryKeys.begin(); _iter366 != this->primaryKeys.end(); ++_iter366) { - xfer += (*_iter364).write(oprot); + xfer += (*_iter366).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8796,11 +8922,11 @@ void swap(PrimaryKeysResponse &a, PrimaryKeysResponse &b) { swap(a.primaryKeys, b.primaryKeys); } -PrimaryKeysResponse::PrimaryKeysResponse(const PrimaryKeysResponse& other365) { - primaryKeys = other365.primaryKeys; +PrimaryKeysResponse::PrimaryKeysResponse(const PrimaryKeysResponse& other367) { + primaryKeys = other367.primaryKeys; } -PrimaryKeysResponse& PrimaryKeysResponse::operator=(const PrimaryKeysResponse& other366) { - primaryKeys = other366.primaryKeys; +PrimaryKeysResponse& PrimaryKeysResponse::operator=(const PrimaryKeysResponse& other368) { + primaryKeys = other368.primaryKeys; return *this; } void PrimaryKeysResponse::printTo(std::ostream& out) const { @@ -8931,19 +9057,19 @@ void swap(ForeignKeysRequest &a, ForeignKeysRequest &b) { swap(a.__isset, b.__isset); } -ForeignKeysRequest::ForeignKeysRequest(const ForeignKeysRequest& other367) { - parent_db_name = other367.parent_db_name; - parent_tbl_name = other367.parent_tbl_name; - foreign_db_name = other367.foreign_db_name; - foreign_tbl_name = other367.foreign_tbl_name; - __isset = other367.__isset; +ForeignKeysRequest::ForeignKeysRequest(const ForeignKeysRequest& other369) { + parent_db_name = other369.parent_db_name; + parent_tbl_name = other369.parent_tbl_name; + foreign_db_name = other369.foreign_db_name; + foreign_tbl_name = other369.foreign_tbl_name; + __isset = other369.__isset; } -ForeignKeysRequest& ForeignKeysRequest::operator=(const ForeignKeysRequest& other368) { - parent_db_name = other368.parent_db_name; - parent_tbl_name = other368.parent_tbl_name; - foreign_db_name = other368.foreign_db_name; - foreign_tbl_name = other368.foreign_tbl_name; - __isset = other368.__isset; +ForeignKeysRequest& ForeignKeysRequest::operator=(const ForeignKeysRequest& other370) { + parent_db_name = other370.parent_db_name; + parent_tbl_name = other370.parent_tbl_name; + foreign_db_name = other370.foreign_db_name; + foreign_tbl_name = other370.foreign_tbl_name; + __isset = other370.__isset; return *this; } void ForeignKeysRequest::printTo(std::ostream& out) const { @@ -8991,14 +9117,14 @@ uint32_t ForeignKeysResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->foreignKeys.clear(); - uint32_t _size369; - ::apache::thrift::protocol::TType _etype372; - xfer += iprot->readListBegin(_etype372, _size369); - this->foreignKeys.resize(_size369); - uint32_t _i373; - for (_i373 = 0; _i373 < _size369; ++_i373) + uint32_t _size371; + ::apache::thrift::protocol::TType _etype374; + xfer += iprot->readListBegin(_etype374, _size371); + this->foreignKeys.resize(_size371); + uint32_t _i375; + for (_i375 = 0; _i375 < _size371; ++_i375) { - xfer += this->foreignKeys[_i373].read(iprot); + xfer += this->foreignKeys[_i375].read(iprot); } xfer += iprot->readListEnd(); } @@ -9029,10 +9155,10 @@ uint32_t ForeignKeysResponse::write(::apache::thrift::protocol::TProtocol* oprot xfer += oprot->writeFieldBegin("foreignKeys", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->foreignKeys.size())); - std::vector ::const_iterator _iter374; - for (_iter374 = this->foreignKeys.begin(); _iter374 != this->foreignKeys.end(); ++_iter374) + std::vector ::const_iterator _iter376; + for (_iter376 = this->foreignKeys.begin(); _iter376 != this->foreignKeys.end(); ++_iter376) { - xfer += (*_iter374).write(oprot); + xfer += (*_iter376).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9048,11 +9174,11 @@ void swap(ForeignKeysResponse &a, ForeignKeysResponse &b) { swap(a.foreignKeys, b.foreignKeys); } -ForeignKeysResponse::ForeignKeysResponse(const ForeignKeysResponse& other375) { - foreignKeys = other375.foreignKeys; +ForeignKeysResponse::ForeignKeysResponse(const ForeignKeysResponse& other377) { + foreignKeys = other377.foreignKeys; } -ForeignKeysResponse& ForeignKeysResponse::operator=(const ForeignKeysResponse& other376) { - foreignKeys = other376.foreignKeys; +ForeignKeysResponse& ForeignKeysResponse::operator=(const ForeignKeysResponse& other378) { + foreignKeys = other378.foreignKeys; return *this; } void ForeignKeysResponse::printTo(std::ostream& out) const { @@ -9174,15 +9300,15 @@ void swap(DropConstraintRequest &a, DropConstraintRequest &b) { swap(a.constraintname, b.constraintname); } -DropConstraintRequest::DropConstraintRequest(const DropConstraintRequest& other377) { - dbname = other377.dbname; - tablename = other377.tablename; - constraintname = other377.constraintname; +DropConstraintRequest::DropConstraintRequest(const DropConstraintRequest& other379) { + dbname = other379.dbname; + tablename = other379.tablename; + constraintname = other379.constraintname; } -DropConstraintRequest& DropConstraintRequest::operator=(const DropConstraintRequest& other378) { - dbname = other378.dbname; - tablename = other378.tablename; - constraintname = other378.constraintname; +DropConstraintRequest& DropConstraintRequest::operator=(const DropConstraintRequest& other380) { + dbname = other380.dbname; + tablename = other380.tablename; + constraintname = other380.constraintname; return *this; } void DropConstraintRequest::printTo(std::ostream& out) const { @@ -9229,14 +9355,14 @@ uint32_t AddPrimaryKeyRequest::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->primaryKeyCols.clear(); - uint32_t _size379; - ::apache::thrift::protocol::TType _etype382; - xfer += iprot->readListBegin(_etype382, _size379); - this->primaryKeyCols.resize(_size379); - uint32_t _i383; - for (_i383 = 0; _i383 < _size379; ++_i383) + uint32_t _size381; + ::apache::thrift::protocol::TType _etype384; + xfer += iprot->readListBegin(_etype384, _size381); + this->primaryKeyCols.resize(_size381); + uint32_t _i385; + for (_i385 = 0; _i385 < _size381; ++_i385) { - xfer += this->primaryKeyCols[_i383].read(iprot); + xfer += this->primaryKeyCols[_i385].read(iprot); } xfer += iprot->readListEnd(); } @@ -9267,10 +9393,10 @@ uint32_t AddPrimaryKeyRequest::write(::apache::thrift::protocol::TProtocol* opro xfer += oprot->writeFieldBegin("primaryKeyCols", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->primaryKeyCols.size())); - std::vector ::const_iterator _iter384; - for (_iter384 = this->primaryKeyCols.begin(); _iter384 != this->primaryKeyCols.end(); ++_iter384) + std::vector ::const_iterator _iter386; + for (_iter386 = this->primaryKeyCols.begin(); _iter386 != this->primaryKeyCols.end(); ++_iter386) { - xfer += (*_iter384).write(oprot); + xfer += (*_iter386).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9286,11 +9412,11 @@ void swap(AddPrimaryKeyRequest &a, AddPrimaryKeyRequest &b) { swap(a.primaryKeyCols, b.primaryKeyCols); } -AddPrimaryKeyRequest::AddPrimaryKeyRequest(const AddPrimaryKeyRequest& other385) { - primaryKeyCols = other385.primaryKeyCols; +AddPrimaryKeyRequest::AddPrimaryKeyRequest(const AddPrimaryKeyRequest& other387) { + primaryKeyCols = other387.primaryKeyCols; } -AddPrimaryKeyRequest& AddPrimaryKeyRequest::operator=(const AddPrimaryKeyRequest& other386) { - primaryKeyCols = other386.primaryKeyCols; +AddPrimaryKeyRequest& AddPrimaryKeyRequest::operator=(const AddPrimaryKeyRequest& other388) { + primaryKeyCols = other388.primaryKeyCols; return *this; } void AddPrimaryKeyRequest::printTo(std::ostream& out) const { @@ -9335,14 +9461,14 @@ uint32_t AddForeignKeyRequest::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->foreignKeyCols.clear(); - uint32_t _size387; - ::apache::thrift::protocol::TType _etype390; - xfer += iprot->readListBegin(_etype390, _size387); - this->foreignKeyCols.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->foreignKeyCols.resize(_size389); + uint32_t _i393; + for (_i393 = 0; _i393 < _size389; ++_i393) { - xfer += this->foreignKeyCols[_i391].read(iprot); + xfer += this->foreignKeyCols[_i393].read(iprot); } xfer += iprot->readListEnd(); } @@ -9373,10 +9499,10 @@ uint32_t AddForeignKeyRequest::write(::apache::thrift::protocol::TProtocol* opro xfer += oprot->writeFieldBegin("foreignKeyCols", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->foreignKeyCols.size())); - std::vector ::const_iterator _iter392; - for (_iter392 = this->foreignKeyCols.begin(); _iter392 != this->foreignKeyCols.end(); ++_iter392) + std::vector ::const_iterator _iter394; + for (_iter394 = this->foreignKeyCols.begin(); _iter394 != this->foreignKeyCols.end(); ++_iter394) { - xfer += (*_iter392).write(oprot); + xfer += (*_iter394).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9392,11 +9518,11 @@ void swap(AddForeignKeyRequest &a, AddForeignKeyRequest &b) { swap(a.foreignKeyCols, b.foreignKeyCols); } -AddForeignKeyRequest::AddForeignKeyRequest(const AddForeignKeyRequest& other393) { - foreignKeyCols = other393.foreignKeyCols; +AddForeignKeyRequest::AddForeignKeyRequest(const AddForeignKeyRequest& other395) { + foreignKeyCols = other395.foreignKeyCols; } -AddForeignKeyRequest& AddForeignKeyRequest::operator=(const AddForeignKeyRequest& other394) { - foreignKeyCols = other394.foreignKeyCols; +AddForeignKeyRequest& AddForeignKeyRequest::operator=(const AddForeignKeyRequest& other396) { + foreignKeyCols = other396.foreignKeyCols; return *this; } void AddForeignKeyRequest::printTo(std::ostream& out) const { @@ -9446,14 +9572,14 @@ uint32_t PartitionsByExprResult::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size395; - ::apache::thrift::protocol::TType _etype398; - xfer += iprot->readListBegin(_etype398, _size395); - this->partitions.resize(_size395); - uint32_t _i399; - for (_i399 = 0; _i399 < _size395; ++_i399) + uint32_t _size397; + ::apache::thrift::protocol::TType _etype400; + xfer += iprot->readListBegin(_etype400, _size397); + this->partitions.resize(_size397); + uint32_t _i401; + for (_i401 = 0; _i401 < _size397; ++_i401) { - xfer += this->partitions[_i399].read(iprot); + xfer += this->partitions[_i401].read(iprot); } xfer += iprot->readListEnd(); } @@ -9494,10 +9620,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 _iter400; - for (_iter400 = this->partitions.begin(); _iter400 != this->partitions.end(); ++_iter400) + std::vector ::const_iterator _iter402; + for (_iter402 = this->partitions.begin(); _iter402 != this->partitions.end(); ++_iter402) { - xfer += (*_iter400).write(oprot); + xfer += (*_iter402).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9518,13 +9644,13 @@ void swap(PartitionsByExprResult &a, PartitionsByExprResult &b) { swap(a.hasUnknownPartitions, b.hasUnknownPartitions); } -PartitionsByExprResult::PartitionsByExprResult(const PartitionsByExprResult& other401) { - partitions = other401.partitions; - hasUnknownPartitions = other401.hasUnknownPartitions; +PartitionsByExprResult::PartitionsByExprResult(const PartitionsByExprResult& other403) { + partitions = other403.partitions; + hasUnknownPartitions = other403.hasUnknownPartitions; } -PartitionsByExprResult& PartitionsByExprResult::operator=(const PartitionsByExprResult& other402) { - partitions = other402.partitions; - hasUnknownPartitions = other402.hasUnknownPartitions; +PartitionsByExprResult& PartitionsByExprResult::operator=(const PartitionsByExprResult& other404) { + partitions = other404.partitions; + hasUnknownPartitions = other404.hasUnknownPartitions; return *this; } void PartitionsByExprResult::printTo(std::ostream& out) const { @@ -9686,21 +9812,21 @@ void swap(PartitionsByExprRequest &a, PartitionsByExprRequest &b) { swap(a.__isset, b.__isset); } -PartitionsByExprRequest::PartitionsByExprRequest(const PartitionsByExprRequest& other403) { - dbName = other403.dbName; - tblName = other403.tblName; - expr = other403.expr; - defaultPartitionName = other403.defaultPartitionName; - maxParts = other403.maxParts; - __isset = other403.__isset; -} -PartitionsByExprRequest& PartitionsByExprRequest::operator=(const PartitionsByExprRequest& other404) { - dbName = other404.dbName; - tblName = other404.tblName; - expr = other404.expr; - defaultPartitionName = other404.defaultPartitionName; - maxParts = other404.maxParts; - __isset = other404.__isset; +PartitionsByExprRequest::PartitionsByExprRequest(const PartitionsByExprRequest& other405) { + dbName = other405.dbName; + tblName = other405.tblName; + expr = other405.expr; + defaultPartitionName = other405.defaultPartitionName; + maxParts = other405.maxParts; + __isset = other405.__isset; +} +PartitionsByExprRequest& PartitionsByExprRequest::operator=(const PartitionsByExprRequest& other406) { + dbName = other406.dbName; + tblName = other406.tblName; + expr = other406.expr; + defaultPartitionName = other406.defaultPartitionName; + maxParts = other406.maxParts; + __isset = other406.__isset; return *this; } void PartitionsByExprRequest::printTo(std::ostream& out) const { @@ -9749,14 +9875,14 @@ uint32_t TableStatsResult::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tableStats.clear(); - uint32_t _size405; - ::apache::thrift::protocol::TType _etype408; - xfer += iprot->readListBegin(_etype408, _size405); - this->tableStats.resize(_size405); - uint32_t _i409; - for (_i409 = 0; _i409 < _size405; ++_i409) + uint32_t _size407; + ::apache::thrift::protocol::TType _etype410; + xfer += iprot->readListBegin(_etype410, _size407); + this->tableStats.resize(_size407); + uint32_t _i411; + for (_i411 = 0; _i411 < _size407; ++_i411) { - xfer += this->tableStats[_i409].read(iprot); + xfer += this->tableStats[_i411].read(iprot); } xfer += iprot->readListEnd(); } @@ -9787,10 +9913,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 _iter410; - for (_iter410 = this->tableStats.begin(); _iter410 != this->tableStats.end(); ++_iter410) + std::vector ::const_iterator _iter412; + for (_iter412 = this->tableStats.begin(); _iter412 != this->tableStats.end(); ++_iter412) { - xfer += (*_iter410).write(oprot); + xfer += (*_iter412).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9806,11 +9932,11 @@ void swap(TableStatsResult &a, TableStatsResult &b) { swap(a.tableStats, b.tableStats); } -TableStatsResult::TableStatsResult(const TableStatsResult& other411) { - tableStats = other411.tableStats; +TableStatsResult::TableStatsResult(const TableStatsResult& other413) { + tableStats = other413.tableStats; } -TableStatsResult& TableStatsResult::operator=(const TableStatsResult& other412) { - tableStats = other412.tableStats; +TableStatsResult& TableStatsResult::operator=(const TableStatsResult& other414) { + tableStats = other414.tableStats; return *this; } void TableStatsResult::printTo(std::ostream& out) const { @@ -9855,26 +9981,26 @@ uint32_t PartitionsStatsResult::read(::apache::thrift::protocol::TProtocol* ipro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partStats.clear(); - uint32_t _size413; - ::apache::thrift::protocol::TType _ktype414; - ::apache::thrift::protocol::TType _vtype415; - xfer += iprot->readMapBegin(_ktype414, _vtype415, _size413); - uint32_t _i417; - for (_i417 = 0; _i417 < _size413; ++_i417) + uint32_t _size415; + ::apache::thrift::protocol::TType _ktype416; + ::apache::thrift::protocol::TType _vtype417; + xfer += iprot->readMapBegin(_ktype416, _vtype417, _size415); + uint32_t _i419; + for (_i419 = 0; _i419 < _size415; ++_i419) { - std::string _key418; - xfer += iprot->readString(_key418); - std::vector & _val419 = this->partStats[_key418]; + std::string _key420; + xfer += iprot->readString(_key420); + std::vector & _val421 = this->partStats[_key420]; { - _val419.clear(); - uint32_t _size420; - ::apache::thrift::protocol::TType _etype423; - xfer += iprot->readListBegin(_etype423, _size420); - _val419.resize(_size420); - uint32_t _i424; - for (_i424 = 0; _i424 < _size420; ++_i424) + _val421.clear(); + uint32_t _size422; + ::apache::thrift::protocol::TType _etype425; + xfer += iprot->readListBegin(_etype425, _size422); + _val421.resize(_size422); + uint32_t _i426; + for (_i426 = 0; _i426 < _size422; ++_i426) { - xfer += _val419[_i424].read(iprot); + xfer += _val421[_i426].read(iprot); } xfer += iprot->readListEnd(); } @@ -9908,16 +10034,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 _iter425; - for (_iter425 = this->partStats.begin(); _iter425 != this->partStats.end(); ++_iter425) + std::map > ::const_iterator _iter427; + for (_iter427 = this->partStats.begin(); _iter427 != this->partStats.end(); ++_iter427) { - xfer += oprot->writeString(_iter425->first); + xfer += oprot->writeString(_iter427->first); { - xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(_iter425->second.size())); - std::vector ::const_iterator _iter426; - for (_iter426 = _iter425->second.begin(); _iter426 != _iter425->second.end(); ++_iter426) + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(_iter427->second.size())); + std::vector ::const_iterator _iter428; + for (_iter428 = _iter427->second.begin(); _iter428 != _iter427->second.end(); ++_iter428) { - xfer += (*_iter426).write(oprot); + xfer += (*_iter428).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9936,11 +10062,11 @@ void swap(PartitionsStatsResult &a, PartitionsStatsResult &b) { swap(a.partStats, b.partStats); } -PartitionsStatsResult::PartitionsStatsResult(const PartitionsStatsResult& other427) { - partStats = other427.partStats; +PartitionsStatsResult::PartitionsStatsResult(const PartitionsStatsResult& other429) { + partStats = other429.partStats; } -PartitionsStatsResult& PartitionsStatsResult::operator=(const PartitionsStatsResult& other428) { - partStats = other428.partStats; +PartitionsStatsResult& PartitionsStatsResult::operator=(const PartitionsStatsResult& other430) { + partStats = other430.partStats; return *this; } void PartitionsStatsResult::printTo(std::ostream& out) const { @@ -10011,14 +10137,14 @@ uint32_t TableStatsRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->colNames.clear(); - uint32_t _size429; - ::apache::thrift::protocol::TType _etype432; - xfer += iprot->readListBegin(_etype432, _size429); - this->colNames.resize(_size429); - uint32_t _i433; - for (_i433 = 0; _i433 < _size429; ++_i433) + uint32_t _size431; + ::apache::thrift::protocol::TType _etype434; + xfer += iprot->readListBegin(_etype434, _size431); + this->colNames.resize(_size431); + uint32_t _i435; + for (_i435 = 0; _i435 < _size431; ++_i435) { - xfer += iprot->readString(this->colNames[_i433]); + xfer += iprot->readString(this->colNames[_i435]); } xfer += iprot->readListEnd(); } @@ -10061,10 +10187,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 _iter434; - for (_iter434 = this->colNames.begin(); _iter434 != this->colNames.end(); ++_iter434) + std::vector ::const_iterator _iter436; + for (_iter436 = this->colNames.begin(); _iter436 != this->colNames.end(); ++_iter436) { - xfer += oprot->writeString((*_iter434)); + xfer += oprot->writeString((*_iter436)); } xfer += oprot->writeListEnd(); } @@ -10082,15 +10208,15 @@ void swap(TableStatsRequest &a, TableStatsRequest &b) { swap(a.colNames, b.colNames); } -TableStatsRequest::TableStatsRequest(const TableStatsRequest& other435) { - dbName = other435.dbName; - tblName = other435.tblName; - colNames = other435.colNames; +TableStatsRequest::TableStatsRequest(const TableStatsRequest& other437) { + dbName = other437.dbName; + tblName = other437.tblName; + colNames = other437.colNames; } -TableStatsRequest& TableStatsRequest::operator=(const TableStatsRequest& other436) { - dbName = other436.dbName; - tblName = other436.tblName; - colNames = other436.colNames; +TableStatsRequest& TableStatsRequest::operator=(const TableStatsRequest& other438) { + dbName = other438.dbName; + tblName = other438.tblName; + colNames = other438.colNames; return *this; } void TableStatsRequest::printTo(std::ostream& out) const { @@ -10168,14 +10294,14 @@ uint32_t PartitionsStatsRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->colNames.clear(); - uint32_t _size437; - ::apache::thrift::protocol::TType _etype440; - xfer += iprot->readListBegin(_etype440, _size437); - this->colNames.resize(_size437); - uint32_t _i441; - for (_i441 = 0; _i441 < _size437; ++_i441) + uint32_t _size439; + ::apache::thrift::protocol::TType _etype442; + xfer += iprot->readListBegin(_etype442, _size439); + this->colNames.resize(_size439); + uint32_t _i443; + for (_i443 = 0; _i443 < _size439; ++_i443) { - xfer += iprot->readString(this->colNames[_i441]); + xfer += iprot->readString(this->colNames[_i443]); } xfer += iprot->readListEnd(); } @@ -10188,14 +10314,14 @@ uint32_t PartitionsStatsRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partNames.clear(); - uint32_t _size442; - ::apache::thrift::protocol::TType _etype445; - xfer += iprot->readListBegin(_etype445, _size442); - this->partNames.resize(_size442); - uint32_t _i446; - for (_i446 = 0; _i446 < _size442; ++_i446) + uint32_t _size444; + ::apache::thrift::protocol::TType _etype447; + xfer += iprot->readListBegin(_etype447, _size444); + this->partNames.resize(_size444); + uint32_t _i448; + for (_i448 = 0; _i448 < _size444; ++_i448) { - xfer += iprot->readString(this->partNames[_i446]); + xfer += iprot->readString(this->partNames[_i448]); } xfer += iprot->readListEnd(); } @@ -10240,10 +10366,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 _iter447; - for (_iter447 = this->colNames.begin(); _iter447 != this->colNames.end(); ++_iter447) + std::vector ::const_iterator _iter449; + for (_iter449 = this->colNames.begin(); _iter449 != this->colNames.end(); ++_iter449) { - xfer += oprot->writeString((*_iter447)); + xfer += oprot->writeString((*_iter449)); } xfer += oprot->writeListEnd(); } @@ -10252,10 +10378,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 _iter448; - for (_iter448 = this->partNames.begin(); _iter448 != this->partNames.end(); ++_iter448) + std::vector ::const_iterator _iter450; + for (_iter450 = this->partNames.begin(); _iter450 != this->partNames.end(); ++_iter450) { - xfer += oprot->writeString((*_iter448)); + xfer += oprot->writeString((*_iter450)); } xfer += oprot->writeListEnd(); } @@ -10274,17 +10400,17 @@ void swap(PartitionsStatsRequest &a, PartitionsStatsRequest &b) { swap(a.partNames, b.partNames); } -PartitionsStatsRequest::PartitionsStatsRequest(const PartitionsStatsRequest& other449) { - dbName = other449.dbName; - tblName = other449.tblName; - colNames = other449.colNames; - partNames = other449.partNames; +PartitionsStatsRequest::PartitionsStatsRequest(const PartitionsStatsRequest& other451) { + dbName = other451.dbName; + tblName = other451.tblName; + colNames = other451.colNames; + partNames = other451.partNames; } -PartitionsStatsRequest& PartitionsStatsRequest::operator=(const PartitionsStatsRequest& other450) { - dbName = other450.dbName; - tblName = other450.tblName; - colNames = other450.colNames; - partNames = other450.partNames; +PartitionsStatsRequest& PartitionsStatsRequest::operator=(const PartitionsStatsRequest& other452) { + dbName = other452.dbName; + tblName = other452.tblName; + colNames = other452.colNames; + partNames = other452.partNames; return *this; } void PartitionsStatsRequest::printTo(std::ostream& out) const { @@ -10332,14 +10458,14 @@ uint32_t AddPartitionsResult::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - 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) + uint32_t _size453; + ::apache::thrift::protocol::TType _etype456; + xfer += iprot->readListBegin(_etype456, _size453); + this->partitions.resize(_size453); + uint32_t _i457; + for (_i457 = 0; _i457 < _size453; ++_i457) { - xfer += this->partitions[_i455].read(iprot); + xfer += this->partitions[_i457].read(iprot); } xfer += iprot->readListEnd(); } @@ -10369,10 +10495,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 _iter456; - for (_iter456 = this->partitions.begin(); _iter456 != this->partitions.end(); ++_iter456) + std::vector ::const_iterator _iter458; + for (_iter458 = this->partitions.begin(); _iter458 != this->partitions.end(); ++_iter458) { - xfer += (*_iter456).write(oprot); + xfer += (*_iter458).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10389,13 +10515,13 @@ void swap(AddPartitionsResult &a, AddPartitionsResult &b) { swap(a.__isset, b.__isset); } -AddPartitionsResult::AddPartitionsResult(const AddPartitionsResult& other457) { - partitions = other457.partitions; - __isset = other457.__isset; +AddPartitionsResult::AddPartitionsResult(const AddPartitionsResult& other459) { + partitions = other459.partitions; + __isset = other459.__isset; } -AddPartitionsResult& AddPartitionsResult::operator=(const AddPartitionsResult& other458) { - partitions = other458.partitions; - __isset = other458.__isset; +AddPartitionsResult& AddPartitionsResult::operator=(const AddPartitionsResult& other460) { + partitions = other460.partitions; + __isset = other460.__isset; return *this; } void AddPartitionsResult::printTo(std::ostream& out) const { @@ -10476,14 +10602,14 @@ uint32_t AddPartitionsRequest::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->parts.clear(); - uint32_t _size459; - ::apache::thrift::protocol::TType _etype462; - xfer += iprot->readListBegin(_etype462, _size459); - this->parts.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->parts.resize(_size461); + uint32_t _i465; + for (_i465 = 0; _i465 < _size461; ++_i465) { - xfer += this->parts[_i463].read(iprot); + xfer += this->parts[_i465].read(iprot); } xfer += iprot->readListEnd(); } @@ -10544,10 +10670,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 _iter464; - for (_iter464 = this->parts.begin(); _iter464 != this->parts.end(); ++_iter464) + std::vector ::const_iterator _iter466; + for (_iter466 = this->parts.begin(); _iter466 != this->parts.end(); ++_iter466) { - xfer += (*_iter464).write(oprot); + xfer += (*_iter466).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10577,21 +10703,21 @@ void swap(AddPartitionsRequest &a, AddPartitionsRequest &b) { swap(a.__isset, b.__isset); } -AddPartitionsRequest::AddPartitionsRequest(const AddPartitionsRequest& other465) { - dbName = other465.dbName; - tblName = other465.tblName; - parts = other465.parts; - ifNotExists = other465.ifNotExists; - needResult = other465.needResult; - __isset = other465.__isset; -} -AddPartitionsRequest& AddPartitionsRequest::operator=(const AddPartitionsRequest& other466) { - dbName = other466.dbName; - tblName = other466.tblName; - parts = other466.parts; - ifNotExists = other466.ifNotExists; - needResult = other466.needResult; - __isset = other466.__isset; +AddPartitionsRequest::AddPartitionsRequest(const AddPartitionsRequest& other467) { + dbName = other467.dbName; + tblName = other467.tblName; + parts = other467.parts; + ifNotExists = other467.ifNotExists; + needResult = other467.needResult; + __isset = other467.__isset; +} +AddPartitionsRequest& AddPartitionsRequest::operator=(const AddPartitionsRequest& other468) { + dbName = other468.dbName; + tblName = other468.tblName; + parts = other468.parts; + ifNotExists = other468.ifNotExists; + needResult = other468.needResult; + __isset = other468.__isset; return *this; } void AddPartitionsRequest::printTo(std::ostream& out) const { @@ -10640,14 +10766,14 @@ uint32_t DropPartitionsResult::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size467; - ::apache::thrift::protocol::TType _etype470; - xfer += iprot->readListBegin(_etype470, _size467); - this->partitions.resize(_size467); - uint32_t _i471; - for (_i471 = 0; _i471 < _size467; ++_i471) + uint32_t _size469; + ::apache::thrift::protocol::TType _etype472; + xfer += iprot->readListBegin(_etype472, _size469); + this->partitions.resize(_size469); + uint32_t _i473; + for (_i473 = 0; _i473 < _size469; ++_i473) { - xfer += this->partitions[_i471].read(iprot); + xfer += this->partitions[_i473].read(iprot); } xfer += iprot->readListEnd(); } @@ -10677,10 +10803,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 _iter472; - for (_iter472 = this->partitions.begin(); _iter472 != this->partitions.end(); ++_iter472) + std::vector ::const_iterator _iter474; + for (_iter474 = this->partitions.begin(); _iter474 != this->partitions.end(); ++_iter474) { - xfer += (*_iter472).write(oprot); + xfer += (*_iter474).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10697,13 +10823,13 @@ void swap(DropPartitionsResult &a, DropPartitionsResult &b) { swap(a.__isset, b.__isset); } -DropPartitionsResult::DropPartitionsResult(const DropPartitionsResult& other473) { - partitions = other473.partitions; - __isset = other473.__isset; +DropPartitionsResult::DropPartitionsResult(const DropPartitionsResult& other475) { + partitions = other475.partitions; + __isset = other475.__isset; } -DropPartitionsResult& DropPartitionsResult::operator=(const DropPartitionsResult& other474) { - partitions = other474.partitions; - __isset = other474.__isset; +DropPartitionsResult& DropPartitionsResult::operator=(const DropPartitionsResult& other476) { + partitions = other476.partitions; + __isset = other476.__isset; return *this; } void DropPartitionsResult::printTo(std::ostream& out) const { @@ -10805,15 +10931,15 @@ void swap(DropPartitionsExpr &a, DropPartitionsExpr &b) { swap(a.__isset, b.__isset); } -DropPartitionsExpr::DropPartitionsExpr(const DropPartitionsExpr& other475) { - expr = other475.expr; - partArchiveLevel = other475.partArchiveLevel; - __isset = other475.__isset; +DropPartitionsExpr::DropPartitionsExpr(const DropPartitionsExpr& other477) { + expr = other477.expr; + partArchiveLevel = other477.partArchiveLevel; + __isset = other477.__isset; } -DropPartitionsExpr& DropPartitionsExpr::operator=(const DropPartitionsExpr& other476) { - expr = other476.expr; - partArchiveLevel = other476.partArchiveLevel; - __isset = other476.__isset; +DropPartitionsExpr& DropPartitionsExpr::operator=(const DropPartitionsExpr& other478) { + expr = other478.expr; + partArchiveLevel = other478.partArchiveLevel; + __isset = other478.__isset; return *this; } void DropPartitionsExpr::printTo(std::ostream& out) const { @@ -10862,14 +10988,14 @@ uint32_t RequestPartsSpec::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->names.clear(); - uint32_t _size477; - ::apache::thrift::protocol::TType _etype480; - xfer += iprot->readListBegin(_etype480, _size477); - this->names.resize(_size477); - uint32_t _i481; - for (_i481 = 0; _i481 < _size477; ++_i481) + uint32_t _size479; + ::apache::thrift::protocol::TType _etype482; + xfer += iprot->readListBegin(_etype482, _size479); + this->names.resize(_size479); + uint32_t _i483; + for (_i483 = 0; _i483 < _size479; ++_i483) { - xfer += iprot->readString(this->names[_i481]); + xfer += iprot->readString(this->names[_i483]); } xfer += iprot->readListEnd(); } @@ -10882,14 +11008,14 @@ uint32_t RequestPartsSpec::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->exprs.clear(); - uint32_t _size482; - ::apache::thrift::protocol::TType _etype485; - xfer += iprot->readListBegin(_etype485, _size482); - this->exprs.resize(_size482); - uint32_t _i486; - for (_i486 = 0; _i486 < _size482; ++_i486) + uint32_t _size484; + ::apache::thrift::protocol::TType _etype487; + xfer += iprot->readListBegin(_etype487, _size484); + this->exprs.resize(_size484); + uint32_t _i488; + for (_i488 = 0; _i488 < _size484; ++_i488) { - xfer += this->exprs[_i486].read(iprot); + xfer += this->exprs[_i488].read(iprot); } xfer += iprot->readListEnd(); } @@ -10918,10 +11044,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 _iter487; - for (_iter487 = this->names.begin(); _iter487 != this->names.end(); ++_iter487) + std::vector ::const_iterator _iter489; + for (_iter489 = this->names.begin(); _iter489 != this->names.end(); ++_iter489) { - xfer += oprot->writeString((*_iter487)); + xfer += oprot->writeString((*_iter489)); } xfer += oprot->writeListEnd(); } @@ -10930,10 +11056,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 _iter488; - for (_iter488 = this->exprs.begin(); _iter488 != this->exprs.end(); ++_iter488) + std::vector ::const_iterator _iter490; + for (_iter490 = this->exprs.begin(); _iter490 != this->exprs.end(); ++_iter490) { - xfer += (*_iter488).write(oprot); + xfer += (*_iter490).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10951,15 +11077,15 @@ void swap(RequestPartsSpec &a, RequestPartsSpec &b) { swap(a.__isset, b.__isset); } -RequestPartsSpec::RequestPartsSpec(const RequestPartsSpec& other489) { - names = other489.names; - exprs = other489.exprs; - __isset = other489.__isset; +RequestPartsSpec::RequestPartsSpec(const RequestPartsSpec& other491) { + names = other491.names; + exprs = other491.exprs; + __isset = other491.__isset; } -RequestPartsSpec& RequestPartsSpec::operator=(const RequestPartsSpec& other490) { - names = other490.names; - exprs = other490.exprs; - __isset = other490.__isset; +RequestPartsSpec& RequestPartsSpec::operator=(const RequestPartsSpec& other492) { + names = other492.names; + exprs = other492.exprs; + __isset = other492.__isset; return *this; } void RequestPartsSpec::printTo(std::ostream& out) const { @@ -11178,27 +11304,27 @@ void swap(DropPartitionsRequest &a, DropPartitionsRequest &b) { swap(a.__isset, b.__isset); } -DropPartitionsRequest::DropPartitionsRequest(const DropPartitionsRequest& other491) { - dbName = other491.dbName; - tblName = other491.tblName; - parts = other491.parts; - deleteData = other491.deleteData; - ifExists = other491.ifExists; - ignoreProtection = other491.ignoreProtection; - environmentContext = other491.environmentContext; - needResult = other491.needResult; - __isset = other491.__isset; -} -DropPartitionsRequest& DropPartitionsRequest::operator=(const DropPartitionsRequest& other492) { - dbName = other492.dbName; - tblName = other492.tblName; - parts = other492.parts; - deleteData = other492.deleteData; - ifExists = other492.ifExists; - ignoreProtection = other492.ignoreProtection; - environmentContext = other492.environmentContext; - needResult = other492.needResult; - __isset = other492.__isset; +DropPartitionsRequest::DropPartitionsRequest(const DropPartitionsRequest& other493) { + dbName = other493.dbName; + tblName = other493.tblName; + parts = other493.parts; + deleteData = other493.deleteData; + ifExists = other493.ifExists; + ignoreProtection = other493.ignoreProtection; + environmentContext = other493.environmentContext; + needResult = other493.needResult; + __isset = other493.__isset; +} +DropPartitionsRequest& DropPartitionsRequest::operator=(const DropPartitionsRequest& other494) { + dbName = other494.dbName; + tblName = other494.tblName; + parts = other494.parts; + deleteData = other494.deleteData; + ifExists = other494.ifExists; + ignoreProtection = other494.ignoreProtection; + environmentContext = other494.environmentContext; + needResult = other494.needResult; + __isset = other494.__isset; return *this; } void DropPartitionsRequest::printTo(std::ostream& out) const { @@ -11251,9 +11377,9 @@ uint32_t ResourceUri::read(::apache::thrift::protocol::TProtocol* iprot) { { case 1: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast493; - xfer += iprot->readI32(ecast493); - this->resourceType = (ResourceType::type)ecast493; + int32_t ecast495; + xfer += iprot->readI32(ecast495); + this->resourceType = (ResourceType::type)ecast495; this->__isset.resourceType = true; } else { xfer += iprot->skip(ftype); @@ -11304,15 +11430,15 @@ void swap(ResourceUri &a, ResourceUri &b) { swap(a.__isset, b.__isset); } -ResourceUri::ResourceUri(const ResourceUri& other494) { - resourceType = other494.resourceType; - uri = other494.uri; - __isset = other494.__isset; +ResourceUri::ResourceUri(const ResourceUri& other496) { + resourceType = other496.resourceType; + uri = other496.uri; + __isset = other496.__isset; } -ResourceUri& ResourceUri::operator=(const ResourceUri& other495) { - resourceType = other495.resourceType; - uri = other495.uri; - __isset = other495.__isset; +ResourceUri& ResourceUri::operator=(const ResourceUri& other497) { + resourceType = other497.resourceType; + uri = other497.uri; + __isset = other497.__isset; return *this; } void ResourceUri::printTo(std::ostream& out) const { @@ -11415,9 +11541,9 @@ uint32_t Function::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast496; - xfer += iprot->readI32(ecast496); - this->ownerType = (PrincipalType::type)ecast496; + int32_t ecast498; + xfer += iprot->readI32(ecast498); + this->ownerType = (PrincipalType::type)ecast498; this->__isset.ownerType = true; } else { xfer += iprot->skip(ftype); @@ -11433,9 +11559,9 @@ uint32_t Function::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 7: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast497; - xfer += iprot->readI32(ecast497); - this->functionType = (FunctionType::type)ecast497; + int32_t ecast499; + xfer += iprot->readI32(ecast499); + this->functionType = (FunctionType::type)ecast499; this->__isset.functionType = true; } else { xfer += iprot->skip(ftype); @@ -11445,14 +11571,14 @@ uint32_t Function::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->resourceUris.clear(); - uint32_t _size498; - ::apache::thrift::protocol::TType _etype501; - xfer += iprot->readListBegin(_etype501, _size498); - this->resourceUris.resize(_size498); - uint32_t _i502; - for (_i502 = 0; _i502 < _size498; ++_i502) + uint32_t _size500; + ::apache::thrift::protocol::TType _etype503; + xfer += iprot->readListBegin(_etype503, _size500); + this->resourceUris.resize(_size500); + uint32_t _i504; + for (_i504 = 0; _i504 < _size500; ++_i504) { - xfer += this->resourceUris[_i502].read(iprot); + xfer += this->resourceUris[_i504].read(iprot); } xfer += iprot->readListEnd(); } @@ -11509,10 +11635,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 _iter503; - for (_iter503 = this->resourceUris.begin(); _iter503 != this->resourceUris.end(); ++_iter503) + std::vector ::const_iterator _iter505; + for (_iter505 = this->resourceUris.begin(); _iter505 != this->resourceUris.end(); ++_iter505) { - xfer += (*_iter503).write(oprot); + xfer += (*_iter505).write(oprot); } xfer += oprot->writeListEnd(); } @@ -11536,27 +11662,27 @@ void swap(Function &a, Function &b) { swap(a.__isset, b.__isset); } -Function::Function(const Function& other504) { - functionName = other504.functionName; - dbName = other504.dbName; - className = other504.className; - ownerName = other504.ownerName; - ownerType = other504.ownerType; - createTime = other504.createTime; - functionType = other504.functionType; - resourceUris = other504.resourceUris; - __isset = other504.__isset; -} -Function& Function::operator=(const Function& other505) { - functionName = other505.functionName; - dbName = other505.dbName; - className = other505.className; - ownerName = other505.ownerName; - ownerType = other505.ownerType; - createTime = other505.createTime; - functionType = other505.functionType; - resourceUris = other505.resourceUris; - __isset = other505.__isset; +Function::Function(const Function& other506) { + functionName = other506.functionName; + dbName = other506.dbName; + className = other506.className; + ownerName = other506.ownerName; + ownerType = other506.ownerType; + createTime = other506.createTime; + functionType = other506.functionType; + resourceUris = other506.resourceUris; + __isset = other506.__isset; +} +Function& Function::operator=(const Function& other507) { + functionName = other507.functionName; + dbName = other507.dbName; + className = other507.className; + ownerName = other507.ownerName; + ownerType = other507.ownerType; + createTime = other507.createTime; + functionType = other507.functionType; + resourceUris = other507.resourceUris; + __isset = other507.__isset; return *this; } void Function::printTo(std::ostream& out) const { @@ -11654,9 +11780,9 @@ uint32_t TxnInfo::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast506; - xfer += iprot->readI32(ecast506); - this->state = (TxnState::type)ecast506; + int32_t ecast508; + xfer += iprot->readI32(ecast508); + this->state = (TxnState::type)ecast508; isset_state = true; } else { xfer += iprot->skip(ftype); @@ -11803,29 +11929,29 @@ void swap(TxnInfo &a, TxnInfo &b) { swap(a.__isset, b.__isset); } -TxnInfo::TxnInfo(const TxnInfo& other507) { - id = other507.id; - state = other507.state; - user = other507.user; - hostname = other507.hostname; - agentInfo = other507.agentInfo; - heartbeatCount = other507.heartbeatCount; - metaInfo = other507.metaInfo; - startedTime = other507.startedTime; - lastHeartbeatTime = other507.lastHeartbeatTime; - __isset = other507.__isset; -} -TxnInfo& TxnInfo::operator=(const TxnInfo& other508) { - id = other508.id; - state = other508.state; - user = other508.user; - hostname = other508.hostname; - agentInfo = other508.agentInfo; - heartbeatCount = other508.heartbeatCount; - metaInfo = other508.metaInfo; - startedTime = other508.startedTime; - lastHeartbeatTime = other508.lastHeartbeatTime; - __isset = other508.__isset; +TxnInfo::TxnInfo(const TxnInfo& other509) { + id = other509.id; + state = other509.state; + user = other509.user; + hostname = other509.hostname; + agentInfo = other509.agentInfo; + heartbeatCount = other509.heartbeatCount; + metaInfo = other509.metaInfo; + startedTime = other509.startedTime; + lastHeartbeatTime = other509.lastHeartbeatTime; + __isset = other509.__isset; +} +TxnInfo& TxnInfo::operator=(const TxnInfo& other510) { + id = other510.id; + state = other510.state; + user = other510.user; + hostname = other510.hostname; + agentInfo = other510.agentInfo; + heartbeatCount = other510.heartbeatCount; + metaInfo = other510.metaInfo; + startedTime = other510.startedTime; + lastHeartbeatTime = other510.lastHeartbeatTime; + __isset = other510.__isset; return *this; } void TxnInfo::printTo(std::ostream& out) const { @@ -11891,14 +12017,14 @@ uint32_t GetOpenTxnsInfoResponse::read(::apache::thrift::protocol::TProtocol* ip if (ftype == ::apache::thrift::protocol::T_LIST) { { this->open_txns.clear(); - uint32_t _size509; - ::apache::thrift::protocol::TType _etype512; - xfer += iprot->readListBegin(_etype512, _size509); - this->open_txns.resize(_size509); - uint32_t _i513; - for (_i513 = 0; _i513 < _size509; ++_i513) + uint32_t _size511; + ::apache::thrift::protocol::TType _etype514; + xfer += iprot->readListBegin(_etype514, _size511); + this->open_txns.resize(_size511); + uint32_t _i515; + for (_i515 = 0; _i515 < _size511; ++_i515) { - xfer += this->open_txns[_i513].read(iprot); + xfer += this->open_txns[_i515].read(iprot); } xfer += iprot->readListEnd(); } @@ -11935,10 +12061,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 _iter514; - for (_iter514 = this->open_txns.begin(); _iter514 != this->open_txns.end(); ++_iter514) + std::vector ::const_iterator _iter516; + for (_iter516 = this->open_txns.begin(); _iter516 != this->open_txns.end(); ++_iter516) { - xfer += (*_iter514).write(oprot); + xfer += (*_iter516).write(oprot); } xfer += oprot->writeListEnd(); } @@ -11955,13 +12081,13 @@ void swap(GetOpenTxnsInfoResponse &a, GetOpenTxnsInfoResponse &b) { swap(a.open_txns, b.open_txns); } -GetOpenTxnsInfoResponse::GetOpenTxnsInfoResponse(const GetOpenTxnsInfoResponse& other515) { - txn_high_water_mark = other515.txn_high_water_mark; - open_txns = other515.open_txns; +GetOpenTxnsInfoResponse::GetOpenTxnsInfoResponse(const GetOpenTxnsInfoResponse& other517) { + txn_high_water_mark = other517.txn_high_water_mark; + open_txns = other517.open_txns; } -GetOpenTxnsInfoResponse& GetOpenTxnsInfoResponse::operator=(const GetOpenTxnsInfoResponse& other516) { - txn_high_water_mark = other516.txn_high_water_mark; - open_txns = other516.open_txns; +GetOpenTxnsInfoResponse& GetOpenTxnsInfoResponse::operator=(const GetOpenTxnsInfoResponse& other518) { + txn_high_water_mark = other518.txn_high_water_mark; + open_txns = other518.open_txns; return *this; } void GetOpenTxnsInfoResponse::printTo(std::ostream& out) const { @@ -12025,15 +12151,15 @@ uint32_t GetOpenTxnsResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_SET) { { this->open_txns.clear(); - uint32_t _size517; - ::apache::thrift::protocol::TType _etype520; - xfer += iprot->readSetBegin(_etype520, _size517); - uint32_t _i521; - for (_i521 = 0; _i521 < _size517; ++_i521) + uint32_t _size519; + ::apache::thrift::protocol::TType _etype522; + xfer += iprot->readSetBegin(_etype522, _size519); + uint32_t _i523; + for (_i523 = 0; _i523 < _size519; ++_i523) { - int64_t _elem522; - xfer += iprot->readI64(_elem522); - this->open_txns.insert(_elem522); + int64_t _elem524; + xfer += iprot->readI64(_elem524); + this->open_txns.insert(_elem524); } xfer += iprot->readSetEnd(); } @@ -12078,10 +12204,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 _iter523; - for (_iter523 = this->open_txns.begin(); _iter523 != this->open_txns.end(); ++_iter523) + std::set ::const_iterator _iter525; + for (_iter525 = this->open_txns.begin(); _iter525 != this->open_txns.end(); ++_iter525) { - xfer += oprot->writeI64((*_iter523)); + xfer += oprot->writeI64((*_iter525)); } xfer += oprot->writeSetEnd(); } @@ -12105,17 +12231,17 @@ void swap(GetOpenTxnsResponse &a, GetOpenTxnsResponse &b) { swap(a.__isset, b.__isset); } -GetOpenTxnsResponse::GetOpenTxnsResponse(const GetOpenTxnsResponse& other524) { - txn_high_water_mark = other524.txn_high_water_mark; - open_txns = other524.open_txns; - min_open_txn = other524.min_open_txn; - __isset = other524.__isset; +GetOpenTxnsResponse::GetOpenTxnsResponse(const GetOpenTxnsResponse& other526) { + txn_high_water_mark = other526.txn_high_water_mark; + open_txns = other526.open_txns; + min_open_txn = other526.min_open_txn; + __isset = other526.__isset; } -GetOpenTxnsResponse& GetOpenTxnsResponse::operator=(const GetOpenTxnsResponse& other525) { - txn_high_water_mark = other525.txn_high_water_mark; - open_txns = other525.open_txns; - min_open_txn = other525.min_open_txn; - __isset = other525.__isset; +GetOpenTxnsResponse& GetOpenTxnsResponse::operator=(const GetOpenTxnsResponse& other527) { + txn_high_water_mark = other527.txn_high_water_mark; + open_txns = other527.open_txns; + min_open_txn = other527.min_open_txn; + __isset = other527.__isset; return *this; } void GetOpenTxnsResponse::printTo(std::ostream& out) const { @@ -12259,19 +12385,19 @@ void swap(OpenTxnRequest &a, OpenTxnRequest &b) { swap(a.__isset, b.__isset); } -OpenTxnRequest::OpenTxnRequest(const OpenTxnRequest& other526) { - num_txns = other526.num_txns; - user = other526.user; - hostname = other526.hostname; - agentInfo = other526.agentInfo; - __isset = other526.__isset; +OpenTxnRequest::OpenTxnRequest(const OpenTxnRequest& other528) { + num_txns = other528.num_txns; + user = other528.user; + hostname = other528.hostname; + agentInfo = other528.agentInfo; + __isset = other528.__isset; } -OpenTxnRequest& OpenTxnRequest::operator=(const OpenTxnRequest& other527) { - num_txns = other527.num_txns; - user = other527.user; - hostname = other527.hostname; - agentInfo = other527.agentInfo; - __isset = other527.__isset; +OpenTxnRequest& OpenTxnRequest::operator=(const OpenTxnRequest& other529) { + num_txns = other529.num_txns; + user = other529.user; + hostname = other529.hostname; + agentInfo = other529.agentInfo; + __isset = other529.__isset; return *this; } void OpenTxnRequest::printTo(std::ostream& out) const { @@ -12319,14 +12445,14 @@ uint32_t OpenTxnsResponse::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->txn_ids.clear(); - uint32_t _size528; - ::apache::thrift::protocol::TType _etype531; - xfer += iprot->readListBegin(_etype531, _size528); - this->txn_ids.resize(_size528); - uint32_t _i532; - for (_i532 = 0; _i532 < _size528; ++_i532) + uint32_t _size530; + ::apache::thrift::protocol::TType _etype533; + xfer += iprot->readListBegin(_etype533, _size530); + this->txn_ids.resize(_size530); + uint32_t _i534; + for (_i534 = 0; _i534 < _size530; ++_i534) { - xfer += iprot->readI64(this->txn_ids[_i532]); + xfer += iprot->readI64(this->txn_ids[_i534]); } xfer += iprot->readListEnd(); } @@ -12357,10 +12483,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 _iter533; - for (_iter533 = this->txn_ids.begin(); _iter533 != this->txn_ids.end(); ++_iter533) + std::vector ::const_iterator _iter535; + for (_iter535 = this->txn_ids.begin(); _iter535 != this->txn_ids.end(); ++_iter535) { - xfer += oprot->writeI64((*_iter533)); + xfer += oprot->writeI64((*_iter535)); } xfer += oprot->writeListEnd(); } @@ -12376,11 +12502,11 @@ void swap(OpenTxnsResponse &a, OpenTxnsResponse &b) { swap(a.txn_ids, b.txn_ids); } -OpenTxnsResponse::OpenTxnsResponse(const OpenTxnsResponse& other534) { - txn_ids = other534.txn_ids; +OpenTxnsResponse::OpenTxnsResponse(const OpenTxnsResponse& other536) { + txn_ids = other536.txn_ids; } -OpenTxnsResponse& OpenTxnsResponse::operator=(const OpenTxnsResponse& other535) { - txn_ids = other535.txn_ids; +OpenTxnsResponse& OpenTxnsResponse::operator=(const OpenTxnsResponse& other537) { + txn_ids = other537.txn_ids; return *this; } void OpenTxnsResponse::printTo(std::ostream& out) const { @@ -12462,11 +12588,11 @@ void swap(AbortTxnRequest &a, AbortTxnRequest &b) { swap(a.txnid, b.txnid); } -AbortTxnRequest::AbortTxnRequest(const AbortTxnRequest& other536) { - txnid = other536.txnid; +AbortTxnRequest::AbortTxnRequest(const AbortTxnRequest& other538) { + txnid = other538.txnid; } -AbortTxnRequest& AbortTxnRequest::operator=(const AbortTxnRequest& other537) { - txnid = other537.txnid; +AbortTxnRequest& AbortTxnRequest::operator=(const AbortTxnRequest& other539) { + txnid = other539.txnid; return *this; } void AbortTxnRequest::printTo(std::ostream& out) const { @@ -12511,14 +12637,14 @@ uint32_t AbortTxnsRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->txn_ids.clear(); - uint32_t _size538; - ::apache::thrift::protocol::TType _etype541; - xfer += iprot->readListBegin(_etype541, _size538); - this->txn_ids.resize(_size538); - uint32_t _i542; - for (_i542 = 0; _i542 < _size538; ++_i542) + uint32_t _size540; + ::apache::thrift::protocol::TType _etype543; + xfer += iprot->readListBegin(_etype543, _size540); + this->txn_ids.resize(_size540); + uint32_t _i544; + for (_i544 = 0; _i544 < _size540; ++_i544) { - xfer += iprot->readI64(this->txn_ids[_i542]); + xfer += iprot->readI64(this->txn_ids[_i544]); } xfer += iprot->readListEnd(); } @@ -12549,10 +12675,10 @@ uint32_t AbortTxnsRequest::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 _iter543; - for (_iter543 = this->txn_ids.begin(); _iter543 != this->txn_ids.end(); ++_iter543) + std::vector ::const_iterator _iter545; + for (_iter545 = this->txn_ids.begin(); _iter545 != this->txn_ids.end(); ++_iter545) { - xfer += oprot->writeI64((*_iter543)); + xfer += oprot->writeI64((*_iter545)); } xfer += oprot->writeListEnd(); } @@ -12568,11 +12694,11 @@ void swap(AbortTxnsRequest &a, AbortTxnsRequest &b) { swap(a.txn_ids, b.txn_ids); } -AbortTxnsRequest::AbortTxnsRequest(const AbortTxnsRequest& other544) { - txn_ids = other544.txn_ids; +AbortTxnsRequest::AbortTxnsRequest(const AbortTxnsRequest& other546) { + txn_ids = other546.txn_ids; } -AbortTxnsRequest& AbortTxnsRequest::operator=(const AbortTxnsRequest& other545) { - txn_ids = other545.txn_ids; +AbortTxnsRequest& AbortTxnsRequest::operator=(const AbortTxnsRequest& other547) { + txn_ids = other547.txn_ids; return *this; } void AbortTxnsRequest::printTo(std::ostream& out) const { @@ -12654,11 +12780,11 @@ void swap(CommitTxnRequest &a, CommitTxnRequest &b) { swap(a.txnid, b.txnid); } -CommitTxnRequest::CommitTxnRequest(const CommitTxnRequest& other546) { - txnid = other546.txnid; +CommitTxnRequest::CommitTxnRequest(const CommitTxnRequest& other548) { + txnid = other548.txnid; } -CommitTxnRequest& CommitTxnRequest::operator=(const CommitTxnRequest& other547) { - txnid = other547.txnid; +CommitTxnRequest& CommitTxnRequest::operator=(const CommitTxnRequest& other549) { + txnid = other549.txnid; return *this; } void CommitTxnRequest::printTo(std::ostream& out) const { @@ -12736,9 +12862,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) { { case 1: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast548; - xfer += iprot->readI32(ecast548); - this->type = (LockType::type)ecast548; + int32_t ecast550; + xfer += iprot->readI32(ecast550); + this->type = (LockType::type)ecast550; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -12746,9 +12872,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast549; - xfer += iprot->readI32(ecast549); - this->level = (LockLevel::type)ecast549; + int32_t ecast551; + xfer += iprot->readI32(ecast551); + this->level = (LockLevel::type)ecast551; isset_level = true; } else { xfer += iprot->skip(ftype); @@ -12780,9 +12906,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 6: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast550; - xfer += iprot->readI32(ecast550); - this->operationType = (DataOperationType::type)ecast550; + int32_t ecast552; + xfer += iprot->readI32(ecast552); + this->operationType = (DataOperationType::type)ecast552; this->__isset.operationType = true; } else { xfer += iprot->skip(ftype); @@ -12882,27 +13008,27 @@ void swap(LockComponent &a, LockComponent &b) { swap(a.__isset, b.__isset); } -LockComponent::LockComponent(const LockComponent& other551) { - type = other551.type; - level = other551.level; - dbname = other551.dbname; - tablename = other551.tablename; - partitionname = other551.partitionname; - operationType = other551.operationType; - isAcid = other551.isAcid; - isDynamicPartitionWrite = other551.isDynamicPartitionWrite; - __isset = other551.__isset; -} -LockComponent& LockComponent::operator=(const LockComponent& other552) { - type = other552.type; - level = other552.level; - dbname = other552.dbname; - tablename = other552.tablename; - partitionname = other552.partitionname; - operationType = other552.operationType; - isAcid = other552.isAcid; - isDynamicPartitionWrite = other552.isDynamicPartitionWrite; - __isset = other552.__isset; +LockComponent::LockComponent(const LockComponent& other553) { + type = other553.type; + level = other553.level; + dbname = other553.dbname; + tablename = other553.tablename; + partitionname = other553.partitionname; + operationType = other553.operationType; + isAcid = other553.isAcid; + isDynamicPartitionWrite = other553.isDynamicPartitionWrite; + __isset = other553.__isset; +} +LockComponent& LockComponent::operator=(const LockComponent& other554) { + type = other554.type; + level = other554.level; + dbname = other554.dbname; + tablename = other554.tablename; + partitionname = other554.partitionname; + operationType = other554.operationType; + isAcid = other554.isAcid; + isDynamicPartitionWrite = other554.isDynamicPartitionWrite; + __isset = other554.__isset; return *this; } void LockComponent::printTo(std::ostream& out) const { @@ -12974,14 +13100,14 @@ uint32_t LockRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->component.clear(); - uint32_t _size553; - ::apache::thrift::protocol::TType _etype556; - xfer += iprot->readListBegin(_etype556, _size553); - this->component.resize(_size553); - uint32_t _i557; - for (_i557 = 0; _i557 < _size553; ++_i557) + uint32_t _size555; + ::apache::thrift::protocol::TType _etype558; + xfer += iprot->readListBegin(_etype558, _size555); + this->component.resize(_size555); + uint32_t _i559; + for (_i559 = 0; _i559 < _size555; ++_i559) { - xfer += this->component[_i557].read(iprot); + xfer += this->component[_i559].read(iprot); } xfer += iprot->readListEnd(); } @@ -13048,10 +13174,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 _iter558; - for (_iter558 = this->component.begin(); _iter558 != this->component.end(); ++_iter558) + std::vector ::const_iterator _iter560; + for (_iter560 = this->component.begin(); _iter560 != this->component.end(); ++_iter560) { - xfer += (*_iter558).write(oprot); + xfer += (*_iter560).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13090,21 +13216,21 @@ void swap(LockRequest &a, LockRequest &b) { swap(a.__isset, b.__isset); } -LockRequest::LockRequest(const LockRequest& other559) { - component = other559.component; - txnid = other559.txnid; - user = other559.user; - hostname = other559.hostname; - agentInfo = other559.agentInfo; - __isset = other559.__isset; -} -LockRequest& LockRequest::operator=(const LockRequest& other560) { - component = other560.component; - txnid = other560.txnid; - user = other560.user; - hostname = other560.hostname; - agentInfo = other560.agentInfo; - __isset = other560.__isset; +LockRequest::LockRequest(const LockRequest& other561) { + component = other561.component; + txnid = other561.txnid; + user = other561.user; + hostname = other561.hostname; + agentInfo = other561.agentInfo; + __isset = other561.__isset; +} +LockRequest& LockRequest::operator=(const LockRequest& other562) { + component = other562.component; + txnid = other562.txnid; + user = other562.user; + hostname = other562.hostname; + agentInfo = other562.agentInfo; + __isset = other562.__isset; return *this; } void LockRequest::printTo(std::ostream& out) const { @@ -13164,9 +13290,9 @@ uint32_t LockResponse::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast561; - xfer += iprot->readI32(ecast561); - this->state = (LockState::type)ecast561; + int32_t ecast563; + xfer += iprot->readI32(ecast563); + this->state = (LockState::type)ecast563; isset_state = true; } else { xfer += iprot->skip(ftype); @@ -13212,13 +13338,13 @@ void swap(LockResponse &a, LockResponse &b) { swap(a.state, b.state); } -LockResponse::LockResponse(const LockResponse& other562) { - lockid = other562.lockid; - state = other562.state; +LockResponse::LockResponse(const LockResponse& other564) { + lockid = other564.lockid; + state = other564.state; } -LockResponse& LockResponse::operator=(const LockResponse& other563) { - lockid = other563.lockid; - state = other563.state; +LockResponse& LockResponse::operator=(const LockResponse& other565) { + lockid = other565.lockid; + state = other565.state; return *this; } void LockResponse::printTo(std::ostream& out) const { @@ -13340,17 +13466,17 @@ void swap(CheckLockRequest &a, CheckLockRequest &b) { swap(a.__isset, b.__isset); } -CheckLockRequest::CheckLockRequest(const CheckLockRequest& other564) { - lockid = other564.lockid; - txnid = other564.txnid; - elapsed_ms = other564.elapsed_ms; - __isset = other564.__isset; +CheckLockRequest::CheckLockRequest(const CheckLockRequest& other566) { + lockid = other566.lockid; + txnid = other566.txnid; + elapsed_ms = other566.elapsed_ms; + __isset = other566.__isset; } -CheckLockRequest& CheckLockRequest::operator=(const CheckLockRequest& other565) { - lockid = other565.lockid; - txnid = other565.txnid; - elapsed_ms = other565.elapsed_ms; - __isset = other565.__isset; +CheckLockRequest& CheckLockRequest::operator=(const CheckLockRequest& other567) { + lockid = other567.lockid; + txnid = other567.txnid; + elapsed_ms = other567.elapsed_ms; + __isset = other567.__isset; return *this; } void CheckLockRequest::printTo(std::ostream& out) const { @@ -13434,11 +13560,11 @@ void swap(UnlockRequest &a, UnlockRequest &b) { swap(a.lockid, b.lockid); } -UnlockRequest::UnlockRequest(const UnlockRequest& other566) { - lockid = other566.lockid; +UnlockRequest::UnlockRequest(const UnlockRequest& other568) { + lockid = other568.lockid; } -UnlockRequest& UnlockRequest::operator=(const UnlockRequest& other567) { - lockid = other567.lockid; +UnlockRequest& UnlockRequest::operator=(const UnlockRequest& other569) { + lockid = other569.lockid; return *this; } void UnlockRequest::printTo(std::ostream& out) const { @@ -13577,19 +13703,19 @@ void swap(ShowLocksRequest &a, ShowLocksRequest &b) { swap(a.__isset, b.__isset); } -ShowLocksRequest::ShowLocksRequest(const ShowLocksRequest& other568) { - dbname = other568.dbname; - tablename = other568.tablename; - partname = other568.partname; - isExtended = other568.isExtended; - __isset = other568.__isset; +ShowLocksRequest::ShowLocksRequest(const ShowLocksRequest& other570) { + dbname = other570.dbname; + tablename = other570.tablename; + partname = other570.partname; + isExtended = other570.isExtended; + __isset = other570.__isset; } -ShowLocksRequest& ShowLocksRequest::operator=(const ShowLocksRequest& other569) { - dbname = other569.dbname; - tablename = other569.tablename; - partname = other569.partname; - isExtended = other569.isExtended; - __isset = other569.__isset; +ShowLocksRequest& ShowLocksRequest::operator=(const ShowLocksRequest& other571) { + dbname = other571.dbname; + tablename = other571.tablename; + partname = other571.partname; + isExtended = other571.isExtended; + __isset = other571.__isset; return *this; } void ShowLocksRequest::printTo(std::ostream& out) const { @@ -13742,9 +13868,9 @@ uint32_t ShowLocksResponseElement::read(::apache::thrift::protocol::TProtocol* i break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast570; - xfer += iprot->readI32(ecast570); - this->state = (LockState::type)ecast570; + int32_t ecast572; + xfer += iprot->readI32(ecast572); + this->state = (LockState::type)ecast572; isset_state = true; } else { xfer += iprot->skip(ftype); @@ -13752,9 +13878,9 @@ uint32_t ShowLocksResponseElement::read(::apache::thrift::protocol::TProtocol* i break; case 6: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast571; - xfer += iprot->readI32(ecast571); - this->type = (LockType::type)ecast571; + int32_t ecast573; + xfer += iprot->readI32(ecast573); + this->type = (LockType::type)ecast573; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -13970,43 +14096,43 @@ void swap(ShowLocksResponseElement &a, ShowLocksResponseElement &b) { swap(a.__isset, b.__isset); } -ShowLocksResponseElement::ShowLocksResponseElement(const ShowLocksResponseElement& other572) { - lockid = other572.lockid; - dbname = other572.dbname; - tablename = other572.tablename; - partname = other572.partname; - state = other572.state; - type = other572.type; - txnid = other572.txnid; - lastheartbeat = other572.lastheartbeat; - acquiredat = other572.acquiredat; - user = other572.user; - hostname = other572.hostname; - heartbeatCount = other572.heartbeatCount; - agentInfo = other572.agentInfo; - blockedByExtId = other572.blockedByExtId; - blockedByIntId = other572.blockedByIntId; - lockIdInternal = other572.lockIdInternal; - __isset = other572.__isset; -} -ShowLocksResponseElement& ShowLocksResponseElement::operator=(const ShowLocksResponseElement& other573) { - lockid = other573.lockid; - dbname = other573.dbname; - tablename = other573.tablename; - partname = other573.partname; - state = other573.state; - type = other573.type; - txnid = other573.txnid; - lastheartbeat = other573.lastheartbeat; - acquiredat = other573.acquiredat; - user = other573.user; - hostname = other573.hostname; - heartbeatCount = other573.heartbeatCount; - agentInfo = other573.agentInfo; - blockedByExtId = other573.blockedByExtId; - blockedByIntId = other573.blockedByIntId; - lockIdInternal = other573.lockIdInternal; - __isset = other573.__isset; +ShowLocksResponseElement::ShowLocksResponseElement(const ShowLocksResponseElement& other574) { + lockid = other574.lockid; + dbname = other574.dbname; + tablename = other574.tablename; + partname = other574.partname; + state = other574.state; + type = other574.type; + txnid = other574.txnid; + lastheartbeat = other574.lastheartbeat; + acquiredat = other574.acquiredat; + user = other574.user; + hostname = other574.hostname; + heartbeatCount = other574.heartbeatCount; + agentInfo = other574.agentInfo; + blockedByExtId = other574.blockedByExtId; + blockedByIntId = other574.blockedByIntId; + lockIdInternal = other574.lockIdInternal; + __isset = other574.__isset; +} +ShowLocksResponseElement& ShowLocksResponseElement::operator=(const ShowLocksResponseElement& other575) { + lockid = other575.lockid; + dbname = other575.dbname; + tablename = other575.tablename; + partname = other575.partname; + state = other575.state; + type = other575.type; + txnid = other575.txnid; + lastheartbeat = other575.lastheartbeat; + acquiredat = other575.acquiredat; + user = other575.user; + hostname = other575.hostname; + heartbeatCount = other575.heartbeatCount; + agentInfo = other575.agentInfo; + blockedByExtId = other575.blockedByExtId; + blockedByIntId = other575.blockedByIntId; + lockIdInternal = other575.lockIdInternal; + __isset = other575.__isset; return *this; } void ShowLocksResponseElement::printTo(std::ostream& out) const { @@ -14065,14 +14191,14 @@ uint32_t ShowLocksResponse::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->locks.clear(); - uint32_t _size574; - ::apache::thrift::protocol::TType _etype577; - xfer += iprot->readListBegin(_etype577, _size574); - this->locks.resize(_size574); - uint32_t _i578; - for (_i578 = 0; _i578 < _size574; ++_i578) + uint32_t _size576; + ::apache::thrift::protocol::TType _etype579; + xfer += iprot->readListBegin(_etype579, _size576); + this->locks.resize(_size576); + uint32_t _i580; + for (_i580 = 0; _i580 < _size576; ++_i580) { - xfer += this->locks[_i578].read(iprot); + xfer += this->locks[_i580].read(iprot); } xfer += iprot->readListEnd(); } @@ -14101,10 +14227,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 _iter579; - for (_iter579 = this->locks.begin(); _iter579 != this->locks.end(); ++_iter579) + std::vector ::const_iterator _iter581; + for (_iter581 = this->locks.begin(); _iter581 != this->locks.end(); ++_iter581) { - xfer += (*_iter579).write(oprot); + xfer += (*_iter581).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14121,13 +14247,13 @@ void swap(ShowLocksResponse &a, ShowLocksResponse &b) { swap(a.__isset, b.__isset); } -ShowLocksResponse::ShowLocksResponse(const ShowLocksResponse& other580) { - locks = other580.locks; - __isset = other580.__isset; +ShowLocksResponse::ShowLocksResponse(const ShowLocksResponse& other582) { + locks = other582.locks; + __isset = other582.__isset; } -ShowLocksResponse& ShowLocksResponse::operator=(const ShowLocksResponse& other581) { - locks = other581.locks; - __isset = other581.__isset; +ShowLocksResponse& ShowLocksResponse::operator=(const ShowLocksResponse& other583) { + locks = other583.locks; + __isset = other583.__isset; return *this; } void ShowLocksResponse::printTo(std::ostream& out) const { @@ -14228,15 +14354,15 @@ void swap(HeartbeatRequest &a, HeartbeatRequest &b) { swap(a.__isset, b.__isset); } -HeartbeatRequest::HeartbeatRequest(const HeartbeatRequest& other582) { - lockid = other582.lockid; - txnid = other582.txnid; - __isset = other582.__isset; +HeartbeatRequest::HeartbeatRequest(const HeartbeatRequest& other584) { + lockid = other584.lockid; + txnid = other584.txnid; + __isset = other584.__isset; } -HeartbeatRequest& HeartbeatRequest::operator=(const HeartbeatRequest& other583) { - lockid = other583.lockid; - txnid = other583.txnid; - __isset = other583.__isset; +HeartbeatRequest& HeartbeatRequest::operator=(const HeartbeatRequest& other585) { + lockid = other585.lockid; + txnid = other585.txnid; + __isset = other585.__isset; return *this; } void HeartbeatRequest::printTo(std::ostream& out) const { @@ -14339,13 +14465,13 @@ void swap(HeartbeatTxnRangeRequest &a, HeartbeatTxnRangeRequest &b) { swap(a.max, b.max); } -HeartbeatTxnRangeRequest::HeartbeatTxnRangeRequest(const HeartbeatTxnRangeRequest& other584) { - min = other584.min; - max = other584.max; +HeartbeatTxnRangeRequest::HeartbeatTxnRangeRequest(const HeartbeatTxnRangeRequest& other586) { + min = other586.min; + max = other586.max; } -HeartbeatTxnRangeRequest& HeartbeatTxnRangeRequest::operator=(const HeartbeatTxnRangeRequest& other585) { - min = other585.min; - max = other585.max; +HeartbeatTxnRangeRequest& HeartbeatTxnRangeRequest::operator=(const HeartbeatTxnRangeRequest& other587) { + min = other587.min; + max = other587.max; return *this; } void HeartbeatTxnRangeRequest::printTo(std::ostream& out) const { @@ -14396,15 +14522,15 @@ uint32_t HeartbeatTxnRangeResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_SET) { { this->aborted.clear(); - uint32_t _size586; - ::apache::thrift::protocol::TType _etype589; - xfer += iprot->readSetBegin(_etype589, _size586); - uint32_t _i590; - for (_i590 = 0; _i590 < _size586; ++_i590) + uint32_t _size588; + ::apache::thrift::protocol::TType _etype591; + xfer += iprot->readSetBegin(_etype591, _size588); + uint32_t _i592; + for (_i592 = 0; _i592 < _size588; ++_i592) { - int64_t _elem591; - xfer += iprot->readI64(_elem591); - this->aborted.insert(_elem591); + int64_t _elem593; + xfer += iprot->readI64(_elem593); + this->aborted.insert(_elem593); } xfer += iprot->readSetEnd(); } @@ -14417,15 +14543,15 @@ uint32_t HeartbeatTxnRangeResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_SET) { { this->nosuch.clear(); - uint32_t _size592; - ::apache::thrift::protocol::TType _etype595; - xfer += iprot->readSetBegin(_etype595, _size592); - uint32_t _i596; - for (_i596 = 0; _i596 < _size592; ++_i596) + uint32_t _size594; + ::apache::thrift::protocol::TType _etype597; + xfer += iprot->readSetBegin(_etype597, _size594); + uint32_t _i598; + for (_i598 = 0; _i598 < _size594; ++_i598) { - int64_t _elem597; - xfer += iprot->readI64(_elem597); - this->nosuch.insert(_elem597); + int64_t _elem599; + xfer += iprot->readI64(_elem599); + this->nosuch.insert(_elem599); } xfer += iprot->readSetEnd(); } @@ -14458,10 +14584,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 _iter598; - for (_iter598 = this->aborted.begin(); _iter598 != this->aborted.end(); ++_iter598) + std::set ::const_iterator _iter600; + for (_iter600 = this->aborted.begin(); _iter600 != this->aborted.end(); ++_iter600) { - xfer += oprot->writeI64((*_iter598)); + xfer += oprot->writeI64((*_iter600)); } xfer += oprot->writeSetEnd(); } @@ -14470,10 +14596,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 _iter599; - for (_iter599 = this->nosuch.begin(); _iter599 != this->nosuch.end(); ++_iter599) + std::set ::const_iterator _iter601; + for (_iter601 = this->nosuch.begin(); _iter601 != this->nosuch.end(); ++_iter601) { - xfer += oprot->writeI64((*_iter599)); + xfer += oprot->writeI64((*_iter601)); } xfer += oprot->writeSetEnd(); } @@ -14490,13 +14616,13 @@ void swap(HeartbeatTxnRangeResponse &a, HeartbeatTxnRangeResponse &b) { swap(a.nosuch, b.nosuch); } -HeartbeatTxnRangeResponse::HeartbeatTxnRangeResponse(const HeartbeatTxnRangeResponse& other600) { - aborted = other600.aborted; - nosuch = other600.nosuch; +HeartbeatTxnRangeResponse::HeartbeatTxnRangeResponse(const HeartbeatTxnRangeResponse& other602) { + aborted = other602.aborted; + nosuch = other602.nosuch; } -HeartbeatTxnRangeResponse& HeartbeatTxnRangeResponse::operator=(const HeartbeatTxnRangeResponse& other601) { - aborted = other601.aborted; - nosuch = other601.nosuch; +HeartbeatTxnRangeResponse& HeartbeatTxnRangeResponse::operator=(const HeartbeatTxnRangeResponse& other603) { + aborted = other603.aborted; + nosuch = other603.nosuch; return *this; } void HeartbeatTxnRangeResponse::printTo(std::ostream& out) const { @@ -14589,9 +14715,9 @@ uint32_t CompactionRequest::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast602; - xfer += iprot->readI32(ecast602); - this->type = (CompactionType::type)ecast602; + int32_t ecast604; + xfer += iprot->readI32(ecast604); + this->type = (CompactionType::type)ecast604; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -14609,17 +14735,17 @@ uint32_t CompactionRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->properties.clear(); - uint32_t _size603; - ::apache::thrift::protocol::TType _ktype604; - ::apache::thrift::protocol::TType _vtype605; - xfer += iprot->readMapBegin(_ktype604, _vtype605, _size603); - uint32_t _i607; - for (_i607 = 0; _i607 < _size603; ++_i607) + uint32_t _size605; + ::apache::thrift::protocol::TType _ktype606; + ::apache::thrift::protocol::TType _vtype607; + xfer += iprot->readMapBegin(_ktype606, _vtype607, _size605); + uint32_t _i609; + for (_i609 = 0; _i609 < _size605; ++_i609) { - std::string _key608; - xfer += iprot->readString(_key608); - std::string& _val609 = this->properties[_key608]; - xfer += iprot->readString(_val609); + std::string _key610; + xfer += iprot->readString(_key610); + std::string& _val611 = this->properties[_key610]; + xfer += iprot->readString(_val611); } xfer += iprot->readMapEnd(); } @@ -14677,11 +14803,11 @@ uint32_t CompactionRequest::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("properties", ::apache::thrift::protocol::T_MAP, 6); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->properties.size())); - std::map ::const_iterator _iter610; - for (_iter610 = this->properties.begin(); _iter610 != this->properties.end(); ++_iter610) + std::map ::const_iterator _iter612; + for (_iter612 = this->properties.begin(); _iter612 != this->properties.end(); ++_iter612) { - xfer += oprot->writeString(_iter610->first); - xfer += oprot->writeString(_iter610->second); + xfer += oprot->writeString(_iter612->first); + xfer += oprot->writeString(_iter612->second); } xfer += oprot->writeMapEnd(); } @@ -14703,23 +14829,23 @@ void swap(CompactionRequest &a, CompactionRequest &b) { swap(a.__isset, b.__isset); } -CompactionRequest::CompactionRequest(const CompactionRequest& other611) { - dbname = other611.dbname; - tablename = other611.tablename; - partitionname = other611.partitionname; - type = other611.type; - runas = other611.runas; - properties = other611.properties; - __isset = other611.__isset; -} -CompactionRequest& CompactionRequest::operator=(const CompactionRequest& other612) { - dbname = other612.dbname; - tablename = other612.tablename; - partitionname = other612.partitionname; - type = other612.type; - runas = other612.runas; - properties = other612.properties; - __isset = other612.__isset; +CompactionRequest::CompactionRequest(const CompactionRequest& other613) { + dbname = other613.dbname; + tablename = other613.tablename; + partitionname = other613.partitionname; + type = other613.type; + runas = other613.runas; + properties = other613.properties; + __isset = other613.__isset; +} +CompactionRequest& CompactionRequest::operator=(const CompactionRequest& other614) { + dbname = other614.dbname; + tablename = other614.tablename; + partitionname = other614.partitionname; + type = other614.type; + runas = other614.runas; + properties = other614.properties; + __isset = other614.__isset; return *this; } void CompactionRequest::printTo(std::ostream& out) const { @@ -14846,15 +14972,15 @@ void swap(CompactionResponse &a, CompactionResponse &b) { swap(a.accepted, b.accepted); } -CompactionResponse::CompactionResponse(const CompactionResponse& other613) { - id = other613.id; - state = other613.state; - accepted = other613.accepted; +CompactionResponse::CompactionResponse(const CompactionResponse& other615) { + id = other615.id; + state = other615.state; + accepted = other615.accepted; } -CompactionResponse& CompactionResponse::operator=(const CompactionResponse& other614) { - id = other614.id; - state = other614.state; - accepted = other614.accepted; +CompactionResponse& CompactionResponse::operator=(const CompactionResponse& other616) { + id = other616.id; + state = other616.state; + accepted = other616.accepted; return *this; } void CompactionResponse::printTo(std::ostream& out) const { @@ -14915,11 +15041,11 @@ void swap(ShowCompactRequest &a, ShowCompactRequest &b) { (void) b; } -ShowCompactRequest::ShowCompactRequest(const ShowCompactRequest& other615) { - (void) other615; +ShowCompactRequest::ShowCompactRequest(const ShowCompactRequest& other617) { + (void) other617; } -ShowCompactRequest& ShowCompactRequest::operator=(const ShowCompactRequest& other616) { - (void) other616; +ShowCompactRequest& ShowCompactRequest::operator=(const ShowCompactRequest& other618) { + (void) other618; return *this; } void ShowCompactRequest::printTo(std::ostream& out) const { @@ -15045,9 +15171,9 @@ uint32_t ShowCompactResponseElement::read(::apache::thrift::protocol::TProtocol* break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast617; - xfer += iprot->readI32(ecast617); - this->type = (CompactionType::type)ecast617; + int32_t ecast619; + xfer += iprot->readI32(ecast619); + this->type = (CompactionType::type)ecast619; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -15234,37 +15360,37 @@ void swap(ShowCompactResponseElement &a, ShowCompactResponseElement &b) { swap(a.__isset, b.__isset); } -ShowCompactResponseElement::ShowCompactResponseElement(const ShowCompactResponseElement& other618) { - dbname = other618.dbname; - tablename = other618.tablename; - partitionname = other618.partitionname; - type = other618.type; - state = other618.state; - workerid = other618.workerid; - start = other618.start; - runAs = other618.runAs; - hightestTxnId = other618.hightestTxnId; - metaInfo = other618.metaInfo; - endTime = other618.endTime; - hadoopJobId = other618.hadoopJobId; - id = other618.id; - __isset = other618.__isset; -} -ShowCompactResponseElement& ShowCompactResponseElement::operator=(const ShowCompactResponseElement& other619) { - dbname = other619.dbname; - tablename = other619.tablename; - partitionname = other619.partitionname; - type = other619.type; - state = other619.state; - workerid = other619.workerid; - start = other619.start; - runAs = other619.runAs; - hightestTxnId = other619.hightestTxnId; - metaInfo = other619.metaInfo; - endTime = other619.endTime; - hadoopJobId = other619.hadoopJobId; - id = other619.id; - __isset = other619.__isset; +ShowCompactResponseElement::ShowCompactResponseElement(const ShowCompactResponseElement& other620) { + dbname = other620.dbname; + tablename = other620.tablename; + partitionname = other620.partitionname; + type = other620.type; + state = other620.state; + workerid = other620.workerid; + start = other620.start; + runAs = other620.runAs; + hightestTxnId = other620.hightestTxnId; + metaInfo = other620.metaInfo; + endTime = other620.endTime; + hadoopJobId = other620.hadoopJobId; + id = other620.id; + __isset = other620.__isset; +} +ShowCompactResponseElement& ShowCompactResponseElement::operator=(const ShowCompactResponseElement& other621) { + dbname = other621.dbname; + tablename = other621.tablename; + partitionname = other621.partitionname; + type = other621.type; + state = other621.state; + workerid = other621.workerid; + start = other621.start; + runAs = other621.runAs; + hightestTxnId = other621.hightestTxnId; + metaInfo = other621.metaInfo; + endTime = other621.endTime; + hadoopJobId = other621.hadoopJobId; + id = other621.id; + __isset = other621.__isset; return *this; } void ShowCompactResponseElement::printTo(std::ostream& out) const { @@ -15321,14 +15447,14 @@ uint32_t ShowCompactResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->compacts.clear(); - uint32_t _size620; - ::apache::thrift::protocol::TType _etype623; - xfer += iprot->readListBegin(_etype623, _size620); - this->compacts.resize(_size620); - uint32_t _i624; - for (_i624 = 0; _i624 < _size620; ++_i624) + uint32_t _size622; + ::apache::thrift::protocol::TType _etype625; + xfer += iprot->readListBegin(_etype625, _size622); + this->compacts.resize(_size622); + uint32_t _i626; + for (_i626 = 0; _i626 < _size622; ++_i626) { - xfer += this->compacts[_i624].read(iprot); + xfer += this->compacts[_i626].read(iprot); } xfer += iprot->readListEnd(); } @@ -15359,10 +15485,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 _iter625; - for (_iter625 = this->compacts.begin(); _iter625 != this->compacts.end(); ++_iter625) + std::vector ::const_iterator _iter627; + for (_iter627 = this->compacts.begin(); _iter627 != this->compacts.end(); ++_iter627) { - xfer += (*_iter625).write(oprot); + xfer += (*_iter627).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15378,11 +15504,11 @@ void swap(ShowCompactResponse &a, ShowCompactResponse &b) { swap(a.compacts, b.compacts); } -ShowCompactResponse::ShowCompactResponse(const ShowCompactResponse& other626) { - compacts = other626.compacts; +ShowCompactResponse::ShowCompactResponse(const ShowCompactResponse& other628) { + compacts = other628.compacts; } -ShowCompactResponse& ShowCompactResponse::operator=(const ShowCompactResponse& other627) { - compacts = other627.compacts; +ShowCompactResponse& ShowCompactResponse::operator=(const ShowCompactResponse& other629) { + compacts = other629.compacts; return *this; } void ShowCompactResponse::printTo(std::ostream& out) const { @@ -15471,14 +15597,14 @@ uint32_t AddDynamicPartitions::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionnames.clear(); - uint32_t _size628; - ::apache::thrift::protocol::TType _etype631; - xfer += iprot->readListBegin(_etype631, _size628); - this->partitionnames.resize(_size628); - uint32_t _i632; - for (_i632 = 0; _i632 < _size628; ++_i632) + uint32_t _size630; + ::apache::thrift::protocol::TType _etype633; + xfer += iprot->readListBegin(_etype633, _size630); + this->partitionnames.resize(_size630); + uint32_t _i634; + for (_i634 = 0; _i634 < _size630; ++_i634) { - xfer += iprot->readString(this->partitionnames[_i632]); + xfer += iprot->readString(this->partitionnames[_i634]); } xfer += iprot->readListEnd(); } @@ -15489,9 +15615,9 @@ uint32_t AddDynamicPartitions::read(::apache::thrift::protocol::TProtocol* iprot break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast633; - xfer += iprot->readI32(ecast633); - this->operationType = (DataOperationType::type)ecast633; + int32_t ecast635; + xfer += iprot->readI32(ecast635); + this->operationType = (DataOperationType::type)ecast635; this->__isset.operationType = true; } else { xfer += iprot->skip(ftype); @@ -15537,10 +15663,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 _iter634; - for (_iter634 = this->partitionnames.begin(); _iter634 != this->partitionnames.end(); ++_iter634) + std::vector ::const_iterator _iter636; + for (_iter636 = this->partitionnames.begin(); _iter636 != this->partitionnames.end(); ++_iter636) { - xfer += oprot->writeString((*_iter634)); + xfer += oprot->writeString((*_iter636)); } xfer += oprot->writeListEnd(); } @@ -15566,21 +15692,21 @@ void swap(AddDynamicPartitions &a, AddDynamicPartitions &b) { swap(a.__isset, b.__isset); } -AddDynamicPartitions::AddDynamicPartitions(const AddDynamicPartitions& other635) { - txnid = other635.txnid; - dbname = other635.dbname; - tablename = other635.tablename; - partitionnames = other635.partitionnames; - operationType = other635.operationType; - __isset = other635.__isset; -} -AddDynamicPartitions& AddDynamicPartitions::operator=(const AddDynamicPartitions& other636) { - txnid = other636.txnid; - dbname = other636.dbname; - tablename = other636.tablename; - partitionnames = other636.partitionnames; - operationType = other636.operationType; - __isset = other636.__isset; +AddDynamicPartitions::AddDynamicPartitions(const AddDynamicPartitions& other637) { + txnid = other637.txnid; + dbname = other637.dbname; + tablename = other637.tablename; + partitionnames = other637.partitionnames; + operationType = other637.operationType; + __isset = other637.__isset; +} +AddDynamicPartitions& AddDynamicPartitions::operator=(const AddDynamicPartitions& other638) { + txnid = other638.txnid; + dbname = other638.dbname; + tablename = other638.tablename; + partitionnames = other638.partitionnames; + operationType = other638.operationType; + __isset = other638.__isset; return *this; } void AddDynamicPartitions::printTo(std::ostream& out) const { @@ -15686,15 +15812,15 @@ void swap(NotificationEventRequest &a, NotificationEventRequest &b) { swap(a.__isset, b.__isset); } -NotificationEventRequest::NotificationEventRequest(const NotificationEventRequest& other637) { - lastEvent = other637.lastEvent; - maxEvents = other637.maxEvents; - __isset = other637.__isset; +NotificationEventRequest::NotificationEventRequest(const NotificationEventRequest& other639) { + lastEvent = other639.lastEvent; + maxEvents = other639.maxEvents; + __isset = other639.__isset; } -NotificationEventRequest& NotificationEventRequest::operator=(const NotificationEventRequest& other638) { - lastEvent = other638.lastEvent; - maxEvents = other638.maxEvents; - __isset = other638.__isset; +NotificationEventRequest& NotificationEventRequest::operator=(const NotificationEventRequest& other640) { + lastEvent = other640.lastEvent; + maxEvents = other640.maxEvents; + __isset = other640.__isset; return *this; } void NotificationEventRequest::printTo(std::ostream& out) const { @@ -15895,25 +16021,25 @@ void swap(NotificationEvent &a, NotificationEvent &b) { swap(a.__isset, b.__isset); } -NotificationEvent::NotificationEvent(const NotificationEvent& other639) { - eventId = other639.eventId; - eventTime = other639.eventTime; - eventType = other639.eventType; - dbName = other639.dbName; - tableName = other639.tableName; - message = other639.message; - messageFormat = other639.messageFormat; - __isset = other639.__isset; -} -NotificationEvent& NotificationEvent::operator=(const NotificationEvent& other640) { - eventId = other640.eventId; - eventTime = other640.eventTime; - eventType = other640.eventType; - dbName = other640.dbName; - tableName = other640.tableName; - message = other640.message; - messageFormat = other640.messageFormat; - __isset = other640.__isset; +NotificationEvent::NotificationEvent(const NotificationEvent& other641) { + eventId = other641.eventId; + eventTime = other641.eventTime; + eventType = other641.eventType; + dbName = other641.dbName; + tableName = other641.tableName; + message = other641.message; + messageFormat = other641.messageFormat; + __isset = other641.__isset; +} +NotificationEvent& NotificationEvent::operator=(const NotificationEvent& other642) { + eventId = other642.eventId; + eventTime = other642.eventTime; + eventType = other642.eventType; + dbName = other642.dbName; + tableName = other642.tableName; + message = other642.message; + messageFormat = other642.messageFormat; + __isset = other642.__isset; return *this; } void NotificationEvent::printTo(std::ostream& out) const { @@ -15964,14 +16090,14 @@ uint32_t NotificationEventResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->events.clear(); - uint32_t _size641; - ::apache::thrift::protocol::TType _etype644; - xfer += iprot->readListBegin(_etype644, _size641); - this->events.resize(_size641); - uint32_t _i645; - for (_i645 = 0; _i645 < _size641; ++_i645) + uint32_t _size643; + ::apache::thrift::protocol::TType _etype646; + xfer += iprot->readListBegin(_etype646, _size643); + this->events.resize(_size643); + uint32_t _i647; + for (_i647 = 0; _i647 < _size643; ++_i647) { - xfer += this->events[_i645].read(iprot); + xfer += this->events[_i647].read(iprot); } xfer += iprot->readListEnd(); } @@ -16002,10 +16128,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 _iter646; - for (_iter646 = this->events.begin(); _iter646 != this->events.end(); ++_iter646) + std::vector ::const_iterator _iter648; + for (_iter648 = this->events.begin(); _iter648 != this->events.end(); ++_iter648) { - xfer += (*_iter646).write(oprot); + xfer += (*_iter648).write(oprot); } xfer += oprot->writeListEnd(); } @@ -16021,11 +16147,11 @@ void swap(NotificationEventResponse &a, NotificationEventResponse &b) { swap(a.events, b.events); } -NotificationEventResponse::NotificationEventResponse(const NotificationEventResponse& other647) { - events = other647.events; +NotificationEventResponse::NotificationEventResponse(const NotificationEventResponse& other649) { + events = other649.events; } -NotificationEventResponse& NotificationEventResponse::operator=(const NotificationEventResponse& other648) { - events = other648.events; +NotificationEventResponse& NotificationEventResponse::operator=(const NotificationEventResponse& other650) { + events = other650.events; return *this; } void NotificationEventResponse::printTo(std::ostream& out) const { @@ -16107,11 +16233,11 @@ void swap(CurrentNotificationEventId &a, CurrentNotificationEventId &b) { swap(a.eventId, b.eventId); } -CurrentNotificationEventId::CurrentNotificationEventId(const CurrentNotificationEventId& other649) { - eventId = other649.eventId; +CurrentNotificationEventId::CurrentNotificationEventId(const CurrentNotificationEventId& other651) { + eventId = other651.eventId; } -CurrentNotificationEventId& CurrentNotificationEventId::operator=(const CurrentNotificationEventId& other650) { - eventId = other650.eventId; +CurrentNotificationEventId& CurrentNotificationEventId::operator=(const CurrentNotificationEventId& other652) { + eventId = other652.eventId; return *this; } void CurrentNotificationEventId::printTo(std::ostream& out) const { @@ -16174,14 +16300,14 @@ uint32_t InsertEventRequestData::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->filesAdded.clear(); - uint32_t _size651; - ::apache::thrift::protocol::TType _etype654; - xfer += iprot->readListBegin(_etype654, _size651); - this->filesAdded.resize(_size651); - uint32_t _i655; - for (_i655 = 0; _i655 < _size651; ++_i655) + uint32_t _size653; + ::apache::thrift::protocol::TType _etype656; + xfer += iprot->readListBegin(_etype656, _size653); + this->filesAdded.resize(_size653); + uint32_t _i657; + for (_i657 = 0; _i657 < _size653; ++_i657) { - xfer += iprot->readString(this->filesAdded[_i655]); + xfer += iprot->readString(this->filesAdded[_i657]); } xfer += iprot->readListEnd(); } @@ -16194,14 +16320,14 @@ uint32_t InsertEventRequestData::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->filesAddedChecksum.clear(); - uint32_t _size656; - ::apache::thrift::protocol::TType _etype659; - xfer += iprot->readListBegin(_etype659, _size656); - this->filesAddedChecksum.resize(_size656); - uint32_t _i660; - for (_i660 = 0; _i660 < _size656; ++_i660) + uint32_t _size658; + ::apache::thrift::protocol::TType _etype661; + xfer += iprot->readListBegin(_etype661, _size658); + this->filesAddedChecksum.resize(_size658); + uint32_t _i662; + for (_i662 = 0; _i662 < _size658; ++_i662) { - xfer += iprot->readString(this->filesAddedChecksum[_i660]); + xfer += iprot->readString(this->filesAddedChecksum[_i662]); } xfer += iprot->readListEnd(); } @@ -16237,10 +16363,10 @@ uint32_t InsertEventRequestData::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("filesAdded", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->filesAdded.size())); - std::vector ::const_iterator _iter661; - for (_iter661 = this->filesAdded.begin(); _iter661 != this->filesAdded.end(); ++_iter661) + std::vector ::const_iterator _iter663; + for (_iter663 = this->filesAdded.begin(); _iter663 != this->filesAdded.end(); ++_iter663) { - xfer += oprot->writeString((*_iter661)); + xfer += oprot->writeString((*_iter663)); } xfer += oprot->writeListEnd(); } @@ -16250,10 +16376,10 @@ uint32_t InsertEventRequestData::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("filesAddedChecksum", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->filesAddedChecksum.size())); - std::vector ::const_iterator _iter662; - for (_iter662 = this->filesAddedChecksum.begin(); _iter662 != this->filesAddedChecksum.end(); ++_iter662) + std::vector ::const_iterator _iter664; + for (_iter664 = this->filesAddedChecksum.begin(); _iter664 != this->filesAddedChecksum.end(); ++_iter664) { - xfer += oprot->writeString((*_iter662)); + xfer += oprot->writeString((*_iter664)); } xfer += oprot->writeListEnd(); } @@ -16272,17 +16398,17 @@ void swap(InsertEventRequestData &a, InsertEventRequestData &b) { swap(a.__isset, b.__isset); } -InsertEventRequestData::InsertEventRequestData(const InsertEventRequestData& other663) { - replace = other663.replace; - filesAdded = other663.filesAdded; - filesAddedChecksum = other663.filesAddedChecksum; - __isset = other663.__isset; +InsertEventRequestData::InsertEventRequestData(const InsertEventRequestData& other665) { + replace = other665.replace; + filesAdded = other665.filesAdded; + filesAddedChecksum = other665.filesAddedChecksum; + __isset = other665.__isset; } -InsertEventRequestData& InsertEventRequestData::operator=(const InsertEventRequestData& other664) { - replace = other664.replace; - filesAdded = other664.filesAdded; - filesAddedChecksum = other664.filesAddedChecksum; - __isset = other664.__isset; +InsertEventRequestData& InsertEventRequestData::operator=(const InsertEventRequestData& other666) { + replace = other666.replace; + filesAdded = other666.filesAdded; + filesAddedChecksum = other666.filesAddedChecksum; + __isset = other666.__isset; return *this; } void InsertEventRequestData::printTo(std::ostream& out) const { @@ -16364,13 +16490,13 @@ void swap(FireEventRequestData &a, FireEventRequestData &b) { swap(a.__isset, b.__isset); } -FireEventRequestData::FireEventRequestData(const FireEventRequestData& other665) { - insertData = other665.insertData; - __isset = other665.__isset; +FireEventRequestData::FireEventRequestData(const FireEventRequestData& other667) { + insertData = other667.insertData; + __isset = other667.__isset; } -FireEventRequestData& FireEventRequestData::operator=(const FireEventRequestData& other666) { - insertData = other666.insertData; - __isset = other666.__isset; +FireEventRequestData& FireEventRequestData::operator=(const FireEventRequestData& other668) { + insertData = other668.insertData; + __isset = other668.__isset; return *this; } void FireEventRequestData::printTo(std::ostream& out) const { @@ -16467,14 +16593,14 @@ uint32_t FireEventRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionVals.clear(); - uint32_t _size667; - ::apache::thrift::protocol::TType _etype670; - xfer += iprot->readListBegin(_etype670, _size667); - this->partitionVals.resize(_size667); - uint32_t _i671; - for (_i671 = 0; _i671 < _size667; ++_i671) + uint32_t _size669; + ::apache::thrift::protocol::TType _etype672; + xfer += iprot->readListBegin(_etype672, _size669); + this->partitionVals.resize(_size669); + uint32_t _i673; + for (_i673 = 0; _i673 < _size669; ++_i673) { - xfer += iprot->readString(this->partitionVals[_i671]); + xfer += iprot->readString(this->partitionVals[_i673]); } xfer += iprot->readListEnd(); } @@ -16526,10 +16652,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 _iter672; - for (_iter672 = this->partitionVals.begin(); _iter672 != this->partitionVals.end(); ++_iter672) + std::vector ::const_iterator _iter674; + for (_iter674 = this->partitionVals.begin(); _iter674 != this->partitionVals.end(); ++_iter674) { - xfer += oprot->writeString((*_iter672)); + xfer += oprot->writeString((*_iter674)); } xfer += oprot->writeListEnd(); } @@ -16550,21 +16676,21 @@ void swap(FireEventRequest &a, FireEventRequest &b) { swap(a.__isset, b.__isset); } -FireEventRequest::FireEventRequest(const FireEventRequest& other673) { - successful = other673.successful; - data = other673.data; - dbName = other673.dbName; - tableName = other673.tableName; - partitionVals = other673.partitionVals; - __isset = other673.__isset; -} -FireEventRequest& FireEventRequest::operator=(const FireEventRequest& other674) { - successful = other674.successful; - data = other674.data; - dbName = other674.dbName; - tableName = other674.tableName; - partitionVals = other674.partitionVals; - __isset = other674.__isset; +FireEventRequest::FireEventRequest(const FireEventRequest& other675) { + successful = other675.successful; + data = other675.data; + dbName = other675.dbName; + tableName = other675.tableName; + partitionVals = other675.partitionVals; + __isset = other675.__isset; +} +FireEventRequest& FireEventRequest::operator=(const FireEventRequest& other676) { + successful = other676.successful; + data = other676.data; + dbName = other676.dbName; + tableName = other676.tableName; + partitionVals = other676.partitionVals; + __isset = other676.__isset; return *this; } void FireEventRequest::printTo(std::ostream& out) const { @@ -16627,11 +16753,11 @@ void swap(FireEventResponse &a, FireEventResponse &b) { (void) b; } -FireEventResponse::FireEventResponse(const FireEventResponse& other675) { - (void) other675; +FireEventResponse::FireEventResponse(const FireEventResponse& other677) { + (void) other677; } -FireEventResponse& FireEventResponse::operator=(const FireEventResponse& other676) { - (void) other676; +FireEventResponse& FireEventResponse::operator=(const FireEventResponse& other678) { + (void) other678; return *this; } void FireEventResponse::printTo(std::ostream& out) const { @@ -16731,15 +16857,15 @@ void swap(MetadataPpdResult &a, MetadataPpdResult &b) { swap(a.__isset, b.__isset); } -MetadataPpdResult::MetadataPpdResult(const MetadataPpdResult& other677) { - metadata = other677.metadata; - includeBitset = other677.includeBitset; - __isset = other677.__isset; +MetadataPpdResult::MetadataPpdResult(const MetadataPpdResult& other679) { + metadata = other679.metadata; + includeBitset = other679.includeBitset; + __isset = other679.__isset; } -MetadataPpdResult& MetadataPpdResult::operator=(const MetadataPpdResult& other678) { - metadata = other678.metadata; - includeBitset = other678.includeBitset; - __isset = other678.__isset; +MetadataPpdResult& MetadataPpdResult::operator=(const MetadataPpdResult& other680) { + metadata = other680.metadata; + includeBitset = other680.includeBitset; + __isset = other680.__isset; return *this; } void MetadataPpdResult::printTo(std::ostream& out) const { @@ -16790,17 +16916,17 @@ uint32_t GetFileMetadataByExprResult::read(::apache::thrift::protocol::TProtocol if (ftype == ::apache::thrift::protocol::T_MAP) { { this->metadata.clear(); - uint32_t _size679; - ::apache::thrift::protocol::TType _ktype680; - ::apache::thrift::protocol::TType _vtype681; - xfer += iprot->readMapBegin(_ktype680, _vtype681, _size679); - uint32_t _i683; - for (_i683 = 0; _i683 < _size679; ++_i683) + uint32_t _size681; + ::apache::thrift::protocol::TType _ktype682; + ::apache::thrift::protocol::TType _vtype683; + xfer += iprot->readMapBegin(_ktype682, _vtype683, _size681); + uint32_t _i685; + for (_i685 = 0; _i685 < _size681; ++_i685) { - int64_t _key684; - xfer += iprot->readI64(_key684); - MetadataPpdResult& _val685 = this->metadata[_key684]; - xfer += _val685.read(iprot); + int64_t _key686; + xfer += iprot->readI64(_key686); + MetadataPpdResult& _val687 = this->metadata[_key686]; + xfer += _val687.read(iprot); } xfer += iprot->readMapEnd(); } @@ -16841,11 +16967,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 _iter686; - for (_iter686 = this->metadata.begin(); _iter686 != this->metadata.end(); ++_iter686) + std::map ::const_iterator _iter688; + for (_iter688 = this->metadata.begin(); _iter688 != this->metadata.end(); ++_iter688) { - xfer += oprot->writeI64(_iter686->first); - xfer += _iter686->second.write(oprot); + xfer += oprot->writeI64(_iter688->first); + xfer += _iter688->second.write(oprot); } xfer += oprot->writeMapEnd(); } @@ -16866,13 +16992,13 @@ void swap(GetFileMetadataByExprResult &a, GetFileMetadataByExprResult &b) { swap(a.isSupported, b.isSupported); } -GetFileMetadataByExprResult::GetFileMetadataByExprResult(const GetFileMetadataByExprResult& other687) { - metadata = other687.metadata; - isSupported = other687.isSupported; +GetFileMetadataByExprResult::GetFileMetadataByExprResult(const GetFileMetadataByExprResult& other689) { + metadata = other689.metadata; + isSupported = other689.isSupported; } -GetFileMetadataByExprResult& GetFileMetadataByExprResult::operator=(const GetFileMetadataByExprResult& other688) { - metadata = other688.metadata; - isSupported = other688.isSupported; +GetFileMetadataByExprResult& GetFileMetadataByExprResult::operator=(const GetFileMetadataByExprResult& other690) { + metadata = other690.metadata; + isSupported = other690.isSupported; return *this; } void GetFileMetadataByExprResult::printTo(std::ostream& out) const { @@ -16933,14 +17059,14 @@ uint32_t GetFileMetadataByExprRequest::read(::apache::thrift::protocol::TProtoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size689; - ::apache::thrift::protocol::TType _etype692; - xfer += iprot->readListBegin(_etype692, _size689); - this->fileIds.resize(_size689); - uint32_t _i693; - for (_i693 = 0; _i693 < _size689; ++_i693) + uint32_t _size691; + ::apache::thrift::protocol::TType _etype694; + xfer += iprot->readListBegin(_etype694, _size691); + this->fileIds.resize(_size691); + uint32_t _i695; + for (_i695 = 0; _i695 < _size691; ++_i695) { - xfer += iprot->readI64(this->fileIds[_i693]); + xfer += iprot->readI64(this->fileIds[_i695]); } xfer += iprot->readListEnd(); } @@ -16967,9 +17093,9 @@ uint32_t GetFileMetadataByExprRequest::read(::apache::thrift::protocol::TProtoco break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast694; - xfer += iprot->readI32(ecast694); - this->type = (FileMetadataExprType::type)ecast694; + int32_t ecast696; + xfer += iprot->readI32(ecast696); + this->type = (FileMetadataExprType::type)ecast696; this->__isset.type = true; } else { xfer += iprot->skip(ftype); @@ -16999,10 +17125,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 _iter695; - for (_iter695 = this->fileIds.begin(); _iter695 != this->fileIds.end(); ++_iter695) + std::vector ::const_iterator _iter697; + for (_iter697 = this->fileIds.begin(); _iter697 != this->fileIds.end(); ++_iter697) { - xfer += oprot->writeI64((*_iter695)); + xfer += oprot->writeI64((*_iter697)); } xfer += oprot->writeListEnd(); } @@ -17036,19 +17162,19 @@ void swap(GetFileMetadataByExprRequest &a, GetFileMetadataByExprRequest &b) { swap(a.__isset, b.__isset); } -GetFileMetadataByExprRequest::GetFileMetadataByExprRequest(const GetFileMetadataByExprRequest& other696) { - fileIds = other696.fileIds; - expr = other696.expr; - doGetFooters = other696.doGetFooters; - type = other696.type; - __isset = other696.__isset; +GetFileMetadataByExprRequest::GetFileMetadataByExprRequest(const GetFileMetadataByExprRequest& other698) { + fileIds = other698.fileIds; + expr = other698.expr; + doGetFooters = other698.doGetFooters; + type = other698.type; + __isset = other698.__isset; } -GetFileMetadataByExprRequest& GetFileMetadataByExprRequest::operator=(const GetFileMetadataByExprRequest& other697) { - fileIds = other697.fileIds; - expr = other697.expr; - doGetFooters = other697.doGetFooters; - type = other697.type; - __isset = other697.__isset; +GetFileMetadataByExprRequest& GetFileMetadataByExprRequest::operator=(const GetFileMetadataByExprRequest& other699) { + fileIds = other699.fileIds; + expr = other699.expr; + doGetFooters = other699.doGetFooters; + type = other699.type; + __isset = other699.__isset; return *this; } void GetFileMetadataByExprRequest::printTo(std::ostream& out) const { @@ -17101,17 +17227,17 @@ uint32_t GetFileMetadataResult::read(::apache::thrift::protocol::TProtocol* ipro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->metadata.clear(); - uint32_t _size698; - ::apache::thrift::protocol::TType _ktype699; - ::apache::thrift::protocol::TType _vtype700; - xfer += iprot->readMapBegin(_ktype699, _vtype700, _size698); - uint32_t _i702; - for (_i702 = 0; _i702 < _size698; ++_i702) + uint32_t _size700; + ::apache::thrift::protocol::TType _ktype701; + ::apache::thrift::protocol::TType _vtype702; + xfer += iprot->readMapBegin(_ktype701, _vtype702, _size700); + uint32_t _i704; + for (_i704 = 0; _i704 < _size700; ++_i704) { - int64_t _key703; - xfer += iprot->readI64(_key703); - std::string& _val704 = this->metadata[_key703]; - xfer += iprot->readBinary(_val704); + int64_t _key705; + xfer += iprot->readI64(_key705); + std::string& _val706 = this->metadata[_key705]; + xfer += iprot->readBinary(_val706); } xfer += iprot->readMapEnd(); } @@ -17152,11 +17278,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 _iter705; - for (_iter705 = this->metadata.begin(); _iter705 != this->metadata.end(); ++_iter705) + std::map ::const_iterator _iter707; + for (_iter707 = this->metadata.begin(); _iter707 != this->metadata.end(); ++_iter707) { - xfer += oprot->writeI64(_iter705->first); - xfer += oprot->writeBinary(_iter705->second); + xfer += oprot->writeI64(_iter707->first); + xfer += oprot->writeBinary(_iter707->second); } xfer += oprot->writeMapEnd(); } @@ -17177,13 +17303,13 @@ void swap(GetFileMetadataResult &a, GetFileMetadataResult &b) { swap(a.isSupported, b.isSupported); } -GetFileMetadataResult::GetFileMetadataResult(const GetFileMetadataResult& other706) { - metadata = other706.metadata; - isSupported = other706.isSupported; +GetFileMetadataResult::GetFileMetadataResult(const GetFileMetadataResult& other708) { + metadata = other708.metadata; + isSupported = other708.isSupported; } -GetFileMetadataResult& GetFileMetadataResult::operator=(const GetFileMetadataResult& other707) { - metadata = other707.metadata; - isSupported = other707.isSupported; +GetFileMetadataResult& GetFileMetadataResult::operator=(const GetFileMetadataResult& other709) { + metadata = other709.metadata; + isSupported = other709.isSupported; return *this; } void GetFileMetadataResult::printTo(std::ostream& out) const { @@ -17229,14 +17355,14 @@ uint32_t GetFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size708; - ::apache::thrift::protocol::TType _etype711; - xfer += iprot->readListBegin(_etype711, _size708); - this->fileIds.resize(_size708); - uint32_t _i712; - for (_i712 = 0; _i712 < _size708; ++_i712) + uint32_t _size710; + ::apache::thrift::protocol::TType _etype713; + xfer += iprot->readListBegin(_etype713, _size710); + this->fileIds.resize(_size710); + uint32_t _i714; + for (_i714 = 0; _i714 < _size710; ++_i714) { - xfer += iprot->readI64(this->fileIds[_i712]); + xfer += iprot->readI64(this->fileIds[_i714]); } xfer += iprot->readListEnd(); } @@ -17267,10 +17393,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 _iter713; - for (_iter713 = this->fileIds.begin(); _iter713 != this->fileIds.end(); ++_iter713) + std::vector ::const_iterator _iter715; + for (_iter715 = this->fileIds.begin(); _iter715 != this->fileIds.end(); ++_iter715) { - xfer += oprot->writeI64((*_iter713)); + xfer += oprot->writeI64((*_iter715)); } xfer += oprot->writeListEnd(); } @@ -17286,11 +17412,11 @@ void swap(GetFileMetadataRequest &a, GetFileMetadataRequest &b) { swap(a.fileIds, b.fileIds); } -GetFileMetadataRequest::GetFileMetadataRequest(const GetFileMetadataRequest& other714) { - fileIds = other714.fileIds; +GetFileMetadataRequest::GetFileMetadataRequest(const GetFileMetadataRequest& other716) { + fileIds = other716.fileIds; } -GetFileMetadataRequest& GetFileMetadataRequest::operator=(const GetFileMetadataRequest& other715) { - fileIds = other715.fileIds; +GetFileMetadataRequest& GetFileMetadataRequest::operator=(const GetFileMetadataRequest& other717) { + fileIds = other717.fileIds; return *this; } void GetFileMetadataRequest::printTo(std::ostream& out) const { @@ -17349,11 +17475,11 @@ void swap(PutFileMetadataResult &a, PutFileMetadataResult &b) { (void) b; } -PutFileMetadataResult::PutFileMetadataResult(const PutFileMetadataResult& other716) { - (void) other716; +PutFileMetadataResult::PutFileMetadataResult(const PutFileMetadataResult& other718) { + (void) other718; } -PutFileMetadataResult& PutFileMetadataResult::operator=(const PutFileMetadataResult& other717) { - (void) other717; +PutFileMetadataResult& PutFileMetadataResult::operator=(const PutFileMetadataResult& other719) { + (void) other719; return *this; } void PutFileMetadataResult::printTo(std::ostream& out) const { @@ -17407,14 +17533,14 @@ uint32_t PutFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size718; - ::apache::thrift::protocol::TType _etype721; - xfer += iprot->readListBegin(_etype721, _size718); - this->fileIds.resize(_size718); - uint32_t _i722; - for (_i722 = 0; _i722 < _size718; ++_i722) + uint32_t _size720; + ::apache::thrift::protocol::TType _etype723; + xfer += iprot->readListBegin(_etype723, _size720); + this->fileIds.resize(_size720); + uint32_t _i724; + for (_i724 = 0; _i724 < _size720; ++_i724) { - xfer += iprot->readI64(this->fileIds[_i722]); + xfer += iprot->readI64(this->fileIds[_i724]); } xfer += iprot->readListEnd(); } @@ -17427,14 +17553,14 @@ uint32_t PutFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->metadata.clear(); - uint32_t _size723; - ::apache::thrift::protocol::TType _etype726; - xfer += iprot->readListBegin(_etype726, _size723); - this->metadata.resize(_size723); - uint32_t _i727; - for (_i727 = 0; _i727 < _size723; ++_i727) + uint32_t _size725; + ::apache::thrift::protocol::TType _etype728; + xfer += iprot->readListBegin(_etype728, _size725); + this->metadata.resize(_size725); + uint32_t _i729; + for (_i729 = 0; _i729 < _size725; ++_i729) { - xfer += iprot->readBinary(this->metadata[_i727]); + xfer += iprot->readBinary(this->metadata[_i729]); } xfer += iprot->readListEnd(); } @@ -17445,9 +17571,9 @@ uint32_t PutFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast728; - xfer += iprot->readI32(ecast728); - this->type = (FileMetadataExprType::type)ecast728; + int32_t ecast730; + xfer += iprot->readI32(ecast730); + this->type = (FileMetadataExprType::type)ecast730; this->__isset.type = true; } else { xfer += iprot->skip(ftype); @@ -17477,10 +17603,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 _iter729; - for (_iter729 = this->fileIds.begin(); _iter729 != this->fileIds.end(); ++_iter729) + std::vector ::const_iterator _iter731; + for (_iter731 = this->fileIds.begin(); _iter731 != this->fileIds.end(); ++_iter731) { - xfer += oprot->writeI64((*_iter729)); + xfer += oprot->writeI64((*_iter731)); } xfer += oprot->writeListEnd(); } @@ -17489,10 +17615,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 _iter730; - for (_iter730 = this->metadata.begin(); _iter730 != this->metadata.end(); ++_iter730) + std::vector ::const_iterator _iter732; + for (_iter732 = this->metadata.begin(); _iter732 != this->metadata.end(); ++_iter732) { - xfer += oprot->writeBinary((*_iter730)); + xfer += oprot->writeBinary((*_iter732)); } xfer += oprot->writeListEnd(); } @@ -17516,17 +17642,17 @@ void swap(PutFileMetadataRequest &a, PutFileMetadataRequest &b) { swap(a.__isset, b.__isset); } -PutFileMetadataRequest::PutFileMetadataRequest(const PutFileMetadataRequest& other731) { - fileIds = other731.fileIds; - metadata = other731.metadata; - type = other731.type; - __isset = other731.__isset; +PutFileMetadataRequest::PutFileMetadataRequest(const PutFileMetadataRequest& other733) { + fileIds = other733.fileIds; + metadata = other733.metadata; + type = other733.type; + __isset = other733.__isset; } -PutFileMetadataRequest& PutFileMetadataRequest::operator=(const PutFileMetadataRequest& other732) { - fileIds = other732.fileIds; - metadata = other732.metadata; - type = other732.type; - __isset = other732.__isset; +PutFileMetadataRequest& PutFileMetadataRequest::operator=(const PutFileMetadataRequest& other734) { + fileIds = other734.fileIds; + metadata = other734.metadata; + type = other734.type; + __isset = other734.__isset; return *this; } void PutFileMetadataRequest::printTo(std::ostream& out) const { @@ -17587,11 +17713,11 @@ void swap(ClearFileMetadataResult &a, ClearFileMetadataResult &b) { (void) b; } -ClearFileMetadataResult::ClearFileMetadataResult(const ClearFileMetadataResult& other733) { - (void) other733; +ClearFileMetadataResult::ClearFileMetadataResult(const ClearFileMetadataResult& other735) { + (void) other735; } -ClearFileMetadataResult& ClearFileMetadataResult::operator=(const ClearFileMetadataResult& other734) { - (void) other734; +ClearFileMetadataResult& ClearFileMetadataResult::operator=(const ClearFileMetadataResult& other736) { + (void) other736; return *this; } void ClearFileMetadataResult::printTo(std::ostream& out) const { @@ -17635,14 +17761,14 @@ uint32_t ClearFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* i if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size735; - ::apache::thrift::protocol::TType _etype738; - xfer += iprot->readListBegin(_etype738, _size735); - this->fileIds.resize(_size735); - uint32_t _i739; - for (_i739 = 0; _i739 < _size735; ++_i739) + uint32_t _size737; + ::apache::thrift::protocol::TType _etype740; + xfer += iprot->readListBegin(_etype740, _size737); + this->fileIds.resize(_size737); + uint32_t _i741; + for (_i741 = 0; _i741 < _size737; ++_i741) { - xfer += iprot->readI64(this->fileIds[_i739]); + xfer += iprot->readI64(this->fileIds[_i741]); } xfer += iprot->readListEnd(); } @@ -17673,10 +17799,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 _iter740; - for (_iter740 = this->fileIds.begin(); _iter740 != this->fileIds.end(); ++_iter740) + std::vector ::const_iterator _iter742; + for (_iter742 = this->fileIds.begin(); _iter742 != this->fileIds.end(); ++_iter742) { - xfer += oprot->writeI64((*_iter740)); + xfer += oprot->writeI64((*_iter742)); } xfer += oprot->writeListEnd(); } @@ -17692,11 +17818,11 @@ void swap(ClearFileMetadataRequest &a, ClearFileMetadataRequest &b) { swap(a.fileIds, b.fileIds); } -ClearFileMetadataRequest::ClearFileMetadataRequest(const ClearFileMetadataRequest& other741) { - fileIds = other741.fileIds; +ClearFileMetadataRequest::ClearFileMetadataRequest(const ClearFileMetadataRequest& other743) { + fileIds = other743.fileIds; } -ClearFileMetadataRequest& ClearFileMetadataRequest::operator=(const ClearFileMetadataRequest& other742) { - fileIds = other742.fileIds; +ClearFileMetadataRequest& ClearFileMetadataRequest::operator=(const ClearFileMetadataRequest& other744) { + fileIds = other744.fileIds; return *this; } void ClearFileMetadataRequest::printTo(std::ostream& out) const { @@ -17778,11 +17904,11 @@ void swap(CacheFileMetadataResult &a, CacheFileMetadataResult &b) { swap(a.isSupported, b.isSupported); } -CacheFileMetadataResult::CacheFileMetadataResult(const CacheFileMetadataResult& other743) { - isSupported = other743.isSupported; +CacheFileMetadataResult::CacheFileMetadataResult(const CacheFileMetadataResult& other745) { + isSupported = other745.isSupported; } -CacheFileMetadataResult& CacheFileMetadataResult::operator=(const CacheFileMetadataResult& other744) { - isSupported = other744.isSupported; +CacheFileMetadataResult& CacheFileMetadataResult::operator=(const CacheFileMetadataResult& other746) { + isSupported = other746.isSupported; return *this; } void CacheFileMetadataResult::printTo(std::ostream& out) const { @@ -17923,19 +18049,19 @@ void swap(CacheFileMetadataRequest &a, CacheFileMetadataRequest &b) { swap(a.__isset, b.__isset); } -CacheFileMetadataRequest::CacheFileMetadataRequest(const CacheFileMetadataRequest& other745) { - dbName = other745.dbName; - tblName = other745.tblName; - partName = other745.partName; - isAllParts = other745.isAllParts; - __isset = other745.__isset; +CacheFileMetadataRequest::CacheFileMetadataRequest(const CacheFileMetadataRequest& other747) { + dbName = other747.dbName; + tblName = other747.tblName; + partName = other747.partName; + isAllParts = other747.isAllParts; + __isset = other747.__isset; } -CacheFileMetadataRequest& CacheFileMetadataRequest::operator=(const CacheFileMetadataRequest& other746) { - dbName = other746.dbName; - tblName = other746.tblName; - partName = other746.partName; - isAllParts = other746.isAllParts; - __isset = other746.__isset; +CacheFileMetadataRequest& CacheFileMetadataRequest::operator=(const CacheFileMetadataRequest& other748) { + dbName = other748.dbName; + tblName = other748.tblName; + partName = other748.partName; + isAllParts = other748.isAllParts; + __isset = other748.__isset; return *this; } void CacheFileMetadataRequest::printTo(std::ostream& out) const { @@ -17983,14 +18109,14 @@ uint32_t GetAllFunctionsResponse::read(::apache::thrift::protocol::TProtocol* ip if (ftype == ::apache::thrift::protocol::T_LIST) { { this->functions.clear(); - uint32_t _size747; - ::apache::thrift::protocol::TType _etype750; - xfer += iprot->readListBegin(_etype750, _size747); - this->functions.resize(_size747); - uint32_t _i751; - for (_i751 = 0; _i751 < _size747; ++_i751) + uint32_t _size749; + ::apache::thrift::protocol::TType _etype752; + xfer += iprot->readListBegin(_etype752, _size749); + this->functions.resize(_size749); + uint32_t _i753; + for (_i753 = 0; _i753 < _size749; ++_i753) { - xfer += this->functions[_i751].read(iprot); + xfer += this->functions[_i753].read(iprot); } xfer += iprot->readListEnd(); } @@ -18020,10 +18146,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 _iter752; - for (_iter752 = this->functions.begin(); _iter752 != this->functions.end(); ++_iter752) + std::vector ::const_iterator _iter754; + for (_iter754 = this->functions.begin(); _iter754 != this->functions.end(); ++_iter754) { - xfer += (*_iter752).write(oprot); + xfer += (*_iter754).write(oprot); } xfer += oprot->writeListEnd(); } @@ -18040,13 +18166,13 @@ void swap(GetAllFunctionsResponse &a, GetAllFunctionsResponse &b) { swap(a.__isset, b.__isset); } -GetAllFunctionsResponse::GetAllFunctionsResponse(const GetAllFunctionsResponse& other753) { - functions = other753.functions; - __isset = other753.__isset; +GetAllFunctionsResponse::GetAllFunctionsResponse(const GetAllFunctionsResponse& other755) { + functions = other755.functions; + __isset = other755.__isset; } -GetAllFunctionsResponse& GetAllFunctionsResponse::operator=(const GetAllFunctionsResponse& other754) { - functions = other754.functions; - __isset = other754.__isset; +GetAllFunctionsResponse& GetAllFunctionsResponse::operator=(const GetAllFunctionsResponse& other756) { + functions = other756.functions; + __isset = other756.__isset; return *this; } void GetAllFunctionsResponse::printTo(std::ostream& out) const { @@ -18091,16 +18217,16 @@ uint32_t ClientCapabilities::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->values.clear(); - uint32_t _size755; - ::apache::thrift::protocol::TType _etype758; - xfer += iprot->readListBegin(_etype758, _size755); - this->values.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->values.resize(_size757); + uint32_t _i761; + for (_i761 = 0; _i761 < _size757; ++_i761) { - int32_t ecast760; - xfer += iprot->readI32(ecast760); - this->values[_i759] = (ClientCapability::type)ecast760; + int32_t ecast762; + xfer += iprot->readI32(ecast762); + this->values[_i761] = (ClientCapability::type)ecast762; } xfer += iprot->readListEnd(); } @@ -18131,10 +18257,10 @@ uint32_t ClientCapabilities::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I32, static_cast(this->values.size())); - std::vector ::const_iterator _iter761; - for (_iter761 = this->values.begin(); _iter761 != this->values.end(); ++_iter761) + std::vector ::const_iterator _iter763; + for (_iter763 = this->values.begin(); _iter763 != this->values.end(); ++_iter763) { - xfer += oprot->writeI32((int32_t)(*_iter761)); + xfer += oprot->writeI32((int32_t)(*_iter763)); } xfer += oprot->writeListEnd(); } @@ -18150,11 +18276,11 @@ void swap(ClientCapabilities &a, ClientCapabilities &b) { swap(a.values, b.values); } -ClientCapabilities::ClientCapabilities(const ClientCapabilities& other762) { - values = other762.values; +ClientCapabilities::ClientCapabilities(const ClientCapabilities& other764) { + values = other764.values; } -ClientCapabilities& ClientCapabilities::operator=(const ClientCapabilities& other763) { - values = other763.values; +ClientCapabilities& ClientCapabilities::operator=(const ClientCapabilities& other765) { + values = other765.values; return *this; } void ClientCapabilities::printTo(std::ostream& out) const { @@ -18276,17 +18402,17 @@ void swap(GetTableRequest &a, GetTableRequest &b) { swap(a.__isset, b.__isset); } -GetTableRequest::GetTableRequest(const GetTableRequest& other764) { - dbName = other764.dbName; - tblName = other764.tblName; - capabilities = other764.capabilities; - __isset = other764.__isset; +GetTableRequest::GetTableRequest(const GetTableRequest& other766) { + dbName = other766.dbName; + tblName = other766.tblName; + capabilities = other766.capabilities; + __isset = other766.__isset; } -GetTableRequest& GetTableRequest::operator=(const GetTableRequest& other765) { - dbName = other765.dbName; - tblName = other765.tblName; - capabilities = other765.capabilities; - __isset = other765.__isset; +GetTableRequest& GetTableRequest::operator=(const GetTableRequest& other767) { + dbName = other767.dbName; + tblName = other767.tblName; + capabilities = other767.capabilities; + __isset = other767.__isset; return *this; } void GetTableRequest::printTo(std::ostream& out) const { @@ -18370,11 +18496,11 @@ void swap(GetTableResult &a, GetTableResult &b) { swap(a.table, b.table); } -GetTableResult::GetTableResult(const GetTableResult& other766) { - table = other766.table; +GetTableResult::GetTableResult(const GetTableResult& other768) { + table = other768.table; } -GetTableResult& GetTableResult::operator=(const GetTableResult& other767) { - table = other767.table; +GetTableResult& GetTableResult::operator=(const GetTableResult& other769) { + table = other769.table; return *this; } void GetTableResult::printTo(std::ostream& out) const { @@ -18437,14 +18563,14 @@ uint32_t GetTablesRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tblNames.clear(); - uint32_t _size768; - ::apache::thrift::protocol::TType _etype771; - xfer += iprot->readListBegin(_etype771, _size768); - this->tblNames.resize(_size768); - uint32_t _i772; - for (_i772 = 0; _i772 < _size768; ++_i772) + uint32_t _size770; + ::apache::thrift::protocol::TType _etype773; + xfer += iprot->readListBegin(_etype773, _size770); + this->tblNames.resize(_size770); + uint32_t _i774; + for (_i774 = 0; _i774 < _size770; ++_i774) { - xfer += iprot->readString(this->tblNames[_i772]); + xfer += iprot->readString(this->tblNames[_i774]); } xfer += iprot->readListEnd(); } @@ -18488,10 +18614,10 @@ uint32_t GetTablesRequest::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("tblNames", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->tblNames.size())); - std::vector ::const_iterator _iter773; - for (_iter773 = this->tblNames.begin(); _iter773 != this->tblNames.end(); ++_iter773) + std::vector ::const_iterator _iter775; + for (_iter775 = this->tblNames.begin(); _iter775 != this->tblNames.end(); ++_iter775) { - xfer += oprot->writeString((*_iter773)); + xfer += oprot->writeString((*_iter775)); } xfer += oprot->writeListEnd(); } @@ -18515,17 +18641,17 @@ void swap(GetTablesRequest &a, GetTablesRequest &b) { swap(a.__isset, b.__isset); } -GetTablesRequest::GetTablesRequest(const GetTablesRequest& other774) { - dbName = other774.dbName; - tblNames = other774.tblNames; - capabilities = other774.capabilities; - __isset = other774.__isset; +GetTablesRequest::GetTablesRequest(const GetTablesRequest& other776) { + dbName = other776.dbName; + tblNames = other776.tblNames; + capabilities = other776.capabilities; + __isset = other776.__isset; } -GetTablesRequest& GetTablesRequest::operator=(const GetTablesRequest& other775) { - dbName = other775.dbName; - tblNames = other775.tblNames; - capabilities = other775.capabilities; - __isset = other775.__isset; +GetTablesRequest& GetTablesRequest::operator=(const GetTablesRequest& other777) { + dbName = other777.dbName; + tblNames = other777.tblNames; + capabilities = other777.capabilities; + __isset = other777.__isset; return *this; } void GetTablesRequest::printTo(std::ostream& out) const { @@ -18572,14 +18698,14 @@ uint32_t GetTablesResult::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tables.clear(); - uint32_t _size776; - ::apache::thrift::protocol::TType _etype779; - xfer += iprot->readListBegin(_etype779, _size776); - this->tables.resize(_size776); - uint32_t _i780; - for (_i780 = 0; _i780 < _size776; ++_i780) + uint32_t _size778; + ::apache::thrift::protocol::TType _etype781; + xfer += iprot->readListBegin(_etype781, _size778); + this->tables.resize(_size778); + uint32_t _i782; + for (_i782 = 0; _i782 < _size778; ++_i782) { - xfer += this->tables[_i780].read(iprot); + xfer += this->tables[_i782].read(iprot); } xfer += iprot->readListEnd(); } @@ -18610,10 +18736,10 @@ uint32_t GetTablesResult::write(::apache::thrift::protocol::TProtocol* oprot) co xfer += oprot->writeFieldBegin("tables", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->tables.size())); - std::vector
::const_iterator _iter781; - for (_iter781 = this->tables.begin(); _iter781 != this->tables.end(); ++_iter781) + std::vector
::const_iterator _iter783; + for (_iter783 = this->tables.begin(); _iter783 != this->tables.end(); ++_iter783) { - xfer += (*_iter781).write(oprot); + xfer += (*_iter783).write(oprot); } xfer += oprot->writeListEnd(); } @@ -18629,11 +18755,11 @@ void swap(GetTablesResult &a, GetTablesResult &b) { swap(a.tables, b.tables); } -GetTablesResult::GetTablesResult(const GetTablesResult& other782) { - tables = other782.tables; +GetTablesResult::GetTablesResult(const GetTablesResult& other784) { + tables = other784.tables; } -GetTablesResult& GetTablesResult::operator=(const GetTablesResult& other783) { - tables = other783.tables; +GetTablesResult& GetTablesResult::operator=(const GetTablesResult& other785) { + tables = other785.tables; return *this; } void GetTablesResult::printTo(std::ostream& out) const { @@ -18775,19 +18901,19 @@ void swap(TableMeta &a, TableMeta &b) { swap(a.__isset, b.__isset); } -TableMeta::TableMeta(const TableMeta& other784) { - dbName = other784.dbName; - tableName = other784.tableName; - tableType = other784.tableType; - comments = other784.comments; - __isset = other784.__isset; +TableMeta::TableMeta(const TableMeta& other786) { + dbName = other786.dbName; + tableName = other786.tableName; + tableType = other786.tableType; + comments = other786.comments; + __isset = other786.__isset; } -TableMeta& TableMeta::operator=(const TableMeta& other785) { - dbName = other785.dbName; - tableName = other785.tableName; - tableType = other785.tableType; - comments = other785.comments; - __isset = other785.__isset; +TableMeta& TableMeta::operator=(const TableMeta& other787) { + dbName = other787.dbName; + tableName = other787.tableName; + tableType = other787.tableType; + comments = other787.comments; + __isset = other787.__isset; return *this; } void TableMeta::printTo(std::ostream& out) const { @@ -18870,13 +18996,13 @@ void swap(MetaException &a, MetaException &b) { swap(a.__isset, b.__isset); } -MetaException::MetaException(const MetaException& other786) : TException() { - message = other786.message; - __isset = other786.__isset; +MetaException::MetaException(const MetaException& other788) : TException() { + message = other788.message; + __isset = other788.__isset; } -MetaException& MetaException::operator=(const MetaException& other787) { - message = other787.message; - __isset = other787.__isset; +MetaException& MetaException::operator=(const MetaException& other789) { + message = other789.message; + __isset = other789.__isset; return *this; } void MetaException::printTo(std::ostream& out) const { @@ -18967,13 +19093,13 @@ void swap(UnknownTableException &a, UnknownTableException &b) { swap(a.__isset, b.__isset); } -UnknownTableException::UnknownTableException(const UnknownTableException& other788) : TException() { - message = other788.message; - __isset = other788.__isset; +UnknownTableException::UnknownTableException(const UnknownTableException& other790) : TException() { + message = other790.message; + __isset = other790.__isset; } -UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other789) { - message = other789.message; - __isset = other789.__isset; +UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other791) { + message = other791.message; + __isset = other791.__isset; return *this; } void UnknownTableException::printTo(std::ostream& out) const { @@ -19064,13 +19190,13 @@ void swap(UnknownDBException &a, UnknownDBException &b) { swap(a.__isset, b.__isset); } -UnknownDBException::UnknownDBException(const UnknownDBException& other790) : TException() { - message = other790.message; - __isset = other790.__isset; +UnknownDBException::UnknownDBException(const UnknownDBException& other792) : TException() { + message = other792.message; + __isset = other792.__isset; } -UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other791) { - message = other791.message; - __isset = other791.__isset; +UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other793) { + message = other793.message; + __isset = other793.__isset; return *this; } void UnknownDBException::printTo(std::ostream& out) const { @@ -19161,13 +19287,13 @@ void swap(AlreadyExistsException &a, AlreadyExistsException &b) { swap(a.__isset, b.__isset); } -AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other792) : TException() { - message = other792.message; - __isset = other792.__isset; +AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other794) : TException() { + message = other794.message; + __isset = other794.__isset; } -AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other793) { - message = other793.message; - __isset = other793.__isset; +AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other795) { + message = other795.message; + __isset = other795.__isset; return *this; } void AlreadyExistsException::printTo(std::ostream& out) const { @@ -19258,13 +19384,13 @@ void swap(InvalidPartitionException &a, InvalidPartitionException &b) { swap(a.__isset, b.__isset); } -InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other794) : TException() { - message = other794.message; - __isset = other794.__isset; +InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other796) : TException() { + message = other796.message; + __isset = other796.__isset; } -InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other795) { - message = other795.message; - __isset = other795.__isset; +InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other797) { + message = other797.message; + __isset = other797.__isset; return *this; } void InvalidPartitionException::printTo(std::ostream& out) const { @@ -19355,13 +19481,13 @@ void swap(UnknownPartitionException &a, UnknownPartitionException &b) { swap(a.__isset, b.__isset); } -UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other796) : TException() { - message = other796.message; - __isset = other796.__isset; +UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other798) : TException() { + message = other798.message; + __isset = other798.__isset; } -UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other797) { - message = other797.message; - __isset = other797.__isset; +UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other799) { + message = other799.message; + __isset = other799.__isset; return *this; } void UnknownPartitionException::printTo(std::ostream& out) const { @@ -19452,13 +19578,13 @@ void swap(InvalidObjectException &a, InvalidObjectException &b) { swap(a.__isset, b.__isset); } -InvalidObjectException::InvalidObjectException(const InvalidObjectException& other798) : TException() { - message = other798.message; - __isset = other798.__isset; +InvalidObjectException::InvalidObjectException(const InvalidObjectException& other800) : TException() { + message = other800.message; + __isset = other800.__isset; } -InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other799) { - message = other799.message; - __isset = other799.__isset; +InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other801) { + message = other801.message; + __isset = other801.__isset; return *this; } void InvalidObjectException::printTo(std::ostream& out) const { @@ -19549,13 +19675,13 @@ void swap(NoSuchObjectException &a, NoSuchObjectException &b) { swap(a.__isset, b.__isset); } -NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other800) : TException() { - message = other800.message; - __isset = other800.__isset; +NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other802) : TException() { + message = other802.message; + __isset = other802.__isset; } -NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other801) { - message = other801.message; - __isset = other801.__isset; +NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other803) { + message = other803.message; + __isset = other803.__isset; return *this; } void NoSuchObjectException::printTo(std::ostream& out) const { @@ -19646,13 +19772,13 @@ void swap(IndexAlreadyExistsException &a, IndexAlreadyExistsException &b) { swap(a.__isset, b.__isset); } -IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other802) : TException() { - message = other802.message; - __isset = other802.__isset; +IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other804) : TException() { + message = other804.message; + __isset = other804.__isset; } -IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other803) { - message = other803.message; - __isset = other803.__isset; +IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other805) { + message = other805.message; + __isset = other805.__isset; return *this; } void IndexAlreadyExistsException::printTo(std::ostream& out) const { @@ -19743,13 +19869,13 @@ void swap(InvalidOperationException &a, InvalidOperationException &b) { swap(a.__isset, b.__isset); } -InvalidOperationException::InvalidOperationException(const InvalidOperationException& other804) : TException() { - message = other804.message; - __isset = other804.__isset; +InvalidOperationException::InvalidOperationException(const InvalidOperationException& other806) : TException() { + message = other806.message; + __isset = other806.__isset; } -InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other805) { - message = other805.message; - __isset = other805.__isset; +InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other807) { + message = other807.message; + __isset = other807.__isset; return *this; } void InvalidOperationException::printTo(std::ostream& out) const { @@ -19840,13 +19966,13 @@ void swap(ConfigValSecurityException &a, ConfigValSecurityException &b) { swap(a.__isset, b.__isset); } -ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other806) : TException() { - message = other806.message; - __isset = other806.__isset; +ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other808) : TException() { + message = other808.message; + __isset = other808.__isset; } -ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other807) { - message = other807.message; - __isset = other807.__isset; +ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other809) { + message = other809.message; + __isset = other809.__isset; return *this; } void ConfigValSecurityException::printTo(std::ostream& out) const { @@ -19937,13 +20063,13 @@ void swap(InvalidInputException &a, InvalidInputException &b) { swap(a.__isset, b.__isset); } -InvalidInputException::InvalidInputException(const InvalidInputException& other808) : TException() { - message = other808.message; - __isset = other808.__isset; +InvalidInputException::InvalidInputException(const InvalidInputException& other810) : TException() { + message = other810.message; + __isset = other810.__isset; } -InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other809) { - message = other809.message; - __isset = other809.__isset; +InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other811) { + message = other811.message; + __isset = other811.__isset; return *this; } void InvalidInputException::printTo(std::ostream& out) const { @@ -20034,13 +20160,13 @@ void swap(NoSuchTxnException &a, NoSuchTxnException &b) { swap(a.__isset, b.__isset); } -NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other810) : TException() { - message = other810.message; - __isset = other810.__isset; +NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other812) : TException() { + message = other812.message; + __isset = other812.__isset; } -NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other811) { - message = other811.message; - __isset = other811.__isset; +NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other813) { + message = other813.message; + __isset = other813.__isset; return *this; } void NoSuchTxnException::printTo(std::ostream& out) const { @@ -20131,13 +20257,13 @@ void swap(TxnAbortedException &a, TxnAbortedException &b) { swap(a.__isset, b.__isset); } -TxnAbortedException::TxnAbortedException(const TxnAbortedException& other812) : TException() { - message = other812.message; - __isset = other812.__isset; +TxnAbortedException::TxnAbortedException(const TxnAbortedException& other814) : TException() { + message = other814.message; + __isset = other814.__isset; } -TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other813) { - message = other813.message; - __isset = other813.__isset; +TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other815) { + message = other815.message; + __isset = other815.__isset; return *this; } void TxnAbortedException::printTo(std::ostream& out) const { @@ -20228,13 +20354,13 @@ void swap(TxnOpenException &a, TxnOpenException &b) { swap(a.__isset, b.__isset); } -TxnOpenException::TxnOpenException(const TxnOpenException& other814) : TException() { - message = other814.message; - __isset = other814.__isset; +TxnOpenException::TxnOpenException(const TxnOpenException& other816) : TException() { + message = other816.message; + __isset = other816.__isset; } -TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other815) { - message = other815.message; - __isset = other815.__isset; +TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other817) { + message = other817.message; + __isset = other817.__isset; return *this; } void TxnOpenException::printTo(std::ostream& out) const { @@ -20325,13 +20451,13 @@ void swap(NoSuchLockException &a, NoSuchLockException &b) { swap(a.__isset, b.__isset); } -NoSuchLockException::NoSuchLockException(const NoSuchLockException& other816) : TException() { - message = other816.message; - __isset = other816.__isset; +NoSuchLockException::NoSuchLockException(const NoSuchLockException& other818) : TException() { + message = other818.message; + __isset = other818.__isset; } -NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other817) { - message = other817.message; - __isset = other817.__isset; +NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other819) { + message = other819.message; + __isset = other819.__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 50c61a78b1eb421efcb44aa78e182ef4fd8b3f8a..6cf089b034b675291e86b4703a9521bb803d63ba 100644 --- a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h +++ b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h @@ -168,6 +168,8 @@ extern const std::map _ClientCapability_VALUES_TO_NAMES; class Version; +class MetastoreDBProperty; + class FieldSchema; class SQLPrimaryKey; @@ -492,6 +494,64 @@ inline std::ostream& operator<<(std::ostream& out, const Version& obj) return out; } +typedef struct _MetastoreDBProperty__isset { + _MetastoreDBProperty__isset() : propertyKey(false), propertyValue(false), description(false) {} + bool propertyKey :1; + bool propertyValue :1; + bool description :1; +} _MetastoreDBProperty__isset; + +class MetastoreDBProperty { + public: + + MetastoreDBProperty(const MetastoreDBProperty&); + MetastoreDBProperty& operator=(const MetastoreDBProperty&); + MetastoreDBProperty() : propertyKey(), propertyValue(), description() { + } + + virtual ~MetastoreDBProperty() throw(); + std::string propertyKey; + std::string propertyValue; + std::string description; + + _MetastoreDBProperty__isset __isset; + + void __set_propertyKey(const std::string& val); + + void __set_propertyValue(const std::string& val); + + void __set_description(const std::string& val); + + bool operator == (const MetastoreDBProperty & rhs) const + { + if (!(propertyKey == rhs.propertyKey)) + return false; + if (!(propertyValue == rhs.propertyValue)) + return false; + if (!(description == rhs.description)) + return false; + return true; + } + bool operator != (const MetastoreDBProperty &rhs) const { + return !(*this == rhs); + } + + bool operator < (const MetastoreDBProperty & ) 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(MetastoreDBProperty &a, MetastoreDBProperty &b); + +inline std::ostream& operator<<(std::ostream& out, const MetastoreDBProperty& obj) +{ + obj.printTo(out); + return out; +} + typedef struct _FieldSchema__isset { _FieldSchema__isset() : name(false), type(false), comment(false) {} bool name :1; diff --git a/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/MetastoreDBProperty.java b/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/MetastoreDBProperty.java new file mode 100644 index 0000000000000000000000000000000000000000..566cbc6fdf1e1af5583614712b3ddf1c06c03b91 --- /dev/null +++ b/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/MetastoreDBProperty.java @@ -0,0 +1,603 @@ +/** + * 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 MetastoreDBProperty 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("MetastoreDBProperty"); + + private static final org.apache.thrift.protocol.TField PROPERTY_KEY_FIELD_DESC = new org.apache.thrift.protocol.TField("propertyKey", org.apache.thrift.protocol.TType.STRING, (short)1); + private static final org.apache.thrift.protocol.TField PROPERTY_VALUE_FIELD_DESC = new org.apache.thrift.protocol.TField("propertyValue", org.apache.thrift.protocol.TType.STRING, (short)2); + private static final org.apache.thrift.protocol.TField DESCRIPTION_FIELD_DESC = new org.apache.thrift.protocol.TField("description", org.apache.thrift.protocol.TType.STRING, (short)3); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new MetastoreDBPropertyStandardSchemeFactory()); + schemes.put(TupleScheme.class, new MetastoreDBPropertyTupleSchemeFactory()); + } + + private String propertyKey; // required + private String propertyValue; // required + private String description; // 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 { + PROPERTY_KEY((short)1, "propertyKey"), + PROPERTY_VALUE((short)2, "propertyValue"), + DESCRIPTION((short)3, "description"); + + 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: // PROPERTY_KEY + return PROPERTY_KEY; + case 2: // PROPERTY_VALUE + return PROPERTY_VALUE; + case 3: // DESCRIPTION + return DESCRIPTION; + 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.PROPERTY_KEY, new org.apache.thrift.meta_data.FieldMetaData("propertyKey", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.PROPERTY_VALUE, new org.apache.thrift.meta_data.FieldMetaData("propertyValue", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.DESCRIPTION, new org.apache.thrift.meta_data.FieldMetaData("description", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(MetastoreDBProperty.class, metaDataMap); + } + + public MetastoreDBProperty() { + } + + public MetastoreDBProperty( + String propertyKey, + String propertyValue, + String description) + { + this(); + this.propertyKey = propertyKey; + this.propertyValue = propertyValue; + this.description = description; + } + + /** + * Performs a deep copy on other. + */ + public MetastoreDBProperty(MetastoreDBProperty other) { + if (other.isSetPropertyKey()) { + this.propertyKey = other.propertyKey; + } + if (other.isSetPropertyValue()) { + this.propertyValue = other.propertyValue; + } + if (other.isSetDescription()) { + this.description = other.description; + } + } + + public MetastoreDBProperty deepCopy() { + return new MetastoreDBProperty(this); + } + + @Override + public void clear() { + this.propertyKey = null; + this.propertyValue = null; + this.description = null; + } + + public String getPropertyKey() { + return this.propertyKey; + } + + public void setPropertyKey(String propertyKey) { + this.propertyKey = propertyKey; + } + + public void unsetPropertyKey() { + this.propertyKey = null; + } + + /** Returns true if field propertyKey is set (has been assigned a value) and false otherwise */ + public boolean isSetPropertyKey() { + return this.propertyKey != null; + } + + public void setPropertyKeyIsSet(boolean value) { + if (!value) { + this.propertyKey = null; + } + } + + public String getPropertyValue() { + return this.propertyValue; + } + + public void setPropertyValue(String propertyValue) { + this.propertyValue = propertyValue; + } + + public void unsetPropertyValue() { + this.propertyValue = null; + } + + /** Returns true if field propertyValue is set (has been assigned a value) and false otherwise */ + public boolean isSetPropertyValue() { + return this.propertyValue != null; + } + + public void setPropertyValueIsSet(boolean value) { + if (!value) { + this.propertyValue = null; + } + } + + public String getDescription() { + return this.description; + } + + public void setDescription(String description) { + this.description = description; + } + + public void unsetDescription() { + this.description = null; + } + + /** Returns true if field description is set (has been assigned a value) and false otherwise */ + public boolean isSetDescription() { + return this.description != null; + } + + public void setDescriptionIsSet(boolean value) { + if (!value) { + this.description = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case PROPERTY_KEY: + if (value == null) { + unsetPropertyKey(); + } else { + setPropertyKey((String)value); + } + break; + + case PROPERTY_VALUE: + if (value == null) { + unsetPropertyValue(); + } else { + setPropertyValue((String)value); + } + break; + + case DESCRIPTION: + if (value == null) { + unsetDescription(); + } else { + setDescription((String)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case PROPERTY_KEY: + return getPropertyKey(); + + case PROPERTY_VALUE: + return getPropertyValue(); + + case DESCRIPTION: + return getDescription(); + + } + 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 PROPERTY_KEY: + return isSetPropertyKey(); + case PROPERTY_VALUE: + return isSetPropertyValue(); + case DESCRIPTION: + return isSetDescription(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof MetastoreDBProperty) + return this.equals((MetastoreDBProperty)that); + return false; + } + + public boolean equals(MetastoreDBProperty that) { + if (that == null) + return false; + + boolean this_present_propertyKey = true && this.isSetPropertyKey(); + boolean that_present_propertyKey = true && that.isSetPropertyKey(); + if (this_present_propertyKey || that_present_propertyKey) { + if (!(this_present_propertyKey && that_present_propertyKey)) + return false; + if (!this.propertyKey.equals(that.propertyKey)) + return false; + } + + boolean this_present_propertyValue = true && this.isSetPropertyValue(); + boolean that_present_propertyValue = true && that.isSetPropertyValue(); + if (this_present_propertyValue || that_present_propertyValue) { + if (!(this_present_propertyValue && that_present_propertyValue)) + return false; + if (!this.propertyValue.equals(that.propertyValue)) + return false; + } + + boolean this_present_description = true && this.isSetDescription(); + boolean that_present_description = true && that.isSetDescription(); + if (this_present_description || that_present_description) { + if (!(this_present_description && that_present_description)) + return false; + if (!this.description.equals(that.description)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + boolean present_propertyKey = true && (isSetPropertyKey()); + list.add(present_propertyKey); + if (present_propertyKey) + list.add(propertyKey); + + boolean present_propertyValue = true && (isSetPropertyValue()); + list.add(present_propertyValue); + if (present_propertyValue) + list.add(propertyValue); + + boolean present_description = true && (isSetDescription()); + list.add(present_description); + if (present_description) + list.add(description); + + return list.hashCode(); + } + + @Override + public int compareTo(MetastoreDBProperty other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetPropertyKey()).compareTo(other.isSetPropertyKey()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPropertyKey()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.propertyKey, other.propertyKey); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetPropertyValue()).compareTo(other.isSetPropertyValue()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPropertyValue()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.propertyValue, other.propertyValue); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetDescription()).compareTo(other.isSetDescription()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetDescription()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.description, other.description); + 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("MetastoreDBProperty("); + boolean first = true; + + sb.append("propertyKey:"); + if (this.propertyKey == null) { + sb.append("null"); + } else { + sb.append(this.propertyKey); + } + first = false; + if (!first) sb.append(", "); + sb.append("propertyValue:"); + if (this.propertyValue == null) { + sb.append("null"); + } else { + sb.append(this.propertyValue); + } + first = false; + if (!first) sb.append(", "); + sb.append("description:"); + if (this.description == null) { + sb.append("null"); + } else { + sb.append(this.description); + } + 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 MetastoreDBPropertyStandardSchemeFactory implements SchemeFactory { + public MetastoreDBPropertyStandardScheme getScheme() { + return new MetastoreDBPropertyStandardScheme(); + } + } + + private static class MetastoreDBPropertyStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, MetastoreDBProperty 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: // PROPERTY_KEY + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.propertyKey = iprot.readString(); + struct.setPropertyKeyIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // PROPERTY_VALUE + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.propertyValue = iprot.readString(); + struct.setPropertyValueIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 3: // DESCRIPTION + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.description = iprot.readString(); + struct.setDescriptionIsSet(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, MetastoreDBProperty struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.propertyKey != null) { + oprot.writeFieldBegin(PROPERTY_KEY_FIELD_DESC); + oprot.writeString(struct.propertyKey); + oprot.writeFieldEnd(); + } + if (struct.propertyValue != null) { + oprot.writeFieldBegin(PROPERTY_VALUE_FIELD_DESC); + oprot.writeString(struct.propertyValue); + oprot.writeFieldEnd(); + } + if (struct.description != null) { + oprot.writeFieldBegin(DESCRIPTION_FIELD_DESC); + oprot.writeString(struct.description); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class MetastoreDBPropertyTupleSchemeFactory implements SchemeFactory { + public MetastoreDBPropertyTupleScheme getScheme() { + return new MetastoreDBPropertyTupleScheme(); + } + } + + private static class MetastoreDBPropertyTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, MetastoreDBProperty struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetPropertyKey()) { + optionals.set(0); + } + if (struct.isSetPropertyValue()) { + optionals.set(1); + } + if (struct.isSetDescription()) { + optionals.set(2); + } + oprot.writeBitSet(optionals, 3); + if (struct.isSetPropertyKey()) { + oprot.writeString(struct.propertyKey); + } + if (struct.isSetPropertyValue()) { + oprot.writeString(struct.propertyValue); + } + if (struct.isSetDescription()) { + oprot.writeString(struct.description); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, MetastoreDBProperty struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(3); + if (incoming.get(0)) { + struct.propertyKey = iprot.readString(); + struct.setPropertyKeyIsSet(true); + } + if (incoming.get(1)) { + struct.propertyValue = iprot.readString(); + struct.setPropertyValueIsSet(true); + } + if (incoming.get(2)) { + struct.description = iprot.readString(); + struct.setDescriptionIsSet(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 b7b7da728eff08a28b62a10ee6311faac59f6d36..e24065fdd65ce186dbf34fb1ae401ee156f68992 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 @@ -348,6 +348,8 @@ public CacheFileMetadataResult cache_file_metadata(CacheFileMetadataRequest req) throws org.apache.thrift.TException; + public String get_metastore_uuid() throws MetaException, org.apache.thrift.TException; + } public interface AsyncIface extends com.facebook.fb303.FacebookService .AsyncIface { @@ -658,6 +660,8 @@ public void cache_file_metadata(CacheFileMetadataRequest req, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void get_metastore_uuid(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + } public static class Client extends com.facebook.fb303.FacebookService.Client implements Iface { @@ -5082,6 +5086,31 @@ public CacheFileMetadataResult recv_cache_file_metadata() throws org.apache.thri throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "cache_file_metadata failed: unknown result"); } + public String get_metastore_uuid() throws MetaException, org.apache.thrift.TException + { + send_get_metastore_uuid(); + return recv_get_metastore_uuid(); + } + + public void send_get_metastore_uuid() throws org.apache.thrift.TException + { + get_metastore_uuid_args args = new get_metastore_uuid_args(); + sendBase("get_metastore_uuid", args); + } + + public String recv_get_metastore_uuid() throws MetaException, org.apache.thrift.TException + { + get_metastore_uuid_result result = new get_metastore_uuid_result(); + receiveBase(result, "get_metastore_uuid"); + if (result.isSetSuccess()) { + return result.success; + } + if (result.o1 != null) { + throw result.o1; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "get_metastore_uuid failed: unknown result"); + } + } public static class AsyncClient extends com.facebook.fb303.FacebookService.AsyncClient implements AsyncIface { public static class Factory implements org.apache.thrift.async.TAsyncClientFactory { @@ -10485,6 +10514,35 @@ public CacheFileMetadataResult getResult() throws org.apache.thrift.TException { } } + public void get_metastore_uuid(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + get_metastore_uuid_call method_call = new get_metastore_uuid_call(resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class get_metastore_uuid_call extends org.apache.thrift.async.TAsyncMethodCall { + public get_metastore_uuid_call(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); + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("get_metastore_uuid", org.apache.thrift.protocol.TMessageType.CALL, 0)); + get_metastore_uuid_args args = new get_metastore_uuid_args(); + args.write(prot); + prot.writeMessageEnd(); + } + + public String getResult() throws MetaException, org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_get_metastore_uuid(); + } + } + } public static class Processor extends com.facebook.fb303.FacebookService.Processor implements org.apache.thrift.TProcessor { @@ -10651,6 +10709,7 @@ protected Processor(I iface, Map extends org.apache.thrift.ProcessFunction { + public get_metastore_uuid() { + super("get_metastore_uuid"); + } + + public get_metastore_uuid_args getEmptyArgsInstance() { + return new get_metastore_uuid_args(); + } + + protected boolean isOneway() { + return false; + } + + public get_metastore_uuid_result getResult(I iface, get_metastore_uuid_args args) throws org.apache.thrift.TException { + get_metastore_uuid_result result = new get_metastore_uuid_result(); + try { + result.success = iface.get_metastore_uuid(); + } catch (MetaException o1) { + result.o1 = o1; + } + return result; + } + } + } public static class AsyncProcessor extends com.facebook.fb303.FacebookService.AsyncProcessor { @@ -14716,6 +14799,7 @@ protected AsyncProcessor(I iface, Map extends org.apache.thrift.AsyncProcessFunction { + public get_metastore_uuid() { + super("get_metastore_uuid"); + } + + public get_metastore_uuid_args getEmptyArgsInstance() { + return new get_metastore_uuid_args(); + } + + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback() { + public void onComplete(String o) { + get_metastore_uuid_result result = new get_metastore_uuid_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_metastore_uuid_result result = new get_metastore_uuid_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_metastore_uuid_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.get_metastore_uuid(resultHandler); + } + } + } public static class getMetaConf_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { @@ -176569,15 +176710,741 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class get_file_metadata_by_expr_argsStandardSchemeFactory implements SchemeFactory { - public get_file_metadata_by_expr_argsStandardScheme getScheme() { - return new get_file_metadata_by_expr_argsStandardScheme(); + private static class get_file_metadata_by_expr_argsStandardSchemeFactory implements SchemeFactory { + public get_file_metadata_by_expr_argsStandardScheme getScheme() { + return new get_file_metadata_by_expr_argsStandardScheme(); + } + } + + private static class get_file_metadata_by_expr_argsStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, get_file_metadata_by_expr_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 GetFileMetadataByExprRequest(); + 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, get_file_metadata_by_expr_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 get_file_metadata_by_expr_argsTupleSchemeFactory implements SchemeFactory { + public get_file_metadata_by_expr_argsTupleScheme getScheme() { + return new get_file_metadata_by_expr_argsTupleScheme(); + } + } + + private static class get_file_metadata_by_expr_argsTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, get_file_metadata_by_expr_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, get_file_metadata_by_expr_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.req = new GetFileMetadataByExprRequest(); + struct.req.read(iprot); + struct.setReqIsSet(true); + } + } + } + + } + + public static class get_file_metadata_by_expr_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("get_file_metadata_by_expr_result"); + + private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new get_file_metadata_by_expr_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new get_file_metadata_by_expr_resultTupleSchemeFactory()); + } + + private GetFileMetadataByExprResult success; // required + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + SUCCESS((short)0, "success"); + + private static final Map byName = new HashMap(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 0: // SUCCESS + return SUCCESS; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, GetFileMetadataByExprResult.class))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(get_file_metadata_by_expr_result.class, metaDataMap); + } + + public get_file_metadata_by_expr_result() { + } + + public get_file_metadata_by_expr_result( + GetFileMetadataByExprResult success) + { + this(); + this.success = success; + } + + /** + * Performs a deep copy on other. + */ + public get_file_metadata_by_expr_result(get_file_metadata_by_expr_result other) { + if (other.isSetSuccess()) { + this.success = new GetFileMetadataByExprResult(other.success); + } + } + + public get_file_metadata_by_expr_result deepCopy() { + return new get_file_metadata_by_expr_result(this); + } + + @Override + public void clear() { + this.success = null; + } + + public GetFileMetadataByExprResult getSuccess() { + return this.success; + } + + public void setSuccess(GetFileMetadataByExprResult success) { + this.success = success; + } + + public void unsetSuccess() { + this.success = null; + } + + /** Returns true if field success is set (has been assigned a value) and false otherwise */ + public boolean isSetSuccess() { + return this.success != null; + } + + public void setSuccessIsSet(boolean value) { + if (!value) { + this.success = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((GetFileMetadataByExprResult)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case SUCCESS: + return isSetSuccess(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof get_file_metadata_by_expr_result) + return this.equals((get_file_metadata_by_expr_result)that); + return false; + } + + public boolean equals(get_file_metadata_by_expr_result that) { + if (that == null) + return false; + + boolean this_present_success = true && this.isSetSuccess(); + boolean that_present_success = true && that.isSetSuccess(); + if (this_present_success || that_present_success) { + if (!(this_present_success && that_present_success)) + return false; + if (!this.success.equals(that.success)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + boolean present_success = true && (isSetSuccess()); + list.add(present_success); + if (present_success) + list.add(success); + + return list.hashCode(); + } + + @Override + public int compareTo(get_file_metadata_by_expr_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(other.isSetSuccess()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetSuccess()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("get_file_metadata_by_expr_result("); + boolean first = true; + + sb.append("success:"); + if (this.success == null) { + sb.append("null"); + } else { + sb.append(this.success); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + if (success != null) { + success.validate(); + } + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class get_file_metadata_by_expr_resultStandardSchemeFactory implements SchemeFactory { + public get_file_metadata_by_expr_resultStandardScheme getScheme() { + return new get_file_metadata_by_expr_resultStandardScheme(); + } + } + + private static class get_file_metadata_by_expr_resultStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, get_file_metadata_by_expr_result struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField schemeField; + iprot.readStructBegin(); + while (true) + { + schemeField = iprot.readFieldBegin(); + if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (schemeField.id) { + case 0: // SUCCESS + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.success = new GetFileMetadataByExprResult(); + struct.success.read(iprot); + struct.setSuccessIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + struct.validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot, get_file_metadata_by_expr_result struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.success != null) { + oprot.writeFieldBegin(SUCCESS_FIELD_DESC); + struct.success.write(oprot); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class get_file_metadata_by_expr_resultTupleSchemeFactory implements SchemeFactory { + public get_file_metadata_by_expr_resultTupleScheme getScheme() { + return new get_file_metadata_by_expr_resultTupleScheme(); + } + } + + private static class get_file_metadata_by_expr_resultTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, get_file_metadata_by_expr_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetSuccess()) { + struct.success.write(oprot); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, get_file_metadata_by_expr_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.success = new GetFileMetadataByExprResult(); + struct.success.read(iprot); + struct.setSuccessIsSet(true); + } + } + } + + } + + public static class get_file_metadata_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("get_file_metadata_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 get_file_metadata_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new get_file_metadata_argsTupleSchemeFactory()); + } + + private GetFileMetadataRequest 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, GetFileMetadataRequest.class))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(get_file_metadata_args.class, metaDataMap); + } + + public get_file_metadata_args() { + } + + public get_file_metadata_args( + GetFileMetadataRequest req) + { + this(); + this.req = req; + } + + /** + * Performs a deep copy on other. + */ + public get_file_metadata_args(get_file_metadata_args other) { + if (other.isSetReq()) { + this.req = new GetFileMetadataRequest(other.req); + } + } + + public get_file_metadata_args deepCopy() { + return new get_file_metadata_args(this); + } + + @Override + public void clear() { + this.req = null; + } + + public GetFileMetadataRequest getReq() { + return this.req; + } + + public void setReq(GetFileMetadataRequest 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((GetFileMetadataRequest)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 get_file_metadata_args) + return this.equals((get_file_metadata_args)that); + return false; + } + + public boolean equals(get_file_metadata_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(get_file_metadata_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("get_file_metadata_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 get_file_metadata_argsStandardSchemeFactory implements SchemeFactory { + public get_file_metadata_argsStandardScheme getScheme() { + return new get_file_metadata_argsStandardScheme(); } } - private static class get_file_metadata_by_expr_argsStandardScheme extends StandardScheme { + private static class get_file_metadata_argsStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, get_file_metadata_by_expr_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, get_file_metadata_args struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -176589,7 +177456,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_file_metadata_b switch (schemeField.id) { case 1: // REQ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.req = new GetFileMetadataByExprRequest(); + struct.req = new GetFileMetadataRequest(); struct.req.read(iprot); struct.setReqIsSet(true); } else { @@ -176605,7 +177472,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_file_metadata_b struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, get_file_metadata_by_expr_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, get_file_metadata_args struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -176620,16 +177487,16 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_file_metadata_ } - private static class get_file_metadata_by_expr_argsTupleSchemeFactory implements SchemeFactory { - public get_file_metadata_by_expr_argsTupleScheme getScheme() { - return new get_file_metadata_by_expr_argsTupleScheme(); + private static class get_file_metadata_argsTupleSchemeFactory implements SchemeFactory { + public get_file_metadata_argsTupleScheme getScheme() { + return new get_file_metadata_argsTupleScheme(); } } - private static class get_file_metadata_by_expr_argsTupleScheme extends TupleScheme { + private static class get_file_metadata_argsTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, get_file_metadata_by_expr_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, get_file_metadata_args struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetReq()) { @@ -176642,11 +177509,11 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_file_metadata_b } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, get_file_metadata_by_expr_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, get_file_metadata_args struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { - struct.req = new GetFileMetadataByExprRequest(); + struct.req = new GetFileMetadataRequest(); struct.req.read(iprot); struct.setReqIsSet(true); } @@ -176655,18 +177522,18 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_file_metadata_by } - public static class get_file_metadata_by_expr_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("get_file_metadata_by_expr_result"); + public static class get_file_metadata_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("get_file_metadata_result"); private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0); private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { - schemes.put(StandardScheme.class, new get_file_metadata_by_expr_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new get_file_metadata_by_expr_resultTupleSchemeFactory()); + schemes.put(StandardScheme.class, new get_file_metadata_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new get_file_metadata_resultTupleSchemeFactory()); } - private GetFileMetadataByExprResult success; // required + private GetFileMetadataResult success; // 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 { @@ -176731,16 +177598,16 @@ public String getFieldName() { static { Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, GetFileMetadataByExprResult.class))); + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, GetFileMetadataResult.class))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(get_file_metadata_by_expr_result.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(get_file_metadata_result.class, metaDataMap); } - public get_file_metadata_by_expr_result() { + public get_file_metadata_result() { } - public get_file_metadata_by_expr_result( - GetFileMetadataByExprResult success) + public get_file_metadata_result( + GetFileMetadataResult success) { this(); this.success = success; @@ -176749,14 +177616,14 @@ public get_file_metadata_by_expr_result( /** * Performs a deep copy on other. */ - public get_file_metadata_by_expr_result(get_file_metadata_by_expr_result other) { + public get_file_metadata_result(get_file_metadata_result other) { if (other.isSetSuccess()) { - this.success = new GetFileMetadataByExprResult(other.success); + this.success = new GetFileMetadataResult(other.success); } } - public get_file_metadata_by_expr_result deepCopy() { - return new get_file_metadata_by_expr_result(this); + public get_file_metadata_result deepCopy() { + return new get_file_metadata_result(this); } @Override @@ -176764,11 +177631,11 @@ public void clear() { this.success = null; } - public GetFileMetadataByExprResult getSuccess() { + public GetFileMetadataResult getSuccess() { return this.success; } - public void setSuccess(GetFileMetadataByExprResult success) { + public void setSuccess(GetFileMetadataResult success) { this.success = success; } @@ -176793,7 +177660,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetSuccess(); } else { - setSuccess((GetFileMetadataByExprResult)value); + setSuccess((GetFileMetadataResult)value); } break; @@ -176826,12 +177693,12 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof get_file_metadata_by_expr_result) - return this.equals((get_file_metadata_by_expr_result)that); + if (that instanceof get_file_metadata_result) + return this.equals((get_file_metadata_result)that); return false; } - public boolean equals(get_file_metadata_by_expr_result that) { + public boolean equals(get_file_metadata_result that) { if (that == null) return false; @@ -176860,7 +177727,7 @@ public int hashCode() { } @Override - public int compareTo(get_file_metadata_by_expr_result other) { + public int compareTo(get_file_metadata_result other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -176894,7 +177761,7 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("get_file_metadata_by_expr_result("); + StringBuilder sb = new StringBuilder("get_file_metadata_result("); boolean first = true; sb.append("success:"); @@ -176932,15 +177799,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class get_file_metadata_by_expr_resultStandardSchemeFactory implements SchemeFactory { - public get_file_metadata_by_expr_resultStandardScheme getScheme() { - return new get_file_metadata_by_expr_resultStandardScheme(); + private static class get_file_metadata_resultStandardSchemeFactory implements SchemeFactory { + public get_file_metadata_resultStandardScheme getScheme() { + return new get_file_metadata_resultStandardScheme(); } } - private static class get_file_metadata_by_expr_resultStandardScheme extends StandardScheme { + private static class get_file_metadata_resultStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, get_file_metadata_by_expr_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, get_file_metadata_result struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -176952,7 +177819,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_file_metadata_b switch (schemeField.id) { case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.success = new GetFileMetadataByExprResult(); + struct.success = new GetFileMetadataResult(); struct.success.read(iprot); struct.setSuccessIsSet(true); } else { @@ -176968,7 +177835,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_file_metadata_b struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, get_file_metadata_by_expr_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, get_file_metadata_result struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -176983,16 +177850,16 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_file_metadata_ } - private static class get_file_metadata_by_expr_resultTupleSchemeFactory implements SchemeFactory { - public get_file_metadata_by_expr_resultTupleScheme getScheme() { - return new get_file_metadata_by_expr_resultTupleScheme(); + private static class get_file_metadata_resultTupleSchemeFactory implements SchemeFactory { + public get_file_metadata_resultTupleScheme getScheme() { + return new get_file_metadata_resultTupleScheme(); } } - private static class get_file_metadata_by_expr_resultTupleScheme extends TupleScheme { + private static class get_file_metadata_resultTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, get_file_metadata_by_expr_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, get_file_metadata_result struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetSuccess()) { @@ -177005,11 +177872,11 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_file_metadata_b } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, get_file_metadata_by_expr_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, get_file_metadata_result struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { - struct.success = new GetFileMetadataByExprResult(); + struct.success = new GetFileMetadataResult(); struct.success.read(iprot); struct.setSuccessIsSet(true); } @@ -177018,18 +177885,18 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_file_metadata_by } - public static class get_file_metadata_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("get_file_metadata_args"); + public static class put_file_metadata_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("put_file_metadata_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 get_file_metadata_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new get_file_metadata_argsTupleSchemeFactory()); + schemes.put(StandardScheme.class, new put_file_metadata_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new put_file_metadata_argsTupleSchemeFactory()); } - private GetFileMetadataRequest req; // required + private PutFileMetadataRequest 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 { @@ -177094,16 +177961,16 @@ public String getFieldName() { static { Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); tmpMap.put(_Fields.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, GetFileMetadataRequest.class))); + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, PutFileMetadataRequest.class))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(get_file_metadata_args.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(put_file_metadata_args.class, metaDataMap); } - public get_file_metadata_args() { + public put_file_metadata_args() { } - public get_file_metadata_args( - GetFileMetadataRequest req) + public put_file_metadata_args( + PutFileMetadataRequest req) { this(); this.req = req; @@ -177112,14 +177979,14 @@ public get_file_metadata_args( /** * Performs a deep copy on other. */ - public get_file_metadata_args(get_file_metadata_args other) { + public put_file_metadata_args(put_file_metadata_args other) { if (other.isSetReq()) { - this.req = new GetFileMetadataRequest(other.req); + this.req = new PutFileMetadataRequest(other.req); } } - public get_file_metadata_args deepCopy() { - return new get_file_metadata_args(this); + public put_file_metadata_args deepCopy() { + return new put_file_metadata_args(this); } @Override @@ -177127,11 +177994,11 @@ public void clear() { this.req = null; } - public GetFileMetadataRequest getReq() { + public PutFileMetadataRequest getReq() { return this.req; } - public void setReq(GetFileMetadataRequest req) { + public void setReq(PutFileMetadataRequest req) { this.req = req; } @@ -177156,7 +178023,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetReq(); } else { - setReq((GetFileMetadataRequest)value); + setReq((PutFileMetadataRequest)value); } break; @@ -177189,12 +178056,12 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof get_file_metadata_args) - return this.equals((get_file_metadata_args)that); + if (that instanceof put_file_metadata_args) + return this.equals((put_file_metadata_args)that); return false; } - public boolean equals(get_file_metadata_args that) { + public boolean equals(put_file_metadata_args that) { if (that == null) return false; @@ -177223,7 +178090,7 @@ public int hashCode() { } @Override - public int compareTo(get_file_metadata_args other) { + public int compareTo(put_file_metadata_args other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -177257,7 +178124,7 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("get_file_metadata_args("); + StringBuilder sb = new StringBuilder("put_file_metadata_args("); boolean first = true; sb.append("req:"); @@ -177295,15 +178162,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class get_file_metadata_argsStandardSchemeFactory implements SchemeFactory { - public get_file_metadata_argsStandardScheme getScheme() { - return new get_file_metadata_argsStandardScheme(); + private static class put_file_metadata_argsStandardSchemeFactory implements SchemeFactory { + public put_file_metadata_argsStandardScheme getScheme() { + return new put_file_metadata_argsStandardScheme(); } } - private static class get_file_metadata_argsStandardScheme extends StandardScheme { + private static class put_file_metadata_argsStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, get_file_metadata_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, put_file_metadata_args struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -177315,7 +178182,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_file_metadata_a switch (schemeField.id) { case 1: // REQ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.req = new GetFileMetadataRequest(); + struct.req = new PutFileMetadataRequest(); struct.req.read(iprot); struct.setReqIsSet(true); } else { @@ -177331,7 +178198,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_file_metadata_a struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, get_file_metadata_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, put_file_metadata_args struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -177346,16 +178213,16 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_file_metadata_ } - private static class get_file_metadata_argsTupleSchemeFactory implements SchemeFactory { - public get_file_metadata_argsTupleScheme getScheme() { - return new get_file_metadata_argsTupleScheme(); + private static class put_file_metadata_argsTupleSchemeFactory implements SchemeFactory { + public put_file_metadata_argsTupleScheme getScheme() { + return new put_file_metadata_argsTupleScheme(); } } - private static class get_file_metadata_argsTupleScheme extends TupleScheme { + private static class put_file_metadata_argsTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, get_file_metadata_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, put_file_metadata_args struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetReq()) { @@ -177368,11 +178235,11 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_file_metadata_a } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, get_file_metadata_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, put_file_metadata_args struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { - struct.req = new GetFileMetadataRequest(); + struct.req = new PutFileMetadataRequest(); struct.req.read(iprot); struct.setReqIsSet(true); } @@ -177381,18 +178248,18 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_file_metadata_ar } - public static class get_file_metadata_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("get_file_metadata_result"); + public static class put_file_metadata_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("put_file_metadata_result"); private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0); private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { - schemes.put(StandardScheme.class, new get_file_metadata_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new get_file_metadata_resultTupleSchemeFactory()); + schemes.put(StandardScheme.class, new put_file_metadata_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new put_file_metadata_resultTupleSchemeFactory()); } - private GetFileMetadataResult success; // required + private PutFileMetadataResult success; // 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 { @@ -177457,16 +178324,16 @@ public String getFieldName() { static { Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, GetFileMetadataResult.class))); + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, PutFileMetadataResult.class))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(get_file_metadata_result.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(put_file_metadata_result.class, metaDataMap); } - public get_file_metadata_result() { + public put_file_metadata_result() { } - public get_file_metadata_result( - GetFileMetadataResult success) + public put_file_metadata_result( + PutFileMetadataResult success) { this(); this.success = success; @@ -177475,14 +178342,14 @@ public get_file_metadata_result( /** * Performs a deep copy on other. */ - public get_file_metadata_result(get_file_metadata_result other) { + public put_file_metadata_result(put_file_metadata_result other) { if (other.isSetSuccess()) { - this.success = new GetFileMetadataResult(other.success); + this.success = new PutFileMetadataResult(other.success); } } - public get_file_metadata_result deepCopy() { - return new get_file_metadata_result(this); + public put_file_metadata_result deepCopy() { + return new put_file_metadata_result(this); } @Override @@ -177490,11 +178357,11 @@ public void clear() { this.success = null; } - public GetFileMetadataResult getSuccess() { + public PutFileMetadataResult getSuccess() { return this.success; } - public void setSuccess(GetFileMetadataResult success) { + public void setSuccess(PutFileMetadataResult success) { this.success = success; } @@ -177519,7 +178386,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetSuccess(); } else { - setSuccess((GetFileMetadataResult)value); + setSuccess((PutFileMetadataResult)value); } break; @@ -177552,12 +178419,12 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof get_file_metadata_result) - return this.equals((get_file_metadata_result)that); + if (that instanceof put_file_metadata_result) + return this.equals((put_file_metadata_result)that); return false; } - public boolean equals(get_file_metadata_result that) { + public boolean equals(put_file_metadata_result that) { if (that == null) return false; @@ -177586,7 +178453,7 @@ public int hashCode() { } @Override - public int compareTo(get_file_metadata_result other) { + public int compareTo(put_file_metadata_result other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -177620,7 +178487,7 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("get_file_metadata_result("); + StringBuilder sb = new StringBuilder("put_file_metadata_result("); boolean first = true; sb.append("success:"); @@ -177658,15 +178525,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class get_file_metadata_resultStandardSchemeFactory implements SchemeFactory { - public get_file_metadata_resultStandardScheme getScheme() { - return new get_file_metadata_resultStandardScheme(); + private static class put_file_metadata_resultStandardSchemeFactory implements SchemeFactory { + public put_file_metadata_resultStandardScheme getScheme() { + return new put_file_metadata_resultStandardScheme(); } } - private static class get_file_metadata_resultStandardScheme extends StandardScheme { + private static class put_file_metadata_resultStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, get_file_metadata_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, put_file_metadata_result struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -177678,7 +178545,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_file_metadata_r switch (schemeField.id) { case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.success = new GetFileMetadataResult(); + struct.success = new PutFileMetadataResult(); struct.success.read(iprot); struct.setSuccessIsSet(true); } else { @@ -177694,7 +178561,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_file_metadata_r struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, get_file_metadata_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, put_file_metadata_result struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -177709,16 +178576,16 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_file_metadata_ } - private static class get_file_metadata_resultTupleSchemeFactory implements SchemeFactory { - public get_file_metadata_resultTupleScheme getScheme() { - return new get_file_metadata_resultTupleScheme(); + private static class put_file_metadata_resultTupleSchemeFactory implements SchemeFactory { + public put_file_metadata_resultTupleScheme getScheme() { + return new put_file_metadata_resultTupleScheme(); } } - private static class get_file_metadata_resultTupleScheme extends TupleScheme { + private static class put_file_metadata_resultTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, get_file_metadata_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, put_file_metadata_result struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetSuccess()) { @@ -177731,11 +178598,11 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_file_metadata_r } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, get_file_metadata_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, put_file_metadata_result struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { - struct.success = new GetFileMetadataResult(); + struct.success = new PutFileMetadataResult(); struct.success.read(iprot); struct.setSuccessIsSet(true); } @@ -177744,18 +178611,18 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_file_metadata_re } - public static class put_file_metadata_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("put_file_metadata_args"); + public static class clear_file_metadata_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("clear_file_metadata_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 put_file_metadata_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new put_file_metadata_argsTupleSchemeFactory()); + schemes.put(StandardScheme.class, new clear_file_metadata_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new clear_file_metadata_argsTupleSchemeFactory()); } - private PutFileMetadataRequest req; // required + private ClearFileMetadataRequest 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 { @@ -177820,16 +178687,16 @@ public String getFieldName() { static { Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); tmpMap.put(_Fields.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, PutFileMetadataRequest.class))); + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, ClearFileMetadataRequest.class))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(put_file_metadata_args.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(clear_file_metadata_args.class, metaDataMap); } - public put_file_metadata_args() { + public clear_file_metadata_args() { } - public put_file_metadata_args( - PutFileMetadataRequest req) + public clear_file_metadata_args( + ClearFileMetadataRequest req) { this(); this.req = req; @@ -177838,14 +178705,14 @@ public put_file_metadata_args( /** * Performs a deep copy on other. */ - public put_file_metadata_args(put_file_metadata_args other) { + public clear_file_metadata_args(clear_file_metadata_args other) { if (other.isSetReq()) { - this.req = new PutFileMetadataRequest(other.req); + this.req = new ClearFileMetadataRequest(other.req); } } - public put_file_metadata_args deepCopy() { - return new put_file_metadata_args(this); + public clear_file_metadata_args deepCopy() { + return new clear_file_metadata_args(this); } @Override @@ -177853,11 +178720,11 @@ public void clear() { this.req = null; } - public PutFileMetadataRequest getReq() { + public ClearFileMetadataRequest getReq() { return this.req; } - public void setReq(PutFileMetadataRequest req) { + public void setReq(ClearFileMetadataRequest req) { this.req = req; } @@ -177882,7 +178749,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetReq(); } else { - setReq((PutFileMetadataRequest)value); + setReq((ClearFileMetadataRequest)value); } break; @@ -177915,12 +178782,12 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof put_file_metadata_args) - return this.equals((put_file_metadata_args)that); + if (that instanceof clear_file_metadata_args) + return this.equals((clear_file_metadata_args)that); return false; } - public boolean equals(put_file_metadata_args that) { + public boolean equals(clear_file_metadata_args that) { if (that == null) return false; @@ -177949,7 +178816,7 @@ public int hashCode() { } @Override - public int compareTo(put_file_metadata_args other) { + public int compareTo(clear_file_metadata_args other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -177983,7 +178850,7 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("put_file_metadata_args("); + StringBuilder sb = new StringBuilder("clear_file_metadata_args("); boolean first = true; sb.append("req:"); @@ -178021,15 +178888,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class put_file_metadata_argsStandardSchemeFactory implements SchemeFactory { - public put_file_metadata_argsStandardScheme getScheme() { - return new put_file_metadata_argsStandardScheme(); + private static class clear_file_metadata_argsStandardSchemeFactory implements SchemeFactory { + public clear_file_metadata_argsStandardScheme getScheme() { + return new clear_file_metadata_argsStandardScheme(); } } - private static class put_file_metadata_argsStandardScheme extends StandardScheme { + private static class clear_file_metadata_argsStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, put_file_metadata_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, clear_file_metadata_args struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -178041,7 +178908,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, put_file_metadata_a switch (schemeField.id) { case 1: // REQ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.req = new PutFileMetadataRequest(); + struct.req = new ClearFileMetadataRequest(); struct.req.read(iprot); struct.setReqIsSet(true); } else { @@ -178057,7 +178924,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, put_file_metadata_a struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, put_file_metadata_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, clear_file_metadata_args struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -178072,16 +178939,16 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, put_file_metadata_ } - private static class put_file_metadata_argsTupleSchemeFactory implements SchemeFactory { - public put_file_metadata_argsTupleScheme getScheme() { - return new put_file_metadata_argsTupleScheme(); + private static class clear_file_metadata_argsTupleSchemeFactory implements SchemeFactory { + public clear_file_metadata_argsTupleScheme getScheme() { + return new clear_file_metadata_argsTupleScheme(); } } - private static class put_file_metadata_argsTupleScheme extends TupleScheme { + private static class clear_file_metadata_argsTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, put_file_metadata_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, clear_file_metadata_args struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetReq()) { @@ -178094,11 +178961,11 @@ public void write(org.apache.thrift.protocol.TProtocol prot, put_file_metadata_a } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, put_file_metadata_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, clear_file_metadata_args struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { - struct.req = new PutFileMetadataRequest(); + struct.req = new ClearFileMetadataRequest(); struct.req.read(iprot); struct.setReqIsSet(true); } @@ -178107,18 +178974,18 @@ public void read(org.apache.thrift.protocol.TProtocol prot, put_file_metadata_ar } - public static class put_file_metadata_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("put_file_metadata_result"); + public static class clear_file_metadata_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("clear_file_metadata_result"); private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0); private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { - schemes.put(StandardScheme.class, new put_file_metadata_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new put_file_metadata_resultTupleSchemeFactory()); + schemes.put(StandardScheme.class, new clear_file_metadata_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new clear_file_metadata_resultTupleSchemeFactory()); } - private PutFileMetadataResult success; // required + private ClearFileMetadataResult success; // 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 { @@ -178183,16 +179050,16 @@ public String getFieldName() { static { Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, PutFileMetadataResult.class))); + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, ClearFileMetadataResult.class))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(put_file_metadata_result.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(clear_file_metadata_result.class, metaDataMap); } - public put_file_metadata_result() { + public clear_file_metadata_result() { } - public put_file_metadata_result( - PutFileMetadataResult success) + public clear_file_metadata_result( + ClearFileMetadataResult success) { this(); this.success = success; @@ -178201,14 +179068,14 @@ public put_file_metadata_result( /** * Performs a deep copy on other. */ - public put_file_metadata_result(put_file_metadata_result other) { + public clear_file_metadata_result(clear_file_metadata_result other) { if (other.isSetSuccess()) { - this.success = new PutFileMetadataResult(other.success); + this.success = new ClearFileMetadataResult(other.success); } } - public put_file_metadata_result deepCopy() { - return new put_file_metadata_result(this); + public clear_file_metadata_result deepCopy() { + return new clear_file_metadata_result(this); } @Override @@ -178216,11 +179083,11 @@ public void clear() { this.success = null; } - public PutFileMetadataResult getSuccess() { + public ClearFileMetadataResult getSuccess() { return this.success; } - public void setSuccess(PutFileMetadataResult success) { + public void setSuccess(ClearFileMetadataResult success) { this.success = success; } @@ -178245,7 +179112,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetSuccess(); } else { - setSuccess((PutFileMetadataResult)value); + setSuccess((ClearFileMetadataResult)value); } break; @@ -178278,12 +179145,12 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof put_file_metadata_result) - return this.equals((put_file_metadata_result)that); + if (that instanceof clear_file_metadata_result) + return this.equals((clear_file_metadata_result)that); return false; } - public boolean equals(put_file_metadata_result that) { + public boolean equals(clear_file_metadata_result that) { if (that == null) return false; @@ -178312,7 +179179,7 @@ public int hashCode() { } @Override - public int compareTo(put_file_metadata_result other) { + public int compareTo(clear_file_metadata_result other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -178346,7 +179213,7 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("put_file_metadata_result("); + StringBuilder sb = new StringBuilder("clear_file_metadata_result("); boolean first = true; sb.append("success:"); @@ -178384,15 +179251,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class put_file_metadata_resultStandardSchemeFactory implements SchemeFactory { - public put_file_metadata_resultStandardScheme getScheme() { - return new put_file_metadata_resultStandardScheme(); + private static class clear_file_metadata_resultStandardSchemeFactory implements SchemeFactory { + public clear_file_metadata_resultStandardScheme getScheme() { + return new clear_file_metadata_resultStandardScheme(); } } - private static class put_file_metadata_resultStandardScheme extends StandardScheme { + private static class clear_file_metadata_resultStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, put_file_metadata_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, clear_file_metadata_result struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -178404,7 +179271,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, put_file_metadata_r switch (schemeField.id) { case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.success = new PutFileMetadataResult(); + struct.success = new ClearFileMetadataResult(); struct.success.read(iprot); struct.setSuccessIsSet(true); } else { @@ -178420,7 +179287,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, put_file_metadata_r struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, put_file_metadata_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, clear_file_metadata_result struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -178435,16 +179302,16 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, put_file_metadata_ } - private static class put_file_metadata_resultTupleSchemeFactory implements SchemeFactory { - public put_file_metadata_resultTupleScheme getScheme() { - return new put_file_metadata_resultTupleScheme(); + private static class clear_file_metadata_resultTupleSchemeFactory implements SchemeFactory { + public clear_file_metadata_resultTupleScheme getScheme() { + return new clear_file_metadata_resultTupleScheme(); } } - private static class put_file_metadata_resultTupleScheme extends TupleScheme { + private static class clear_file_metadata_resultTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, put_file_metadata_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, clear_file_metadata_result struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetSuccess()) { @@ -178457,11 +179324,11 @@ public void write(org.apache.thrift.protocol.TProtocol prot, put_file_metadata_r } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, put_file_metadata_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, clear_file_metadata_result struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { - struct.success = new PutFileMetadataResult(); + struct.success = new ClearFileMetadataResult(); struct.success.read(iprot); struct.setSuccessIsSet(true); } @@ -178470,18 +179337,18 @@ public void read(org.apache.thrift.protocol.TProtocol prot, put_file_metadata_re } - public static class clear_file_metadata_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("clear_file_metadata_args"); + public static class cache_file_metadata_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("cache_file_metadata_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 clear_file_metadata_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new clear_file_metadata_argsTupleSchemeFactory()); + schemes.put(StandardScheme.class, new cache_file_metadata_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new cache_file_metadata_argsTupleSchemeFactory()); } - private ClearFileMetadataRequest req; // required + private CacheFileMetadataRequest 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 { @@ -178546,16 +179413,16 @@ public String getFieldName() { static { Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); tmpMap.put(_Fields.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, ClearFileMetadataRequest.class))); + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, CacheFileMetadataRequest.class))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(clear_file_metadata_args.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(cache_file_metadata_args.class, metaDataMap); } - public clear_file_metadata_args() { + public cache_file_metadata_args() { } - public clear_file_metadata_args( - ClearFileMetadataRequest req) + public cache_file_metadata_args( + CacheFileMetadataRequest req) { this(); this.req = req; @@ -178564,14 +179431,14 @@ public clear_file_metadata_args( /** * Performs a deep copy on other. */ - public clear_file_metadata_args(clear_file_metadata_args other) { + public cache_file_metadata_args(cache_file_metadata_args other) { if (other.isSetReq()) { - this.req = new ClearFileMetadataRequest(other.req); + this.req = new CacheFileMetadataRequest(other.req); } } - public clear_file_metadata_args deepCopy() { - return new clear_file_metadata_args(this); + public cache_file_metadata_args deepCopy() { + return new cache_file_metadata_args(this); } @Override @@ -178579,11 +179446,11 @@ public void clear() { this.req = null; } - public ClearFileMetadataRequest getReq() { + public CacheFileMetadataRequest getReq() { return this.req; } - public void setReq(ClearFileMetadataRequest req) { + public void setReq(CacheFileMetadataRequest req) { this.req = req; } @@ -178608,7 +179475,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetReq(); } else { - setReq((ClearFileMetadataRequest)value); + setReq((CacheFileMetadataRequest)value); } break; @@ -178641,12 +179508,12 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof clear_file_metadata_args) - return this.equals((clear_file_metadata_args)that); + if (that instanceof cache_file_metadata_args) + return this.equals((cache_file_metadata_args)that); return false; } - public boolean equals(clear_file_metadata_args that) { + public boolean equals(cache_file_metadata_args that) { if (that == null) return false; @@ -178675,7 +179542,7 @@ public int hashCode() { } @Override - public int compareTo(clear_file_metadata_args other) { + public int compareTo(cache_file_metadata_args other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -178709,7 +179576,7 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("clear_file_metadata_args("); + StringBuilder sb = new StringBuilder("cache_file_metadata_args("); boolean first = true; sb.append("req:"); @@ -178747,15 +179614,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class clear_file_metadata_argsStandardSchemeFactory implements SchemeFactory { - public clear_file_metadata_argsStandardScheme getScheme() { - return new clear_file_metadata_argsStandardScheme(); + private static class cache_file_metadata_argsStandardSchemeFactory implements SchemeFactory { + public cache_file_metadata_argsStandardScheme getScheme() { + return new cache_file_metadata_argsStandardScheme(); } } - private static class clear_file_metadata_argsStandardScheme extends StandardScheme { + private static class cache_file_metadata_argsStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, clear_file_metadata_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, cache_file_metadata_args struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -178767,7 +179634,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, clear_file_metadata switch (schemeField.id) { case 1: // REQ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.req = new ClearFileMetadataRequest(); + struct.req = new CacheFileMetadataRequest(); struct.req.read(iprot); struct.setReqIsSet(true); } else { @@ -178783,7 +179650,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, clear_file_metadata struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, clear_file_metadata_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, cache_file_metadata_args struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -178798,16 +179665,16 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, clear_file_metadat } - private static class clear_file_metadata_argsTupleSchemeFactory implements SchemeFactory { - public clear_file_metadata_argsTupleScheme getScheme() { - return new clear_file_metadata_argsTupleScheme(); + private static class cache_file_metadata_argsTupleSchemeFactory implements SchemeFactory { + public cache_file_metadata_argsTupleScheme getScheme() { + return new cache_file_metadata_argsTupleScheme(); } } - private static class clear_file_metadata_argsTupleScheme extends TupleScheme { + private static class cache_file_metadata_argsTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, clear_file_metadata_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, cache_file_metadata_args struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetReq()) { @@ -178820,11 +179687,11 @@ public void write(org.apache.thrift.protocol.TProtocol prot, clear_file_metadata } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, clear_file_metadata_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, cache_file_metadata_args struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { - struct.req = new ClearFileMetadataRequest(); + struct.req = new CacheFileMetadataRequest(); struct.req.read(iprot); struct.setReqIsSet(true); } @@ -178833,18 +179700,18 @@ public void read(org.apache.thrift.protocol.TProtocol prot, clear_file_metadata_ } - public static class clear_file_metadata_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("clear_file_metadata_result"); + public static class cache_file_metadata_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("cache_file_metadata_result"); private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0); private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { - schemes.put(StandardScheme.class, new clear_file_metadata_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new clear_file_metadata_resultTupleSchemeFactory()); + schemes.put(StandardScheme.class, new cache_file_metadata_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new cache_file_metadata_resultTupleSchemeFactory()); } - private ClearFileMetadataResult success; // required + private CacheFileMetadataResult success; // 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 { @@ -178909,16 +179776,16 @@ public String getFieldName() { static { Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, ClearFileMetadataResult.class))); + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, CacheFileMetadataResult.class))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(clear_file_metadata_result.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(cache_file_metadata_result.class, metaDataMap); } - public clear_file_metadata_result() { + public cache_file_metadata_result() { } - public clear_file_metadata_result( - ClearFileMetadataResult success) + public cache_file_metadata_result( + CacheFileMetadataResult success) { this(); this.success = success; @@ -178927,14 +179794,14 @@ public clear_file_metadata_result( /** * Performs a deep copy on other. */ - public clear_file_metadata_result(clear_file_metadata_result other) { + public cache_file_metadata_result(cache_file_metadata_result other) { if (other.isSetSuccess()) { - this.success = new ClearFileMetadataResult(other.success); + this.success = new CacheFileMetadataResult(other.success); } } - public clear_file_metadata_result deepCopy() { - return new clear_file_metadata_result(this); + public cache_file_metadata_result deepCopy() { + return new cache_file_metadata_result(this); } @Override @@ -178942,11 +179809,11 @@ public void clear() { this.success = null; } - public ClearFileMetadataResult getSuccess() { + public CacheFileMetadataResult getSuccess() { return this.success; } - public void setSuccess(ClearFileMetadataResult success) { + public void setSuccess(CacheFileMetadataResult success) { this.success = success; } @@ -178971,7 +179838,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetSuccess(); } else { - setSuccess((ClearFileMetadataResult)value); + setSuccess((CacheFileMetadataResult)value); } break; @@ -179004,12 +179871,12 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof clear_file_metadata_result) - return this.equals((clear_file_metadata_result)that); + if (that instanceof cache_file_metadata_result) + return this.equals((cache_file_metadata_result)that); return false; } - public boolean equals(clear_file_metadata_result that) { + public boolean equals(cache_file_metadata_result that) { if (that == null) return false; @@ -179038,7 +179905,7 @@ public int hashCode() { } @Override - public int compareTo(clear_file_metadata_result other) { + public int compareTo(cache_file_metadata_result other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -179072,7 +179939,7 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("clear_file_metadata_result("); + StringBuilder sb = new StringBuilder("cache_file_metadata_result("); boolean first = true; sb.append("success:"); @@ -179110,15 +179977,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class clear_file_metadata_resultStandardSchemeFactory implements SchemeFactory { - public clear_file_metadata_resultStandardScheme getScheme() { - return new clear_file_metadata_resultStandardScheme(); + private static class cache_file_metadata_resultStandardSchemeFactory implements SchemeFactory { + public cache_file_metadata_resultStandardScheme getScheme() { + return new cache_file_metadata_resultStandardScheme(); } } - private static class clear_file_metadata_resultStandardScheme extends StandardScheme { + private static class cache_file_metadata_resultStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, clear_file_metadata_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, cache_file_metadata_result struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -179130,7 +179997,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, clear_file_metadata switch (schemeField.id) { case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.success = new ClearFileMetadataResult(); + struct.success = new CacheFileMetadataResult(); struct.success.read(iprot); struct.setSuccessIsSet(true); } else { @@ -179146,7 +180013,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, clear_file_metadata struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, clear_file_metadata_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, cache_file_metadata_result struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -179161,16 +180028,16 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, clear_file_metadat } - private static class clear_file_metadata_resultTupleSchemeFactory implements SchemeFactory { - public clear_file_metadata_resultTupleScheme getScheme() { - return new clear_file_metadata_resultTupleScheme(); + private static class cache_file_metadata_resultTupleSchemeFactory implements SchemeFactory { + public cache_file_metadata_resultTupleScheme getScheme() { + return new cache_file_metadata_resultTupleScheme(); } } - private static class clear_file_metadata_resultTupleScheme extends TupleScheme { + private static class cache_file_metadata_resultTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, clear_file_metadata_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, cache_file_metadata_result struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetSuccess()) { @@ -179183,11 +180050,11 @@ public void write(org.apache.thrift.protocol.TProtocol prot, clear_file_metadata } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, clear_file_metadata_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, cache_file_metadata_result struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { - struct.success = new ClearFileMetadataResult(); + struct.success = new CacheFileMetadataResult(); struct.success.read(iprot); struct.setSuccessIsSet(true); } @@ -179196,22 +180063,20 @@ public void read(org.apache.thrift.protocol.TProtocol prot, clear_file_metadata_ } - public static class cache_file_metadata_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("cache_file_metadata_args"); + public static class get_metastore_uuid_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("get_metastore_uuid_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 cache_file_metadata_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new cache_file_metadata_argsTupleSchemeFactory()); + schemes.put(StandardScheme.class, new get_metastore_uuid_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new get_metastore_uuid_argsTupleSchemeFactory()); } - private CacheFileMetadataRequest 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(); @@ -179226,8 +180091,6 @@ public void read(org.apache.thrift.protocol.TProtocol prot, clear_file_metadata_ */ public static _Fields findByThriftId(int fieldId) { switch(fieldId) { - case 1: // REQ - return REQ; default: return null; } @@ -179266,86 +180129,37 @@ 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, CacheFileMetadataRequest.class))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(cache_file_metadata_args.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(get_metastore_uuid_args.class, metaDataMap); } - public cache_file_metadata_args() { - } - - public cache_file_metadata_args( - CacheFileMetadataRequest req) - { - this(); - this.req = req; + public get_metastore_uuid_args() { } /** * Performs a deep copy on other. */ - public cache_file_metadata_args(cache_file_metadata_args other) { - if (other.isSetReq()) { - this.req = new CacheFileMetadataRequest(other.req); - } + public get_metastore_uuid_args(get_metastore_uuid_args other) { } - public cache_file_metadata_args deepCopy() { - return new cache_file_metadata_args(this); + public get_metastore_uuid_args deepCopy() { + return new get_metastore_uuid_args(this); } @Override public void clear() { - this.req = null; - } - - public CacheFileMetadataRequest getReq() { - return this.req; - } - - public void setReq(CacheFileMetadataRequest 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((CacheFileMetadataRequest)value); - } - break; - } } public Object getFieldValue(_Fields field) { switch (field) { - case REQ: - return getReq(); - } throw new IllegalStateException(); } @@ -179357,8 +180171,6 @@ public boolean isSet(_Fields field) { } switch (field) { - case REQ: - return isSetReq(); } throw new IllegalStateException(); } @@ -179367,24 +180179,15 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof cache_file_metadata_args) - return this.equals((cache_file_metadata_args)that); + if (that instanceof get_metastore_uuid_args) + return this.equals((get_metastore_uuid_args)that); return false; } - public boolean equals(cache_file_metadata_args that) { + public boolean equals(get_metastore_uuid_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; } @@ -179392,32 +180195,17 @@ public boolean equals(cache_file_metadata_args that) { 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(cache_file_metadata_args other) { + public int compareTo(get_metastore_uuid_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; } @@ -179435,16 +180223,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("cache_file_metadata_args("); + StringBuilder sb = new StringBuilder("get_metastore_uuid_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(); } @@ -179452,9 +180233,6 @@ public String 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 { @@ -179473,15 +180251,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class cache_file_metadata_argsStandardSchemeFactory implements SchemeFactory { - public cache_file_metadata_argsStandardScheme getScheme() { - return new cache_file_metadata_argsStandardScheme(); + private static class get_metastore_uuid_argsStandardSchemeFactory implements SchemeFactory { + public get_metastore_uuid_argsStandardScheme getScheme() { + return new get_metastore_uuid_argsStandardScheme(); } } - private static class cache_file_metadata_argsStandardScheme extends StandardScheme { + private static class get_metastore_uuid_argsStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, cache_file_metadata_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, get_metastore_uuid_args struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -179491,15 +180269,6 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, cache_file_metadata break; } switch (schemeField.id) { - case 1: // REQ - if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.req = new CacheFileMetadataRequest(); - 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); } @@ -179509,72 +180278,56 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, cache_file_metadata struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, cache_file_metadata_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, get_metastore_uuid_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 cache_file_metadata_argsTupleSchemeFactory implements SchemeFactory { - public cache_file_metadata_argsTupleScheme getScheme() { - return new cache_file_metadata_argsTupleScheme(); + private static class get_metastore_uuid_argsTupleSchemeFactory implements SchemeFactory { + public get_metastore_uuid_argsTupleScheme getScheme() { + return new get_metastore_uuid_argsTupleScheme(); } } - private static class cache_file_metadata_argsTupleScheme extends TupleScheme { + private static class get_metastore_uuid_argsTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, cache_file_metadata_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, get_metastore_uuid_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, cache_file_metadata_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, get_metastore_uuid_args struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - struct.req = new CacheFileMetadataRequest(); - struct.req.read(iprot); - struct.setReqIsSet(true); - } } } } - public static class cache_file_metadata_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("cache_file_metadata_result"); + public static class get_metastore_uuid_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("get_metastore_uuid_result"); - private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0); + private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRING, (short)0); + private static final org.apache.thrift.protocol.TField O1_FIELD_DESC = new org.apache.thrift.protocol.TField("o1", org.apache.thrift.protocol.TType.STRUCT, (short)1); private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { - schemes.put(StandardScheme.class, new cache_file_metadata_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new cache_file_metadata_resultTupleSchemeFactory()); + schemes.put(StandardScheme.class, new get_metastore_uuid_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new get_metastore_uuid_resultTupleSchemeFactory()); } - private CacheFileMetadataResult success; // required + private String success; // required + private MetaException o1; // required /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ public enum _Fields implements org.apache.thrift.TFieldIdEnum { - SUCCESS((short)0, "success"); + SUCCESS((short)0, "success"), + O1((short)1, "o1"); private static final Map byName = new HashMap(); @@ -179591,6 +180344,8 @@ public static _Fields findByThriftId(int fieldId) { switch(fieldId) { case 0: // SUCCESS return SUCCESS; + case 1: // O1 + return O1; default: return null; } @@ -179635,44 +180390,52 @@ public String getFieldName() { static { Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, CacheFileMetadataResult.class))); + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.O1, new org.apache.thrift.meta_data.FieldMetaData("o1", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(cache_file_metadata_result.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(get_metastore_uuid_result.class, metaDataMap); } - public cache_file_metadata_result() { + public get_metastore_uuid_result() { } - public cache_file_metadata_result( - CacheFileMetadataResult success) + public get_metastore_uuid_result( + String success, + MetaException o1) { this(); this.success = success; + this.o1 = o1; } /** * Performs a deep copy on other. */ - public cache_file_metadata_result(cache_file_metadata_result other) { + public get_metastore_uuid_result(get_metastore_uuid_result other) { if (other.isSetSuccess()) { - this.success = new CacheFileMetadataResult(other.success); + this.success = other.success; + } + if (other.isSetO1()) { + this.o1 = new MetaException(other.o1); } } - public cache_file_metadata_result deepCopy() { - return new cache_file_metadata_result(this); + public get_metastore_uuid_result deepCopy() { + return new get_metastore_uuid_result(this); } @Override public void clear() { this.success = null; + this.o1 = null; } - public CacheFileMetadataResult getSuccess() { + public String getSuccess() { return this.success; } - public void setSuccess(CacheFileMetadataResult success) { + public void setSuccess(String success) { this.success = success; } @@ -179691,13 +180454,44 @@ public void setSuccessIsSet(boolean value) { } } + public MetaException getO1() { + return this.o1; + } + + public void setO1(MetaException o1) { + this.o1 = o1; + } + + public void unsetO1() { + this.o1 = null; + } + + /** Returns true if field o1 is set (has been assigned a value) and false otherwise */ + public boolean isSetO1() { + return this.o1 != null; + } + + public void setO1IsSet(boolean value) { + if (!value) { + this.o1 = null; + } + } + public void setFieldValue(_Fields field, Object value) { switch (field) { case SUCCESS: if (value == null) { unsetSuccess(); } else { - setSuccess((CacheFileMetadataResult)value); + setSuccess((String)value); + } + break; + + case O1: + if (value == null) { + unsetO1(); + } else { + setO1((MetaException)value); } break; @@ -179709,6 +180503,9 @@ public Object getFieldValue(_Fields field) { case SUCCESS: return getSuccess(); + case O1: + return getO1(); + } throw new IllegalStateException(); } @@ -179722,6 +180519,8 @@ public boolean isSet(_Fields field) { switch (field) { case SUCCESS: return isSetSuccess(); + case O1: + return isSetO1(); } throw new IllegalStateException(); } @@ -179730,12 +180529,12 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof cache_file_metadata_result) - return this.equals((cache_file_metadata_result)that); + if (that instanceof get_metastore_uuid_result) + return this.equals((get_metastore_uuid_result)that); return false; } - public boolean equals(cache_file_metadata_result that) { + public boolean equals(get_metastore_uuid_result that) { if (that == null) return false; @@ -179748,6 +180547,15 @@ public boolean equals(cache_file_metadata_result that) { return false; } + boolean this_present_o1 = true && this.isSetO1(); + boolean that_present_o1 = true && that.isSetO1(); + if (this_present_o1 || that_present_o1) { + if (!(this_present_o1 && that_present_o1)) + return false; + if (!this.o1.equals(that.o1)) + return false; + } + return true; } @@ -179760,11 +180568,16 @@ public int hashCode() { if (present_success) list.add(success); + boolean present_o1 = true && (isSetO1()); + list.add(present_o1); + if (present_o1) + list.add(o1); + return list.hashCode(); } @Override - public int compareTo(cache_file_metadata_result other) { + public int compareTo(get_metastore_uuid_result other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -179781,6 +180594,16 @@ public int compareTo(cache_file_metadata_result other) { return lastComparison; } } + lastComparison = Boolean.valueOf(isSetO1()).compareTo(other.isSetO1()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetO1()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.o1, other.o1); + if (lastComparison != 0) { + return lastComparison; + } + } return 0; } @@ -179798,7 +180621,7 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("cache_file_metadata_result("); + StringBuilder sb = new StringBuilder("get_metastore_uuid_result("); boolean first = true; sb.append("success:"); @@ -179808,6 +180631,14 @@ public String toString() { sb.append(this.success); } first = false; + if (!first) sb.append(", "); + sb.append("o1:"); + if (this.o1 == null) { + sb.append("null"); + } else { + sb.append(this.o1); + } + first = false; sb.append(")"); return sb.toString(); } @@ -179815,9 +180646,6 @@ public String toString() { public void validate() throws org.apache.thrift.TException { // check for required fields // check for sub-struct validity - if (success != null) { - success.validate(); - } } private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { @@ -179836,15 +180664,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class cache_file_metadata_resultStandardSchemeFactory implements SchemeFactory { - public cache_file_metadata_resultStandardScheme getScheme() { - return new cache_file_metadata_resultStandardScheme(); + private static class get_metastore_uuid_resultStandardSchemeFactory implements SchemeFactory { + public get_metastore_uuid_resultStandardScheme getScheme() { + return new get_metastore_uuid_resultStandardScheme(); } } - private static class cache_file_metadata_resultStandardScheme extends StandardScheme { + private static class get_metastore_uuid_resultStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, cache_file_metadata_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, get_metastore_uuid_result struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -179855,14 +180683,22 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, cache_file_metadata } switch (schemeField.id) { case 0: // SUCCESS - if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.success = new CacheFileMetadataResult(); - struct.success.read(iprot); + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.success = iprot.readString(); struct.setSuccessIsSet(true); } else { org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } break; + case 1: // O1 + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.o1 = new MetaException(); + struct.o1.read(iprot); + struct.setO1IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; default: org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } @@ -179872,13 +180708,18 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, cache_file_metadata struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, cache_file_metadata_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, get_metastore_uuid_result struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); if (struct.success != null) { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); - struct.success.write(oprot); + oprot.writeString(struct.success); + oprot.writeFieldEnd(); + } + if (struct.o1 != null) { + oprot.writeFieldBegin(O1_FIELD_DESC); + struct.o1.write(oprot); oprot.writeFieldEnd(); } oprot.writeFieldStop(); @@ -179887,36 +180728,46 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, cache_file_metadat } - private static class cache_file_metadata_resultTupleSchemeFactory implements SchemeFactory { - public cache_file_metadata_resultTupleScheme getScheme() { - return new cache_file_metadata_resultTupleScheme(); + private static class get_metastore_uuid_resultTupleSchemeFactory implements SchemeFactory { + public get_metastore_uuid_resultTupleScheme getScheme() { + return new get_metastore_uuid_resultTupleScheme(); } } - private static class cache_file_metadata_resultTupleScheme extends TupleScheme { + private static class get_metastore_uuid_resultTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, cache_file_metadata_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, get_metastore_uuid_result struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetSuccess()) { optionals.set(0); } - oprot.writeBitSet(optionals, 1); + if (struct.isSetO1()) { + optionals.set(1); + } + oprot.writeBitSet(optionals, 2); if (struct.isSetSuccess()) { - struct.success.write(oprot); + oprot.writeString(struct.success); + } + if (struct.isSetO1()) { + struct.o1.write(oprot); } } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, cache_file_metadata_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, get_metastore_uuid_result struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); + BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { - struct.success = new CacheFileMetadataResult(); - struct.success.read(iprot); + struct.success = iprot.readString(); struct.setSuccessIsSet(true); } + if (incoming.get(1)) { + struct.o1 = new MetaException(); + struct.o1.read(iprot); + struct.setO1IsSet(true); + } } } diff --git a/metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php b/metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php index 9bfc2b25232c60bf28c81b4443e0af72862333bc..76bcac39ad6fedbe3f7613614507edb329ac0ac7 100644 --- a/metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php +++ b/metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php @@ -1188,6 +1188,11 @@ interface ThriftHiveMetastoreIf extends \FacebookServiceIf { * @return \metastore\CacheFileMetadataResult */ public function cache_file_metadata(\metastore\CacheFileMetadataRequest $req); + /** + * @return string + * @throws \metastore\MetaException + */ + public function get_metastore_uuid(); } class ThriftHiveMetastoreClient extends \FacebookServiceClient implements \metastore\ThriftHiveMetastoreIf { @@ -9881,6 +9886,59 @@ class ThriftHiveMetastoreClient extends \FacebookServiceClient implements \metas throw new \Exception("cache_file_metadata failed: unknown result"); } + public function get_metastore_uuid() + { + $this->send_get_metastore_uuid(); + return $this->recv_get_metastore_uuid(); + } + + public function send_get_metastore_uuid() + { + $args = new \metastore\ThriftHiveMetastore_get_metastore_uuid_args(); + $bin_accel = ($this->output_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_write_binary'); + if ($bin_accel) + { + thrift_protocol_write_binary($this->output_, 'get_metastore_uuid', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite()); + } + else + { + $this->output_->writeMessageBegin('get_metastore_uuid', TMessageType::CALL, $this->seqid_); + $args->write($this->output_); + $this->output_->writeMessageEnd(); + $this->output_->getTransport()->flush(); + } + } + + public function recv_get_metastore_uuid() + { + $bin_accel = ($this->input_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_read_binary'); + if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\metastore\ThriftHiveMetastore_get_metastore_uuid_result', $this->input_->isStrictRead()); + else + { + $rseqid = 0; + $fname = null; + $mtype = 0; + + $this->input_->readMessageBegin($fname, $mtype, $rseqid); + if ($mtype == TMessageType::EXCEPTION) { + $x = new TApplicationException(); + $x->read($this->input_); + $this->input_->readMessageEnd(); + throw $x; + } + $result = new \metastore\ThriftHiveMetastore_get_metastore_uuid_result(); + $result->read($this->input_); + $this->input_->readMessageEnd(); + } + if ($result->success !== null) { + return $result->success; + } + if ($result->o1 !== null) { + throw $result->o1; + } + throw new \Exception("get_metastore_uuid failed: unknown result"); + } + } // HELPER FUNCTIONS AND STRUCTURES @@ -45034,4 +45092,154 @@ class ThriftHiveMetastore_cache_file_metadata_result { } +class ThriftHiveMetastore_get_metastore_uuid_args { + static $_TSPEC; + + + public function __construct() { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + ); + } + } + + public function getName() { + return 'ThriftHiveMetastore_get_metastore_uuid_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) + { + default: + $xfer += $input->skip($ftype); + break; + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; + } + + public function write($output) { + $xfer = 0; + $xfer += $output->writeStructBegin('ThriftHiveMetastore_get_metastore_uuid_args'); + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class ThriftHiveMetastore_get_metastore_uuid_result { + static $_TSPEC; + + /** + * @var string + */ + public $success = null; + /** + * @var \metastore\MetaException + */ + public $o1 = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 0 => array( + 'var' => 'success', + 'type' => TType::STRING, + ), + 1 => array( + 'var' => 'o1', + 'type' => TType::STRUCT, + 'class' => '\metastore\MetaException', + ), + ); + } + if (is_array($vals)) { + if (isset($vals['success'])) { + $this->success = $vals['success']; + } + if (isset($vals['o1'])) { + $this->o1 = $vals['o1']; + } + } + } + + public function getName() { + return 'ThriftHiveMetastore_get_metastore_uuid_result'; + } + + public function read($input) + { + $xfer = 0; + $fname = null; + $ftype = 0; + $fid = 0; + $xfer += $input->readStructBegin($fname); + while (true) + { + $xfer += $input->readFieldBegin($fname, $ftype, $fid); + if ($ftype == TType::STOP) { + break; + } + switch ($fid) + { + case 0: + if ($ftype == TType::STRING) { + $xfer += $input->readString($this->success); + } else { + $xfer += $input->skip($ftype); + } + break; + case 1: + if ($ftype == TType::STRUCT) { + $this->o1 = new \metastore\MetaException(); + $xfer += $this->o1->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + default: + $xfer += $input->skip($ftype); + break; + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; + } + + public function write($output) { + $xfer = 0; + $xfer += $output->writeStructBegin('ThriftHiveMetastore_get_metastore_uuid_result'); + if ($this->success !== null) { + $xfer += $output->writeFieldBegin('success', TType::STRING, 0); + $xfer += $output->writeString($this->success); + $xfer += $output->writeFieldEnd(); + } + if ($this->o1 !== null) { + $xfer += $output->writeFieldBegin('o1', TType::STRUCT, 1); + $xfer += $this->o1->write($output); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + diff --git a/metastore/src/gen/thrift/gen-php/metastore/Types.php b/metastore/src/gen/thrift/gen-php/metastore/Types.php index 4a3bf85f33ca6d1c982cd5ea8557a4b885bd057e..4cefb8275fd3ad9c8eba51d0cd5b47ba26d75230 100644 --- a/metastore/src/gen/thrift/gen-php/metastore/Types.php +++ b/metastore/src/gen/thrift/gen-php/metastore/Types.php @@ -272,6 +272,127 @@ class Version { } +class MetastoreDBProperty { + static $_TSPEC; + + /** + * @var string + */ + public $propertyKey = null; + /** + * @var string + */ + public $propertyValue = null; + /** + * @var string + */ + public $description = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'propertyKey', + 'type' => TType::STRING, + ), + 2 => array( + 'var' => 'propertyValue', + 'type' => TType::STRING, + ), + 3 => array( + 'var' => 'description', + 'type' => TType::STRING, + ), + ); + } + if (is_array($vals)) { + if (isset($vals['propertyKey'])) { + $this->propertyKey = $vals['propertyKey']; + } + if (isset($vals['propertyValue'])) { + $this->propertyValue = $vals['propertyValue']; + } + if (isset($vals['description'])) { + $this->description = $vals['description']; + } + } + } + + public function getName() { + return 'MetastoreDBProperty'; + } + + 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->propertyKey); + } else { + $xfer += $input->skip($ftype); + } + break; + case 2: + if ($ftype == TType::STRING) { + $xfer += $input->readString($this->propertyValue); + } else { + $xfer += $input->skip($ftype); + } + break; + case 3: + if ($ftype == TType::STRING) { + $xfer += $input->readString($this->description); + } 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('MetastoreDBProperty'); + if ($this->propertyKey !== null) { + $xfer += $output->writeFieldBegin('propertyKey', TType::STRING, 1); + $xfer += $output->writeString($this->propertyKey); + $xfer += $output->writeFieldEnd(); + } + if ($this->propertyValue !== null) { + $xfer += $output->writeFieldBegin('propertyValue', TType::STRING, 2); + $xfer += $output->writeString($this->propertyValue); + $xfer += $output->writeFieldEnd(); + } + if ($this->description !== null) { + $xfer += $output->writeFieldBegin('description', TType::STRING, 3); + $xfer += $output->writeString($this->description); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + class FieldSchema { 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 5c247075ef89644870d1f483a0f52682476ad7ae..5f7e63da46a63aa7733f1c3d3dc2c38aaccb7e84 100755 --- a/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote +++ b/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote @@ -177,6 +177,7 @@ if len(sys.argv) <= 1 or sys.argv[1] == '--help': print(' PutFileMetadataResult put_file_metadata(PutFileMetadataRequest req)') print(' ClearFileMetadataResult clear_file_metadata(ClearFileMetadataRequest req)') print(' CacheFileMetadataResult cache_file_metadata(CacheFileMetadataRequest req)') + print(' string get_metastore_uuid()') print(' string getName()') print(' string getVersion()') print(' fb_status getStatus()') @@ -1164,6 +1165,12 @@ elif cmd == 'cache_file_metadata': sys.exit(1) pp.pprint(client.cache_file_metadata(eval(args[0]),)) +elif cmd == 'get_metastore_uuid': + if len(args) != 0: + print('get_metastore_uuid requires 0 args') + sys.exit(1) + pp.pprint(client.get_metastore_uuid()) + elif cmd == 'getName': if len(args) != 0: print('getName requires 0 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 86bbef38f4ad796ef9af6da861adb80141acfe8f..ac19b7eb871f9e4b9770858e963efdf52e60f587 100644 --- a/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py +++ b/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py @@ -1230,6 +1230,9 @@ def cache_file_metadata(self, req): """ pass + def get_metastore_uuid(self): + pass + class Client(fb303.FacebookService.Client, Iface): """ @@ -6760,6 +6763,34 @@ def recv_cache_file_metadata(self): return result.success raise TApplicationException(TApplicationException.MISSING_RESULT, "cache_file_metadata failed: unknown result") + def get_metastore_uuid(self): + self.send_get_metastore_uuid() + return self.recv_get_metastore_uuid() + + def send_get_metastore_uuid(self): + self._oprot.writeMessageBegin('get_metastore_uuid', TMessageType.CALL, self._seqid) + args = get_metastore_uuid_args() + args.write(self._oprot) + self._oprot.writeMessageEnd() + self._oprot.trans.flush() + + def recv_get_metastore_uuid(self): + iprot = self._iprot + (fname, mtype, rseqid) = iprot.readMessageBegin() + if mtype == TMessageType.EXCEPTION: + x = TApplicationException() + x.read(iprot) + iprot.readMessageEnd() + raise x + result = get_metastore_uuid_result() + result.read(iprot) + iprot.readMessageEnd() + if result.success is not None: + return result.success + if result.o1 is not None: + raise result.o1 + raise TApplicationException(TApplicationException.MISSING_RESULT, "get_metastore_uuid failed: unknown result") + class Processor(fb303.FacebookService.Processor, Iface, TProcessor): def __init__(self, handler): @@ -6917,6 +6948,7 @@ def __init__(self, handler): self._processMap["put_file_metadata"] = Processor.process_put_file_metadata self._processMap["clear_file_metadata"] = Processor.process_clear_file_metadata self._processMap["cache_file_metadata"] = Processor.process_cache_file_metadata + self._processMap["get_metastore_uuid"] = Processor.process_get_metastore_uuid def process(self, iprot, oprot): (name, type, seqid) = iprot.readMessageBegin() @@ -10665,6 +10697,28 @@ def process_cache_file_metadata(self, seqid, iprot, oprot): oprot.writeMessageEnd() oprot.trans.flush() + def process_get_metastore_uuid(self, seqid, iprot, oprot): + args = get_metastore_uuid_args() + args.read(iprot) + iprot.readMessageEnd() + result = get_metastore_uuid_result() + try: + result.success = self._handler.get_metastore_uuid() + msg_type = TMessageType.REPLY + except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): + raise + except MetaException as o1: + msg_type = TMessageType.REPLY + result.o1 = o1 + except Exception as ex: + msg_type = TMessageType.EXCEPTION + logging.exception(ex) + result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') + oprot.writeMessageBegin("get_metastore_uuid", msg_type, seqid) + result.write(oprot) + oprot.writeMessageEnd() + oprot.trans.flush() + # HELPER FUNCTIONS AND STRUCTURES @@ -36564,3 +36618,127 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) + +class get_metastore_uuid_args: + + thrift_spec = ( + ) + + def read(self, iprot): + if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: + fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) + return + iprot.readStructBegin() + while True: + (fname, ftype, fid) = iprot.readFieldBegin() + if ftype == TType.STOP: + break + else: + iprot.skip(ftype) + iprot.readFieldEnd() + iprot.readStructEnd() + + def write(self, oprot): + if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: + oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) + return + oprot.writeStructBegin('get_metastore_uuid_args') + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + return value + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + +class get_metastore_uuid_result: + """ + Attributes: + - success + - o1 + """ + + thrift_spec = ( + (0, TType.STRING, 'success', None, None, ), # 0 + (1, TType.STRUCT, 'o1', (MetaException, MetaException.thrift_spec), None, ), # 1 + ) + + def __init__(self, success=None, o1=None,): + self.success = success + self.o1 = o1 + + def read(self, iprot): + if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: + fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) + return + iprot.readStructBegin() + while True: + (fname, ftype, fid) = iprot.readFieldBegin() + if ftype == TType.STOP: + break + if fid == 0: + if ftype == TType.STRING: + self.success = iprot.readString() + else: + iprot.skip(ftype) + elif fid == 1: + if ftype == TType.STRUCT: + self.o1 = MetaException() + self.o1.read(iprot) + else: + iprot.skip(ftype) + else: + iprot.skip(ftype) + iprot.readFieldEnd() + iprot.readStructEnd() + + def write(self, oprot): + if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: + oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) + return + oprot.writeStructBegin('get_metastore_uuid_result') + if self.success is not None: + oprot.writeFieldBegin('success', TType.STRING, 0) + oprot.writeString(self.success) + oprot.writeFieldEnd() + if self.o1 is not None: + oprot.writeFieldBegin('o1', TType.STRUCT, 1) + self.o1.write(oprot) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.success) + value = (value * 31) ^ hash(self.o1) + return value + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) 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 9480c855185240a0033e40a7102586704f7df346..879b0c71feec295984928d9d0ba9f9853f0785e5 100644 --- a/metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py +++ b/metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py @@ -340,6 +340,97 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) +class MetastoreDBProperty: + """ + Attributes: + - propertyKey + - propertyValue + - description + """ + + thrift_spec = ( + None, # 0 + (1, TType.STRING, 'propertyKey', None, None, ), # 1 + (2, TType.STRING, 'propertyValue', None, None, ), # 2 + (3, TType.STRING, 'description', None, None, ), # 3 + ) + + def __init__(self, propertyKey=None, propertyValue=None, description=None,): + self.propertyKey = propertyKey + self.propertyValue = propertyValue + self.description = description + + 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.propertyKey = iprot.readString() + else: + iprot.skip(ftype) + elif fid == 2: + if ftype == TType.STRING: + self.propertyValue = iprot.readString() + else: + iprot.skip(ftype) + elif fid == 3: + if ftype == TType.STRING: + self.description = 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('MetastoreDBProperty') + if self.propertyKey is not None: + oprot.writeFieldBegin('propertyKey', TType.STRING, 1) + oprot.writeString(self.propertyKey) + oprot.writeFieldEnd() + if self.propertyValue is not None: + oprot.writeFieldBegin('propertyValue', TType.STRING, 2) + oprot.writeString(self.propertyValue) + oprot.writeFieldEnd() + if self.description is not None: + oprot.writeFieldBegin('description', TType.STRING, 3) + oprot.writeString(self.description) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.propertyKey) + value = (value * 31) ^ hash(self.propertyValue) + value = (value * 31) ^ hash(self.description) + 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 FieldSchema: """ 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 7766071542e3b8d86af1bc0a6c47e0b20d279e33..c54feb8a3b0802e6c98e129c323cc7f9c05e717a 100644 --- a/metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb +++ b/metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb @@ -142,6 +142,26 @@ class Version ::Thrift::Struct.generate_accessors self end +class MetastoreDBProperty + include ::Thrift::Struct, ::Thrift::Struct_Union + PROPERTYKEY = 1 + PROPERTYVALUE = 2 + DESCRIPTION = 3 + + FIELDS = { + PROPERTYKEY => {:type => ::Thrift::Types::STRING, :name => 'propertyKey'}, + PROPERTYVALUE => {:type => ::Thrift::Types::STRING, :name => 'propertyValue'}, + DESCRIPTION => {:type => ::Thrift::Types::STRING, :name => 'description'} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self +end + class FieldSchema include ::Thrift::Struct, ::Thrift::Struct_Union NAME = 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 7cdfc8665770a469eef408c13940927b91f2882c..fa3104638364fbc7ef5c5b58360d09023e16a656 100644 --- a/metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb +++ b/metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb @@ -2547,6 +2547,22 @@ module ThriftHiveMetastore raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'cache_file_metadata failed: unknown result') end + def get_metastore_uuid() + send_get_metastore_uuid() + return recv_get_metastore_uuid() + end + + def send_get_metastore_uuid() + send_message('get_metastore_uuid', Get_metastore_uuid_args) + end + + def recv_get_metastore_uuid() + result = receive_message(Get_metastore_uuid_result) + return result.success unless result.success.nil? + raise result.o1 unless result.o1.nil? + raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'get_metastore_uuid failed: unknown result') + end + end class Processor < ::FacebookService::Processor @@ -4431,6 +4447,17 @@ module ThriftHiveMetastore write_result(result, oprot, 'cache_file_metadata', seqid) end + def process_get_metastore_uuid(seqid, iprot, oprot) + args = read_args(iprot, Get_metastore_uuid_args) + result = Get_metastore_uuid_result.new() + begin + result.success = @handler.get_metastore_uuid() + rescue ::MetaException => o1 + result.o1 = o1 + end + write_result(result, oprot, 'get_metastore_uuid', seqid) + end + end # HELPER FUNCTIONS AND STRUCTURES @@ -10169,5 +10196,38 @@ module ThriftHiveMetastore ::Thrift::Struct.generate_accessors self end + class Get_metastore_uuid_args + include ::Thrift::Struct, ::Thrift::Struct_Union + + FIELDS = { + + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Get_metastore_uuid_result + include ::Thrift::Struct, ::Thrift::Struct_Union + SUCCESS = 0 + O1 = 1 + + FIELDS = { + SUCCESS => {:type => ::Thrift::Types::STRING, :name => 'success'}, + O1 => {:type => ::Thrift::Types::STRUCT, :name => 'o1', :class => ::MetaException} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + end 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 a8fa1ef4e3e8f6a8f9ec916757d33d7562dcf97b..dd32906bc62264cf06f6ddc21c24554f472ab14c 100644 --- a/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java +++ b/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java @@ -6872,6 +6872,16 @@ public ForeignKeysResponse get_foreign_keys(ForeignKeysRequest request) throws M } return new ForeignKeysResponse(ret); } + + @Override + public String get_metastore_uuid() throws MetaException, TException { + try { + return getMS().getMetastoreUuid(); + } catch (MetaException e) { + LOG.error("Exception thrown while querying metastore db uuid", e); + throw e; + } + } } 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 dcb14e8084af966541a291cb3981fced6b7bc191..1942a91f204fbcd74561cde45d348040d551d017 100644 --- a/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java +++ b/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java @@ -2519,4 +2519,10 @@ public boolean cacheFileMetadata( CacheFileMetadataResult result = client.cache_file_metadata(req); return result.isIsSupported(); } + + @Override + public String getMetastoreUuid() throws TException { + String uuid = client.get_metastore_uuid(); + return uuid; + } } 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 e9df1e149ac069a6c20a7d8ed15fbd1a54df72d7..301c01ead2ec0b65c38841aec594daf69f4d0a34 100644 --- a/metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java +++ b/metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java @@ -1650,4 +1650,6 @@ void addPrimaryKey(List primaryKeyCols) throws void addForeignKey(List foreignKeyCols) throws MetaException, NoSuchObjectException, TException; + + String getMetastoreUuid() throws MetaException, 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 6b217516bc74c612348b8edeca077dfbdbdb1a40..19b5425a5d3481816de26acf79cb70609fa4805f 100644 --- a/metastore/src/java/org/apache/hadoop/hive/metastore/ObjectStore.java +++ b/metastore/src/java/org/apache/hadoop/hive/metastore/ObjectStore.java @@ -38,6 +38,7 @@ import java.util.Map.Entry; import java.util.Properties; import java.util.Set; +import java.util.UUID; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.locks.Lock; @@ -145,6 +146,7 @@ import org.apache.hadoop.hive.metastore.model.MTablePrivilege; import org.apache.hadoop.hive.metastore.model.MType; import org.apache.hadoop.hive.metastore.model.MVersionTable; +import org.apache.hadoop.hive.metastore.model.MMetastoreDBProperties; import org.apache.hadoop.hive.metastore.parser.ExpressionTree; import org.apache.hadoop.hive.metastore.parser.ExpressionTree.FilterBuilder; import org.apache.hadoop.hive.metastore.partition.spec.PartitionSpecProxy; @@ -3601,6 +3603,84 @@ public void addForeignKeys( addForeignKeys(fks, true); } + @Override + public String getMetastoreUuid() throws MetaException { + return getMetastoreUuidInternal(); + } + + private String getMetastoreUuidInternal() throws MetaException { + String ret = getUuidFromDB(); + if (ret == null) { + createUuidAndPersist(); + } + ret = getUuidFromDB(); + if(ret == null) { + throw new MetaException("Unable to fetch the metastore database uuid"); + } + return ret; + } + + private void createUuidAndPersist() throws MetaException { + boolean flag = false; + Query query = null; + try { + openTransaction(); + LOG.info("Generating UUID"); + MMetastoreDBProperties prop = new MMetastoreDBProperties(); + prop.setPropertykey("guid"); + prop.setPropertyValue(UUID.randomUUID().toString()); + prop.setDescription("Metastore DB GUID"); + pm.makePersistent(prop); + flag = commitTransaction(); + } catch (Exception e) { + LOG.warn(e.getMessage(), e); + } finally { + if (!flag) { + rollbackTransaction(); + } + if (query != null) { + query.closeAll(); + } + } + } + + private String getUuidFromDB() throws MetaException { + String ret = null; + boolean success = false; + Query query = null; + try { + openTransaction(); + LOG.info("Executing getMetastoreUuidInternal"); + query = pm.newQuery(MMetastoreDBProperties.class, "this.propertyKey == key"); + query.declareParameters("java.lang.String key"); + Collection names = (Collection) query.execute("guid"); + List uuids = new ArrayList(); + for (Iterator i = names.iterator(); i.hasNext();) { + String uuid = i.next().getPropertyValue(); + LOG.info("Found uuid " + uuid); + uuids.add(uuid); + } + success = commitTransaction(); + if(uuids.size() > 1) { + throw new Exception("Multiple uuids found"); + } + if(!uuids.isEmpty()) { + ret = uuids.get(0); + } + } catch(Exception e) { + LOG.error(e.getMessage(), e); + throw new MetaException(e.getMessage()); + } finally { + if (!success) { + rollbackTransaction(); + } + if (query != null) { + query.closeAll(); + } + } + return ret; + } + private void addForeignKeys( List fks, boolean retrieveCD) throws InvalidObjectException, MetaException { 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 6f4f0317103a0e1cf4dc9d10954d73b7e929bcf1..4ede3a261272ad9d2e93d04856fa476d4bb746b7 100644 --- a/metastore/src/java/org/apache/hadoop/hive/metastore/RawStore.java +++ b/metastore/src/java/org/apache/hadoop/hive/metastore/RawStore.java @@ -696,4 +696,6 @@ void createTableWithConstraints(Table tbl, List primaryKeys, void addPrimaryKeys(List pks) throws InvalidObjectException, MetaException; void addForeignKeys(List fks) throws InvalidObjectException, MetaException; + + String getMetastoreUuid() throws MetaException; } 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 f9619e5f71c3e33b571c7feda9d384187a448a80..1a88da954c9387bb356797b13b8c13171295cef1 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 @@ -2852,4 +2852,9 @@ public void addForeignKeys(List fks) throws InvalidObjectExceptio commitOrRoleBack(commit); } } + + @Override + public String getMetastoreUuid() throws MetaException { + throw new MetaException("getMetastoreUUID is not implemented for HBasestore"); + } } diff --git a/metastore/src/model/org/apache/hadoop/hive/metastore/model/MMetastoreDBProperties.java b/metastore/src/model/org/apache/hadoop/hive/metastore/model/MMetastoreDBProperties.java new file mode 100644 index 0000000000000000000000000000000000000000..c0a2485df44e2298eddbada8b23f9928d18de2bb --- /dev/null +++ b/metastore/src/model/org/apache/hadoop/hive/metastore/model/MMetastoreDBProperties.java @@ -0,0 +1,56 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.hadoop.hive.metastore.model; + +public class MMetastoreDBProperties { + private String propertyKey; + private String propertyValue; + private String description; + + public MMetastoreDBProperties() {} + + public MMetastoreDBProperties(String propertykey, String propertyValue, String description) { + this.propertyKey = propertykey; + this.propertyValue = propertyValue; + this.description = description; + } + + public String getPropertykey() { + return propertyKey; + } + + public void setPropertykey(String propertykey) { + this.propertyKey = propertykey; + } + + public String getPropertyValue() { + return propertyValue; + } + + public void setPropertyValue(String propertyValue) { + this.propertyValue = propertyValue; + } + + public String getDescription() { + return description; + } + + public void setDescription(String description) { + this.description = description; + } +} diff --git a/metastore/src/model/package.jdo b/metastore/src/model/package.jdo index 969e19912791b5f5a2b9c5fa4c43800310f5080c..8450d199e14668982df8df26bb6df5679280bbfe 100644 --- a/metastore/src/model/package.jdo +++ b/metastore/src/model/package.jdo @@ -971,6 +971,24 @@ + + + + + + + + + + + + + + + + + + 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 f64b08d8fead5e5226e1de4e5f483503fce96c04..52c962be3747b587a1fd913d79520d8d2a92aa25 100644 --- a/metastore/src/test/org/apache/hadoop/hive/metastore/DummyRawStoreControlledCommit.java +++ b/metastore/src/test/org/apache/hadoop/hive/metastore/DummyRawStoreControlledCommit.java @@ -869,4 +869,10 @@ public void addForeignKeys(List fks) throws InvalidObjectException, MetaException { // TODO Auto-generated method stub } + + @Override + public String getMetastoreUuid() throws MetaException { + // TODO Auto-generated method stub + return null; + } } 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 26828865bc4851237125b55017f5dc609555a5bf..4a3a997c474e9ae6e519a07c0f67502314baf60d 100644 --- a/metastore/src/test/org/apache/hadoop/hive/metastore/DummyRawStoreForJdoConnection.java +++ b/metastore/src/test/org/apache/hadoop/hive/metastore/DummyRawStoreForJdoConnection.java @@ -885,6 +885,12 @@ public void addForeignKeys(List fks) throws InvalidObjectException, MetaException { // TODO Auto-generated method stub } + + @Override + public String getMetastoreUuid() throws MetaException { + // TODO Auto-generated method stub + return null; + } }