commit 44730b72ed289fe4121af4a75175d2bd751c28d1 Author: Vihang Karajgaonkar Date: Tue May 2 16:18:32 2017 -0700 HIVE-16555 : Add a new thrift API call for get_metastore_uuid diff --git itests/hcatalog-unit/src/test/java/org/apache/hive/hcatalog/listener/DummyRawStoreFailEvent.java itests/hcatalog-unit/src/test/java/org/apache/hive/hcatalog/listener/DummyRawStoreFailEvent.java index 88b9faf8394a59de39be55b2dd2315db7a8d5ab4..6774fdf2fbd557d0e1d312f78927e75a8db6c958 100644 --- itests/hcatalog-unit/src/test/java/org/apache/hive/hcatalog/listener/DummyRawStoreFailEvent.java +++ itests/hcatalog-unit/src/test/java/org/apache/hive/hcatalog/listener/DummyRawStoreFailEvent.java @@ -918,4 +918,10 @@ public void addForeignKeys(List fks) String tableName) throws MetaException, NoSuchObjectException { return objectStore.getAggrColStatsForTablePartitions(dbName, tableName); } -} \ No newline at end of file + + @Override + public String getMetastoreUuid() throws MetaException { + throw new MetaException("MetastoreUUID is not implemented"); + } +} + diff --git itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/TestEmbeddedHiveMetaStore.java itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/TestEmbeddedHiveMetaStore.java index bc00d11e2a1c9fd66b89f1ceca100aaafe43cfed..63b124a5b7a42797ab39539e0b4cc9cce459fcf3 100644 --- itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/TestEmbeddedHiveMetaStore.java +++ 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 itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/TestHiveMetaStore.java itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/TestHiveMetaStore.java index b95c25ca00751629577e014801c3fb9f1a99bd70..4f7d56bd60f12779fe7702f4fd0d39e626955daa 100644 --- itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/TestHiveMetaStore.java +++ 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.getMetastoreDbUuid(); + 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.getMetastoreDbUuid(); + 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 itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/TestRemoteHiveMetaStore.java itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/TestRemoteHiveMetaStore.java index ef02968e22363d537f58b6054266bf9bc87033ae..878f9131f7d206d497622af9e0eda219badbb1af 100644 --- itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/TestRemoteHiveMetaStore.java +++ 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 itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/TestSetUGIOnOnlyClient.java itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/TestSetUGIOnOnlyClient.java index 29768c1d660aac937c0cd1fa15fb70b571007d14..1a9abc9c8cfbcccb3aebb85fe7fab6f70a46d8cd 100644 --- itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/TestSetUGIOnOnlyClient.java +++ 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 itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/TestSetUGIOnOnlyServer.java itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/TestSetUGIOnOnlyServer.java index 4a46f7537f3ceb16c45010b88786907109fd1090..b45fd011b96b704bfb9835c17961a429dc5ccf42 100644 --- itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/TestSetUGIOnOnlyServer.java +++ 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 metastore/if/hive_metastore.thrift metastore/if/hive_metastore.thrift index ca6a0076d1fbee4b0d904c1bafcc056ab739e4c4..8d5230fd649375f6cb58b7bbf67602ad31f56a3b 100755 --- metastore/if/hive_metastore.thrift +++ 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 @@ -1491,6 +1497,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_db_uuid() throws (1:MetaException o1) } // * Note about the DDL_TIME: When creating or altering a table or a partition, diff --git metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp index 9042cdb265373cd25ee9050fb59f6547f4dfc669..675a7f80343bf580f2015c499a8d802982b57a31 100644 --- metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp +++ 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 _size817; - ::apache::thrift::protocol::TType _etype820; - xfer += iprot->readListBegin(_etype820, _size817); - this->success.resize(_size817); - uint32_t _i821; - for (_i821 = 0; _i821 < _size817; ++_i821) + uint32_t _size819; + ::apache::thrift::protocol::TType _etype822; + xfer += iprot->readListBegin(_etype822, _size819); + this->success.resize(_size819); + uint32_t _i823; + for (_i823 = 0; _i823 < _size819; ++_i823) { - xfer += iprot->readString(this->success[_i821]); + xfer += iprot->readString(this->success[_i823]); } 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 _iter822; - for (_iter822 = this->success.begin(); _iter822 != this->success.end(); ++_iter822) + std::vector ::const_iterator _iter824; + for (_iter824 = this->success.begin(); _iter824 != this->success.end(); ++_iter824) { - xfer += oprot->writeString((*_iter822)); + xfer += oprot->writeString((*_iter824)); } 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 _size823; - ::apache::thrift::protocol::TType _etype826; - xfer += iprot->readListBegin(_etype826, _size823); - (*(this->success)).resize(_size823); - uint32_t _i827; - for (_i827 = 0; _i827 < _size823; ++_i827) + uint32_t _size825; + ::apache::thrift::protocol::TType _etype828; + xfer += iprot->readListBegin(_etype828, _size825); + (*(this->success)).resize(_size825); + uint32_t _i829; + for (_i829 = 0; _i829 < _size825; ++_i829) { - xfer += iprot->readString((*(this->success))[_i827]); + xfer += iprot->readString((*(this->success))[_i829]); } 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 _size828; - ::apache::thrift::protocol::TType _etype831; - xfer += iprot->readListBegin(_etype831, _size828); - this->success.resize(_size828); - uint32_t _i832; - for (_i832 = 0; _i832 < _size828; ++_i832) + uint32_t _size830; + ::apache::thrift::protocol::TType _etype833; + xfer += iprot->readListBegin(_etype833, _size830); + this->success.resize(_size830); + uint32_t _i834; + for (_i834 = 0; _i834 < _size830; ++_i834) { - xfer += iprot->readString(this->success[_i832]); + xfer += iprot->readString(this->success[_i834]); } 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 _iter833; - for (_iter833 = this->success.begin(); _iter833 != this->success.end(); ++_iter833) + std::vector ::const_iterator _iter835; + for (_iter835 = this->success.begin(); _iter835 != this->success.end(); ++_iter835) { - xfer += oprot->writeString((*_iter833)); + xfer += oprot->writeString((*_iter835)); } 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 _size834; - ::apache::thrift::protocol::TType _etype837; - xfer += iprot->readListBegin(_etype837, _size834); - (*(this->success)).resize(_size834); - uint32_t _i838; - for (_i838 = 0; _i838 < _size834; ++_i838) + uint32_t _size836; + ::apache::thrift::protocol::TType _etype839; + xfer += iprot->readListBegin(_etype839, _size836); + (*(this->success)).resize(_size836); + uint32_t _i840; + for (_i840 = 0; _i840 < _size836; ++_i840) { - xfer += iprot->readString((*(this->success))[_i838]); + xfer += iprot->readString((*(this->success))[_i840]); } 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 _size839; - ::apache::thrift::protocol::TType _ktype840; - ::apache::thrift::protocol::TType _vtype841; - xfer += iprot->readMapBegin(_ktype840, _vtype841, _size839); - uint32_t _i843; - for (_i843 = 0; _i843 < _size839; ++_i843) + uint32_t _size841; + ::apache::thrift::protocol::TType _ktype842; + ::apache::thrift::protocol::TType _vtype843; + xfer += iprot->readMapBegin(_ktype842, _vtype843, _size841); + uint32_t _i845; + for (_i845 = 0; _i845 < _size841; ++_i845) { - std::string _key844; - xfer += iprot->readString(_key844); - Type& _val845 = this->success[_key844]; - xfer += _val845.read(iprot); + std::string _key846; + xfer += iprot->readString(_key846); + Type& _val847 = this->success[_key846]; + xfer += _val847.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 _iter846; - for (_iter846 = this->success.begin(); _iter846 != this->success.end(); ++_iter846) + std::map ::const_iterator _iter848; + for (_iter848 = this->success.begin(); _iter848 != this->success.end(); ++_iter848) { - xfer += oprot->writeString(_iter846->first); - xfer += _iter846->second.write(oprot); + xfer += oprot->writeString(_iter848->first); + xfer += _iter848->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 _size847; - ::apache::thrift::protocol::TType _ktype848; - ::apache::thrift::protocol::TType _vtype849; - xfer += iprot->readMapBegin(_ktype848, _vtype849, _size847); - uint32_t _i851; - for (_i851 = 0; _i851 < _size847; ++_i851) + uint32_t _size849; + ::apache::thrift::protocol::TType _ktype850; + ::apache::thrift::protocol::TType _vtype851; + xfer += iprot->readMapBegin(_ktype850, _vtype851, _size849); + uint32_t _i853; + for (_i853 = 0; _i853 < _size849; ++_i853) { - std::string _key852; - xfer += iprot->readString(_key852); - Type& _val853 = (*(this->success))[_key852]; - xfer += _val853.read(iprot); + std::string _key854; + xfer += iprot->readString(_key854); + Type& _val855 = (*(this->success))[_key854]; + xfer += _val855.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 _size854; - ::apache::thrift::protocol::TType _etype857; - xfer += iprot->readListBegin(_etype857, _size854); - this->success.resize(_size854); - uint32_t _i858; - for (_i858 = 0; _i858 < _size854; ++_i858) + uint32_t _size856; + ::apache::thrift::protocol::TType _etype859; + xfer += iprot->readListBegin(_etype859, _size856); + this->success.resize(_size856); + uint32_t _i860; + for (_i860 = 0; _i860 < _size856; ++_i860) { - xfer += this->success[_i858].read(iprot); + xfer += this->success[_i860].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 _iter859; - for (_iter859 = this->success.begin(); _iter859 != this->success.end(); ++_iter859) + std::vector ::const_iterator _iter861; + for (_iter861 = this->success.begin(); _iter861 != this->success.end(); ++_iter861) { - xfer += (*_iter859).write(oprot); + xfer += (*_iter861).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 _size860; - ::apache::thrift::protocol::TType _etype863; - xfer += iprot->readListBegin(_etype863, _size860); - (*(this->success)).resize(_size860); - uint32_t _i864; - for (_i864 = 0; _i864 < _size860; ++_i864) + uint32_t _size862; + ::apache::thrift::protocol::TType _etype865; + xfer += iprot->readListBegin(_etype865, _size862); + (*(this->success)).resize(_size862); + uint32_t _i866; + for (_i866 = 0; _i866 < _size862; ++_i866) { - xfer += (*(this->success))[_i864].read(iprot); + xfer += (*(this->success))[_i866].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 _size865; - ::apache::thrift::protocol::TType _etype868; - xfer += iprot->readListBegin(_etype868, _size865); - this->success.resize(_size865); - uint32_t _i869; - for (_i869 = 0; _i869 < _size865; ++_i869) + uint32_t _size867; + ::apache::thrift::protocol::TType _etype870; + xfer += iprot->readListBegin(_etype870, _size867); + this->success.resize(_size867); + uint32_t _i871; + for (_i871 = 0; _i871 < _size867; ++_i871) { - xfer += this->success[_i869].read(iprot); + xfer += this->success[_i871].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 _iter870; - for (_iter870 = this->success.begin(); _iter870 != this->success.end(); ++_iter870) + std::vector ::const_iterator _iter872; + for (_iter872 = this->success.begin(); _iter872 != this->success.end(); ++_iter872) { - xfer += (*_iter870).write(oprot); + xfer += (*_iter872).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 _size871; - ::apache::thrift::protocol::TType _etype874; - xfer += iprot->readListBegin(_etype874, _size871); - (*(this->success)).resize(_size871); - uint32_t _i875; - for (_i875 = 0; _i875 < _size871; ++_i875) + uint32_t _size873; + ::apache::thrift::protocol::TType _etype876; + xfer += iprot->readListBegin(_etype876, _size873); + (*(this->success)).resize(_size873); + uint32_t _i877; + for (_i877 = 0; _i877 < _size873; ++_i877) { - xfer += (*(this->success))[_i875].read(iprot); + xfer += (*(this->success))[_i877].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 _size876; - ::apache::thrift::protocol::TType _etype879; - xfer += iprot->readListBegin(_etype879, _size876); - this->success.resize(_size876); - uint32_t _i880; - for (_i880 = 0; _i880 < _size876; ++_i880) + uint32_t _size878; + ::apache::thrift::protocol::TType _etype881; + xfer += iprot->readListBegin(_etype881, _size878); + this->success.resize(_size878); + uint32_t _i882; + for (_i882 = 0; _i882 < _size878; ++_i882) { - xfer += this->success[_i880].read(iprot); + xfer += this->success[_i882].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 _iter881; - for (_iter881 = this->success.begin(); _iter881 != this->success.end(); ++_iter881) + std::vector ::const_iterator _iter883; + for (_iter883 = this->success.begin(); _iter883 != this->success.end(); ++_iter883) { - xfer += (*_iter881).write(oprot); + xfer += (*_iter883).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 _size882; - ::apache::thrift::protocol::TType _etype885; - xfer += iprot->readListBegin(_etype885, _size882); - (*(this->success)).resize(_size882); - uint32_t _i886; - for (_i886 = 0; _i886 < _size882; ++_i886) + uint32_t _size884; + ::apache::thrift::protocol::TType _etype887; + xfer += iprot->readListBegin(_etype887, _size884); + (*(this->success)).resize(_size884); + uint32_t _i888; + for (_i888 = 0; _i888 < _size884; ++_i888) { - xfer += (*(this->success))[_i886].read(iprot); + xfer += (*(this->success))[_i888].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 _size887; - ::apache::thrift::protocol::TType _etype890; - xfer += iprot->readListBegin(_etype890, _size887); - this->success.resize(_size887); - uint32_t _i891; - for (_i891 = 0; _i891 < _size887; ++_i891) + uint32_t _size889; + ::apache::thrift::protocol::TType _etype892; + xfer += iprot->readListBegin(_etype892, _size889); + this->success.resize(_size889); + uint32_t _i893; + for (_i893 = 0; _i893 < _size889; ++_i893) { - xfer += this->success[_i891].read(iprot); + xfer += this->success[_i893].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 _iter892; - for (_iter892 = this->success.begin(); _iter892 != this->success.end(); ++_iter892) + std::vector ::const_iterator _iter894; + for (_iter894 = this->success.begin(); _iter894 != this->success.end(); ++_iter894) { - xfer += (*_iter892).write(oprot); + xfer += (*_iter894).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 _size893; - ::apache::thrift::protocol::TType _etype896; - xfer += iprot->readListBegin(_etype896, _size893); - (*(this->success)).resize(_size893); - uint32_t _i897; - for (_i897 = 0; _i897 < _size893; ++_i897) + uint32_t _size895; + ::apache::thrift::protocol::TType _etype898; + xfer += iprot->readListBegin(_etype898, _size895); + (*(this->success)).resize(_size895); + uint32_t _i899; + for (_i899 = 0; _i899 < _size895; ++_i899) { - xfer += (*(this->success))[_i897].read(iprot); + xfer += (*(this->success))[_i899].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 _size898; - ::apache::thrift::protocol::TType _etype901; - xfer += iprot->readListBegin(_etype901, _size898); - this->primaryKeys.resize(_size898); - uint32_t _i902; - for (_i902 = 0; _i902 < _size898; ++_i902) + uint32_t _size900; + ::apache::thrift::protocol::TType _etype903; + xfer += iprot->readListBegin(_etype903, _size900); + this->primaryKeys.resize(_size900); + uint32_t _i904; + for (_i904 = 0; _i904 < _size900; ++_i904) { - xfer += this->primaryKeys[_i902].read(iprot); + xfer += this->primaryKeys[_i904].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 _size903; - ::apache::thrift::protocol::TType _etype906; - xfer += iprot->readListBegin(_etype906, _size903); - this->foreignKeys.resize(_size903); - uint32_t _i907; - for (_i907 = 0; _i907 < _size903; ++_i907) + uint32_t _size905; + ::apache::thrift::protocol::TType _etype908; + xfer += iprot->readListBegin(_etype908, _size905); + this->foreignKeys.resize(_size905); + uint32_t _i909; + for (_i909 = 0; _i909 < _size905; ++_i909) { - xfer += this->foreignKeys[_i907].read(iprot); + xfer += this->foreignKeys[_i909].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 _iter908; - for (_iter908 = this->primaryKeys.begin(); _iter908 != this->primaryKeys.end(); ++_iter908) + std::vector ::const_iterator _iter910; + for (_iter910 = this->primaryKeys.begin(); _iter910 != this->primaryKeys.end(); ++_iter910) { - xfer += (*_iter908).write(oprot); + xfer += (*_iter910).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 _iter909; - for (_iter909 = this->foreignKeys.begin(); _iter909 != this->foreignKeys.end(); ++_iter909) + std::vector ::const_iterator _iter911; + for (_iter911 = this->foreignKeys.begin(); _iter911 != this->foreignKeys.end(); ++_iter911) { - xfer += (*_iter909).write(oprot); + xfer += (*_iter911).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 _iter910; - for (_iter910 = (*(this->primaryKeys)).begin(); _iter910 != (*(this->primaryKeys)).end(); ++_iter910) + std::vector ::const_iterator _iter912; + for (_iter912 = (*(this->primaryKeys)).begin(); _iter912 != (*(this->primaryKeys)).end(); ++_iter912) { - xfer += (*_iter910).write(oprot); + xfer += (*_iter912).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 _iter911; - for (_iter911 = (*(this->foreignKeys)).begin(); _iter911 != (*(this->foreignKeys)).end(); ++_iter911) + std::vector ::const_iterator _iter913; + for (_iter913 = (*(this->foreignKeys)).begin(); _iter913 != (*(this->foreignKeys)).end(); ++_iter913) { - xfer += (*_iter911).write(oprot); + xfer += (*_iter913).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5976,14 +5976,14 @@ uint32_t ThriftHiveMetastore_truncate_table_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partNames.clear(); - uint32_t _size912; - ::apache::thrift::protocol::TType _etype915; - xfer += iprot->readListBegin(_etype915, _size912); - this->partNames.resize(_size912); - uint32_t _i916; - for (_i916 = 0; _i916 < _size912; ++_i916) + uint32_t _size914; + ::apache::thrift::protocol::TType _etype917; + xfer += iprot->readListBegin(_etype917, _size914); + this->partNames.resize(_size914); + uint32_t _i918; + for (_i918 = 0; _i918 < _size914; ++_i918) { - xfer += iprot->readString(this->partNames[_i916]); + xfer += iprot->readString(this->partNames[_i918]); } xfer += iprot->readListEnd(); } @@ -6020,10 +6020,10 @@ uint32_t ThriftHiveMetastore_truncate_table_args::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("partNames", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partNames.size())); - std::vector ::const_iterator _iter917; - for (_iter917 = this->partNames.begin(); _iter917 != this->partNames.end(); ++_iter917) + std::vector ::const_iterator _iter919; + for (_iter919 = this->partNames.begin(); _iter919 != this->partNames.end(); ++_iter919) { - xfer += oprot->writeString((*_iter917)); + xfer += oprot->writeString((*_iter919)); } xfer += oprot->writeListEnd(); } @@ -6055,10 +6055,10 @@ uint32_t ThriftHiveMetastore_truncate_table_pargs::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("partNames", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->partNames)).size())); - std::vector ::const_iterator _iter918; - for (_iter918 = (*(this->partNames)).begin(); _iter918 != (*(this->partNames)).end(); ++_iter918) + std::vector ::const_iterator _iter920; + for (_iter920 = (*(this->partNames)).begin(); _iter920 != (*(this->partNames)).end(); ++_iter920) { - xfer += oprot->writeString((*_iter918)); + xfer += oprot->writeString((*_iter920)); } xfer += oprot->writeListEnd(); } @@ -6302,14 +6302,14 @@ uint32_t ThriftHiveMetastore_get_tables_result::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(); } @@ -6348,10 +6348,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 _iter924; - for (_iter924 = this->success.begin(); _iter924 != this->success.end(); ++_iter924) + std::vector ::const_iterator _iter926; + for (_iter926 = this->success.begin(); _iter926 != this->success.end(); ++_iter926) { - xfer += oprot->writeString((*_iter924)); + xfer += oprot->writeString((*_iter926)); } xfer += oprot->writeListEnd(); } @@ -6396,14 +6396,14 @@ uint32_t ThriftHiveMetastore_get_tables_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size925; - ::apache::thrift::protocol::TType _etype928; - xfer += iprot->readListBegin(_etype928, _size925); - (*(this->success)).resize(_size925); - uint32_t _i929; - for (_i929 = 0; _i929 < _size925; ++_i929) + uint32_t _size927; + ::apache::thrift::protocol::TType _etype930; + xfer += iprot->readListBegin(_etype930, _size927); + (*(this->success)).resize(_size927); + uint32_t _i931; + for (_i931 = 0; _i931 < _size927; ++_i931) { - xfer += iprot->readString((*(this->success))[_i929]); + xfer += iprot->readString((*(this->success))[_i931]); } xfer += iprot->readListEnd(); } @@ -6573,14 +6573,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 _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(); } @@ -6619,10 +6619,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 _iter935; - for (_iter935 = this->success.begin(); _iter935 != this->success.end(); ++_iter935) + std::vector ::const_iterator _iter937; + for (_iter937 = this->success.begin(); _iter937 != this->success.end(); ++_iter937) { - xfer += oprot->writeString((*_iter935)); + xfer += oprot->writeString((*_iter937)); } xfer += oprot->writeListEnd(); } @@ -6667,14 +6667,14 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_presult::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size936; - ::apache::thrift::protocol::TType _etype939; - xfer += iprot->readListBegin(_etype939, _size936); - (*(this->success)).resize(_size936); - uint32_t _i940; - for (_i940 = 0; _i940 < _size936; ++_i940) + uint32_t _size938; + ::apache::thrift::protocol::TType _etype941; + xfer += iprot->readListBegin(_etype941, _size938); + (*(this->success)).resize(_size938); + uint32_t _i942; + for (_i942 = 0; _i942 < _size938; ++_i942) { - xfer += iprot->readString((*(this->success))[_i940]); + xfer += iprot->readString((*(this->success))[_i942]); } xfer += iprot->readListEnd(); } @@ -6749,14 +6749,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 _size941; - ::apache::thrift::protocol::TType _etype944; - xfer += iprot->readListBegin(_etype944, _size941); - this->tbl_types.resize(_size941); - uint32_t _i945; - for (_i945 = 0; _i945 < _size941; ++_i945) + uint32_t _size943; + ::apache::thrift::protocol::TType _etype946; + xfer += iprot->readListBegin(_etype946, _size943); + this->tbl_types.resize(_size943); + uint32_t _i947; + for (_i947 = 0; _i947 < _size943; ++_i947) { - xfer += iprot->readString(this->tbl_types[_i945]); + xfer += iprot->readString(this->tbl_types[_i947]); } xfer += iprot->readListEnd(); } @@ -6793,10 +6793,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 _iter946; - for (_iter946 = this->tbl_types.begin(); _iter946 != this->tbl_types.end(); ++_iter946) + std::vector ::const_iterator _iter948; + for (_iter948 = this->tbl_types.begin(); _iter948 != this->tbl_types.end(); ++_iter948) { - xfer += oprot->writeString((*_iter946)); + xfer += oprot->writeString((*_iter948)); } xfer += oprot->writeListEnd(); } @@ -6828,10 +6828,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 _iter947; - for (_iter947 = (*(this->tbl_types)).begin(); _iter947 != (*(this->tbl_types)).end(); ++_iter947) + std::vector ::const_iterator _iter949; + for (_iter949 = (*(this->tbl_types)).begin(); _iter949 != (*(this->tbl_types)).end(); ++_iter949) { - xfer += oprot->writeString((*_iter947)); + xfer += oprot->writeString((*_iter949)); } xfer += oprot->writeListEnd(); } @@ -6872,14 +6872,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_result::read(::apache::thrift::proto 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(); } @@ -6918,10 +6918,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 _iter953; - for (_iter953 = this->success.begin(); _iter953 != this->success.end(); ++_iter953) + std::vector ::const_iterator _iter955; + for (_iter955 = this->success.begin(); _iter955 != this->success.end(); ++_iter955) { - xfer += (*_iter953).write(oprot); + xfer += (*_iter955).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6966,14 +6966,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size954; - ::apache::thrift::protocol::TType _etype957; - xfer += iprot->readListBegin(_etype957, _size954); - (*(this->success)).resize(_size954); - uint32_t _i958; - for (_i958 = 0; _i958 < _size954; ++_i958) + uint32_t _size956; + ::apache::thrift::protocol::TType _etype959; + xfer += iprot->readListBegin(_etype959, _size956); + (*(this->success)).resize(_size956); + uint32_t _i960; + for (_i960 = 0; _i960 < _size956; ++_i960) { - xfer += (*(this->success))[_i958].read(iprot); + xfer += (*(this->success))[_i960].read(iprot); } xfer += iprot->readListEnd(); } @@ -7111,14 +7111,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_result::read(::apache::thrift::proto 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(); } @@ -7157,10 +7157,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 _iter964; - for (_iter964 = this->success.begin(); _iter964 != this->success.end(); ++_iter964) + std::vector ::const_iterator _iter966; + for (_iter966 = this->success.begin(); _iter966 != this->success.end(); ++_iter966) { - xfer += oprot->writeString((*_iter964)); + xfer += oprot->writeString((*_iter966)); } xfer += oprot->writeListEnd(); } @@ -7205,14 +7205,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size965; - ::apache::thrift::protocol::TType _etype968; - xfer += iprot->readListBegin(_etype968, _size965); - (*(this->success)).resize(_size965); - uint32_t _i969; - for (_i969 = 0; _i969 < _size965; ++_i969) + uint32_t _size967; + ::apache::thrift::protocol::TType _etype970; + xfer += iprot->readListBegin(_etype970, _size967); + (*(this->success)).resize(_size967); + uint32_t _i971; + for (_i971 = 0; _i971 < _size967; ++_i971) { - xfer += iprot->readString((*(this->success))[_i969]); + xfer += iprot->readString((*(this->success))[_i971]); } xfer += iprot->readListEnd(); } @@ -7522,14 +7522,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 _size970; - ::apache::thrift::protocol::TType _etype973; - xfer += iprot->readListBegin(_etype973, _size970); - this->tbl_names.resize(_size970); - uint32_t _i974; - for (_i974 = 0; _i974 < _size970; ++_i974) + uint32_t _size972; + ::apache::thrift::protocol::TType _etype975; + xfer += iprot->readListBegin(_etype975, _size972); + this->tbl_names.resize(_size972); + uint32_t _i976; + for (_i976 = 0; _i976 < _size972; ++_i976) { - xfer += iprot->readString(this->tbl_names[_i974]); + xfer += iprot->readString(this->tbl_names[_i976]); } xfer += iprot->readListEnd(); } @@ -7562,10 +7562,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 _iter975; - for (_iter975 = this->tbl_names.begin(); _iter975 != this->tbl_names.end(); ++_iter975) + std::vector ::const_iterator _iter977; + for (_iter977 = this->tbl_names.begin(); _iter977 != this->tbl_names.end(); ++_iter977) { - xfer += oprot->writeString((*_iter975)); + xfer += oprot->writeString((*_iter977)); } xfer += oprot->writeListEnd(); } @@ -7593,10 +7593,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 _iter976; - for (_iter976 = (*(this->tbl_names)).begin(); _iter976 != (*(this->tbl_names)).end(); ++_iter976) + std::vector ::const_iterator _iter978; + for (_iter978 = (*(this->tbl_names)).begin(); _iter978 != (*(this->tbl_names)).end(); ++_iter978) { - xfer += oprot->writeString((*_iter976)); + xfer += oprot->writeString((*_iter978)); } xfer += oprot->writeListEnd(); } @@ -7637,14 +7637,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 _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(); } @@ -7675,10 +7675,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 _iter982; - for (_iter982 = this->success.begin(); _iter982 != this->success.end(); ++_iter982) + std::vector
::const_iterator _iter984; + for (_iter984 = this->success.begin(); _iter984 != this->success.end(); ++_iter984) { - xfer += (*_iter982).write(oprot); + xfer += (*_iter984).write(oprot); } xfer += oprot->writeListEnd(); } @@ -7719,14 +7719,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 _size983; - ::apache::thrift::protocol::TType _etype986; - xfer += iprot->readListBegin(_etype986, _size983); - (*(this->success)).resize(_size983); - uint32_t _i987; - for (_i987 = 0; _i987 < _size983; ++_i987) + uint32_t _size985; + ::apache::thrift::protocol::TType _etype988; + xfer += iprot->readListBegin(_etype988, _size985); + (*(this->success)).resize(_size985); + uint32_t _i989; + for (_i989 = 0; _i989 < _size985; ++_i989) { - xfer += (*(this->success))[_i987].read(iprot); + xfer += (*(this->success))[_i989].read(iprot); } xfer += iprot->readListEnd(); } @@ -8362,14 +8362,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 _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(); } @@ -8424,10 +8424,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 _iter993; - for (_iter993 = this->success.begin(); _iter993 != this->success.end(); ++_iter993) + std::vector ::const_iterator _iter995; + for (_iter995 = this->success.begin(); _iter995 != this->success.end(); ++_iter995) { - xfer += oprot->writeString((*_iter993)); + xfer += oprot->writeString((*_iter995)); } xfer += oprot->writeListEnd(); } @@ -8480,14 +8480,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 _size994; - ::apache::thrift::protocol::TType _etype997; - xfer += iprot->readListBegin(_etype997, _size994); - (*(this->success)).resize(_size994); - uint32_t _i998; - for (_i998 = 0; _i998 < _size994; ++_i998) + uint32_t _size996; + ::apache::thrift::protocol::TType _etype999; + xfer += iprot->readListBegin(_etype999, _size996); + (*(this->success)).resize(_size996); + uint32_t _i1000; + for (_i1000 = 0; _i1000 < _size996; ++_i1000) { - xfer += iprot->readString((*(this->success))[_i998]); + xfer += iprot->readString((*(this->success))[_i1000]); } xfer += iprot->readListEnd(); } @@ -9821,14 +9821,14 @@ uint32_t ThriftHiveMetastore_add_partitions_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size999; - ::apache::thrift::protocol::TType _etype1002; - xfer += iprot->readListBegin(_etype1002, _size999); - this->new_parts.resize(_size999); - uint32_t _i1003; - for (_i1003 = 0; _i1003 < _size999; ++_i1003) + uint32_t _size1001; + ::apache::thrift::protocol::TType _etype1004; + xfer += iprot->readListBegin(_etype1004, _size1001); + this->new_parts.resize(_size1001); + uint32_t _i1005; + for (_i1005 = 0; _i1005 < _size1001; ++_i1005) { - xfer += this->new_parts[_i1003].read(iprot); + xfer += this->new_parts[_i1005].read(iprot); } xfer += iprot->readListEnd(); } @@ -9857,10 +9857,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 _iter1004; - for (_iter1004 = this->new_parts.begin(); _iter1004 != this->new_parts.end(); ++_iter1004) + std::vector ::const_iterator _iter1006; + for (_iter1006 = this->new_parts.begin(); _iter1006 != this->new_parts.end(); ++_iter1006) { - xfer += (*_iter1004).write(oprot); + xfer += (*_iter1006).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9884,10 +9884,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 _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(); } @@ -10096,14 +10096,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 _size1006; - ::apache::thrift::protocol::TType _etype1009; - xfer += iprot->readListBegin(_etype1009, _size1006); - this->new_parts.resize(_size1006); - uint32_t _i1010; - for (_i1010 = 0; _i1010 < _size1006; ++_i1010) + uint32_t _size1008; + ::apache::thrift::protocol::TType _etype1011; + xfer += iprot->readListBegin(_etype1011, _size1008); + this->new_parts.resize(_size1008); + uint32_t _i1012; + for (_i1012 = 0; _i1012 < _size1008; ++_i1012) { - xfer += this->new_parts[_i1010].read(iprot); + xfer += this->new_parts[_i1012].read(iprot); } xfer += iprot->readListEnd(); } @@ -10132,10 +10132,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 _iter1011; - for (_iter1011 = this->new_parts.begin(); _iter1011 != this->new_parts.end(); ++_iter1011) + std::vector ::const_iterator _iter1013; + for (_iter1013 = this->new_parts.begin(); _iter1013 != this->new_parts.end(); ++_iter1013) { - xfer += (*_iter1011).write(oprot); + xfer += (*_iter1013).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10159,10 +10159,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 _iter1012; - for (_iter1012 = (*(this->new_parts)).begin(); _iter1012 != (*(this->new_parts)).end(); ++_iter1012) + std::vector ::const_iterator _iter1014; + for (_iter1014 = (*(this->new_parts)).begin(); _iter1014 != (*(this->new_parts)).end(); ++_iter1014) { - xfer += (*_iter1012).write(oprot); + xfer += (*_iter1014).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10387,14 +10387,14 @@ uint32_t ThriftHiveMetastore_append_partition_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1013; - ::apache::thrift::protocol::TType _etype1016; - xfer += iprot->readListBegin(_etype1016, _size1013); - this->part_vals.resize(_size1013); - uint32_t _i1017; - for (_i1017 = 0; _i1017 < _size1013; ++_i1017) + uint32_t _size1015; + ::apache::thrift::protocol::TType _etype1018; + xfer += iprot->readListBegin(_etype1018, _size1015); + this->part_vals.resize(_size1015); + uint32_t _i1019; + for (_i1019 = 0; _i1019 < _size1015; ++_i1019) { - xfer += iprot->readString(this->part_vals[_i1017]); + xfer += iprot->readString(this->part_vals[_i1019]); } xfer += iprot->readListEnd(); } @@ -10431,10 +10431,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 _iter1018; - for (_iter1018 = this->part_vals.begin(); _iter1018 != this->part_vals.end(); ++_iter1018) + std::vector ::const_iterator _iter1020; + for (_iter1020 = this->part_vals.begin(); _iter1020 != this->part_vals.end(); ++_iter1020) { - xfer += oprot->writeString((*_iter1018)); + xfer += oprot->writeString((*_iter1020)); } xfer += oprot->writeListEnd(); } @@ -10466,10 +10466,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 _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(); } @@ -10941,14 +10941,14 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::rea if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1020; - ::apache::thrift::protocol::TType _etype1023; - xfer += iprot->readListBegin(_etype1023, _size1020); - this->part_vals.resize(_size1020); - uint32_t _i1024; - for (_i1024 = 0; _i1024 < _size1020; ++_i1024) + uint32_t _size1022; + ::apache::thrift::protocol::TType _etype1025; + xfer += iprot->readListBegin(_etype1025, _size1022); + this->part_vals.resize(_size1022); + uint32_t _i1026; + for (_i1026 = 0; _i1026 < _size1022; ++_i1026) { - xfer += iprot->readString(this->part_vals[_i1024]); + xfer += iprot->readString(this->part_vals[_i1026]); } xfer += iprot->readListEnd(); } @@ -10993,10 +10993,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 _iter1025; - for (_iter1025 = this->part_vals.begin(); _iter1025 != this->part_vals.end(); ++_iter1025) + std::vector ::const_iterator _iter1027; + for (_iter1027 = this->part_vals.begin(); _iter1027 != this->part_vals.end(); ++_iter1027) { - xfer += oprot->writeString((*_iter1025)); + xfer += oprot->writeString((*_iter1027)); } xfer += oprot->writeListEnd(); } @@ -11032,10 +11032,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 _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(); } @@ -11838,14 +11838,14 @@ uint32_t ThriftHiveMetastore_drop_partition_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1027; - ::apache::thrift::protocol::TType _etype1030; - xfer += iprot->readListBegin(_etype1030, _size1027); - this->part_vals.resize(_size1027); - uint32_t _i1031; - for (_i1031 = 0; _i1031 < _size1027; ++_i1031) + uint32_t _size1029; + ::apache::thrift::protocol::TType _etype1032; + xfer += iprot->readListBegin(_etype1032, _size1029); + this->part_vals.resize(_size1029); + uint32_t _i1033; + for (_i1033 = 0; _i1033 < _size1029; ++_i1033) { - xfer += iprot->readString(this->part_vals[_i1031]); + xfer += iprot->readString(this->part_vals[_i1033]); } xfer += iprot->readListEnd(); } @@ -11890,10 +11890,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 _iter1032; - for (_iter1032 = this->part_vals.begin(); _iter1032 != this->part_vals.end(); ++_iter1032) + std::vector ::const_iterator _iter1034; + for (_iter1034 = this->part_vals.begin(); _iter1034 != this->part_vals.end(); ++_iter1034) { - xfer += oprot->writeString((*_iter1032)); + xfer += oprot->writeString((*_iter1034)); } xfer += oprot->writeListEnd(); } @@ -11929,10 +11929,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 _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(); } @@ -12141,14 +12141,14 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::read( if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1034; - ::apache::thrift::protocol::TType _etype1037; - xfer += iprot->readListBegin(_etype1037, _size1034); - this->part_vals.resize(_size1034); - uint32_t _i1038; - for (_i1038 = 0; _i1038 < _size1034; ++_i1038) + uint32_t _size1036; + ::apache::thrift::protocol::TType _etype1039; + xfer += iprot->readListBegin(_etype1039, _size1036); + this->part_vals.resize(_size1036); + uint32_t _i1040; + for (_i1040 = 0; _i1040 < _size1036; ++_i1040) { - xfer += iprot->readString(this->part_vals[_i1038]); + xfer += iprot->readString(this->part_vals[_i1040]); } xfer += iprot->readListEnd(); } @@ -12201,10 +12201,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 _iter1039; - for (_iter1039 = this->part_vals.begin(); _iter1039 != this->part_vals.end(); ++_iter1039) + std::vector ::const_iterator _iter1041; + for (_iter1041 = this->part_vals.begin(); _iter1041 != this->part_vals.end(); ++_iter1041) { - xfer += oprot->writeString((*_iter1039)); + xfer += oprot->writeString((*_iter1041)); } xfer += oprot->writeListEnd(); } @@ -12244,10 +12244,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 _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(); } @@ -13253,14 +13253,14 @@ uint32_t ThriftHiveMetastore_get_partition_args::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1041; - ::apache::thrift::protocol::TType _etype1044; - xfer += iprot->readListBegin(_etype1044, _size1041); - this->part_vals.resize(_size1041); - uint32_t _i1045; - for (_i1045 = 0; _i1045 < _size1041; ++_i1045) + uint32_t _size1043; + ::apache::thrift::protocol::TType _etype1046; + xfer += iprot->readListBegin(_etype1046, _size1043); + this->part_vals.resize(_size1043); + uint32_t _i1047; + for (_i1047 = 0; _i1047 < _size1043; ++_i1047) { - xfer += iprot->readString(this->part_vals[_i1045]); + xfer += iprot->readString(this->part_vals[_i1047]); } xfer += iprot->readListEnd(); } @@ -13297,10 +13297,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 _iter1046; - for (_iter1046 = this->part_vals.begin(); _iter1046 != this->part_vals.end(); ++_iter1046) + std::vector ::const_iterator _iter1048; + for (_iter1048 = this->part_vals.begin(); _iter1048 != this->part_vals.end(); ++_iter1048) { - xfer += oprot->writeString((*_iter1046)); + xfer += oprot->writeString((*_iter1048)); } xfer += oprot->writeListEnd(); } @@ -13332,10 +13332,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 _iter1047; - for (_iter1047 = (*(this->part_vals)).begin(); _iter1047 != (*(this->part_vals)).end(); ++_iter1047) + std::vector ::const_iterator _iter1049; + for (_iter1049 = (*(this->part_vals)).begin(); _iter1049 != (*(this->part_vals)).end(); ++_iter1049) { - xfer += oprot->writeString((*_iter1047)); + xfer += oprot->writeString((*_iter1049)); } xfer += oprot->writeListEnd(); } @@ -13524,17 +13524,17 @@ uint32_t ThriftHiveMetastore_exchange_partition_args::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size1048; - ::apache::thrift::protocol::TType _ktype1049; - ::apache::thrift::protocol::TType _vtype1050; - xfer += iprot->readMapBegin(_ktype1049, _vtype1050, _size1048); - uint32_t _i1052; - for (_i1052 = 0; _i1052 < _size1048; ++_i1052) + uint32_t _size1050; + ::apache::thrift::protocol::TType _ktype1051; + ::apache::thrift::protocol::TType _vtype1052; + xfer += iprot->readMapBegin(_ktype1051, _vtype1052, _size1050); + uint32_t _i1054; + for (_i1054 = 0; _i1054 < _size1050; ++_i1054) { - std::string _key1053; - xfer += iprot->readString(_key1053); - std::string& _val1054 = this->partitionSpecs[_key1053]; - xfer += iprot->readString(_val1054); + std::string _key1055; + xfer += iprot->readString(_key1055); + std::string& _val1056 = this->partitionSpecs[_key1055]; + xfer += iprot->readString(_val1056); } xfer += iprot->readMapEnd(); } @@ -13595,11 +13595,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 _iter1055; - for (_iter1055 = this->partitionSpecs.begin(); _iter1055 != this->partitionSpecs.end(); ++_iter1055) + std::map ::const_iterator _iter1057; + for (_iter1057 = this->partitionSpecs.begin(); _iter1057 != this->partitionSpecs.end(); ++_iter1057) { - xfer += oprot->writeString(_iter1055->first); - xfer += oprot->writeString(_iter1055->second); + xfer += oprot->writeString(_iter1057->first); + xfer += oprot->writeString(_iter1057->second); } xfer += oprot->writeMapEnd(); } @@ -13639,11 +13639,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 _iter1056; - for (_iter1056 = (*(this->partitionSpecs)).begin(); _iter1056 != (*(this->partitionSpecs)).end(); ++_iter1056) + std::map ::const_iterator _iter1058; + for (_iter1058 = (*(this->partitionSpecs)).begin(); _iter1058 != (*(this->partitionSpecs)).end(); ++_iter1058) { - xfer += oprot->writeString(_iter1056->first); - xfer += oprot->writeString(_iter1056->second); + xfer += oprot->writeString(_iter1058->first); + xfer += oprot->writeString(_iter1058->second); } xfer += oprot->writeMapEnd(); } @@ -13888,17 +13888,17 @@ uint32_t ThriftHiveMetastore_exchange_partitions_args::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size1057; - ::apache::thrift::protocol::TType _ktype1058; - ::apache::thrift::protocol::TType _vtype1059; - xfer += iprot->readMapBegin(_ktype1058, _vtype1059, _size1057); - uint32_t _i1061; - for (_i1061 = 0; _i1061 < _size1057; ++_i1061) + uint32_t _size1059; + ::apache::thrift::protocol::TType _ktype1060; + ::apache::thrift::protocol::TType _vtype1061; + xfer += iprot->readMapBegin(_ktype1060, _vtype1061, _size1059); + uint32_t _i1063; + for (_i1063 = 0; _i1063 < _size1059; ++_i1063) { - std::string _key1062; - xfer += iprot->readString(_key1062); - std::string& _val1063 = this->partitionSpecs[_key1062]; - xfer += iprot->readString(_val1063); + std::string _key1064; + xfer += iprot->readString(_key1064); + std::string& _val1065 = this->partitionSpecs[_key1064]; + xfer += iprot->readString(_val1065); } xfer += iprot->readMapEnd(); } @@ -13959,11 +13959,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 _iter1064; - for (_iter1064 = this->partitionSpecs.begin(); _iter1064 != this->partitionSpecs.end(); ++_iter1064) + std::map ::const_iterator _iter1066; + for (_iter1066 = this->partitionSpecs.begin(); _iter1066 != this->partitionSpecs.end(); ++_iter1066) { - xfer += oprot->writeString(_iter1064->first); - xfer += oprot->writeString(_iter1064->second); + xfer += oprot->writeString(_iter1066->first); + xfer += oprot->writeString(_iter1066->second); } xfer += oprot->writeMapEnd(); } @@ -14003,11 +14003,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 _iter1065; - for (_iter1065 = (*(this->partitionSpecs)).begin(); _iter1065 != (*(this->partitionSpecs)).end(); ++_iter1065) + std::map ::const_iterator _iter1067; + for (_iter1067 = (*(this->partitionSpecs)).begin(); _iter1067 != (*(this->partitionSpecs)).end(); ++_iter1067) { - xfer += oprot->writeString(_iter1065->first); - xfer += oprot->writeString(_iter1065->second); + xfer += oprot->writeString(_iter1067->first); + xfer += oprot->writeString(_iter1067->second); } xfer += oprot->writeMapEnd(); } @@ -14064,14 +14064,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_result::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(); } @@ -14134,10 +14134,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 _iter1071; - for (_iter1071 = this->success.begin(); _iter1071 != this->success.end(); ++_iter1071) + std::vector ::const_iterator _iter1073; + for (_iter1073 = this->success.begin(); _iter1073 != this->success.end(); ++_iter1073) { - xfer += (*_iter1071).write(oprot); + xfer += (*_iter1073).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14194,14 +14194,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1072; - ::apache::thrift::protocol::TType _etype1075; - xfer += iprot->readListBegin(_etype1075, _size1072); - (*(this->success)).resize(_size1072); - uint32_t _i1076; - for (_i1076 = 0; _i1076 < _size1072; ++_i1076) + uint32_t _size1074; + ::apache::thrift::protocol::TType _etype1077; + xfer += iprot->readListBegin(_etype1077, _size1074); + (*(this->success)).resize(_size1074); + uint32_t _i1078; + for (_i1078 = 0; _i1078 < _size1074; ++_i1078) { - xfer += (*(this->success))[_i1076].read(iprot); + xfer += (*(this->success))[_i1078].read(iprot); } xfer += iprot->readListEnd(); } @@ -14300,14 +14300,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 _size1077; - ::apache::thrift::protocol::TType _etype1080; - xfer += iprot->readListBegin(_etype1080, _size1077); - this->part_vals.resize(_size1077); - uint32_t _i1081; - for (_i1081 = 0; _i1081 < _size1077; ++_i1081) + uint32_t _size1079; + ::apache::thrift::protocol::TType _etype1082; + xfer += iprot->readListBegin(_etype1082, _size1079); + this->part_vals.resize(_size1079); + uint32_t _i1083; + for (_i1083 = 0; _i1083 < _size1079; ++_i1083) { - xfer += iprot->readString(this->part_vals[_i1081]); + xfer += iprot->readString(this->part_vals[_i1083]); } xfer += iprot->readListEnd(); } @@ -14328,14 +14328,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 _size1082; - ::apache::thrift::protocol::TType _etype1085; - xfer += iprot->readListBegin(_etype1085, _size1082); - this->group_names.resize(_size1082); - uint32_t _i1086; - for (_i1086 = 0; _i1086 < _size1082; ++_i1086) + uint32_t _size1084; + ::apache::thrift::protocol::TType _etype1087; + xfer += iprot->readListBegin(_etype1087, _size1084); + this->group_names.resize(_size1084); + uint32_t _i1088; + for (_i1088 = 0; _i1088 < _size1084; ++_i1088) { - xfer += iprot->readString(this->group_names[_i1086]); + xfer += iprot->readString(this->group_names[_i1088]); } xfer += iprot->readListEnd(); } @@ -14372,10 +14372,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 _iter1087; - for (_iter1087 = this->part_vals.begin(); _iter1087 != this->part_vals.end(); ++_iter1087) + std::vector ::const_iterator _iter1089; + for (_iter1089 = this->part_vals.begin(); _iter1089 != this->part_vals.end(); ++_iter1089) { - xfer += oprot->writeString((*_iter1087)); + xfer += oprot->writeString((*_iter1089)); } xfer += oprot->writeListEnd(); } @@ -14388,10 +14388,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 _iter1088; - for (_iter1088 = this->group_names.begin(); _iter1088 != this->group_names.end(); ++_iter1088) + std::vector ::const_iterator _iter1090; + for (_iter1090 = this->group_names.begin(); _iter1090 != this->group_names.end(); ++_iter1090) { - xfer += oprot->writeString((*_iter1088)); + xfer += oprot->writeString((*_iter1090)); } xfer += oprot->writeListEnd(); } @@ -14423,10 +14423,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 _iter1089; - for (_iter1089 = (*(this->part_vals)).begin(); _iter1089 != (*(this->part_vals)).end(); ++_iter1089) + std::vector ::const_iterator _iter1091; + for (_iter1091 = (*(this->part_vals)).begin(); _iter1091 != (*(this->part_vals)).end(); ++_iter1091) { - xfer += oprot->writeString((*_iter1089)); + xfer += oprot->writeString((*_iter1091)); } xfer += oprot->writeListEnd(); } @@ -14439,10 +14439,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 _iter1090; - for (_iter1090 = (*(this->group_names)).begin(); _iter1090 != (*(this->group_names)).end(); ++_iter1090) + std::vector ::const_iterator _iter1092; + for (_iter1092 = (*(this->group_names)).begin(); _iter1092 != (*(this->group_names)).end(); ++_iter1092) { - xfer += oprot->writeString((*_iter1090)); + xfer += oprot->writeString((*_iter1092)); } xfer += oprot->writeListEnd(); } @@ -15001,14 +15001,14 @@ uint32_t ThriftHiveMetastore_get_partitions_result::read(::apache::thrift::proto 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(); } @@ -15055,10 +15055,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 _iter1096; - for (_iter1096 = this->success.begin(); _iter1096 != this->success.end(); ++_iter1096) + std::vector ::const_iterator _iter1098; + for (_iter1098 = this->success.begin(); _iter1098 != this->success.end(); ++_iter1098) { - xfer += (*_iter1096).write(oprot); + xfer += (*_iter1098).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15107,14 +15107,14 @@ uint32_t ThriftHiveMetastore_get_partitions_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1097; - ::apache::thrift::protocol::TType _etype1100; - xfer += iprot->readListBegin(_etype1100, _size1097); - (*(this->success)).resize(_size1097); - uint32_t _i1101; - for (_i1101 = 0; _i1101 < _size1097; ++_i1101) + uint32_t _size1099; + ::apache::thrift::protocol::TType _etype1102; + xfer += iprot->readListBegin(_etype1102, _size1099); + (*(this->success)).resize(_size1099); + uint32_t _i1103; + for (_i1103 = 0; _i1103 < _size1099; ++_i1103) { - xfer += (*(this->success))[_i1101].read(iprot); + xfer += (*(this->success))[_i1103].read(iprot); } xfer += iprot->readListEnd(); } @@ -15213,14 +15213,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 _size1102; - ::apache::thrift::protocol::TType _etype1105; - xfer += iprot->readListBegin(_etype1105, _size1102); - this->group_names.resize(_size1102); - uint32_t _i1106; - for (_i1106 = 0; _i1106 < _size1102; ++_i1106) + uint32_t _size1104; + ::apache::thrift::protocol::TType _etype1107; + xfer += iprot->readListBegin(_etype1107, _size1104); + this->group_names.resize(_size1104); + uint32_t _i1108; + for (_i1108 = 0; _i1108 < _size1104; ++_i1108) { - xfer += iprot->readString(this->group_names[_i1106]); + xfer += iprot->readString(this->group_names[_i1108]); } xfer += iprot->readListEnd(); } @@ -15265,10 +15265,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 _iter1107; - for (_iter1107 = this->group_names.begin(); _iter1107 != this->group_names.end(); ++_iter1107) + std::vector ::const_iterator _iter1109; + for (_iter1109 = this->group_names.begin(); _iter1109 != this->group_names.end(); ++_iter1109) { - xfer += oprot->writeString((*_iter1107)); + xfer += oprot->writeString((*_iter1109)); } xfer += oprot->writeListEnd(); } @@ -15308,10 +15308,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 _iter1108; - for (_iter1108 = (*(this->group_names)).begin(); _iter1108 != (*(this->group_names)).end(); ++_iter1108) + std::vector ::const_iterator _iter1110; + for (_iter1110 = (*(this->group_names)).begin(); _iter1110 != (*(this->group_names)).end(); ++_iter1110) { - xfer += oprot->writeString((*_iter1108)); + xfer += oprot->writeString((*_iter1110)); } xfer += oprot->writeListEnd(); } @@ -15352,14 +15352,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_result::read(::apache::thr 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(); } @@ -15406,10 +15406,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 _iter1114; - for (_iter1114 = this->success.begin(); _iter1114 != this->success.end(); ++_iter1114) + std::vector ::const_iterator _iter1116; + for (_iter1116 = this->success.begin(); _iter1116 != this->success.end(); ++_iter1116) { - xfer += (*_iter1114).write(oprot); + xfer += (*_iter1116).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15458,14 +15458,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1115; - ::apache::thrift::protocol::TType _etype1118; - xfer += iprot->readListBegin(_etype1118, _size1115); - (*(this->success)).resize(_size1115); - uint32_t _i1119; - for (_i1119 = 0; _i1119 < _size1115; ++_i1119) + uint32_t _size1117; + ::apache::thrift::protocol::TType _etype1120; + xfer += iprot->readListBegin(_etype1120, _size1117); + (*(this->success)).resize(_size1117); + uint32_t _i1121; + for (_i1121 = 0; _i1121 < _size1117; ++_i1121) { - xfer += (*(this->success))[_i1119].read(iprot); + xfer += (*(this->success))[_i1121].read(iprot); } xfer += iprot->readListEnd(); } @@ -15643,14 +15643,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_result::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(); } @@ -15697,10 +15697,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 _iter1125; - for (_iter1125 = this->success.begin(); _iter1125 != this->success.end(); ++_iter1125) + std::vector ::const_iterator _iter1127; + for (_iter1127 = this->success.begin(); _iter1127 != this->success.end(); ++_iter1127) { - xfer += (*_iter1125).write(oprot); + xfer += (*_iter1127).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15749,14 +15749,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_presult::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1126; - ::apache::thrift::protocol::TType _etype1129; - xfer += iprot->readListBegin(_etype1129, _size1126); - (*(this->success)).resize(_size1126); - uint32_t _i1130; - for (_i1130 = 0; _i1130 < _size1126; ++_i1130) + uint32_t _size1128; + ::apache::thrift::protocol::TType _etype1131; + xfer += iprot->readListBegin(_etype1131, _size1128); + (*(this->success)).resize(_size1128); + uint32_t _i1132; + for (_i1132 = 0; _i1132 < _size1128; ++_i1132) { - xfer += (*(this->success))[_i1130].read(iprot); + xfer += (*(this->success))[_i1132].read(iprot); } xfer += iprot->readListEnd(); } @@ -15934,14 +15934,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_result::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(); } @@ -15980,10 +15980,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 _iter1136; - for (_iter1136 = this->success.begin(); _iter1136 != this->success.end(); ++_iter1136) + std::vector ::const_iterator _iter1138; + for (_iter1138 = this->success.begin(); _iter1138 != this->success.end(); ++_iter1138) { - xfer += oprot->writeString((*_iter1136)); + xfer += oprot->writeString((*_iter1138)); } xfer += oprot->writeListEnd(); } @@ -16028,14 +16028,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1137; - ::apache::thrift::protocol::TType _etype1140; - xfer += iprot->readListBegin(_etype1140, _size1137); - (*(this->success)).resize(_size1137); - uint32_t _i1141; - for (_i1141 = 0; _i1141 < _size1137; ++_i1141) + uint32_t _size1139; + ::apache::thrift::protocol::TType _etype1142; + xfer += iprot->readListBegin(_etype1142, _size1139); + (*(this->success)).resize(_size1139); + uint32_t _i1143; + for (_i1143 = 0; _i1143 < _size1139; ++_i1143) { - xfer += iprot->readString((*(this->success))[_i1141]); + xfer += iprot->readString((*(this->success))[_i1143]); } xfer += iprot->readListEnd(); } @@ -16110,14 +16110,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 _size1142; - ::apache::thrift::protocol::TType _etype1145; - xfer += iprot->readListBegin(_etype1145, _size1142); - this->part_vals.resize(_size1142); - uint32_t _i1146; - for (_i1146 = 0; _i1146 < _size1142; ++_i1146) + uint32_t _size1144; + ::apache::thrift::protocol::TType _etype1147; + xfer += iprot->readListBegin(_etype1147, _size1144); + this->part_vals.resize(_size1144); + uint32_t _i1148; + for (_i1148 = 0; _i1148 < _size1144; ++_i1148) { - xfer += iprot->readString(this->part_vals[_i1146]); + xfer += iprot->readString(this->part_vals[_i1148]); } xfer += iprot->readListEnd(); } @@ -16162,10 +16162,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 _iter1147; - for (_iter1147 = this->part_vals.begin(); _iter1147 != this->part_vals.end(); ++_iter1147) + std::vector ::const_iterator _iter1149; + for (_iter1149 = this->part_vals.begin(); _iter1149 != this->part_vals.end(); ++_iter1149) { - xfer += oprot->writeString((*_iter1147)); + xfer += oprot->writeString((*_iter1149)); } xfer += oprot->writeListEnd(); } @@ -16201,10 +16201,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 _iter1148; - for (_iter1148 = (*(this->part_vals)).begin(); _iter1148 != (*(this->part_vals)).end(); ++_iter1148) + std::vector ::const_iterator _iter1150; + for (_iter1150 = (*(this->part_vals)).begin(); _iter1150 != (*(this->part_vals)).end(); ++_iter1150) { - xfer += oprot->writeString((*_iter1148)); + xfer += oprot->writeString((*_iter1150)); } xfer += oprot->writeListEnd(); } @@ -16249,14 +16249,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_result::read(::apache::thrift::pr 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(); } @@ -16303,10 +16303,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 _iter1154; - for (_iter1154 = this->success.begin(); _iter1154 != this->success.end(); ++_iter1154) + std::vector ::const_iterator _iter1156; + for (_iter1156 = this->success.begin(); _iter1156 != this->success.end(); ++_iter1156) { - xfer += (*_iter1154).write(oprot); + xfer += (*_iter1156).write(oprot); } xfer += oprot->writeListEnd(); } @@ -16355,14 +16355,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_presult::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1155; - ::apache::thrift::protocol::TType _etype1158; - xfer += iprot->readListBegin(_etype1158, _size1155); - (*(this->success)).resize(_size1155); - uint32_t _i1159; - for (_i1159 = 0; _i1159 < _size1155; ++_i1159) + uint32_t _size1157; + ::apache::thrift::protocol::TType _etype1160; + xfer += iprot->readListBegin(_etype1160, _size1157); + (*(this->success)).resize(_size1157); + uint32_t _i1161; + for (_i1161 = 0; _i1161 < _size1157; ++_i1161) { - xfer += (*(this->success))[_i1159].read(iprot); + xfer += (*(this->success))[_i1161].read(iprot); } xfer += iprot->readListEnd(); } @@ -16445,14 +16445,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 _size1160; - ::apache::thrift::protocol::TType _etype1163; - xfer += iprot->readListBegin(_etype1163, _size1160); - this->part_vals.resize(_size1160); - uint32_t _i1164; - for (_i1164 = 0; _i1164 < _size1160; ++_i1164) + uint32_t _size1162; + ::apache::thrift::protocol::TType _etype1165; + xfer += iprot->readListBegin(_etype1165, _size1162); + this->part_vals.resize(_size1162); + uint32_t _i1166; + for (_i1166 = 0; _i1166 < _size1162; ++_i1166) { - xfer += iprot->readString(this->part_vals[_i1164]); + xfer += iprot->readString(this->part_vals[_i1166]); } xfer += iprot->readListEnd(); } @@ -16481,14 +16481,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 _size1165; - ::apache::thrift::protocol::TType _etype1168; - xfer += iprot->readListBegin(_etype1168, _size1165); - this->group_names.resize(_size1165); - uint32_t _i1169; - for (_i1169 = 0; _i1169 < _size1165; ++_i1169) + uint32_t _size1167; + ::apache::thrift::protocol::TType _etype1170; + xfer += iprot->readListBegin(_etype1170, _size1167); + this->group_names.resize(_size1167); + uint32_t _i1171; + for (_i1171 = 0; _i1171 < _size1167; ++_i1171) { - xfer += iprot->readString(this->group_names[_i1169]); + xfer += iprot->readString(this->group_names[_i1171]); } xfer += iprot->readListEnd(); } @@ -16525,10 +16525,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 _iter1170; - for (_iter1170 = this->part_vals.begin(); _iter1170 != this->part_vals.end(); ++_iter1170) + std::vector ::const_iterator _iter1172; + for (_iter1172 = this->part_vals.begin(); _iter1172 != this->part_vals.end(); ++_iter1172) { - xfer += oprot->writeString((*_iter1170)); + xfer += oprot->writeString((*_iter1172)); } xfer += oprot->writeListEnd(); } @@ -16545,10 +16545,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 _iter1171; - for (_iter1171 = this->group_names.begin(); _iter1171 != this->group_names.end(); ++_iter1171) + std::vector ::const_iterator _iter1173; + for (_iter1173 = this->group_names.begin(); _iter1173 != this->group_names.end(); ++_iter1173) { - xfer += oprot->writeString((*_iter1171)); + xfer += oprot->writeString((*_iter1173)); } xfer += oprot->writeListEnd(); } @@ -16580,10 +16580,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 _iter1172; - for (_iter1172 = (*(this->part_vals)).begin(); _iter1172 != (*(this->part_vals)).end(); ++_iter1172) + std::vector ::const_iterator _iter1174; + for (_iter1174 = (*(this->part_vals)).begin(); _iter1174 != (*(this->part_vals)).end(); ++_iter1174) { - xfer += oprot->writeString((*_iter1172)); + xfer += oprot->writeString((*_iter1174)); } xfer += oprot->writeListEnd(); } @@ -16600,10 +16600,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 _iter1173; - for (_iter1173 = (*(this->group_names)).begin(); _iter1173 != (*(this->group_names)).end(); ++_iter1173) + std::vector ::const_iterator _iter1175; + for (_iter1175 = (*(this->group_names)).begin(); _iter1175 != (*(this->group_names)).end(); ++_iter1175) { - xfer += oprot->writeString((*_iter1173)); + xfer += oprot->writeString((*_iter1175)); } xfer += oprot->writeListEnd(); } @@ -16644,14 +16644,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_result::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(); } @@ -16698,10 +16698,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 _iter1179; - for (_iter1179 = this->success.begin(); _iter1179 != this->success.end(); ++_iter1179) + std::vector ::const_iterator _iter1181; + for (_iter1181 = this->success.begin(); _iter1181 != this->success.end(); ++_iter1181) { - xfer += (*_iter1179).write(oprot); + xfer += (*_iter1181).write(oprot); } xfer += oprot->writeListEnd(); } @@ -16750,14 +16750,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_presult::read(::apache: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1180; - ::apache::thrift::protocol::TType _etype1183; - xfer += iprot->readListBegin(_etype1183, _size1180); - (*(this->success)).resize(_size1180); - uint32_t _i1184; - for (_i1184 = 0; _i1184 < _size1180; ++_i1184) + uint32_t _size1182; + ::apache::thrift::protocol::TType _etype1185; + xfer += iprot->readListBegin(_etype1185, _size1182); + (*(this->success)).resize(_size1182); + uint32_t _i1186; + for (_i1186 = 0; _i1186 < _size1182; ++_i1186) { - xfer += (*(this->success))[_i1184].read(iprot); + xfer += (*(this->success))[_i1186].read(iprot); } xfer += iprot->readListEnd(); } @@ -16840,14 +16840,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 _size1185; - ::apache::thrift::protocol::TType _etype1188; - xfer += iprot->readListBegin(_etype1188, _size1185); - this->part_vals.resize(_size1185); - uint32_t _i1189; - for (_i1189 = 0; _i1189 < _size1185; ++_i1189) + uint32_t _size1187; + ::apache::thrift::protocol::TType _etype1190; + xfer += iprot->readListBegin(_etype1190, _size1187); + this->part_vals.resize(_size1187); + uint32_t _i1191; + for (_i1191 = 0; _i1191 < _size1187; ++_i1191) { - xfer += iprot->readString(this->part_vals[_i1189]); + xfer += iprot->readString(this->part_vals[_i1191]); } xfer += iprot->readListEnd(); } @@ -16892,10 +16892,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 _iter1190; - for (_iter1190 = this->part_vals.begin(); _iter1190 != this->part_vals.end(); ++_iter1190) + std::vector ::const_iterator _iter1192; + for (_iter1192 = this->part_vals.begin(); _iter1192 != this->part_vals.end(); ++_iter1192) { - xfer += oprot->writeString((*_iter1190)); + xfer += oprot->writeString((*_iter1192)); } xfer += oprot->writeListEnd(); } @@ -16931,10 +16931,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 _iter1191; - for (_iter1191 = (*(this->part_vals)).begin(); _iter1191 != (*(this->part_vals)).end(); ++_iter1191) + std::vector ::const_iterator _iter1193; + for (_iter1193 = (*(this->part_vals)).begin(); _iter1193 != (*(this->part_vals)).end(); ++_iter1193) { - xfer += oprot->writeString((*_iter1191)); + xfer += oprot->writeString((*_iter1193)); } xfer += oprot->writeListEnd(); } @@ -16979,14 +16979,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_result::read(::apache::thrif 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(); } @@ -17033,10 +17033,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 _iter1197; - for (_iter1197 = this->success.begin(); _iter1197 != this->success.end(); ++_iter1197) + std::vector ::const_iterator _iter1199; + for (_iter1199 = this->success.begin(); _iter1199 != this->success.end(); ++_iter1199) { - xfer += oprot->writeString((*_iter1197)); + xfer += oprot->writeString((*_iter1199)); } xfer += oprot->writeListEnd(); } @@ -17085,14 +17085,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1198; - ::apache::thrift::protocol::TType _etype1201; - xfer += iprot->readListBegin(_etype1201, _size1198); - (*(this->success)).resize(_size1198); - uint32_t _i1202; - for (_i1202 = 0; _i1202 < _size1198; ++_i1202) + uint32_t _size1200; + ::apache::thrift::protocol::TType _etype1203; + xfer += iprot->readListBegin(_etype1203, _size1200); + (*(this->success)).resize(_size1200); + uint32_t _i1204; + for (_i1204 = 0; _i1204 < _size1200; ++_i1204) { - xfer += iprot->readString((*(this->success))[_i1202]); + xfer += iprot->readString((*(this->success))[_i1204]); } xfer += iprot->readListEnd(); } @@ -17286,14 +17286,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_result::read(::apache::thr 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(); } @@ -17340,10 +17340,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 _iter1208; - for (_iter1208 = this->success.begin(); _iter1208 != this->success.end(); ++_iter1208) + std::vector ::const_iterator _iter1210; + for (_iter1210 = this->success.begin(); _iter1210 != this->success.end(); ++_iter1210) { - xfer += (*_iter1208).write(oprot); + xfer += (*_iter1210).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17392,14 +17392,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1209; - ::apache::thrift::protocol::TType _etype1212; - xfer += iprot->readListBegin(_etype1212, _size1209); - (*(this->success)).resize(_size1209); - uint32_t _i1213; - for (_i1213 = 0; _i1213 < _size1209; ++_i1213) + uint32_t _size1211; + ::apache::thrift::protocol::TType _etype1214; + xfer += iprot->readListBegin(_etype1214, _size1211); + (*(this->success)).resize(_size1211); + uint32_t _i1215; + for (_i1215 = 0; _i1215 < _size1211; ++_i1215) { - xfer += (*(this->success))[_i1213].read(iprot); + xfer += (*(this->success))[_i1215].read(iprot); } xfer += iprot->readListEnd(); } @@ -17593,14 +17593,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 _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(); } @@ -17647,10 +17647,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 _iter1219; - for (_iter1219 = this->success.begin(); _iter1219 != this->success.end(); ++_iter1219) + std::vector ::const_iterator _iter1221; + for (_iter1221 = this->success.begin(); _iter1221 != this->success.end(); ++_iter1221) { - xfer += (*_iter1219).write(oprot); + xfer += (*_iter1221).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17699,14 +17699,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 _size1220; - ::apache::thrift::protocol::TType _etype1223; - xfer += iprot->readListBegin(_etype1223, _size1220); - (*(this->success)).resize(_size1220); - uint32_t _i1224; - for (_i1224 = 0; _i1224 < _size1220; ++_i1224) + uint32_t _size1222; + ::apache::thrift::protocol::TType _etype1225; + xfer += iprot->readListBegin(_etype1225, _size1222); + (*(this->success)).resize(_size1222); + uint32_t _i1226; + for (_i1226 = 0; _i1226 < _size1222; ++_i1226) { - xfer += (*(this->success))[_i1224].read(iprot); + xfer += (*(this->success))[_i1226].read(iprot); } xfer += iprot->readListEnd(); } @@ -18275,14 +18275,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_args::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { this->names.clear(); - uint32_t _size1225; - ::apache::thrift::protocol::TType _etype1228; - xfer += iprot->readListBegin(_etype1228, _size1225); - this->names.resize(_size1225); - uint32_t _i1229; - for (_i1229 = 0; _i1229 < _size1225; ++_i1229) + uint32_t _size1227; + ::apache::thrift::protocol::TType _etype1230; + xfer += iprot->readListBegin(_etype1230, _size1227); + this->names.resize(_size1227); + uint32_t _i1231; + for (_i1231 = 0; _i1231 < _size1227; ++_i1231) { - xfer += iprot->readString(this->names[_i1229]); + xfer += iprot->readString(this->names[_i1231]); } xfer += iprot->readListEnd(); } @@ -18319,10 +18319,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 _iter1230; - for (_iter1230 = this->names.begin(); _iter1230 != this->names.end(); ++_iter1230) + std::vector ::const_iterator _iter1232; + for (_iter1232 = this->names.begin(); _iter1232 != this->names.end(); ++_iter1232) { - xfer += oprot->writeString((*_iter1230)); + xfer += oprot->writeString((*_iter1232)); } xfer += oprot->writeListEnd(); } @@ -18354,10 +18354,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 _iter1231; - for (_iter1231 = (*(this->names)).begin(); _iter1231 != (*(this->names)).end(); ++_iter1231) + std::vector ::const_iterator _iter1233; + for (_iter1233 = (*(this->names)).begin(); _iter1233 != (*(this->names)).end(); ++_iter1233) { - xfer += oprot->writeString((*_iter1231)); + xfer += oprot->writeString((*_iter1233)); } xfer += oprot->writeListEnd(); } @@ -18398,14 +18398,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_result::read(::apache::thri 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(); } @@ -18452,10 +18452,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 _iter1237; - for (_iter1237 = this->success.begin(); _iter1237 != this->success.end(); ++_iter1237) + std::vector ::const_iterator _iter1239; + for (_iter1239 = this->success.begin(); _iter1239 != this->success.end(); ++_iter1239) { - xfer += (*_iter1237).write(oprot); + xfer += (*_iter1239).write(oprot); } xfer += oprot->writeListEnd(); } @@ -18504,14 +18504,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_presult::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1238; - ::apache::thrift::protocol::TType _etype1241; - xfer += iprot->readListBegin(_etype1241, _size1238); - (*(this->success)).resize(_size1238); - uint32_t _i1242; - for (_i1242 = 0; _i1242 < _size1238; ++_i1242) + uint32_t _size1240; + ::apache::thrift::protocol::TType _etype1243; + xfer += iprot->readListBegin(_etype1243, _size1240); + (*(this->success)).resize(_size1240); + uint32_t _i1244; + for (_i1244 = 0; _i1244 < _size1240; ++_i1244) { - xfer += (*(this->success))[_i1242].read(iprot); + xfer += (*(this->success))[_i1244].read(iprot); } xfer += iprot->readListEnd(); } @@ -18833,14 +18833,14 @@ uint32_t ThriftHiveMetastore_alter_partitions_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size1243; - ::apache::thrift::protocol::TType _etype1246; - xfer += iprot->readListBegin(_etype1246, _size1243); - this->new_parts.resize(_size1243); - uint32_t _i1247; - for (_i1247 = 0; _i1247 < _size1243; ++_i1247) + uint32_t _size1245; + ::apache::thrift::protocol::TType _etype1248; + xfer += iprot->readListBegin(_etype1248, _size1245); + this->new_parts.resize(_size1245); + uint32_t _i1249; + for (_i1249 = 0; _i1249 < _size1245; ++_i1249) { - xfer += this->new_parts[_i1247].read(iprot); + xfer += this->new_parts[_i1249].read(iprot); } xfer += iprot->readListEnd(); } @@ -18877,10 +18877,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 _iter1248; - for (_iter1248 = this->new_parts.begin(); _iter1248 != this->new_parts.end(); ++_iter1248) + std::vector ::const_iterator _iter1250; + for (_iter1250 = this->new_parts.begin(); _iter1250 != this->new_parts.end(); ++_iter1250) { - xfer += (*_iter1248).write(oprot); + xfer += (*_iter1250).write(oprot); } xfer += oprot->writeListEnd(); } @@ -18912,10 +18912,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 _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(); } @@ -19100,14 +19100,14 @@ uint32_t ThriftHiveMetastore_alter_partitions_with_environment_context_args::rea if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size1250; - ::apache::thrift::protocol::TType _etype1253; - xfer += iprot->readListBegin(_etype1253, _size1250); - this->new_parts.resize(_size1250); - uint32_t _i1254; - for (_i1254 = 0; _i1254 < _size1250; ++_i1254) + uint32_t _size1252; + ::apache::thrift::protocol::TType _etype1255; + xfer += iprot->readListBegin(_etype1255, _size1252); + this->new_parts.resize(_size1252); + uint32_t _i1256; + for (_i1256 = 0; _i1256 < _size1252; ++_i1256) { - xfer += this->new_parts[_i1254].read(iprot); + xfer += this->new_parts[_i1256].read(iprot); } xfer += iprot->readListEnd(); } @@ -19152,10 +19152,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 _iter1255; - for (_iter1255 = this->new_parts.begin(); _iter1255 != this->new_parts.end(); ++_iter1255) + std::vector ::const_iterator _iter1257; + for (_iter1257 = this->new_parts.begin(); _iter1257 != this->new_parts.end(); ++_iter1257) { - xfer += (*_iter1255).write(oprot); + xfer += (*_iter1257).write(oprot); } xfer += oprot->writeListEnd(); } @@ -19191,10 +19191,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 _iter1256; - for (_iter1256 = (*(this->new_parts)).begin(); _iter1256 != (*(this->new_parts)).end(); ++_iter1256) + std::vector ::const_iterator _iter1258; + for (_iter1258 = (*(this->new_parts)).begin(); _iter1258 != (*(this->new_parts)).end(); ++_iter1258) { - xfer += (*_iter1256).write(oprot); + xfer += (*_iter1258).write(oprot); } xfer += oprot->writeListEnd(); } @@ -19638,14 +19638,14 @@ uint32_t ThriftHiveMetastore_rename_partition_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1257; - ::apache::thrift::protocol::TType _etype1260; - xfer += iprot->readListBegin(_etype1260, _size1257); - this->part_vals.resize(_size1257); - uint32_t _i1261; - for (_i1261 = 0; _i1261 < _size1257; ++_i1261) + uint32_t _size1259; + ::apache::thrift::protocol::TType _etype1262; + xfer += iprot->readListBegin(_etype1262, _size1259); + this->part_vals.resize(_size1259); + uint32_t _i1263; + for (_i1263 = 0; _i1263 < _size1259; ++_i1263) { - xfer += iprot->readString(this->part_vals[_i1261]); + xfer += iprot->readString(this->part_vals[_i1263]); } xfer += iprot->readListEnd(); } @@ -19690,10 +19690,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 _iter1262; - for (_iter1262 = this->part_vals.begin(); _iter1262 != this->part_vals.end(); ++_iter1262) + std::vector ::const_iterator _iter1264; + for (_iter1264 = this->part_vals.begin(); _iter1264 != this->part_vals.end(); ++_iter1264) { - xfer += oprot->writeString((*_iter1262)); + xfer += oprot->writeString((*_iter1264)); } xfer += oprot->writeListEnd(); } @@ -19729,10 +19729,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 _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(); } @@ -19905,14 +19905,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 _size1264; - ::apache::thrift::protocol::TType _etype1267; - xfer += iprot->readListBegin(_etype1267, _size1264); - this->part_vals.resize(_size1264); - uint32_t _i1268; - for (_i1268 = 0; _i1268 < _size1264; ++_i1268) + uint32_t _size1266; + ::apache::thrift::protocol::TType _etype1269; + xfer += iprot->readListBegin(_etype1269, _size1266); + this->part_vals.resize(_size1266); + uint32_t _i1270; + for (_i1270 = 0; _i1270 < _size1266; ++_i1270) { - xfer += iprot->readString(this->part_vals[_i1268]); + xfer += iprot->readString(this->part_vals[_i1270]); } xfer += iprot->readListEnd(); } @@ -19949,10 +19949,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 _iter1269; - for (_iter1269 = this->part_vals.begin(); _iter1269 != this->part_vals.end(); ++_iter1269) + std::vector ::const_iterator _iter1271; + for (_iter1271 = this->part_vals.begin(); _iter1271 != this->part_vals.end(); ++_iter1271) { - xfer += oprot->writeString((*_iter1269)); + xfer += oprot->writeString((*_iter1271)); } xfer += oprot->writeListEnd(); } @@ -19980,10 +19980,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 _iter1270; - for (_iter1270 = (*(this->part_vals)).begin(); _iter1270 != (*(this->part_vals)).end(); ++_iter1270) + std::vector ::const_iterator _iter1272; + for (_iter1272 = (*(this->part_vals)).begin(); _iter1272 != (*(this->part_vals)).end(); ++_iter1272) { - xfer += oprot->writeString((*_iter1270)); + xfer += oprot->writeString((*_iter1272)); } xfer += oprot->writeListEnd(); } @@ -20458,14 +20458,14 @@ uint32_t ThriftHiveMetastore_partition_name_to_vals_result::read(::apache::thrif 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(); } @@ -20504,10 +20504,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 _iter1276; - for (_iter1276 = this->success.begin(); _iter1276 != this->success.end(); ++_iter1276) + std::vector ::const_iterator _iter1278; + for (_iter1278 = this->success.begin(); _iter1278 != this->success.end(); ++_iter1278) { - xfer += oprot->writeString((*_iter1276)); + xfer += oprot->writeString((*_iter1278)); } xfer += oprot->writeListEnd(); } @@ -20552,14 +20552,14 @@ uint32_t ThriftHiveMetastore_partition_name_to_vals_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1277; - ::apache::thrift::protocol::TType _etype1280; - xfer += iprot->readListBegin(_etype1280, _size1277); - (*(this->success)).resize(_size1277); - uint32_t _i1281; - for (_i1281 = 0; _i1281 < _size1277; ++_i1281) + uint32_t _size1279; + ::apache::thrift::protocol::TType _etype1282; + xfer += iprot->readListBegin(_etype1282, _size1279); + (*(this->success)).resize(_size1279); + uint32_t _i1283; + for (_i1283 = 0; _i1283 < _size1279; ++_i1283) { - xfer += iprot->readString((*(this->success))[_i1281]); + xfer += iprot->readString((*(this->success))[_i1283]); } xfer += iprot->readListEnd(); } @@ -20697,17 +20697,17 @@ uint32_t ThriftHiveMetastore_partition_name_to_spec_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_MAP) { { this->success.clear(); - uint32_t _size1282; - ::apache::thrift::protocol::TType _ktype1283; - ::apache::thrift::protocol::TType _vtype1284; - xfer += iprot->readMapBegin(_ktype1283, _vtype1284, _size1282); - uint32_t _i1286; - for (_i1286 = 0; _i1286 < _size1282; ++_i1286) + 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) { - std::string _key1287; - xfer += iprot->readString(_key1287); - std::string& _val1288 = this->success[_key1287]; - xfer += iprot->readString(_val1288); + std::string _key1289; + xfer += iprot->readString(_key1289); + std::string& _val1290 = this->success[_key1289]; + xfer += iprot->readString(_val1290); } xfer += iprot->readMapEnd(); } @@ -20746,11 +20746,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 _iter1289; - for (_iter1289 = this->success.begin(); _iter1289 != this->success.end(); ++_iter1289) + std::map ::const_iterator _iter1291; + for (_iter1291 = this->success.begin(); _iter1291 != this->success.end(); ++_iter1291) { - xfer += oprot->writeString(_iter1289->first); - xfer += oprot->writeString(_iter1289->second); + xfer += oprot->writeString(_iter1291->first); + xfer += oprot->writeString(_iter1291->second); } xfer += oprot->writeMapEnd(); } @@ -20795,17 +20795,17 @@ uint32_t ThriftHiveMetastore_partition_name_to_spec_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_MAP) { { (*(this->success)).clear(); - uint32_t _size1290; - ::apache::thrift::protocol::TType _ktype1291; - ::apache::thrift::protocol::TType _vtype1292; - xfer += iprot->readMapBegin(_ktype1291, _vtype1292, _size1290); - uint32_t _i1294; - for (_i1294 = 0; _i1294 < _size1290; ++_i1294) + uint32_t _size1292; + ::apache::thrift::protocol::TType _ktype1293; + ::apache::thrift::protocol::TType _vtype1294; + xfer += iprot->readMapBegin(_ktype1293, _vtype1294, _size1292); + uint32_t _i1296; + for (_i1296 = 0; _i1296 < _size1292; ++_i1296) { - std::string _key1295; - xfer += iprot->readString(_key1295); - std::string& _val1296 = (*(this->success))[_key1295]; - xfer += iprot->readString(_val1296); + std::string _key1297; + xfer += iprot->readString(_key1297); + std::string& _val1298 = (*(this->success))[_key1297]; + xfer += iprot->readString(_val1298); } xfer += iprot->readMapEnd(); } @@ -20880,17 +20880,17 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_args::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_MAP) { { this->part_vals.clear(); - uint32_t _size1297; - ::apache::thrift::protocol::TType _ktype1298; - ::apache::thrift::protocol::TType _vtype1299; - xfer += iprot->readMapBegin(_ktype1298, _vtype1299, _size1297); - uint32_t _i1301; - for (_i1301 = 0; _i1301 < _size1297; ++_i1301) + uint32_t _size1299; + ::apache::thrift::protocol::TType _ktype1300; + ::apache::thrift::protocol::TType _vtype1301; + xfer += iprot->readMapBegin(_ktype1300, _vtype1301, _size1299); + uint32_t _i1303; + for (_i1303 = 0; _i1303 < _size1299; ++_i1303) { - std::string _key1302; - xfer += iprot->readString(_key1302); - std::string& _val1303 = this->part_vals[_key1302]; - xfer += iprot->readString(_val1303); + std::string _key1304; + xfer += iprot->readString(_key1304); + std::string& _val1305 = this->part_vals[_key1304]; + xfer += iprot->readString(_val1305); } xfer += iprot->readMapEnd(); } @@ -20901,9 +20901,9 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_args::read(::apache::thrift:: break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1304; - xfer += iprot->readI32(ecast1304); - this->eventType = (PartitionEventType::type)ecast1304; + int32_t ecast1306; + xfer += iprot->readI32(ecast1306); + this->eventType = (PartitionEventType::type)ecast1306; this->__isset.eventType = true; } else { xfer += iprot->skip(ftype); @@ -20937,11 +20937,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 _iter1305; - for (_iter1305 = this->part_vals.begin(); _iter1305 != this->part_vals.end(); ++_iter1305) + std::map ::const_iterator _iter1307; + for (_iter1307 = this->part_vals.begin(); _iter1307 != this->part_vals.end(); ++_iter1307) { - xfer += oprot->writeString(_iter1305->first); - xfer += oprot->writeString(_iter1305->second); + xfer += oprot->writeString(_iter1307->first); + xfer += oprot->writeString(_iter1307->second); } xfer += oprot->writeMapEnd(); } @@ -20977,11 +20977,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 _iter1306; - for (_iter1306 = (*(this->part_vals)).begin(); _iter1306 != (*(this->part_vals)).end(); ++_iter1306) + std::map ::const_iterator _iter1308; + for (_iter1308 = (*(this->part_vals)).begin(); _iter1308 != (*(this->part_vals)).end(); ++_iter1308) { - xfer += oprot->writeString(_iter1306->first); - xfer += oprot->writeString(_iter1306->second); + xfer += oprot->writeString(_iter1308->first); + xfer += oprot->writeString(_iter1308->second); } xfer += oprot->writeMapEnd(); } @@ -21250,17 +21250,17 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_MAP) { { this->part_vals.clear(); - uint32_t _size1307; - ::apache::thrift::protocol::TType _ktype1308; - ::apache::thrift::protocol::TType _vtype1309; - xfer += iprot->readMapBegin(_ktype1308, _vtype1309, _size1307); - uint32_t _i1311; - for (_i1311 = 0; _i1311 < _size1307; ++_i1311) + uint32_t _size1309; + ::apache::thrift::protocol::TType _ktype1310; + ::apache::thrift::protocol::TType _vtype1311; + xfer += iprot->readMapBegin(_ktype1310, _vtype1311, _size1309); + uint32_t _i1313; + for (_i1313 = 0; _i1313 < _size1309; ++_i1313) { - std::string _key1312; - xfer += iprot->readString(_key1312); - std::string& _val1313 = this->part_vals[_key1312]; - xfer += iprot->readString(_val1313); + std::string _key1314; + xfer += iprot->readString(_key1314); + std::string& _val1315 = this->part_vals[_key1314]; + xfer += iprot->readString(_val1315); } xfer += iprot->readMapEnd(); } @@ -21271,9 +21271,9 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::read(::apache::thri break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1314; - xfer += iprot->readI32(ecast1314); - this->eventType = (PartitionEventType::type)ecast1314; + int32_t ecast1316; + xfer += iprot->readI32(ecast1316); + this->eventType = (PartitionEventType::type)ecast1316; this->__isset.eventType = true; } else { xfer += iprot->skip(ftype); @@ -21307,11 +21307,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 _iter1315; - for (_iter1315 = this->part_vals.begin(); _iter1315 != this->part_vals.end(); ++_iter1315) + std::map ::const_iterator _iter1317; + for (_iter1317 = this->part_vals.begin(); _iter1317 != this->part_vals.end(); ++_iter1317) { - xfer += oprot->writeString(_iter1315->first); - xfer += oprot->writeString(_iter1315->second); + xfer += oprot->writeString(_iter1317->first); + xfer += oprot->writeString(_iter1317->second); } xfer += oprot->writeMapEnd(); } @@ -21347,11 +21347,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 _iter1316; - for (_iter1316 = (*(this->part_vals)).begin(); _iter1316 != (*(this->part_vals)).end(); ++_iter1316) + std::map ::const_iterator _iter1318; + for (_iter1318 = (*(this->part_vals)).begin(); _iter1318 != (*(this->part_vals)).end(); ++_iter1318) { - xfer += oprot->writeString(_iter1316->first); - xfer += oprot->writeString(_iter1316->second); + xfer += oprot->writeString(_iter1318->first); + xfer += oprot->writeString(_iter1318->second); } xfer += oprot->writeMapEnd(); } @@ -22787,14 +22787,14 @@ uint32_t ThriftHiveMetastore_get_indexes_result::read(::apache::thrift::protocol 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(); } @@ -22841,10 +22841,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 _iter1322; - for (_iter1322 = this->success.begin(); _iter1322 != this->success.end(); ++_iter1322) + std::vector ::const_iterator _iter1324; + for (_iter1324 = this->success.begin(); _iter1324 != this->success.end(); ++_iter1324) { - xfer += (*_iter1322).write(oprot); + xfer += (*_iter1324).write(oprot); } xfer += oprot->writeListEnd(); } @@ -22893,14 +22893,14 @@ uint32_t ThriftHiveMetastore_get_indexes_presult::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1323; - ::apache::thrift::protocol::TType _etype1326; - xfer += iprot->readListBegin(_etype1326, _size1323); - (*(this->success)).resize(_size1323); - uint32_t _i1327; - for (_i1327 = 0; _i1327 < _size1323; ++_i1327) + uint32_t _size1325; + ::apache::thrift::protocol::TType _etype1328; + xfer += iprot->readListBegin(_etype1328, _size1325); + (*(this->success)).resize(_size1325); + uint32_t _i1329; + for (_i1329 = 0; _i1329 < _size1325; ++_i1329) { - xfer += (*(this->success))[_i1327].read(iprot); + xfer += (*(this->success))[_i1329].read(iprot); } xfer += iprot->readListEnd(); } @@ -23078,14 +23078,14 @@ uint32_t ThriftHiveMetastore_get_index_names_result::read(::apache::thrift::prot 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(); } @@ -23124,10 +23124,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 _iter1333; - for (_iter1333 = this->success.begin(); _iter1333 != this->success.end(); ++_iter1333) + std::vector ::const_iterator _iter1335; + for (_iter1335 = this->success.begin(); _iter1335 != this->success.end(); ++_iter1335) { - xfer += oprot->writeString((*_iter1333)); + xfer += oprot->writeString((*_iter1335)); } xfer += oprot->writeListEnd(); } @@ -23172,14 +23172,14 @@ uint32_t ThriftHiveMetastore_get_index_names_presult::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1334; - ::apache::thrift::protocol::TType _etype1337; - xfer += iprot->readListBegin(_etype1337, _size1334); - (*(this->success)).resize(_size1334); - uint32_t _i1338; - for (_i1338 = 0; _i1338 < _size1334; ++_i1338) + uint32_t _size1336; + ::apache::thrift::protocol::TType _etype1339; + xfer += iprot->readListBegin(_etype1339, _size1336); + (*(this->success)).resize(_size1336); + uint32_t _i1340; + for (_i1340 = 0; _i1340 < _size1336; ++_i1340) { - xfer += iprot->readString((*(this->success))[_i1338]); + xfer += iprot->readString((*(this->success))[_i1340]); } xfer += iprot->readListEnd(); } @@ -27206,14 +27206,14 @@ uint32_t ThriftHiveMetastore_get_functions_result::read(::apache::thrift::protoc 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(); } @@ -27252,10 +27252,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 _iter1344; - for (_iter1344 = this->success.begin(); _iter1344 != this->success.end(); ++_iter1344) + std::vector ::const_iterator _iter1346; + for (_iter1346 = this->success.begin(); _iter1346 != this->success.end(); ++_iter1346) { - xfer += oprot->writeString((*_iter1344)); + xfer += oprot->writeString((*_iter1346)); } xfer += oprot->writeListEnd(); } @@ -27300,14 +27300,14 @@ uint32_t ThriftHiveMetastore_get_functions_presult::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1345; - ::apache::thrift::protocol::TType _etype1348; - xfer += iprot->readListBegin(_etype1348, _size1345); - (*(this->success)).resize(_size1345); - uint32_t _i1349; - for (_i1349 = 0; _i1349 < _size1345; ++_i1349) + uint32_t _size1347; + ::apache::thrift::protocol::TType _etype1350; + xfer += iprot->readListBegin(_etype1350, _size1347); + (*(this->success)).resize(_size1347); + uint32_t _i1351; + for (_i1351 = 0; _i1351 < _size1347; ++_i1351) { - xfer += iprot->readString((*(this->success))[_i1349]); + xfer += iprot->readString((*(this->success))[_i1351]); } xfer += iprot->readListEnd(); } @@ -28267,14 +28267,14 @@ uint32_t ThriftHiveMetastore_get_role_names_result::read(::apache::thrift::proto 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(); } @@ -28313,10 +28313,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 _iter1355; - for (_iter1355 = this->success.begin(); _iter1355 != this->success.end(); ++_iter1355) + std::vector ::const_iterator _iter1357; + for (_iter1357 = this->success.begin(); _iter1357 != this->success.end(); ++_iter1357) { - xfer += oprot->writeString((*_iter1355)); + xfer += oprot->writeString((*_iter1357)); } xfer += oprot->writeListEnd(); } @@ -28361,14 +28361,14 @@ uint32_t ThriftHiveMetastore_get_role_names_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1356; - ::apache::thrift::protocol::TType _etype1359; - xfer += iprot->readListBegin(_etype1359, _size1356); - (*(this->success)).resize(_size1356); - uint32_t _i1360; - for (_i1360 = 0; _i1360 < _size1356; ++_i1360) + uint32_t _size1358; + ::apache::thrift::protocol::TType _etype1361; + xfer += iprot->readListBegin(_etype1361, _size1358); + (*(this->success)).resize(_size1358); + uint32_t _i1362; + for (_i1362 = 0; _i1362 < _size1358; ++_i1362) { - xfer += iprot->readString((*(this->success))[_i1360]); + xfer += iprot->readString((*(this->success))[_i1362]); } xfer += iprot->readListEnd(); } @@ -28441,9 +28441,9 @@ uint32_t ThriftHiveMetastore_grant_role_args::read(::apache::thrift::protocol::T break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1361; - xfer += iprot->readI32(ecast1361); - this->principal_type = (PrincipalType::type)ecast1361; + int32_t ecast1363; + xfer += iprot->readI32(ecast1363); + this->principal_type = (PrincipalType::type)ecast1363; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -28459,9 +28459,9 @@ uint32_t ThriftHiveMetastore_grant_role_args::read(::apache::thrift::protocol::T break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1362; - xfer += iprot->readI32(ecast1362); - this->grantorType = (PrincipalType::type)ecast1362; + int32_t ecast1364; + xfer += iprot->readI32(ecast1364); + this->grantorType = (PrincipalType::type)ecast1364; this->__isset.grantorType = true; } else { xfer += iprot->skip(ftype); @@ -28732,9 +28732,9 @@ uint32_t ThriftHiveMetastore_revoke_role_args::read(::apache::thrift::protocol:: break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1363; - xfer += iprot->readI32(ecast1363); - this->principal_type = (PrincipalType::type)ecast1363; + int32_t ecast1365; + xfer += iprot->readI32(ecast1365); + this->principal_type = (PrincipalType::type)ecast1365; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -28965,9 +28965,9 @@ uint32_t ThriftHiveMetastore_list_roles_args::read(::apache::thrift::protocol::T break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1364; - xfer += iprot->readI32(ecast1364); - this->principal_type = (PrincipalType::type)ecast1364; + int32_t ecast1366; + xfer += iprot->readI32(ecast1366); + this->principal_type = (PrincipalType::type)ecast1366; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -29056,14 +29056,14 @@ uint32_t ThriftHiveMetastore_list_roles_result::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(); } @@ -29102,10 +29102,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 _iter1370; - for (_iter1370 = this->success.begin(); _iter1370 != this->success.end(); ++_iter1370) + std::vector ::const_iterator _iter1372; + for (_iter1372 = this->success.begin(); _iter1372 != this->success.end(); ++_iter1372) { - xfer += (*_iter1370).write(oprot); + xfer += (*_iter1372).write(oprot); } xfer += oprot->writeListEnd(); } @@ -29150,14 +29150,14 @@ uint32_t ThriftHiveMetastore_list_roles_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1371; - ::apache::thrift::protocol::TType _etype1374; - xfer += iprot->readListBegin(_etype1374, _size1371); - (*(this->success)).resize(_size1371); - uint32_t _i1375; - for (_i1375 = 0; _i1375 < _size1371; ++_i1375) + uint32_t _size1373; + ::apache::thrift::protocol::TType _etype1376; + xfer += iprot->readListBegin(_etype1376, _size1373); + (*(this->success)).resize(_size1373); + uint32_t _i1377; + for (_i1377 = 0; _i1377 < _size1373; ++_i1377) { - xfer += (*(this->success))[_i1375].read(iprot); + xfer += (*(this->success))[_i1377].read(iprot); } xfer += iprot->readListEnd(); } @@ -29853,14 +29853,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 _size1376; - ::apache::thrift::protocol::TType _etype1379; - xfer += iprot->readListBegin(_etype1379, _size1376); - this->group_names.resize(_size1376); - uint32_t _i1380; - for (_i1380 = 0; _i1380 < _size1376; ++_i1380) + uint32_t _size1378; + ::apache::thrift::protocol::TType _etype1381; + xfer += iprot->readListBegin(_etype1381, _size1378); + this->group_names.resize(_size1378); + uint32_t _i1382; + for (_i1382 = 0; _i1382 < _size1378; ++_i1382) { - xfer += iprot->readString(this->group_names[_i1380]); + xfer += iprot->readString(this->group_names[_i1382]); } xfer += iprot->readListEnd(); } @@ -29897,10 +29897,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 _iter1381; - for (_iter1381 = this->group_names.begin(); _iter1381 != this->group_names.end(); ++_iter1381) + std::vector ::const_iterator _iter1383; + for (_iter1383 = this->group_names.begin(); _iter1383 != this->group_names.end(); ++_iter1383) { - xfer += oprot->writeString((*_iter1381)); + xfer += oprot->writeString((*_iter1383)); } xfer += oprot->writeListEnd(); } @@ -29932,10 +29932,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 _iter1382; - for (_iter1382 = (*(this->group_names)).begin(); _iter1382 != (*(this->group_names)).end(); ++_iter1382) + std::vector ::const_iterator _iter1384; + for (_iter1384 = (*(this->group_names)).begin(); _iter1384 != (*(this->group_names)).end(); ++_iter1384) { - xfer += oprot->writeString((*_iter1382)); + xfer += oprot->writeString((*_iter1384)); } xfer += oprot->writeListEnd(); } @@ -30110,9 +30110,9 @@ uint32_t ThriftHiveMetastore_list_privileges_args::read(::apache::thrift::protoc break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1383; - xfer += iprot->readI32(ecast1383); - this->principal_type = (PrincipalType::type)ecast1383; + int32_t ecast1385; + xfer += iprot->readI32(ecast1385); + this->principal_type = (PrincipalType::type)ecast1385; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -30217,14 +30217,14 @@ uint32_t ThriftHiveMetastore_list_privileges_result::read(::apache::thrift::prot 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(); } @@ -30263,10 +30263,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 _iter1389; - for (_iter1389 = this->success.begin(); _iter1389 != this->success.end(); ++_iter1389) + std::vector ::const_iterator _iter1391; + for (_iter1391 = this->success.begin(); _iter1391 != this->success.end(); ++_iter1391) { - xfer += (*_iter1389).write(oprot); + xfer += (*_iter1391).write(oprot); } xfer += oprot->writeListEnd(); } @@ -30311,14 +30311,14 @@ uint32_t ThriftHiveMetastore_list_privileges_presult::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1390; - ::apache::thrift::protocol::TType _etype1393; - xfer += iprot->readListBegin(_etype1393, _size1390); - (*(this->success)).resize(_size1390); - uint32_t _i1394; - for (_i1394 = 0; _i1394 < _size1390; ++_i1394) + uint32_t _size1392; + ::apache::thrift::protocol::TType _etype1395; + xfer += iprot->readListBegin(_etype1395, _size1392); + (*(this->success)).resize(_size1392); + uint32_t _i1396; + for (_i1396 = 0; _i1396 < _size1392; ++_i1396) { - xfer += (*(this->success))[_i1394].read(iprot); + xfer += (*(this->success))[_i1396].read(iprot); } xfer += iprot->readListEnd(); } @@ -31006,14 +31006,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 _size1395; - ::apache::thrift::protocol::TType _etype1398; - xfer += iprot->readListBegin(_etype1398, _size1395); - this->group_names.resize(_size1395); - uint32_t _i1399; - for (_i1399 = 0; _i1399 < _size1395; ++_i1399) + uint32_t _size1397; + ::apache::thrift::protocol::TType _etype1400; + xfer += iprot->readListBegin(_etype1400, _size1397); + this->group_names.resize(_size1397); + uint32_t _i1401; + for (_i1401 = 0; _i1401 < _size1397; ++_i1401) { - xfer += iprot->readString(this->group_names[_i1399]); + xfer += iprot->readString(this->group_names[_i1401]); } xfer += iprot->readListEnd(); } @@ -31046,10 +31046,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 _iter1400; - for (_iter1400 = this->group_names.begin(); _iter1400 != this->group_names.end(); ++_iter1400) + std::vector ::const_iterator _iter1402; + for (_iter1402 = this->group_names.begin(); _iter1402 != this->group_names.end(); ++_iter1402) { - xfer += oprot->writeString((*_iter1400)); + xfer += oprot->writeString((*_iter1402)); } xfer += oprot->writeListEnd(); } @@ -31077,10 +31077,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 _iter1401; - for (_iter1401 = (*(this->group_names)).begin(); _iter1401 != (*(this->group_names)).end(); ++_iter1401) + std::vector ::const_iterator _iter1403; + for (_iter1403 = (*(this->group_names)).begin(); _iter1403 != (*(this->group_names)).end(); ++_iter1403) { - xfer += oprot->writeString((*_iter1401)); + xfer += oprot->writeString((*_iter1403)); } xfer += oprot->writeListEnd(); } @@ -31121,14 +31121,14 @@ uint32_t ThriftHiveMetastore_set_ugi_result::read(::apache::thrift::protocol::TP 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(); } @@ -31167,10 +31167,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 _iter1407; - for (_iter1407 = this->success.begin(); _iter1407 != this->success.end(); ++_iter1407) + std::vector ::const_iterator _iter1409; + for (_iter1409 = this->success.begin(); _iter1409 != this->success.end(); ++_iter1409) { - xfer += oprot->writeString((*_iter1407)); + xfer += oprot->writeString((*_iter1409)); } xfer += oprot->writeListEnd(); } @@ -31215,14 +31215,14 @@ uint32_t ThriftHiveMetastore_set_ugi_presult::read(::apache::thrift::protocol::T if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1408; - ::apache::thrift::protocol::TType _etype1411; - xfer += iprot->readListBegin(_etype1411, _size1408); - (*(this->success)).resize(_size1408); - uint32_t _i1412; - for (_i1412 = 0; _i1412 < _size1408; ++_i1412) + uint32_t _size1410; + ::apache::thrift::protocol::TType _etype1413; + xfer += iprot->readListBegin(_etype1413, _size1410); + (*(this->success)).resize(_size1410); + uint32_t _i1414; + for (_i1414 = 0; _i1414 < _size1410; ++_i1414) { - xfer += iprot->readString((*(this->success))[_i1412]); + xfer += iprot->readString((*(this->success))[_i1414]); } xfer += iprot->readListEnd(); } @@ -32533,14 +32533,14 @@ uint32_t ThriftHiveMetastore_get_all_token_identifiers_result::read(::apache::th 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(); } @@ -32571,10 +32571,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 _iter1418; - for (_iter1418 = this->success.begin(); _iter1418 != this->success.end(); ++_iter1418) + std::vector ::const_iterator _iter1420; + for (_iter1420 = this->success.begin(); _iter1420 != this->success.end(); ++_iter1420) { - xfer += oprot->writeString((*_iter1418)); + xfer += oprot->writeString((*_iter1420)); } xfer += oprot->writeListEnd(); } @@ -32615,14 +32615,14 @@ uint32_t ThriftHiveMetastore_get_all_token_identifiers_presult::read(::apache::t if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1419; - ::apache::thrift::protocol::TType _etype1422; - xfer += iprot->readListBegin(_etype1422, _size1419); - (*(this->success)).resize(_size1419); - uint32_t _i1423; - for (_i1423 = 0; _i1423 < _size1419; ++_i1423) + uint32_t _size1421; + ::apache::thrift::protocol::TType _etype1424; + xfer += iprot->readListBegin(_etype1424, _size1421); + (*(this->success)).resize(_size1421); + uint32_t _i1425; + for (_i1425 = 0; _i1425 < _size1421; ++_i1425) { - xfer += iprot->readString((*(this->success))[_i1423]); + xfer += iprot->readString((*(this->success))[_i1425]); } xfer += iprot->readListEnd(); } @@ -33348,14 +33348,14 @@ uint32_t ThriftHiveMetastore_get_master_keys_result::read(::apache::thrift::prot 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(); } @@ -33386,10 +33386,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 _iter1429; - for (_iter1429 = this->success.begin(); _iter1429 != this->success.end(); ++_iter1429) + std::vector ::const_iterator _iter1431; + for (_iter1431 = this->success.begin(); _iter1431 != this->success.end(); ++_iter1431) { - xfer += oprot->writeString((*_iter1429)); + xfer += oprot->writeString((*_iter1431)); } xfer += oprot->writeListEnd(); } @@ -33430,14 +33430,14 @@ uint32_t ThriftHiveMetastore_get_master_keys_presult::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1430; - ::apache::thrift::protocol::TType _etype1433; - xfer += iprot->readListBegin(_etype1433, _size1430); - (*(this->success)).resize(_size1430); - uint32_t _i1434; - for (_i1434 = 0; _i1434 < _size1430; ++_i1434) + uint32_t _size1432; + ::apache::thrift::protocol::TType _etype1435; + xfer += iprot->readListBegin(_etype1435, _size1432); + (*(this->success)).resize(_size1432); + uint32_t _i1436; + for (_i1436 = 0; _i1436 < _size1432; ++_i1436) { - xfer += iprot->readString((*(this->success))[_i1434]); + xfer += iprot->readString((*(this->success))[_i1436]); } xfer += iprot->readListEnd(); } @@ -38187,6 +38187,192 @@ uint32_t ThriftHiveMetastore_cache_file_metadata_presult::read(::apache::thrift: return xfer; } + +ThriftHiveMetastore_get_metastore_db_uuid_args::~ThriftHiveMetastore_get_metastore_db_uuid_args() throw() { +} + + +uint32_t ThriftHiveMetastore_get_metastore_db_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_db_uuid_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_metastore_db_uuid_args"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_metastore_db_uuid_pargs::~ThriftHiveMetastore_get_metastore_db_uuid_pargs() throw() { +} + + +uint32_t ThriftHiveMetastore_get_metastore_db_uuid_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_metastore_db_uuid_pargs"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_metastore_db_uuid_result::~ThriftHiveMetastore_get_metastore_db_uuid_result() throw() { +} + + +uint32_t ThriftHiveMetastore_get_metastore_db_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_db_uuid_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_metastore_db_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_db_uuid_presult::~ThriftHiveMetastore_get_metastore_db_uuid_presult() throw() { +} + + +uint32_t ThriftHiveMetastore_get_metastore_db_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); @@ -47932,6 +48118,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_db_uuid(std::string& _return) +{ + send_get_metastore_db_uuid(); + recv_get_metastore_db_uuid(_return); +} + +void ThriftHiveMetastoreClient::send_get_metastore_db_uuid() +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("get_metastore_db_uuid", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_metastore_db_uuid_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_get_metastore_db_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_db_uuid") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_get_metastore_db_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_db_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); @@ -57050,6 +57296,63 @@ void ThriftHiveMetastoreProcessor::process_cache_file_metadata(int32_t seqid, :: } } +void ThriftHiveMetastoreProcessor::process_get_metastore_db_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_db_uuid", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.get_metastore_db_uuid"); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.get_metastore_db_uuid"); + } + + ThriftHiveMetastore_get_metastore_db_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_db_uuid", bytes); + } + + ThriftHiveMetastore_get_metastore_db_uuid_result result; + try { + iface_->get_metastore_db_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_db_uuid"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("get_metastore_db_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_db_uuid"); + } + + oprot->writeMessageBegin("get_metastore_db_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_db_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); @@ -71046,5 +71349,92 @@ void ThriftHiveMetastoreConcurrentClient::recv_cache_file_metadata(CacheFileMeta } // end while(true) } +void ThriftHiveMetastoreConcurrentClient::get_metastore_db_uuid(std::string& _return) +{ + int32_t seqid = send_get_metastore_db_uuid(); + recv_get_metastore_db_uuid(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_get_metastore_db_uuid() +{ + int32_t cseqid = this->sync_.generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); + oprot_->writeMessageBegin("get_metastore_db_uuid", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_get_metastore_db_uuid_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_get_metastore_db_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_db_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_db_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_db_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 metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h index ca71711e09de962d1cd2ee2ee72b3fcbbac228bc..ac08ce139767a003693c7d9248518534b8a94182 100644 --- metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h +++ metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h @@ -176,6 +176,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_db_uuid(std::string& _return) = 0; }; class ThriftHiveMetastoreIfFactory : virtual public ::facebook::fb303::FacebookServiceIfFactory { @@ -695,6 +696,9 @@ class ThriftHiveMetastoreNull : virtual public ThriftHiveMetastoreIf , virtual p void cache_file_metadata(CacheFileMetadataResult& /* _return */, const CacheFileMetadataRequest& /* req */) { return; } + void get_metastore_db_uuid(std::string& /* _return */) { + return; + } }; typedef struct _ThriftHiveMetastore_getMetaConf_args__isset { @@ -19723,6 +19727,106 @@ class ThriftHiveMetastore_cache_file_metadata_presult { }; + +class ThriftHiveMetastore_get_metastore_db_uuid_args { + public: + + ThriftHiveMetastore_get_metastore_db_uuid_args(const ThriftHiveMetastore_get_metastore_db_uuid_args&); + ThriftHiveMetastore_get_metastore_db_uuid_args& operator=(const ThriftHiveMetastore_get_metastore_db_uuid_args&); + ThriftHiveMetastore_get_metastore_db_uuid_args() { + } + + virtual ~ThriftHiveMetastore_get_metastore_db_uuid_args() throw(); + + bool operator == (const ThriftHiveMetastore_get_metastore_db_uuid_args & /* rhs */) const + { + return true; + } + bool operator != (const ThriftHiveMetastore_get_metastore_db_uuid_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_metastore_db_uuid_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_metastore_db_uuid_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_metastore_db_uuid_pargs() throw(); + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_metastore_db_uuid_result__isset { + _ThriftHiveMetastore_get_metastore_db_uuid_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_metastore_db_uuid_result__isset; + +class ThriftHiveMetastore_get_metastore_db_uuid_result { + public: + + ThriftHiveMetastore_get_metastore_db_uuid_result(const ThriftHiveMetastore_get_metastore_db_uuid_result&); + ThriftHiveMetastore_get_metastore_db_uuid_result& operator=(const ThriftHiveMetastore_get_metastore_db_uuid_result&); + ThriftHiveMetastore_get_metastore_db_uuid_result() : success() { + } + + virtual ~ThriftHiveMetastore_get_metastore_db_uuid_result() throw(); + std::string success; + MetaException o1; + + _ThriftHiveMetastore_get_metastore_db_uuid_result__isset __isset; + + void __set_success(const std::string& val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_get_metastore_db_uuid_result & rhs) const + { + if (!(success == rhs.success)) + return false; + if (!(o1 == rhs.o1)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_get_metastore_db_uuid_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_metastore_db_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_db_uuid_presult__isset { + _ThriftHiveMetastore_get_metastore_db_uuid_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_get_metastore_db_uuid_presult__isset; + +class ThriftHiveMetastore_get_metastore_db_uuid_presult { + public: + + + virtual ~ThriftHiveMetastore_get_metastore_db_uuid_presult() throw(); + std::string* success; + MetaException o1; + + _ThriftHiveMetastore_get_metastore_db_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) : @@ -20196,6 +20300,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_db_uuid(std::string& _return); + void send_get_metastore_db_uuid(); + void recv_get_metastore_db_uuid(std::string& _return); }; class ThriftHiveMetastoreProcessor : public ::facebook::fb303::FacebookServiceProcessor { @@ -20360,6 +20467,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_db_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), @@ -20518,6 +20626,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_db_uuid"] = &ThriftHiveMetastoreProcessor::process_get_metastore_db_uuid; } virtual ~ThriftHiveMetastoreProcessor() {} @@ -22027,6 +22136,16 @@ class ThriftHiveMetastoreMultiface : virtual public ThriftHiveMetastoreIf, publi return; } + void get_metastore_db_uuid(std::string& _return) { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_metastore_db_uuid(_return); + } + ifaces_[i]->get_metastore_db_uuid(_return); + return; + } + }; // The 'concurrent' client is a thread safe client that correctly handles @@ -22505,6 +22624,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_db_uuid(std::string& _return); + int32_t send_get_metastore_db_uuid(); + void recv_get_metastore_db_uuid(std::string& _return, const int32_t seqid); }; #ifdef _WIN32 diff --git metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp index b4a2a926428d529cc88954552eb561041404877d..80786e18605e17a66523b0d10dee7fa18137ae59 100644 --- metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp +++ metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp @@ -792,6 +792,11 @@ class ThriftHiveMetastoreHandler : virtual public ThriftHiveMetastoreIf { printf("cache_file_metadata\n"); } + void get_metastore_db_uuid(std::string& _return) { + // Your implementation goes here + printf("get_metastore_db_uuid\n"); + } + }; int main(int argc, char **argv) { diff --git metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp index e3725a543ec44ae46f7475156cae270b37b01196..ee70ca27872c0c282ab8341007343c4c870b0fb6 100644 --- metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp +++ 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 { @@ -12030,14 +12156,14 @@ uint32_t GetOpenTxnsResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->open_txns.clear(); - uint32_t _size517; - ::apache::thrift::protocol::TType _etype520; - xfer += iprot->readListBegin(_etype520, _size517); - this->open_txns.resize(_size517); - uint32_t _i521; - for (_i521 = 0; _i521 < _size517; ++_i521) + uint32_t _size519; + ::apache::thrift::protocol::TType _etype522; + xfer += iprot->readListBegin(_etype522, _size519); + this->open_txns.resize(_size519); + uint32_t _i523; + for (_i523 = 0; _i523 < _size519; ++_i523) { - xfer += iprot->readI64(this->open_txns[_i521]); + xfer += iprot->readI64(this->open_txns[_i523]); } xfer += iprot->readListEnd(); } @@ -12092,10 +12218,10 @@ uint32_t GetOpenTxnsResponse::write(::apache::thrift::protocol::TProtocol* oprot xfer += oprot->writeFieldBegin("open_txns", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->open_txns.size())); - std::vector ::const_iterator _iter522; - for (_iter522 = this->open_txns.begin(); _iter522 != this->open_txns.end(); ++_iter522) + std::vector ::const_iterator _iter524; + for (_iter524 = this->open_txns.begin(); _iter524 != this->open_txns.end(); ++_iter524) { - xfer += oprot->writeI64((*_iter522)); + xfer += oprot->writeI64((*_iter524)); } xfer += oprot->writeListEnd(); } @@ -12124,19 +12250,19 @@ void swap(GetOpenTxnsResponse &a, GetOpenTxnsResponse &b) { swap(a.__isset, b.__isset); } -GetOpenTxnsResponse::GetOpenTxnsResponse(const GetOpenTxnsResponse& other523) { - txn_high_water_mark = other523.txn_high_water_mark; - open_txns = other523.open_txns; - min_open_txn = other523.min_open_txn; - abortedBits = other523.abortedBits; - __isset = other523.__isset; +GetOpenTxnsResponse::GetOpenTxnsResponse(const GetOpenTxnsResponse& other525) { + txn_high_water_mark = other525.txn_high_water_mark; + open_txns = other525.open_txns; + min_open_txn = other525.min_open_txn; + abortedBits = other525.abortedBits; + __isset = other525.__isset; } -GetOpenTxnsResponse& GetOpenTxnsResponse::operator=(const GetOpenTxnsResponse& other524) { - txn_high_water_mark = other524.txn_high_water_mark; - open_txns = other524.open_txns; - min_open_txn = other524.min_open_txn; - abortedBits = other524.abortedBits; - __isset = other524.__isset; +GetOpenTxnsResponse& GetOpenTxnsResponse::operator=(const GetOpenTxnsResponse& other526) { + txn_high_water_mark = other526.txn_high_water_mark; + open_txns = other526.open_txns; + min_open_txn = other526.min_open_txn; + abortedBits = other526.abortedBits; + __isset = other526.__isset; return *this; } void GetOpenTxnsResponse::printTo(std::ostream& out) const { @@ -12281,19 +12407,19 @@ void swap(OpenTxnRequest &a, OpenTxnRequest &b) { swap(a.__isset, b.__isset); } -OpenTxnRequest::OpenTxnRequest(const OpenTxnRequest& other525) { - num_txns = other525.num_txns; - user = other525.user; - hostname = other525.hostname; - agentInfo = other525.agentInfo; - __isset = other525.__isset; +OpenTxnRequest::OpenTxnRequest(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& other526) { - num_txns = other526.num_txns; - user = other526.user; - hostname = other526.hostname; - agentInfo = other526.agentInfo; - __isset = other526.__isset; +OpenTxnRequest& OpenTxnRequest::operator=(const OpenTxnRequest& other528) { + num_txns = other528.num_txns; + user = other528.user; + hostname = other528.hostname; + agentInfo = other528.agentInfo; + __isset = other528.__isset; return *this; } void OpenTxnRequest::printTo(std::ostream& out) const { @@ -12341,14 +12467,14 @@ uint32_t OpenTxnsResponse::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->txn_ids.clear(); - uint32_t _size527; - ::apache::thrift::protocol::TType _etype530; - xfer += iprot->readListBegin(_etype530, _size527); - this->txn_ids.resize(_size527); - uint32_t _i531; - for (_i531 = 0; _i531 < _size527; ++_i531) + uint32_t _size529; + ::apache::thrift::protocol::TType _etype532; + xfer += iprot->readListBegin(_etype532, _size529); + this->txn_ids.resize(_size529); + uint32_t _i533; + for (_i533 = 0; _i533 < _size529; ++_i533) { - xfer += iprot->readI64(this->txn_ids[_i531]); + xfer += iprot->readI64(this->txn_ids[_i533]); } xfer += iprot->readListEnd(); } @@ -12379,10 +12505,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 _iter532; - for (_iter532 = this->txn_ids.begin(); _iter532 != this->txn_ids.end(); ++_iter532) + std::vector ::const_iterator _iter534; + for (_iter534 = this->txn_ids.begin(); _iter534 != this->txn_ids.end(); ++_iter534) { - xfer += oprot->writeI64((*_iter532)); + xfer += oprot->writeI64((*_iter534)); } xfer += oprot->writeListEnd(); } @@ -12398,11 +12524,11 @@ void swap(OpenTxnsResponse &a, OpenTxnsResponse &b) { swap(a.txn_ids, b.txn_ids); } -OpenTxnsResponse::OpenTxnsResponse(const OpenTxnsResponse& other533) { - txn_ids = other533.txn_ids; +OpenTxnsResponse::OpenTxnsResponse(const OpenTxnsResponse& other535) { + txn_ids = other535.txn_ids; } -OpenTxnsResponse& OpenTxnsResponse::operator=(const OpenTxnsResponse& other534) { - txn_ids = other534.txn_ids; +OpenTxnsResponse& OpenTxnsResponse::operator=(const OpenTxnsResponse& other536) { + txn_ids = other536.txn_ids; return *this; } void OpenTxnsResponse::printTo(std::ostream& out) const { @@ -12484,11 +12610,11 @@ void swap(AbortTxnRequest &a, AbortTxnRequest &b) { swap(a.txnid, b.txnid); } -AbortTxnRequest::AbortTxnRequest(const AbortTxnRequest& other535) { - txnid = other535.txnid; +AbortTxnRequest::AbortTxnRequest(const AbortTxnRequest& other537) { + txnid = other537.txnid; } -AbortTxnRequest& AbortTxnRequest::operator=(const AbortTxnRequest& other536) { - txnid = other536.txnid; +AbortTxnRequest& AbortTxnRequest::operator=(const AbortTxnRequest& other538) { + txnid = other538.txnid; return *this; } void AbortTxnRequest::printTo(std::ostream& out) const { @@ -12533,14 +12659,14 @@ uint32_t AbortTxnsRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->txn_ids.clear(); - uint32_t _size537; - ::apache::thrift::protocol::TType _etype540; - xfer += iprot->readListBegin(_etype540, _size537); - this->txn_ids.resize(_size537); - uint32_t _i541; - for (_i541 = 0; _i541 < _size537; ++_i541) + uint32_t _size539; + ::apache::thrift::protocol::TType _etype542; + xfer += iprot->readListBegin(_etype542, _size539); + this->txn_ids.resize(_size539); + uint32_t _i543; + for (_i543 = 0; _i543 < _size539; ++_i543) { - xfer += iprot->readI64(this->txn_ids[_i541]); + xfer += iprot->readI64(this->txn_ids[_i543]); } xfer += iprot->readListEnd(); } @@ -12571,10 +12697,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 _iter542; - for (_iter542 = this->txn_ids.begin(); _iter542 != this->txn_ids.end(); ++_iter542) + std::vector ::const_iterator _iter544; + for (_iter544 = this->txn_ids.begin(); _iter544 != this->txn_ids.end(); ++_iter544) { - xfer += oprot->writeI64((*_iter542)); + xfer += oprot->writeI64((*_iter544)); } xfer += oprot->writeListEnd(); } @@ -12590,11 +12716,11 @@ void swap(AbortTxnsRequest &a, AbortTxnsRequest &b) { swap(a.txn_ids, b.txn_ids); } -AbortTxnsRequest::AbortTxnsRequest(const AbortTxnsRequest& other543) { - txn_ids = other543.txn_ids; +AbortTxnsRequest::AbortTxnsRequest(const AbortTxnsRequest& other545) { + txn_ids = other545.txn_ids; } -AbortTxnsRequest& AbortTxnsRequest::operator=(const AbortTxnsRequest& other544) { - txn_ids = other544.txn_ids; +AbortTxnsRequest& AbortTxnsRequest::operator=(const AbortTxnsRequest& other546) { + txn_ids = other546.txn_ids; return *this; } void AbortTxnsRequest::printTo(std::ostream& out) const { @@ -12676,11 +12802,11 @@ void swap(CommitTxnRequest &a, CommitTxnRequest &b) { swap(a.txnid, b.txnid); } -CommitTxnRequest::CommitTxnRequest(const CommitTxnRequest& other545) { - txnid = other545.txnid; +CommitTxnRequest::CommitTxnRequest(const CommitTxnRequest& other547) { + txnid = other547.txnid; } -CommitTxnRequest& CommitTxnRequest::operator=(const CommitTxnRequest& other546) { - txnid = other546.txnid; +CommitTxnRequest& CommitTxnRequest::operator=(const CommitTxnRequest& other548) { + txnid = other548.txnid; return *this; } void CommitTxnRequest::printTo(std::ostream& out) const { @@ -12758,9 +12884,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) { { case 1: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast547; - xfer += iprot->readI32(ecast547); - this->type = (LockType::type)ecast547; + int32_t ecast549; + xfer += iprot->readI32(ecast549); + this->type = (LockType::type)ecast549; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -12768,9 +12894,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast548; - xfer += iprot->readI32(ecast548); - this->level = (LockLevel::type)ecast548; + int32_t ecast550; + xfer += iprot->readI32(ecast550); + this->level = (LockLevel::type)ecast550; isset_level = true; } else { xfer += iprot->skip(ftype); @@ -12802,9 +12928,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 6: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast549; - xfer += iprot->readI32(ecast549); - this->operationType = (DataOperationType::type)ecast549; + int32_t ecast551; + xfer += iprot->readI32(ecast551); + this->operationType = (DataOperationType::type)ecast551; this->__isset.operationType = true; } else { xfer += iprot->skip(ftype); @@ -12904,27 +13030,27 @@ void swap(LockComponent &a, LockComponent &b) { swap(a.__isset, b.__isset); } -LockComponent::LockComponent(const LockComponent& other550) { - type = other550.type; - level = other550.level; - dbname = other550.dbname; - tablename = other550.tablename; - partitionname = other550.partitionname; - operationType = other550.operationType; - isAcid = other550.isAcid; - isDynamicPartitionWrite = other550.isDynamicPartitionWrite; - __isset = other550.__isset; -} -LockComponent& LockComponent::operator=(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(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::operator=(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; return *this; } void LockComponent::printTo(std::ostream& out) const { @@ -12996,14 +13122,14 @@ uint32_t LockRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->component.clear(); - uint32_t _size552; - ::apache::thrift::protocol::TType _etype555; - xfer += iprot->readListBegin(_etype555, _size552); - this->component.resize(_size552); - uint32_t _i556; - for (_i556 = 0; _i556 < _size552; ++_i556) + uint32_t _size554; + ::apache::thrift::protocol::TType _etype557; + xfer += iprot->readListBegin(_etype557, _size554); + this->component.resize(_size554); + uint32_t _i558; + for (_i558 = 0; _i558 < _size554; ++_i558) { - xfer += this->component[_i556].read(iprot); + xfer += this->component[_i558].read(iprot); } xfer += iprot->readListEnd(); } @@ -13070,10 +13196,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 _iter557; - for (_iter557 = this->component.begin(); _iter557 != this->component.end(); ++_iter557) + std::vector ::const_iterator _iter559; + for (_iter559 = this->component.begin(); _iter559 != this->component.end(); ++_iter559) { - xfer += (*_iter557).write(oprot); + xfer += (*_iter559).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13112,21 +13238,21 @@ void swap(LockRequest &a, LockRequest &b) { swap(a.__isset, b.__isset); } -LockRequest::LockRequest(const LockRequest& other558) { - component = other558.component; - txnid = other558.txnid; - user = other558.user; - hostname = other558.hostname; - agentInfo = other558.agentInfo; - __isset = other558.__isset; -} -LockRequest& LockRequest::operator=(const LockRequest& other559) { - component = other559.component; - txnid = other559.txnid; - user = other559.user; - hostname = other559.hostname; - agentInfo = other559.agentInfo; - __isset = other559.__isset; +LockRequest::LockRequest(const LockRequest& other560) { + component = other560.component; + txnid = other560.txnid; + user = other560.user; + hostname = other560.hostname; + agentInfo = other560.agentInfo; + __isset = other560.__isset; +} +LockRequest& LockRequest::operator=(const LockRequest& other561) { + component = other561.component; + txnid = other561.txnid; + user = other561.user; + hostname = other561.hostname; + agentInfo = other561.agentInfo; + __isset = other561.__isset; return *this; } void LockRequest::printTo(std::ostream& out) const { @@ -13186,9 +13312,9 @@ uint32_t LockResponse::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast560; - xfer += iprot->readI32(ecast560); - this->state = (LockState::type)ecast560; + int32_t ecast562; + xfer += iprot->readI32(ecast562); + this->state = (LockState::type)ecast562; isset_state = true; } else { xfer += iprot->skip(ftype); @@ -13234,13 +13360,13 @@ void swap(LockResponse &a, LockResponse &b) { swap(a.state, b.state); } -LockResponse::LockResponse(const LockResponse& other561) { - lockid = other561.lockid; - state = other561.state; +LockResponse::LockResponse(const LockResponse& other563) { + lockid = other563.lockid; + state = other563.state; } -LockResponse& LockResponse::operator=(const LockResponse& other562) { - lockid = other562.lockid; - state = other562.state; +LockResponse& LockResponse::operator=(const LockResponse& other564) { + lockid = other564.lockid; + state = other564.state; return *this; } void LockResponse::printTo(std::ostream& out) const { @@ -13362,17 +13488,17 @@ void swap(CheckLockRequest &a, CheckLockRequest &b) { swap(a.__isset, b.__isset); } -CheckLockRequest::CheckLockRequest(const CheckLockRequest& other563) { - lockid = other563.lockid; - txnid = other563.txnid; - elapsed_ms = other563.elapsed_ms; - __isset = other563.__isset; +CheckLockRequest::CheckLockRequest(const CheckLockRequest& other565) { + lockid = other565.lockid; + txnid = other565.txnid; + elapsed_ms = other565.elapsed_ms; + __isset = other565.__isset; } -CheckLockRequest& CheckLockRequest::operator=(const CheckLockRequest& other564) { - lockid = other564.lockid; - txnid = other564.txnid; - elapsed_ms = other564.elapsed_ms; - __isset = other564.__isset; +CheckLockRequest& CheckLockRequest::operator=(const CheckLockRequest& other566) { + lockid = other566.lockid; + txnid = other566.txnid; + elapsed_ms = other566.elapsed_ms; + __isset = other566.__isset; return *this; } void CheckLockRequest::printTo(std::ostream& out) const { @@ -13456,11 +13582,11 @@ void swap(UnlockRequest &a, UnlockRequest &b) { swap(a.lockid, b.lockid); } -UnlockRequest::UnlockRequest(const UnlockRequest& other565) { - lockid = other565.lockid; +UnlockRequest::UnlockRequest(const UnlockRequest& other567) { + lockid = other567.lockid; } -UnlockRequest& UnlockRequest::operator=(const UnlockRequest& other566) { - lockid = other566.lockid; +UnlockRequest& UnlockRequest::operator=(const UnlockRequest& other568) { + lockid = other568.lockid; return *this; } void UnlockRequest::printTo(std::ostream& out) const { @@ -13599,19 +13725,19 @@ void swap(ShowLocksRequest &a, ShowLocksRequest &b) { swap(a.__isset, b.__isset); } -ShowLocksRequest::ShowLocksRequest(const ShowLocksRequest& other567) { - dbname = other567.dbname; - tablename = other567.tablename; - partname = other567.partname; - isExtended = other567.isExtended; - __isset = other567.__isset; +ShowLocksRequest::ShowLocksRequest(const ShowLocksRequest& other569) { + dbname = other569.dbname; + tablename = other569.tablename; + partname = other569.partname; + isExtended = other569.isExtended; + __isset = other569.__isset; } -ShowLocksRequest& ShowLocksRequest::operator=(const ShowLocksRequest& other568) { - dbname = other568.dbname; - tablename = other568.tablename; - partname = other568.partname; - isExtended = other568.isExtended; - __isset = other568.__isset; +ShowLocksRequest& ShowLocksRequest::operator=(const ShowLocksRequest& other570) { + dbname = other570.dbname; + tablename = other570.tablename; + partname = other570.partname; + isExtended = other570.isExtended; + __isset = other570.__isset; return *this; } void ShowLocksRequest::printTo(std::ostream& out) const { @@ -13764,9 +13890,9 @@ uint32_t ShowLocksResponseElement::read(::apache::thrift::protocol::TProtocol* i break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast569; - xfer += iprot->readI32(ecast569); - this->state = (LockState::type)ecast569; + int32_t ecast571; + xfer += iprot->readI32(ecast571); + this->state = (LockState::type)ecast571; isset_state = true; } else { xfer += iprot->skip(ftype); @@ -13774,9 +13900,9 @@ uint32_t ShowLocksResponseElement::read(::apache::thrift::protocol::TProtocol* i break; case 6: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast570; - xfer += iprot->readI32(ecast570); - this->type = (LockType::type)ecast570; + int32_t ecast572; + xfer += iprot->readI32(ecast572); + this->type = (LockType::type)ecast572; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -13992,43 +14118,43 @@ void swap(ShowLocksResponseElement &a, ShowLocksResponseElement &b) { swap(a.__isset, b.__isset); } -ShowLocksResponseElement::ShowLocksResponseElement(const ShowLocksResponseElement& other571) { - lockid = other571.lockid; - dbname = other571.dbname; - tablename = other571.tablename; - partname = other571.partname; - state = other571.state; - type = other571.type; - txnid = other571.txnid; - lastheartbeat = other571.lastheartbeat; - acquiredat = other571.acquiredat; - user = other571.user; - hostname = other571.hostname; - heartbeatCount = other571.heartbeatCount; - agentInfo = other571.agentInfo; - blockedByExtId = other571.blockedByExtId; - blockedByIntId = other571.blockedByIntId; - lockIdInternal = other571.lockIdInternal; - __isset = other571.__isset; -} -ShowLocksResponseElement& ShowLocksResponseElement::operator=(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(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::operator=(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; return *this; } void ShowLocksResponseElement::printTo(std::ostream& out) const { @@ -14087,14 +14213,14 @@ uint32_t ShowLocksResponse::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->locks.clear(); - uint32_t _size573; - ::apache::thrift::protocol::TType _etype576; - xfer += iprot->readListBegin(_etype576, _size573); - this->locks.resize(_size573); - uint32_t _i577; - for (_i577 = 0; _i577 < _size573; ++_i577) + uint32_t _size575; + ::apache::thrift::protocol::TType _etype578; + xfer += iprot->readListBegin(_etype578, _size575); + this->locks.resize(_size575); + uint32_t _i579; + for (_i579 = 0; _i579 < _size575; ++_i579) { - xfer += this->locks[_i577].read(iprot); + xfer += this->locks[_i579].read(iprot); } xfer += iprot->readListEnd(); } @@ -14123,10 +14249,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 _iter578; - for (_iter578 = this->locks.begin(); _iter578 != this->locks.end(); ++_iter578) + std::vector ::const_iterator _iter580; + for (_iter580 = this->locks.begin(); _iter580 != this->locks.end(); ++_iter580) { - xfer += (*_iter578).write(oprot); + xfer += (*_iter580).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14143,13 +14269,13 @@ void swap(ShowLocksResponse &a, ShowLocksResponse &b) { swap(a.__isset, b.__isset); } -ShowLocksResponse::ShowLocksResponse(const ShowLocksResponse& other579) { - locks = other579.locks; - __isset = other579.__isset; +ShowLocksResponse::ShowLocksResponse(const ShowLocksResponse& other581) { + locks = other581.locks; + __isset = other581.__isset; } -ShowLocksResponse& ShowLocksResponse::operator=(const ShowLocksResponse& other580) { - locks = other580.locks; - __isset = other580.__isset; +ShowLocksResponse& ShowLocksResponse::operator=(const ShowLocksResponse& other582) { + locks = other582.locks; + __isset = other582.__isset; return *this; } void ShowLocksResponse::printTo(std::ostream& out) const { @@ -14250,15 +14376,15 @@ void swap(HeartbeatRequest &a, HeartbeatRequest &b) { swap(a.__isset, b.__isset); } -HeartbeatRequest::HeartbeatRequest(const HeartbeatRequest& other581) { - lockid = other581.lockid; - txnid = other581.txnid; - __isset = other581.__isset; +HeartbeatRequest::HeartbeatRequest(const HeartbeatRequest& other583) { + lockid = other583.lockid; + txnid = other583.txnid; + __isset = other583.__isset; } -HeartbeatRequest& HeartbeatRequest::operator=(const HeartbeatRequest& other582) { - lockid = other582.lockid; - txnid = other582.txnid; - __isset = other582.__isset; +HeartbeatRequest& HeartbeatRequest::operator=(const HeartbeatRequest& other584) { + lockid = other584.lockid; + txnid = other584.txnid; + __isset = other584.__isset; return *this; } void HeartbeatRequest::printTo(std::ostream& out) const { @@ -14361,13 +14487,13 @@ void swap(HeartbeatTxnRangeRequest &a, HeartbeatTxnRangeRequest &b) { swap(a.max, b.max); } -HeartbeatTxnRangeRequest::HeartbeatTxnRangeRequest(const HeartbeatTxnRangeRequest& other583) { - min = other583.min; - max = other583.max; +HeartbeatTxnRangeRequest::HeartbeatTxnRangeRequest(const HeartbeatTxnRangeRequest& other585) { + min = other585.min; + max = other585.max; } -HeartbeatTxnRangeRequest& HeartbeatTxnRangeRequest::operator=(const HeartbeatTxnRangeRequest& other584) { - min = other584.min; - max = other584.max; +HeartbeatTxnRangeRequest& HeartbeatTxnRangeRequest::operator=(const HeartbeatTxnRangeRequest& other586) { + min = other586.min; + max = other586.max; return *this; } void HeartbeatTxnRangeRequest::printTo(std::ostream& out) const { @@ -14418,15 +14544,15 @@ uint32_t HeartbeatTxnRangeResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_SET) { { this->aborted.clear(); - uint32_t _size585; - ::apache::thrift::protocol::TType _etype588; - xfer += iprot->readSetBegin(_etype588, _size585); - uint32_t _i589; - for (_i589 = 0; _i589 < _size585; ++_i589) + uint32_t _size587; + ::apache::thrift::protocol::TType _etype590; + xfer += iprot->readSetBegin(_etype590, _size587); + uint32_t _i591; + for (_i591 = 0; _i591 < _size587; ++_i591) { - int64_t _elem590; - xfer += iprot->readI64(_elem590); - this->aborted.insert(_elem590); + int64_t _elem592; + xfer += iprot->readI64(_elem592); + this->aborted.insert(_elem592); } xfer += iprot->readSetEnd(); } @@ -14439,15 +14565,15 @@ uint32_t HeartbeatTxnRangeResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_SET) { { this->nosuch.clear(); - uint32_t _size591; - ::apache::thrift::protocol::TType _etype594; - xfer += iprot->readSetBegin(_etype594, _size591); - uint32_t _i595; - for (_i595 = 0; _i595 < _size591; ++_i595) + uint32_t _size593; + ::apache::thrift::protocol::TType _etype596; + xfer += iprot->readSetBegin(_etype596, _size593); + uint32_t _i597; + for (_i597 = 0; _i597 < _size593; ++_i597) { - int64_t _elem596; - xfer += iprot->readI64(_elem596); - this->nosuch.insert(_elem596); + int64_t _elem598; + xfer += iprot->readI64(_elem598); + this->nosuch.insert(_elem598); } xfer += iprot->readSetEnd(); } @@ -14480,10 +14606,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 _iter597; - for (_iter597 = this->aborted.begin(); _iter597 != this->aborted.end(); ++_iter597) + std::set ::const_iterator _iter599; + for (_iter599 = this->aborted.begin(); _iter599 != this->aborted.end(); ++_iter599) { - xfer += oprot->writeI64((*_iter597)); + xfer += oprot->writeI64((*_iter599)); } xfer += oprot->writeSetEnd(); } @@ -14492,10 +14618,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 _iter598; - for (_iter598 = this->nosuch.begin(); _iter598 != this->nosuch.end(); ++_iter598) + std::set ::const_iterator _iter600; + for (_iter600 = this->nosuch.begin(); _iter600 != this->nosuch.end(); ++_iter600) { - xfer += oprot->writeI64((*_iter598)); + xfer += oprot->writeI64((*_iter600)); } xfer += oprot->writeSetEnd(); } @@ -14512,13 +14638,13 @@ void swap(HeartbeatTxnRangeResponse &a, HeartbeatTxnRangeResponse &b) { swap(a.nosuch, b.nosuch); } -HeartbeatTxnRangeResponse::HeartbeatTxnRangeResponse(const HeartbeatTxnRangeResponse& other599) { - aborted = other599.aborted; - nosuch = other599.nosuch; +HeartbeatTxnRangeResponse::HeartbeatTxnRangeResponse(const HeartbeatTxnRangeResponse& other601) { + aborted = other601.aborted; + nosuch = other601.nosuch; } -HeartbeatTxnRangeResponse& HeartbeatTxnRangeResponse::operator=(const HeartbeatTxnRangeResponse& other600) { - aborted = other600.aborted; - nosuch = other600.nosuch; +HeartbeatTxnRangeResponse& HeartbeatTxnRangeResponse::operator=(const HeartbeatTxnRangeResponse& other602) { + aborted = other602.aborted; + nosuch = other602.nosuch; return *this; } void HeartbeatTxnRangeResponse::printTo(std::ostream& out) const { @@ -14611,9 +14737,9 @@ uint32_t CompactionRequest::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast601; - xfer += iprot->readI32(ecast601); - this->type = (CompactionType::type)ecast601; + int32_t ecast603; + xfer += iprot->readI32(ecast603); + this->type = (CompactionType::type)ecast603; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -14631,17 +14757,17 @@ uint32_t CompactionRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->properties.clear(); - uint32_t _size602; - ::apache::thrift::protocol::TType _ktype603; - ::apache::thrift::protocol::TType _vtype604; - xfer += iprot->readMapBegin(_ktype603, _vtype604, _size602); - uint32_t _i606; - for (_i606 = 0; _i606 < _size602; ++_i606) + uint32_t _size604; + ::apache::thrift::protocol::TType _ktype605; + ::apache::thrift::protocol::TType _vtype606; + xfer += iprot->readMapBegin(_ktype605, _vtype606, _size604); + uint32_t _i608; + for (_i608 = 0; _i608 < _size604; ++_i608) { - std::string _key607; - xfer += iprot->readString(_key607); - std::string& _val608 = this->properties[_key607]; - xfer += iprot->readString(_val608); + std::string _key609; + xfer += iprot->readString(_key609); + std::string& _val610 = this->properties[_key609]; + xfer += iprot->readString(_val610); } xfer += iprot->readMapEnd(); } @@ -14699,11 +14825,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 _iter609; - for (_iter609 = this->properties.begin(); _iter609 != this->properties.end(); ++_iter609) + std::map ::const_iterator _iter611; + for (_iter611 = this->properties.begin(); _iter611 != this->properties.end(); ++_iter611) { - xfer += oprot->writeString(_iter609->first); - xfer += oprot->writeString(_iter609->second); + xfer += oprot->writeString(_iter611->first); + xfer += oprot->writeString(_iter611->second); } xfer += oprot->writeMapEnd(); } @@ -14725,23 +14851,23 @@ void swap(CompactionRequest &a, CompactionRequest &b) { swap(a.__isset, b.__isset); } -CompactionRequest::CompactionRequest(const CompactionRequest& other610) { - dbname = other610.dbname; - tablename = other610.tablename; - partitionname = other610.partitionname; - type = other610.type; - runas = other610.runas; - properties = other610.properties; - __isset = other610.__isset; -} -CompactionRequest& CompactionRequest::operator=(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(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::operator=(const CompactionRequest& other613) { + dbname = other613.dbname; + tablename = other613.tablename; + partitionname = other613.partitionname; + type = other613.type; + runas = other613.runas; + properties = other613.properties; + __isset = other613.__isset; return *this; } void CompactionRequest::printTo(std::ostream& out) const { @@ -14868,15 +14994,15 @@ void swap(CompactionResponse &a, CompactionResponse &b) { swap(a.accepted, b.accepted); } -CompactionResponse::CompactionResponse(const CompactionResponse& other612) { - id = other612.id; - state = other612.state; - accepted = other612.accepted; +CompactionResponse::CompactionResponse(const CompactionResponse& other614) { + id = other614.id; + state = other614.state; + accepted = other614.accepted; } -CompactionResponse& CompactionResponse::operator=(const CompactionResponse& other613) { - id = other613.id; - state = other613.state; - accepted = other613.accepted; +CompactionResponse& CompactionResponse::operator=(const CompactionResponse& other615) { + id = other615.id; + state = other615.state; + accepted = other615.accepted; return *this; } void CompactionResponse::printTo(std::ostream& out) const { @@ -14937,11 +15063,11 @@ void swap(ShowCompactRequest &a, ShowCompactRequest &b) { (void) b; } -ShowCompactRequest::ShowCompactRequest(const ShowCompactRequest& other614) { - (void) other614; +ShowCompactRequest::ShowCompactRequest(const ShowCompactRequest& other616) { + (void) other616; } -ShowCompactRequest& ShowCompactRequest::operator=(const ShowCompactRequest& other615) { - (void) other615; +ShowCompactRequest& ShowCompactRequest::operator=(const ShowCompactRequest& other617) { + (void) other617; return *this; } void ShowCompactRequest::printTo(std::ostream& out) const { @@ -15067,9 +15193,9 @@ uint32_t ShowCompactResponseElement::read(::apache::thrift::protocol::TProtocol* break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast616; - xfer += iprot->readI32(ecast616); - this->type = (CompactionType::type)ecast616; + int32_t ecast618; + xfer += iprot->readI32(ecast618); + this->type = (CompactionType::type)ecast618; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -15256,37 +15382,37 @@ void swap(ShowCompactResponseElement &a, ShowCompactResponseElement &b) { swap(a.__isset, b.__isset); } -ShowCompactResponseElement::ShowCompactResponseElement(const ShowCompactResponseElement& other617) { - dbname = other617.dbname; - tablename = other617.tablename; - partitionname = other617.partitionname; - type = other617.type; - state = other617.state; - workerid = other617.workerid; - start = other617.start; - runAs = other617.runAs; - hightestTxnId = other617.hightestTxnId; - metaInfo = other617.metaInfo; - endTime = other617.endTime; - hadoopJobId = other617.hadoopJobId; - id = other617.id; - __isset = other617.__isset; -} -ShowCompactResponseElement& ShowCompactResponseElement::operator=(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(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::operator=(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; return *this; } void ShowCompactResponseElement::printTo(std::ostream& out) const { @@ -15343,14 +15469,14 @@ uint32_t ShowCompactResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->compacts.clear(); - uint32_t _size619; - ::apache::thrift::protocol::TType _etype622; - xfer += iprot->readListBegin(_etype622, _size619); - this->compacts.resize(_size619); - uint32_t _i623; - for (_i623 = 0; _i623 < _size619; ++_i623) + uint32_t _size621; + ::apache::thrift::protocol::TType _etype624; + xfer += iprot->readListBegin(_etype624, _size621); + this->compacts.resize(_size621); + uint32_t _i625; + for (_i625 = 0; _i625 < _size621; ++_i625) { - xfer += this->compacts[_i623].read(iprot); + xfer += this->compacts[_i625].read(iprot); } xfer += iprot->readListEnd(); } @@ -15381,10 +15507,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 _iter624; - for (_iter624 = this->compacts.begin(); _iter624 != this->compacts.end(); ++_iter624) + std::vector ::const_iterator _iter626; + for (_iter626 = this->compacts.begin(); _iter626 != this->compacts.end(); ++_iter626) { - xfer += (*_iter624).write(oprot); + xfer += (*_iter626).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15400,11 +15526,11 @@ void swap(ShowCompactResponse &a, ShowCompactResponse &b) { swap(a.compacts, b.compacts); } -ShowCompactResponse::ShowCompactResponse(const ShowCompactResponse& other625) { - compacts = other625.compacts; +ShowCompactResponse::ShowCompactResponse(const ShowCompactResponse& other627) { + compacts = other627.compacts; } -ShowCompactResponse& ShowCompactResponse::operator=(const ShowCompactResponse& other626) { - compacts = other626.compacts; +ShowCompactResponse& ShowCompactResponse::operator=(const ShowCompactResponse& other628) { + compacts = other628.compacts; return *this; } void ShowCompactResponse::printTo(std::ostream& out) const { @@ -15493,14 +15619,14 @@ uint32_t AddDynamicPartitions::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionnames.clear(); - uint32_t _size627; - ::apache::thrift::protocol::TType _etype630; - xfer += iprot->readListBegin(_etype630, _size627); - this->partitionnames.resize(_size627); - uint32_t _i631; - for (_i631 = 0; _i631 < _size627; ++_i631) + uint32_t _size629; + ::apache::thrift::protocol::TType _etype632; + xfer += iprot->readListBegin(_etype632, _size629); + this->partitionnames.resize(_size629); + uint32_t _i633; + for (_i633 = 0; _i633 < _size629; ++_i633) { - xfer += iprot->readString(this->partitionnames[_i631]); + xfer += iprot->readString(this->partitionnames[_i633]); } xfer += iprot->readListEnd(); } @@ -15511,9 +15637,9 @@ uint32_t AddDynamicPartitions::read(::apache::thrift::protocol::TProtocol* iprot break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast632; - xfer += iprot->readI32(ecast632); - this->operationType = (DataOperationType::type)ecast632; + int32_t ecast634; + xfer += iprot->readI32(ecast634); + this->operationType = (DataOperationType::type)ecast634; this->__isset.operationType = true; } else { xfer += iprot->skip(ftype); @@ -15559,10 +15685,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 _iter633; - for (_iter633 = this->partitionnames.begin(); _iter633 != this->partitionnames.end(); ++_iter633) + std::vector ::const_iterator _iter635; + for (_iter635 = this->partitionnames.begin(); _iter635 != this->partitionnames.end(); ++_iter635) { - xfer += oprot->writeString((*_iter633)); + xfer += oprot->writeString((*_iter635)); } xfer += oprot->writeListEnd(); } @@ -15588,21 +15714,21 @@ void swap(AddDynamicPartitions &a, AddDynamicPartitions &b) { swap(a.__isset, b.__isset); } -AddDynamicPartitions::AddDynamicPartitions(const AddDynamicPartitions& other634) { - txnid = other634.txnid; - dbname = other634.dbname; - tablename = other634.tablename; - partitionnames = other634.partitionnames; - operationType = other634.operationType; - __isset = other634.__isset; -} -AddDynamicPartitions& AddDynamicPartitions::operator=(const AddDynamicPartitions& other635) { - txnid = other635.txnid; - dbname = other635.dbname; - tablename = other635.tablename; - partitionnames = other635.partitionnames; - operationType = other635.operationType; - __isset = other635.__isset; +AddDynamicPartitions::AddDynamicPartitions(const AddDynamicPartitions& other636) { + txnid = other636.txnid; + dbname = other636.dbname; + tablename = other636.tablename; + partitionnames = other636.partitionnames; + operationType = other636.operationType; + __isset = other636.__isset; +} +AddDynamicPartitions& AddDynamicPartitions::operator=(const AddDynamicPartitions& other637) { + txnid = other637.txnid; + dbname = other637.dbname; + tablename = other637.tablename; + partitionnames = other637.partitionnames; + operationType = other637.operationType; + __isset = other637.__isset; return *this; } void AddDynamicPartitions::printTo(std::ostream& out) const { @@ -15708,15 +15834,15 @@ void swap(NotificationEventRequest &a, NotificationEventRequest &b) { swap(a.__isset, b.__isset); } -NotificationEventRequest::NotificationEventRequest(const NotificationEventRequest& other636) { - lastEvent = other636.lastEvent; - maxEvents = other636.maxEvents; - __isset = other636.__isset; +NotificationEventRequest::NotificationEventRequest(const NotificationEventRequest& other638) { + lastEvent = other638.lastEvent; + maxEvents = other638.maxEvents; + __isset = other638.__isset; } -NotificationEventRequest& NotificationEventRequest::operator=(const NotificationEventRequest& other637) { - lastEvent = other637.lastEvent; - maxEvents = other637.maxEvents; - __isset = other637.__isset; +NotificationEventRequest& NotificationEventRequest::operator=(const NotificationEventRequest& other639) { + lastEvent = other639.lastEvent; + maxEvents = other639.maxEvents; + __isset = other639.__isset; return *this; } void NotificationEventRequest::printTo(std::ostream& out) const { @@ -15917,25 +16043,25 @@ void swap(NotificationEvent &a, NotificationEvent &b) { swap(a.__isset, b.__isset); } -NotificationEvent::NotificationEvent(const NotificationEvent& other638) { - eventId = other638.eventId; - eventTime = other638.eventTime; - eventType = other638.eventType; - dbName = other638.dbName; - tableName = other638.tableName; - message = other638.message; - messageFormat = other638.messageFormat; - __isset = other638.__isset; -} -NotificationEvent& NotificationEvent::operator=(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(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::operator=(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; return *this; } void NotificationEvent::printTo(std::ostream& out) const { @@ -15986,14 +16112,14 @@ uint32_t NotificationEventResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->events.clear(); - uint32_t _size640; - ::apache::thrift::protocol::TType _etype643; - xfer += iprot->readListBegin(_etype643, _size640); - this->events.resize(_size640); - uint32_t _i644; - for (_i644 = 0; _i644 < _size640; ++_i644) + uint32_t _size642; + ::apache::thrift::protocol::TType _etype645; + xfer += iprot->readListBegin(_etype645, _size642); + this->events.resize(_size642); + uint32_t _i646; + for (_i646 = 0; _i646 < _size642; ++_i646) { - xfer += this->events[_i644].read(iprot); + xfer += this->events[_i646].read(iprot); } xfer += iprot->readListEnd(); } @@ -16024,10 +16150,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 _iter645; - for (_iter645 = this->events.begin(); _iter645 != this->events.end(); ++_iter645) + std::vector ::const_iterator _iter647; + for (_iter647 = this->events.begin(); _iter647 != this->events.end(); ++_iter647) { - xfer += (*_iter645).write(oprot); + xfer += (*_iter647).write(oprot); } xfer += oprot->writeListEnd(); } @@ -16043,11 +16169,11 @@ void swap(NotificationEventResponse &a, NotificationEventResponse &b) { swap(a.events, b.events); } -NotificationEventResponse::NotificationEventResponse(const NotificationEventResponse& other646) { - events = other646.events; +NotificationEventResponse::NotificationEventResponse(const NotificationEventResponse& other648) { + events = other648.events; } -NotificationEventResponse& NotificationEventResponse::operator=(const NotificationEventResponse& other647) { - events = other647.events; +NotificationEventResponse& NotificationEventResponse::operator=(const NotificationEventResponse& other649) { + events = other649.events; return *this; } void NotificationEventResponse::printTo(std::ostream& out) const { @@ -16129,11 +16255,11 @@ void swap(CurrentNotificationEventId &a, CurrentNotificationEventId &b) { swap(a.eventId, b.eventId); } -CurrentNotificationEventId::CurrentNotificationEventId(const CurrentNotificationEventId& other648) { - eventId = other648.eventId; +CurrentNotificationEventId::CurrentNotificationEventId(const CurrentNotificationEventId& other650) { + eventId = other650.eventId; } -CurrentNotificationEventId& CurrentNotificationEventId::operator=(const CurrentNotificationEventId& other649) { - eventId = other649.eventId; +CurrentNotificationEventId& CurrentNotificationEventId::operator=(const CurrentNotificationEventId& other651) { + eventId = other651.eventId; return *this; } void CurrentNotificationEventId::printTo(std::ostream& out) const { @@ -16196,14 +16322,14 @@ uint32_t InsertEventRequestData::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->filesAdded.clear(); - uint32_t _size650; - ::apache::thrift::protocol::TType _etype653; - xfer += iprot->readListBegin(_etype653, _size650); - this->filesAdded.resize(_size650); - uint32_t _i654; - for (_i654 = 0; _i654 < _size650; ++_i654) + uint32_t _size652; + ::apache::thrift::protocol::TType _etype655; + xfer += iprot->readListBegin(_etype655, _size652); + this->filesAdded.resize(_size652); + uint32_t _i656; + for (_i656 = 0; _i656 < _size652; ++_i656) { - xfer += iprot->readString(this->filesAdded[_i654]); + xfer += iprot->readString(this->filesAdded[_i656]); } xfer += iprot->readListEnd(); } @@ -16216,14 +16342,14 @@ uint32_t InsertEventRequestData::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->filesAddedChecksum.clear(); - uint32_t _size655; - ::apache::thrift::protocol::TType _etype658; - xfer += iprot->readListBegin(_etype658, _size655); - this->filesAddedChecksum.resize(_size655); - uint32_t _i659; - for (_i659 = 0; _i659 < _size655; ++_i659) + uint32_t _size657; + ::apache::thrift::protocol::TType _etype660; + xfer += iprot->readListBegin(_etype660, _size657); + this->filesAddedChecksum.resize(_size657); + uint32_t _i661; + for (_i661 = 0; _i661 < _size657; ++_i661) { - xfer += iprot->readString(this->filesAddedChecksum[_i659]); + xfer += iprot->readString(this->filesAddedChecksum[_i661]); } xfer += iprot->readListEnd(); } @@ -16259,10 +16385,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 _iter660; - for (_iter660 = this->filesAdded.begin(); _iter660 != this->filesAdded.end(); ++_iter660) + std::vector ::const_iterator _iter662; + for (_iter662 = this->filesAdded.begin(); _iter662 != this->filesAdded.end(); ++_iter662) { - xfer += oprot->writeString((*_iter660)); + xfer += oprot->writeString((*_iter662)); } xfer += oprot->writeListEnd(); } @@ -16272,10 +16398,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 _iter661; - for (_iter661 = this->filesAddedChecksum.begin(); _iter661 != this->filesAddedChecksum.end(); ++_iter661) + std::vector ::const_iterator _iter663; + for (_iter663 = this->filesAddedChecksum.begin(); _iter663 != this->filesAddedChecksum.end(); ++_iter663) { - xfer += oprot->writeString((*_iter661)); + xfer += oprot->writeString((*_iter663)); } xfer += oprot->writeListEnd(); } @@ -16294,17 +16420,17 @@ void swap(InsertEventRequestData &a, InsertEventRequestData &b) { swap(a.__isset, b.__isset); } -InsertEventRequestData::InsertEventRequestData(const InsertEventRequestData& other662) { - replace = other662.replace; - filesAdded = other662.filesAdded; - filesAddedChecksum = other662.filesAddedChecksum; - __isset = other662.__isset; +InsertEventRequestData::InsertEventRequestData(const InsertEventRequestData& other664) { + replace = other664.replace; + filesAdded = other664.filesAdded; + filesAddedChecksum = other664.filesAddedChecksum; + __isset = other664.__isset; } -InsertEventRequestData& InsertEventRequestData::operator=(const InsertEventRequestData& other663) { - replace = other663.replace; - filesAdded = other663.filesAdded; - filesAddedChecksum = other663.filesAddedChecksum; - __isset = other663.__isset; +InsertEventRequestData& InsertEventRequestData::operator=(const InsertEventRequestData& other665) { + replace = other665.replace; + filesAdded = other665.filesAdded; + filesAddedChecksum = other665.filesAddedChecksum; + __isset = other665.__isset; return *this; } void InsertEventRequestData::printTo(std::ostream& out) const { @@ -16386,13 +16512,13 @@ void swap(FireEventRequestData &a, FireEventRequestData &b) { swap(a.__isset, b.__isset); } -FireEventRequestData::FireEventRequestData(const FireEventRequestData& other664) { - insertData = other664.insertData; - __isset = other664.__isset; +FireEventRequestData::FireEventRequestData(const FireEventRequestData& other666) { + insertData = other666.insertData; + __isset = other666.__isset; } -FireEventRequestData& FireEventRequestData::operator=(const FireEventRequestData& other665) { - insertData = other665.insertData; - __isset = other665.__isset; +FireEventRequestData& FireEventRequestData::operator=(const FireEventRequestData& other667) { + insertData = other667.insertData; + __isset = other667.__isset; return *this; } void FireEventRequestData::printTo(std::ostream& out) const { @@ -16489,14 +16615,14 @@ uint32_t FireEventRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionVals.clear(); - uint32_t _size666; - ::apache::thrift::protocol::TType _etype669; - xfer += iprot->readListBegin(_etype669, _size666); - this->partitionVals.resize(_size666); - uint32_t _i670; - for (_i670 = 0; _i670 < _size666; ++_i670) + uint32_t _size668; + ::apache::thrift::protocol::TType _etype671; + xfer += iprot->readListBegin(_etype671, _size668); + this->partitionVals.resize(_size668); + uint32_t _i672; + for (_i672 = 0; _i672 < _size668; ++_i672) { - xfer += iprot->readString(this->partitionVals[_i670]); + xfer += iprot->readString(this->partitionVals[_i672]); } xfer += iprot->readListEnd(); } @@ -16548,10 +16674,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 _iter671; - for (_iter671 = this->partitionVals.begin(); _iter671 != this->partitionVals.end(); ++_iter671) + std::vector ::const_iterator _iter673; + for (_iter673 = this->partitionVals.begin(); _iter673 != this->partitionVals.end(); ++_iter673) { - xfer += oprot->writeString((*_iter671)); + xfer += oprot->writeString((*_iter673)); } xfer += oprot->writeListEnd(); } @@ -16572,21 +16698,21 @@ void swap(FireEventRequest &a, FireEventRequest &b) { swap(a.__isset, b.__isset); } -FireEventRequest::FireEventRequest(const FireEventRequest& other672) { - successful = other672.successful; - data = other672.data; - dbName = other672.dbName; - tableName = other672.tableName; - partitionVals = other672.partitionVals; - __isset = other672.__isset; -} -FireEventRequest& FireEventRequest::operator=(const FireEventRequest& other673) { - successful = other673.successful; - data = other673.data; - dbName = other673.dbName; - tableName = other673.tableName; - partitionVals = other673.partitionVals; - __isset = other673.__isset; +FireEventRequest::FireEventRequest(const FireEventRequest& other674) { + successful = other674.successful; + data = other674.data; + dbName = other674.dbName; + tableName = other674.tableName; + partitionVals = other674.partitionVals; + __isset = other674.__isset; +} +FireEventRequest& FireEventRequest::operator=(const FireEventRequest& other675) { + successful = other675.successful; + data = other675.data; + dbName = other675.dbName; + tableName = other675.tableName; + partitionVals = other675.partitionVals; + __isset = other675.__isset; return *this; } void FireEventRequest::printTo(std::ostream& out) const { @@ -16649,11 +16775,11 @@ void swap(FireEventResponse &a, FireEventResponse &b) { (void) b; } -FireEventResponse::FireEventResponse(const FireEventResponse& other674) { - (void) other674; +FireEventResponse::FireEventResponse(const FireEventResponse& other676) { + (void) other676; } -FireEventResponse& FireEventResponse::operator=(const FireEventResponse& other675) { - (void) other675; +FireEventResponse& FireEventResponse::operator=(const FireEventResponse& other677) { + (void) other677; return *this; } void FireEventResponse::printTo(std::ostream& out) const { @@ -16753,15 +16879,15 @@ void swap(MetadataPpdResult &a, MetadataPpdResult &b) { swap(a.__isset, b.__isset); } -MetadataPpdResult::MetadataPpdResult(const MetadataPpdResult& other676) { - metadata = other676.metadata; - includeBitset = other676.includeBitset; - __isset = other676.__isset; +MetadataPpdResult::MetadataPpdResult(const MetadataPpdResult& other678) { + metadata = other678.metadata; + includeBitset = other678.includeBitset; + __isset = other678.__isset; } -MetadataPpdResult& MetadataPpdResult::operator=(const MetadataPpdResult& other677) { - metadata = other677.metadata; - includeBitset = other677.includeBitset; - __isset = other677.__isset; +MetadataPpdResult& MetadataPpdResult::operator=(const MetadataPpdResult& other679) { + metadata = other679.metadata; + includeBitset = other679.includeBitset; + __isset = other679.__isset; return *this; } void MetadataPpdResult::printTo(std::ostream& out) const { @@ -16812,17 +16938,17 @@ uint32_t GetFileMetadataByExprResult::read(::apache::thrift::protocol::TProtocol if (ftype == ::apache::thrift::protocol::T_MAP) { { this->metadata.clear(); - uint32_t _size678; - ::apache::thrift::protocol::TType _ktype679; - ::apache::thrift::protocol::TType _vtype680; - xfer += iprot->readMapBegin(_ktype679, _vtype680, _size678); - uint32_t _i682; - for (_i682 = 0; _i682 < _size678; ++_i682) + uint32_t _size680; + ::apache::thrift::protocol::TType _ktype681; + ::apache::thrift::protocol::TType _vtype682; + xfer += iprot->readMapBegin(_ktype681, _vtype682, _size680); + uint32_t _i684; + for (_i684 = 0; _i684 < _size680; ++_i684) { - int64_t _key683; - xfer += iprot->readI64(_key683); - MetadataPpdResult& _val684 = this->metadata[_key683]; - xfer += _val684.read(iprot); + int64_t _key685; + xfer += iprot->readI64(_key685); + MetadataPpdResult& _val686 = this->metadata[_key685]; + xfer += _val686.read(iprot); } xfer += iprot->readMapEnd(); } @@ -16863,11 +16989,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 _iter685; - for (_iter685 = this->metadata.begin(); _iter685 != this->metadata.end(); ++_iter685) + std::map ::const_iterator _iter687; + for (_iter687 = this->metadata.begin(); _iter687 != this->metadata.end(); ++_iter687) { - xfer += oprot->writeI64(_iter685->first); - xfer += _iter685->second.write(oprot); + xfer += oprot->writeI64(_iter687->first); + xfer += _iter687->second.write(oprot); } xfer += oprot->writeMapEnd(); } @@ -16888,13 +17014,13 @@ void swap(GetFileMetadataByExprResult &a, GetFileMetadataByExprResult &b) { swap(a.isSupported, b.isSupported); } -GetFileMetadataByExprResult::GetFileMetadataByExprResult(const GetFileMetadataByExprResult& other686) { - metadata = other686.metadata; - isSupported = other686.isSupported; +GetFileMetadataByExprResult::GetFileMetadataByExprResult(const GetFileMetadataByExprResult& other688) { + metadata = other688.metadata; + isSupported = other688.isSupported; } -GetFileMetadataByExprResult& GetFileMetadataByExprResult::operator=(const GetFileMetadataByExprResult& other687) { - metadata = other687.metadata; - isSupported = other687.isSupported; +GetFileMetadataByExprResult& GetFileMetadataByExprResult::operator=(const GetFileMetadataByExprResult& other689) { + metadata = other689.metadata; + isSupported = other689.isSupported; return *this; } void GetFileMetadataByExprResult::printTo(std::ostream& out) const { @@ -16955,14 +17081,14 @@ uint32_t GetFileMetadataByExprRequest::read(::apache::thrift::protocol::TProtoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size688; - ::apache::thrift::protocol::TType _etype691; - xfer += iprot->readListBegin(_etype691, _size688); - this->fileIds.resize(_size688); - uint32_t _i692; - for (_i692 = 0; _i692 < _size688; ++_i692) + uint32_t _size690; + ::apache::thrift::protocol::TType _etype693; + xfer += iprot->readListBegin(_etype693, _size690); + this->fileIds.resize(_size690); + uint32_t _i694; + for (_i694 = 0; _i694 < _size690; ++_i694) { - xfer += iprot->readI64(this->fileIds[_i692]); + xfer += iprot->readI64(this->fileIds[_i694]); } xfer += iprot->readListEnd(); } @@ -16989,9 +17115,9 @@ uint32_t GetFileMetadataByExprRequest::read(::apache::thrift::protocol::TProtoco break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast693; - xfer += iprot->readI32(ecast693); - this->type = (FileMetadataExprType::type)ecast693; + int32_t ecast695; + xfer += iprot->readI32(ecast695); + this->type = (FileMetadataExprType::type)ecast695; this->__isset.type = true; } else { xfer += iprot->skip(ftype); @@ -17021,10 +17147,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 _iter694; - for (_iter694 = this->fileIds.begin(); _iter694 != this->fileIds.end(); ++_iter694) + std::vector ::const_iterator _iter696; + for (_iter696 = this->fileIds.begin(); _iter696 != this->fileIds.end(); ++_iter696) { - xfer += oprot->writeI64((*_iter694)); + xfer += oprot->writeI64((*_iter696)); } xfer += oprot->writeListEnd(); } @@ -17058,19 +17184,19 @@ void swap(GetFileMetadataByExprRequest &a, GetFileMetadataByExprRequest &b) { swap(a.__isset, b.__isset); } -GetFileMetadataByExprRequest::GetFileMetadataByExprRequest(const GetFileMetadataByExprRequest& other695) { - fileIds = other695.fileIds; - expr = other695.expr; - doGetFooters = other695.doGetFooters; - type = other695.type; - __isset = other695.__isset; +GetFileMetadataByExprRequest::GetFileMetadataByExprRequest(const GetFileMetadataByExprRequest& other697) { + fileIds = other697.fileIds; + expr = other697.expr; + doGetFooters = other697.doGetFooters; + type = other697.type; + __isset = other697.__isset; } -GetFileMetadataByExprRequest& GetFileMetadataByExprRequest::operator=(const GetFileMetadataByExprRequest& other696) { - fileIds = other696.fileIds; - expr = other696.expr; - doGetFooters = other696.doGetFooters; - type = other696.type; - __isset = other696.__isset; +GetFileMetadataByExprRequest& GetFileMetadataByExprRequest::operator=(const GetFileMetadataByExprRequest& other698) { + fileIds = other698.fileIds; + expr = other698.expr; + doGetFooters = other698.doGetFooters; + type = other698.type; + __isset = other698.__isset; return *this; } void GetFileMetadataByExprRequest::printTo(std::ostream& out) const { @@ -17123,17 +17249,17 @@ uint32_t GetFileMetadataResult::read(::apache::thrift::protocol::TProtocol* ipro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->metadata.clear(); - uint32_t _size697; - ::apache::thrift::protocol::TType _ktype698; - ::apache::thrift::protocol::TType _vtype699; - xfer += iprot->readMapBegin(_ktype698, _vtype699, _size697); - uint32_t _i701; - for (_i701 = 0; _i701 < _size697; ++_i701) + uint32_t _size699; + ::apache::thrift::protocol::TType _ktype700; + ::apache::thrift::protocol::TType _vtype701; + xfer += iprot->readMapBegin(_ktype700, _vtype701, _size699); + uint32_t _i703; + for (_i703 = 0; _i703 < _size699; ++_i703) { - int64_t _key702; - xfer += iprot->readI64(_key702); - std::string& _val703 = this->metadata[_key702]; - xfer += iprot->readBinary(_val703); + int64_t _key704; + xfer += iprot->readI64(_key704); + std::string& _val705 = this->metadata[_key704]; + xfer += iprot->readBinary(_val705); } xfer += iprot->readMapEnd(); } @@ -17174,11 +17300,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 _iter704; - for (_iter704 = this->metadata.begin(); _iter704 != this->metadata.end(); ++_iter704) + std::map ::const_iterator _iter706; + for (_iter706 = this->metadata.begin(); _iter706 != this->metadata.end(); ++_iter706) { - xfer += oprot->writeI64(_iter704->first); - xfer += oprot->writeBinary(_iter704->second); + xfer += oprot->writeI64(_iter706->first); + xfer += oprot->writeBinary(_iter706->second); } xfer += oprot->writeMapEnd(); } @@ -17199,13 +17325,13 @@ void swap(GetFileMetadataResult &a, GetFileMetadataResult &b) { swap(a.isSupported, b.isSupported); } -GetFileMetadataResult::GetFileMetadataResult(const GetFileMetadataResult& other705) { - metadata = other705.metadata; - isSupported = other705.isSupported; +GetFileMetadataResult::GetFileMetadataResult(const GetFileMetadataResult& other707) { + metadata = other707.metadata; + isSupported = other707.isSupported; } -GetFileMetadataResult& GetFileMetadataResult::operator=(const GetFileMetadataResult& other706) { - metadata = other706.metadata; - isSupported = other706.isSupported; +GetFileMetadataResult& GetFileMetadataResult::operator=(const GetFileMetadataResult& other708) { + metadata = other708.metadata; + isSupported = other708.isSupported; return *this; } void GetFileMetadataResult::printTo(std::ostream& out) const { @@ -17251,14 +17377,14 @@ uint32_t GetFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size707; - ::apache::thrift::protocol::TType _etype710; - xfer += iprot->readListBegin(_etype710, _size707); - this->fileIds.resize(_size707); - uint32_t _i711; - for (_i711 = 0; _i711 < _size707; ++_i711) + uint32_t _size709; + ::apache::thrift::protocol::TType _etype712; + xfer += iprot->readListBegin(_etype712, _size709); + this->fileIds.resize(_size709); + uint32_t _i713; + for (_i713 = 0; _i713 < _size709; ++_i713) { - xfer += iprot->readI64(this->fileIds[_i711]); + xfer += iprot->readI64(this->fileIds[_i713]); } xfer += iprot->readListEnd(); } @@ -17289,10 +17415,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 _iter712; - for (_iter712 = this->fileIds.begin(); _iter712 != this->fileIds.end(); ++_iter712) + std::vector ::const_iterator _iter714; + for (_iter714 = this->fileIds.begin(); _iter714 != this->fileIds.end(); ++_iter714) { - xfer += oprot->writeI64((*_iter712)); + xfer += oprot->writeI64((*_iter714)); } xfer += oprot->writeListEnd(); } @@ -17308,11 +17434,11 @@ void swap(GetFileMetadataRequest &a, GetFileMetadataRequest &b) { swap(a.fileIds, b.fileIds); } -GetFileMetadataRequest::GetFileMetadataRequest(const GetFileMetadataRequest& other713) { - fileIds = other713.fileIds; +GetFileMetadataRequest::GetFileMetadataRequest(const GetFileMetadataRequest& other715) { + fileIds = other715.fileIds; } -GetFileMetadataRequest& GetFileMetadataRequest::operator=(const GetFileMetadataRequest& other714) { - fileIds = other714.fileIds; +GetFileMetadataRequest& GetFileMetadataRequest::operator=(const GetFileMetadataRequest& other716) { + fileIds = other716.fileIds; return *this; } void GetFileMetadataRequest::printTo(std::ostream& out) const { @@ -17371,11 +17497,11 @@ void swap(PutFileMetadataResult &a, PutFileMetadataResult &b) { (void) b; } -PutFileMetadataResult::PutFileMetadataResult(const PutFileMetadataResult& other715) { - (void) other715; +PutFileMetadataResult::PutFileMetadataResult(const PutFileMetadataResult& other717) { + (void) other717; } -PutFileMetadataResult& PutFileMetadataResult::operator=(const PutFileMetadataResult& other716) { - (void) other716; +PutFileMetadataResult& PutFileMetadataResult::operator=(const PutFileMetadataResult& other718) { + (void) other718; return *this; } void PutFileMetadataResult::printTo(std::ostream& out) const { @@ -17429,14 +17555,14 @@ uint32_t PutFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size717; - ::apache::thrift::protocol::TType _etype720; - xfer += iprot->readListBegin(_etype720, _size717); - this->fileIds.resize(_size717); - uint32_t _i721; - for (_i721 = 0; _i721 < _size717; ++_i721) + uint32_t _size719; + ::apache::thrift::protocol::TType _etype722; + xfer += iprot->readListBegin(_etype722, _size719); + this->fileIds.resize(_size719); + uint32_t _i723; + for (_i723 = 0; _i723 < _size719; ++_i723) { - xfer += iprot->readI64(this->fileIds[_i721]); + xfer += iprot->readI64(this->fileIds[_i723]); } xfer += iprot->readListEnd(); } @@ -17449,14 +17575,14 @@ uint32_t PutFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->metadata.clear(); - uint32_t _size722; - ::apache::thrift::protocol::TType _etype725; - xfer += iprot->readListBegin(_etype725, _size722); - this->metadata.resize(_size722); - uint32_t _i726; - for (_i726 = 0; _i726 < _size722; ++_i726) + uint32_t _size724; + ::apache::thrift::protocol::TType _etype727; + xfer += iprot->readListBegin(_etype727, _size724); + this->metadata.resize(_size724); + uint32_t _i728; + for (_i728 = 0; _i728 < _size724; ++_i728) { - xfer += iprot->readBinary(this->metadata[_i726]); + xfer += iprot->readBinary(this->metadata[_i728]); } xfer += iprot->readListEnd(); } @@ -17467,9 +17593,9 @@ uint32_t PutFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast727; - xfer += iprot->readI32(ecast727); - this->type = (FileMetadataExprType::type)ecast727; + int32_t ecast729; + xfer += iprot->readI32(ecast729); + this->type = (FileMetadataExprType::type)ecast729; this->__isset.type = true; } else { xfer += iprot->skip(ftype); @@ -17499,10 +17625,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 _iter728; - for (_iter728 = this->fileIds.begin(); _iter728 != this->fileIds.end(); ++_iter728) + std::vector ::const_iterator _iter730; + for (_iter730 = this->fileIds.begin(); _iter730 != this->fileIds.end(); ++_iter730) { - xfer += oprot->writeI64((*_iter728)); + xfer += oprot->writeI64((*_iter730)); } xfer += oprot->writeListEnd(); } @@ -17511,10 +17637,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 _iter729; - for (_iter729 = this->metadata.begin(); _iter729 != this->metadata.end(); ++_iter729) + std::vector ::const_iterator _iter731; + for (_iter731 = this->metadata.begin(); _iter731 != this->metadata.end(); ++_iter731) { - xfer += oprot->writeBinary((*_iter729)); + xfer += oprot->writeBinary((*_iter731)); } xfer += oprot->writeListEnd(); } @@ -17538,17 +17664,17 @@ void swap(PutFileMetadataRequest &a, PutFileMetadataRequest &b) { swap(a.__isset, b.__isset); } -PutFileMetadataRequest::PutFileMetadataRequest(const PutFileMetadataRequest& other730) { - fileIds = other730.fileIds; - metadata = other730.metadata; - type = other730.type; - __isset = other730.__isset; +PutFileMetadataRequest::PutFileMetadataRequest(const PutFileMetadataRequest& other732) { + fileIds = other732.fileIds; + metadata = other732.metadata; + type = other732.type; + __isset = other732.__isset; } -PutFileMetadataRequest& PutFileMetadataRequest::operator=(const PutFileMetadataRequest& other731) { - fileIds = other731.fileIds; - metadata = other731.metadata; - type = other731.type; - __isset = other731.__isset; +PutFileMetadataRequest& PutFileMetadataRequest::operator=(const PutFileMetadataRequest& other733) { + fileIds = other733.fileIds; + metadata = other733.metadata; + type = other733.type; + __isset = other733.__isset; return *this; } void PutFileMetadataRequest::printTo(std::ostream& out) const { @@ -17609,11 +17735,11 @@ void swap(ClearFileMetadataResult &a, ClearFileMetadataResult &b) { (void) b; } -ClearFileMetadataResult::ClearFileMetadataResult(const ClearFileMetadataResult& other732) { - (void) other732; +ClearFileMetadataResult::ClearFileMetadataResult(const ClearFileMetadataResult& other734) { + (void) other734; } -ClearFileMetadataResult& ClearFileMetadataResult::operator=(const ClearFileMetadataResult& other733) { - (void) other733; +ClearFileMetadataResult& ClearFileMetadataResult::operator=(const ClearFileMetadataResult& other735) { + (void) other735; return *this; } void ClearFileMetadataResult::printTo(std::ostream& out) const { @@ -17657,14 +17783,14 @@ uint32_t ClearFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* i if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size734; - ::apache::thrift::protocol::TType _etype737; - xfer += iprot->readListBegin(_etype737, _size734); - this->fileIds.resize(_size734); - uint32_t _i738; - for (_i738 = 0; _i738 < _size734; ++_i738) + uint32_t _size736; + ::apache::thrift::protocol::TType _etype739; + xfer += iprot->readListBegin(_etype739, _size736); + this->fileIds.resize(_size736); + uint32_t _i740; + for (_i740 = 0; _i740 < _size736; ++_i740) { - xfer += iprot->readI64(this->fileIds[_i738]); + xfer += iprot->readI64(this->fileIds[_i740]); } xfer += iprot->readListEnd(); } @@ -17695,10 +17821,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 _iter739; - for (_iter739 = this->fileIds.begin(); _iter739 != this->fileIds.end(); ++_iter739) + std::vector ::const_iterator _iter741; + for (_iter741 = this->fileIds.begin(); _iter741 != this->fileIds.end(); ++_iter741) { - xfer += oprot->writeI64((*_iter739)); + xfer += oprot->writeI64((*_iter741)); } xfer += oprot->writeListEnd(); } @@ -17714,11 +17840,11 @@ void swap(ClearFileMetadataRequest &a, ClearFileMetadataRequest &b) { swap(a.fileIds, b.fileIds); } -ClearFileMetadataRequest::ClearFileMetadataRequest(const ClearFileMetadataRequest& other740) { - fileIds = other740.fileIds; +ClearFileMetadataRequest::ClearFileMetadataRequest(const ClearFileMetadataRequest& other742) { + fileIds = other742.fileIds; } -ClearFileMetadataRequest& ClearFileMetadataRequest::operator=(const ClearFileMetadataRequest& other741) { - fileIds = other741.fileIds; +ClearFileMetadataRequest& ClearFileMetadataRequest::operator=(const ClearFileMetadataRequest& other743) { + fileIds = other743.fileIds; return *this; } void ClearFileMetadataRequest::printTo(std::ostream& out) const { @@ -17800,11 +17926,11 @@ void swap(CacheFileMetadataResult &a, CacheFileMetadataResult &b) { swap(a.isSupported, b.isSupported); } -CacheFileMetadataResult::CacheFileMetadataResult(const CacheFileMetadataResult& other742) { - isSupported = other742.isSupported; +CacheFileMetadataResult::CacheFileMetadataResult(const CacheFileMetadataResult& other744) { + isSupported = other744.isSupported; } -CacheFileMetadataResult& CacheFileMetadataResult::operator=(const CacheFileMetadataResult& other743) { - isSupported = other743.isSupported; +CacheFileMetadataResult& CacheFileMetadataResult::operator=(const CacheFileMetadataResult& other745) { + isSupported = other745.isSupported; return *this; } void CacheFileMetadataResult::printTo(std::ostream& out) const { @@ -17945,19 +18071,19 @@ void swap(CacheFileMetadataRequest &a, CacheFileMetadataRequest &b) { swap(a.__isset, b.__isset); } -CacheFileMetadataRequest::CacheFileMetadataRequest(const CacheFileMetadataRequest& other744) { - dbName = other744.dbName; - tblName = other744.tblName; - partName = other744.partName; - isAllParts = other744.isAllParts; - __isset = other744.__isset; +CacheFileMetadataRequest::CacheFileMetadataRequest(const CacheFileMetadataRequest& other746) { + dbName = other746.dbName; + tblName = other746.tblName; + partName = other746.partName; + isAllParts = other746.isAllParts; + __isset = other746.__isset; } -CacheFileMetadataRequest& CacheFileMetadataRequest::operator=(const CacheFileMetadataRequest& other745) { - dbName = other745.dbName; - tblName = other745.tblName; - partName = other745.partName; - isAllParts = other745.isAllParts; - __isset = other745.__isset; +CacheFileMetadataRequest& CacheFileMetadataRequest::operator=(const CacheFileMetadataRequest& other747) { + dbName = other747.dbName; + tblName = other747.tblName; + partName = other747.partName; + isAllParts = other747.isAllParts; + __isset = other747.__isset; return *this; } void CacheFileMetadataRequest::printTo(std::ostream& out) const { @@ -18005,14 +18131,14 @@ uint32_t GetAllFunctionsResponse::read(::apache::thrift::protocol::TProtocol* ip if (ftype == ::apache::thrift::protocol::T_LIST) { { this->functions.clear(); - uint32_t _size746; - ::apache::thrift::protocol::TType _etype749; - xfer += iprot->readListBegin(_etype749, _size746); - this->functions.resize(_size746); - uint32_t _i750; - for (_i750 = 0; _i750 < _size746; ++_i750) + uint32_t _size748; + ::apache::thrift::protocol::TType _etype751; + xfer += iprot->readListBegin(_etype751, _size748); + this->functions.resize(_size748); + uint32_t _i752; + for (_i752 = 0; _i752 < _size748; ++_i752) { - xfer += this->functions[_i750].read(iprot); + xfer += this->functions[_i752].read(iprot); } xfer += iprot->readListEnd(); } @@ -18042,10 +18168,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 _iter751; - for (_iter751 = this->functions.begin(); _iter751 != this->functions.end(); ++_iter751) + std::vector ::const_iterator _iter753; + for (_iter753 = this->functions.begin(); _iter753 != this->functions.end(); ++_iter753) { - xfer += (*_iter751).write(oprot); + xfer += (*_iter753).write(oprot); } xfer += oprot->writeListEnd(); } @@ -18062,13 +18188,13 @@ void swap(GetAllFunctionsResponse &a, GetAllFunctionsResponse &b) { swap(a.__isset, b.__isset); } -GetAllFunctionsResponse::GetAllFunctionsResponse(const GetAllFunctionsResponse& other752) { - functions = other752.functions; - __isset = other752.__isset; +GetAllFunctionsResponse::GetAllFunctionsResponse(const GetAllFunctionsResponse& other754) { + functions = other754.functions; + __isset = other754.__isset; } -GetAllFunctionsResponse& GetAllFunctionsResponse::operator=(const GetAllFunctionsResponse& other753) { - functions = other753.functions; - __isset = other753.__isset; +GetAllFunctionsResponse& GetAllFunctionsResponse::operator=(const GetAllFunctionsResponse& other755) { + functions = other755.functions; + __isset = other755.__isset; return *this; } void GetAllFunctionsResponse::printTo(std::ostream& out) const { @@ -18113,16 +18239,16 @@ uint32_t ClientCapabilities::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->values.clear(); - uint32_t _size754; - ::apache::thrift::protocol::TType _etype757; - xfer += iprot->readListBegin(_etype757, _size754); - this->values.resize(_size754); - uint32_t _i758; - for (_i758 = 0; _i758 < _size754; ++_i758) + uint32_t _size756; + ::apache::thrift::protocol::TType _etype759; + xfer += iprot->readListBegin(_etype759, _size756); + this->values.resize(_size756); + uint32_t _i760; + for (_i760 = 0; _i760 < _size756; ++_i760) { - int32_t ecast759; - xfer += iprot->readI32(ecast759); - this->values[_i758] = (ClientCapability::type)ecast759; + int32_t ecast761; + xfer += iprot->readI32(ecast761); + this->values[_i760] = (ClientCapability::type)ecast761; } xfer += iprot->readListEnd(); } @@ -18153,10 +18279,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 _iter760; - for (_iter760 = this->values.begin(); _iter760 != this->values.end(); ++_iter760) + std::vector ::const_iterator _iter762; + for (_iter762 = this->values.begin(); _iter762 != this->values.end(); ++_iter762) { - xfer += oprot->writeI32((int32_t)(*_iter760)); + xfer += oprot->writeI32((int32_t)(*_iter762)); } xfer += oprot->writeListEnd(); } @@ -18172,11 +18298,11 @@ void swap(ClientCapabilities &a, ClientCapabilities &b) { swap(a.values, b.values); } -ClientCapabilities::ClientCapabilities(const ClientCapabilities& other761) { - values = other761.values; +ClientCapabilities::ClientCapabilities(const ClientCapabilities& other763) { + values = other763.values; } -ClientCapabilities& ClientCapabilities::operator=(const ClientCapabilities& other762) { - values = other762.values; +ClientCapabilities& ClientCapabilities::operator=(const ClientCapabilities& other764) { + values = other764.values; return *this; } void ClientCapabilities::printTo(std::ostream& out) const { @@ -18298,17 +18424,17 @@ void swap(GetTableRequest &a, GetTableRequest &b) { swap(a.__isset, b.__isset); } -GetTableRequest::GetTableRequest(const GetTableRequest& other763) { - dbName = other763.dbName; - tblName = other763.tblName; - capabilities = other763.capabilities; - __isset = other763.__isset; +GetTableRequest::GetTableRequest(const GetTableRequest& other765) { + dbName = other765.dbName; + tblName = other765.tblName; + capabilities = other765.capabilities; + __isset = other765.__isset; } -GetTableRequest& GetTableRequest::operator=(const GetTableRequest& other764) { - dbName = other764.dbName; - tblName = other764.tblName; - capabilities = other764.capabilities; - __isset = other764.__isset; +GetTableRequest& GetTableRequest::operator=(const GetTableRequest& other766) { + dbName = other766.dbName; + tblName = other766.tblName; + capabilities = other766.capabilities; + __isset = other766.__isset; return *this; } void GetTableRequest::printTo(std::ostream& out) const { @@ -18392,11 +18518,11 @@ void swap(GetTableResult &a, GetTableResult &b) { swap(a.table, b.table); } -GetTableResult::GetTableResult(const GetTableResult& other765) { - table = other765.table; +GetTableResult::GetTableResult(const GetTableResult& other767) { + table = other767.table; } -GetTableResult& GetTableResult::operator=(const GetTableResult& other766) { - table = other766.table; +GetTableResult& GetTableResult::operator=(const GetTableResult& other768) { + table = other768.table; return *this; } void GetTableResult::printTo(std::ostream& out) const { @@ -18459,14 +18585,14 @@ uint32_t GetTablesRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tblNames.clear(); - uint32_t _size767; - ::apache::thrift::protocol::TType _etype770; - xfer += iprot->readListBegin(_etype770, _size767); - this->tblNames.resize(_size767); - uint32_t _i771; - for (_i771 = 0; _i771 < _size767; ++_i771) + uint32_t _size769; + ::apache::thrift::protocol::TType _etype772; + xfer += iprot->readListBegin(_etype772, _size769); + this->tblNames.resize(_size769); + uint32_t _i773; + for (_i773 = 0; _i773 < _size769; ++_i773) { - xfer += iprot->readString(this->tblNames[_i771]); + xfer += iprot->readString(this->tblNames[_i773]); } xfer += iprot->readListEnd(); } @@ -18510,10 +18636,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 _iter772; - for (_iter772 = this->tblNames.begin(); _iter772 != this->tblNames.end(); ++_iter772) + std::vector ::const_iterator _iter774; + for (_iter774 = this->tblNames.begin(); _iter774 != this->tblNames.end(); ++_iter774) { - xfer += oprot->writeString((*_iter772)); + xfer += oprot->writeString((*_iter774)); } xfer += oprot->writeListEnd(); } @@ -18537,17 +18663,17 @@ void swap(GetTablesRequest &a, GetTablesRequest &b) { swap(a.__isset, b.__isset); } -GetTablesRequest::GetTablesRequest(const GetTablesRequest& other773) { - dbName = other773.dbName; - tblNames = other773.tblNames; - capabilities = other773.capabilities; - __isset = other773.__isset; +GetTablesRequest::GetTablesRequest(const GetTablesRequest& other775) { + dbName = other775.dbName; + tblNames = other775.tblNames; + capabilities = other775.capabilities; + __isset = other775.__isset; } -GetTablesRequest& GetTablesRequest::operator=(const GetTablesRequest& other774) { - dbName = other774.dbName; - tblNames = other774.tblNames; - capabilities = other774.capabilities; - __isset = other774.__isset; +GetTablesRequest& GetTablesRequest::operator=(const GetTablesRequest& other776) { + dbName = other776.dbName; + tblNames = other776.tblNames; + capabilities = other776.capabilities; + __isset = other776.__isset; return *this; } void GetTablesRequest::printTo(std::ostream& out) const { @@ -18594,14 +18720,14 @@ uint32_t GetTablesResult::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tables.clear(); - uint32_t _size775; - ::apache::thrift::protocol::TType _etype778; - xfer += iprot->readListBegin(_etype778, _size775); - this->tables.resize(_size775); - uint32_t _i779; - for (_i779 = 0; _i779 < _size775; ++_i779) + uint32_t _size777; + ::apache::thrift::protocol::TType _etype780; + xfer += iprot->readListBegin(_etype780, _size777); + this->tables.resize(_size777); + uint32_t _i781; + for (_i781 = 0; _i781 < _size777; ++_i781) { - xfer += this->tables[_i779].read(iprot); + xfer += this->tables[_i781].read(iprot); } xfer += iprot->readListEnd(); } @@ -18632,10 +18758,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 _iter780; - for (_iter780 = this->tables.begin(); _iter780 != this->tables.end(); ++_iter780) + std::vector
::const_iterator _iter782; + for (_iter782 = this->tables.begin(); _iter782 != this->tables.end(); ++_iter782) { - xfer += (*_iter780).write(oprot); + xfer += (*_iter782).write(oprot); } xfer += oprot->writeListEnd(); } @@ -18651,11 +18777,11 @@ void swap(GetTablesResult &a, GetTablesResult &b) { swap(a.tables, b.tables); } -GetTablesResult::GetTablesResult(const GetTablesResult& other781) { - tables = other781.tables; +GetTablesResult::GetTablesResult(const GetTablesResult& other783) { + tables = other783.tables; } -GetTablesResult& GetTablesResult::operator=(const GetTablesResult& other782) { - tables = other782.tables; +GetTablesResult& GetTablesResult::operator=(const GetTablesResult& other784) { + tables = other784.tables; return *this; } void GetTablesResult::printTo(std::ostream& out) const { @@ -18797,19 +18923,19 @@ void swap(TableMeta &a, TableMeta &b) { swap(a.__isset, b.__isset); } -TableMeta::TableMeta(const TableMeta& other783) { - dbName = other783.dbName; - tableName = other783.tableName; - tableType = other783.tableType; - comments = other783.comments; - __isset = other783.__isset; +TableMeta::TableMeta(const TableMeta& other785) { + dbName = other785.dbName; + tableName = other785.tableName; + tableType = other785.tableType; + comments = other785.comments; + __isset = other785.__isset; } -TableMeta& TableMeta::operator=(const TableMeta& other784) { - dbName = other784.dbName; - tableName = other784.tableName; - tableType = other784.tableType; - comments = other784.comments; - __isset = other784.__isset; +TableMeta& TableMeta::operator=(const TableMeta& other786) { + dbName = other786.dbName; + tableName = other786.tableName; + tableType = other786.tableType; + comments = other786.comments; + __isset = other786.__isset; return *this; } void TableMeta::printTo(std::ostream& out) const { @@ -18892,13 +19018,13 @@ void swap(MetaException &a, MetaException &b) { swap(a.__isset, b.__isset); } -MetaException::MetaException(const MetaException& other785) : TException() { - message = other785.message; - __isset = other785.__isset; +MetaException::MetaException(const MetaException& other787) : TException() { + message = other787.message; + __isset = other787.__isset; } -MetaException& MetaException::operator=(const MetaException& other786) { - message = other786.message; - __isset = other786.__isset; +MetaException& MetaException::operator=(const MetaException& other788) { + message = other788.message; + __isset = other788.__isset; return *this; } void MetaException::printTo(std::ostream& out) const { @@ -18989,13 +19115,13 @@ void swap(UnknownTableException &a, UnknownTableException &b) { swap(a.__isset, b.__isset); } -UnknownTableException::UnknownTableException(const UnknownTableException& other787) : TException() { - message = other787.message; - __isset = other787.__isset; +UnknownTableException::UnknownTableException(const UnknownTableException& other789) : TException() { + message = other789.message; + __isset = other789.__isset; } -UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other788) { - message = other788.message; - __isset = other788.__isset; +UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other790) { + message = other790.message; + __isset = other790.__isset; return *this; } void UnknownTableException::printTo(std::ostream& out) const { @@ -19086,13 +19212,13 @@ void swap(UnknownDBException &a, UnknownDBException &b) { swap(a.__isset, b.__isset); } -UnknownDBException::UnknownDBException(const UnknownDBException& other789) : TException() { - message = other789.message; - __isset = other789.__isset; +UnknownDBException::UnknownDBException(const UnknownDBException& other791) : TException() { + message = other791.message; + __isset = other791.__isset; } -UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other790) { - message = other790.message; - __isset = other790.__isset; +UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other792) { + message = other792.message; + __isset = other792.__isset; return *this; } void UnknownDBException::printTo(std::ostream& out) const { @@ -19183,13 +19309,13 @@ void swap(AlreadyExistsException &a, AlreadyExistsException &b) { swap(a.__isset, b.__isset); } -AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other791) : TException() { - message = other791.message; - __isset = other791.__isset; +AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other793) : TException() { + message = other793.message; + __isset = other793.__isset; } -AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other792) { - message = other792.message; - __isset = other792.__isset; +AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other794) { + message = other794.message; + __isset = other794.__isset; return *this; } void AlreadyExistsException::printTo(std::ostream& out) const { @@ -19280,13 +19406,13 @@ void swap(InvalidPartitionException &a, InvalidPartitionException &b) { swap(a.__isset, b.__isset); } -InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other793) : TException() { - message = other793.message; - __isset = other793.__isset; +InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other795) : TException() { + message = other795.message; + __isset = other795.__isset; } -InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other794) { - message = other794.message; - __isset = other794.__isset; +InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other796) { + message = other796.message; + __isset = other796.__isset; return *this; } void InvalidPartitionException::printTo(std::ostream& out) const { @@ -19377,13 +19503,13 @@ void swap(UnknownPartitionException &a, UnknownPartitionException &b) { swap(a.__isset, b.__isset); } -UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other795) : TException() { - message = other795.message; - __isset = other795.__isset; +UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other797) : TException() { + message = other797.message; + __isset = other797.__isset; } -UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other796) { - message = other796.message; - __isset = other796.__isset; +UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other798) { + message = other798.message; + __isset = other798.__isset; return *this; } void UnknownPartitionException::printTo(std::ostream& out) const { @@ -19474,13 +19600,13 @@ void swap(InvalidObjectException &a, InvalidObjectException &b) { swap(a.__isset, b.__isset); } -InvalidObjectException::InvalidObjectException(const InvalidObjectException& other797) : TException() { - message = other797.message; - __isset = other797.__isset; +InvalidObjectException::InvalidObjectException(const InvalidObjectException& other799) : TException() { + message = other799.message; + __isset = other799.__isset; } -InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other798) { - message = other798.message; - __isset = other798.__isset; +InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other800) { + message = other800.message; + __isset = other800.__isset; return *this; } void InvalidObjectException::printTo(std::ostream& out) const { @@ -19571,13 +19697,13 @@ void swap(NoSuchObjectException &a, NoSuchObjectException &b) { swap(a.__isset, b.__isset); } -NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other799) : TException() { - message = other799.message; - __isset = other799.__isset; +NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other801) : TException() { + message = other801.message; + __isset = other801.__isset; } -NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other800) { - message = other800.message; - __isset = other800.__isset; +NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other802) { + message = other802.message; + __isset = other802.__isset; return *this; } void NoSuchObjectException::printTo(std::ostream& out) const { @@ -19668,13 +19794,13 @@ void swap(IndexAlreadyExistsException &a, IndexAlreadyExistsException &b) { swap(a.__isset, b.__isset); } -IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other801) : TException() { - message = other801.message; - __isset = other801.__isset; +IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other803) : TException() { + message = other803.message; + __isset = other803.__isset; } -IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other802) { - message = other802.message; - __isset = other802.__isset; +IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other804) { + message = other804.message; + __isset = other804.__isset; return *this; } void IndexAlreadyExistsException::printTo(std::ostream& out) const { @@ -19765,13 +19891,13 @@ void swap(InvalidOperationException &a, InvalidOperationException &b) { swap(a.__isset, b.__isset); } -InvalidOperationException::InvalidOperationException(const InvalidOperationException& other803) : TException() { - message = other803.message; - __isset = other803.__isset; +InvalidOperationException::InvalidOperationException(const InvalidOperationException& other805) : TException() { + message = other805.message; + __isset = other805.__isset; } -InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other804) { - message = other804.message; - __isset = other804.__isset; +InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other806) { + message = other806.message; + __isset = other806.__isset; return *this; } void InvalidOperationException::printTo(std::ostream& out) const { @@ -19862,13 +19988,13 @@ void swap(ConfigValSecurityException &a, ConfigValSecurityException &b) { swap(a.__isset, b.__isset); } -ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other805) : TException() { - message = other805.message; - __isset = other805.__isset; +ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other807) : TException() { + message = other807.message; + __isset = other807.__isset; } -ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other806) { - message = other806.message; - __isset = other806.__isset; +ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other808) { + message = other808.message; + __isset = other808.__isset; return *this; } void ConfigValSecurityException::printTo(std::ostream& out) const { @@ -19959,13 +20085,13 @@ void swap(InvalidInputException &a, InvalidInputException &b) { swap(a.__isset, b.__isset); } -InvalidInputException::InvalidInputException(const InvalidInputException& other807) : TException() { - message = other807.message; - __isset = other807.__isset; +InvalidInputException::InvalidInputException(const InvalidInputException& other809) : TException() { + message = other809.message; + __isset = other809.__isset; } -InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other808) { - message = other808.message; - __isset = other808.__isset; +InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other810) { + message = other810.message; + __isset = other810.__isset; return *this; } void InvalidInputException::printTo(std::ostream& out) const { @@ -20056,13 +20182,13 @@ void swap(NoSuchTxnException &a, NoSuchTxnException &b) { swap(a.__isset, b.__isset); } -NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other809) : TException() { - message = other809.message; - __isset = other809.__isset; +NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other811) : TException() { + message = other811.message; + __isset = other811.__isset; } -NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other810) { - message = other810.message; - __isset = other810.__isset; +NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other812) { + message = other812.message; + __isset = other812.__isset; return *this; } void NoSuchTxnException::printTo(std::ostream& out) const { @@ -20153,13 +20279,13 @@ void swap(TxnAbortedException &a, TxnAbortedException &b) { swap(a.__isset, b.__isset); } -TxnAbortedException::TxnAbortedException(const TxnAbortedException& other811) : TException() { - message = other811.message; - __isset = other811.__isset; +TxnAbortedException::TxnAbortedException(const TxnAbortedException& other813) : TException() { + message = other813.message; + __isset = other813.__isset; } -TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other812) { - message = other812.message; - __isset = other812.__isset; +TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other814) { + message = other814.message; + __isset = other814.__isset; return *this; } void TxnAbortedException::printTo(std::ostream& out) const { @@ -20250,13 +20376,13 @@ void swap(TxnOpenException &a, TxnOpenException &b) { swap(a.__isset, b.__isset); } -TxnOpenException::TxnOpenException(const TxnOpenException& other813) : TException() { - message = other813.message; - __isset = other813.__isset; +TxnOpenException::TxnOpenException(const TxnOpenException& other815) : TException() { + message = other815.message; + __isset = other815.__isset; } -TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other814) { - message = other814.message; - __isset = other814.__isset; +TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other816) { + message = other816.message; + __isset = other816.__isset; return *this; } void TxnOpenException::printTo(std::ostream& out) const { @@ -20347,13 +20473,13 @@ void swap(NoSuchLockException &a, NoSuchLockException &b) { swap(a.__isset, b.__isset); } -NoSuchLockException::NoSuchLockException(const NoSuchLockException& other815) : TException() { - message = other815.message; - __isset = other815.__isset; +NoSuchLockException::NoSuchLockException(const NoSuchLockException& other817) : TException() { + message = other817.message; + __isset = other817.__isset; } -NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other816) { - message = other816.message; - __isset = other816.__isset; +NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other818) { + message = other818.message; + __isset = other818.__isset; return *this; } void NoSuchLockException::printTo(std::ostream& out) const { diff --git metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h index c21ded144484f83cf59b989eada5506ed8e9ba3b..c5c0646b42e289dd74edc8ddcec4f406acd91f71 100644 --- metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h +++ 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 metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/MetastoreDBProperty.java metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/MetastoreDBProperty.java new file mode 100644 index 0000000000000000000000000000000000000000..566cbc6fdf1e1af5583614712b3ddf1c06c03b91 --- /dev/null +++ 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 metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java index 19151507cae1921a38028582ce00e34cd00585eb..19c88cb91fa8cac581b1fc67830026096db2b673 100644 --- metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java +++ metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java @@ -350,6 +350,8 @@ public CacheFileMetadataResult cache_file_metadata(CacheFileMetadataRequest req) throws org.apache.thrift.TException; + public String get_metastore_db_uuid() throws MetaException, org.apache.thrift.TException; + } public interface AsyncIface extends com.facebook.fb303.FacebookService .AsyncIface { @@ -662,6 +664,8 @@ public void cache_file_metadata(CacheFileMetadataRequest req, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void get_metastore_db_uuid(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + } public static class Client extends com.facebook.fb303.FacebookService.Client implements Iface { @@ -5111,6 +5115,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_db_uuid() throws MetaException, org.apache.thrift.TException + { + send_get_metastore_db_uuid(); + return recv_get_metastore_db_uuid(); + } + + public void send_get_metastore_db_uuid() throws org.apache.thrift.TException + { + get_metastore_db_uuid_args args = new get_metastore_db_uuid_args(); + sendBase("get_metastore_db_uuid", args); + } + + public String recv_get_metastore_db_uuid() throws MetaException, org.apache.thrift.TException + { + get_metastore_db_uuid_result result = new get_metastore_db_uuid_result(); + receiveBase(result, "get_metastore_db_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_db_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 { @@ -10552,6 +10581,35 @@ public CacheFileMetadataResult getResult() throws org.apache.thrift.TException { } } + public void get_metastore_db_uuid(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + get_metastore_db_uuid_call method_call = new get_metastore_db_uuid_call(resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class get_metastore_db_uuid_call extends org.apache.thrift.async.TAsyncMethodCall { + public get_metastore_db_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_db_uuid", org.apache.thrift.protocol.TMessageType.CALL, 0)); + get_metastore_db_uuid_args args = new get_metastore_db_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_db_uuid(); + } + } + } public static class Processor extends com.facebook.fb303.FacebookService.Processor implements org.apache.thrift.TProcessor { @@ -10719,6 +10777,7 @@ protected Processor(I iface, Map extends org.apache.thrift.ProcessFunction { + public get_metastore_db_uuid() { + super("get_metastore_db_uuid"); + } + + public get_metastore_db_uuid_args getEmptyArgsInstance() { + return new get_metastore_db_uuid_args(); + } + + protected boolean isOneway() { + return false; + } + + public get_metastore_db_uuid_result getResult(I iface, get_metastore_db_uuid_args args) throws org.apache.thrift.TException { + get_metastore_db_uuid_result result = new get_metastore_db_uuid_result(); + try { + result.success = iface.get_metastore_db_uuid(); + } catch (MetaException o1) { + result.o1 = o1; + } + return result; + } + } + } public static class AsyncProcessor extends com.facebook.fb303.FacebookService.AsyncProcessor { @@ -14809,6 +14892,7 @@ protected AsyncProcessor(I iface, Map extends org.apache.thrift.AsyncProcessFunction { + public get_metastore_db_uuid() { + super("get_metastore_db_uuid"); + } + + public get_metastore_db_uuid_args getEmptyArgsInstance() { + return new get_metastore_db_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_db_uuid_result result = new get_metastore_db_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_db_uuid_result result = new get_metastore_db_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_db_uuid_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.get_metastore_db_uuid(resultHandler); + } + } + } public static class getMetaConf_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { @@ -177693,15 +177834,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) @@ -177713,7 +178580,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 { @@ -177729,7 +178596,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); @@ -177744,16 +178611,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()) { @@ -177766,11 +178633,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); } @@ -177779,18 +178646,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 { @@ -177855,16 +178722,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; @@ -177873,14 +178740,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 @@ -177888,11 +178755,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; } @@ -177917,7 +178784,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetSuccess(); } else { - setSuccess((GetFileMetadataByExprResult)value); + setSuccess((GetFileMetadataResult)value); } break; @@ -177950,12 +178817,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; @@ -177984,7 +178851,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()); } @@ -178018,7 +178885,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:"); @@ -178056,15 +178923,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) @@ -178076,7 +178943,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 { @@ -178092,7 +178959,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); @@ -178107,16 +178974,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()) { @@ -178129,11 +178996,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); } @@ -178142,18 +179009,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 { @@ -178218,16 +179085,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; @@ -178236,14 +179103,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 @@ -178251,11 +179118,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; } @@ -178280,7 +179147,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetReq(); } else { - setReq((GetFileMetadataRequest)value); + setReq((PutFileMetadataRequest)value); } break; @@ -178313,12 +179180,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; @@ -178347,7 +179214,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()); } @@ -178381,7 +179248,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:"); @@ -178419,15 +179286,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) @@ -178439,7 +179306,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 { @@ -178455,7 +179322,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); @@ -178470,16 +179337,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()) { @@ -178492,11 +179359,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); } @@ -178505,18 +179372,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 { @@ -178581,16 +179448,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; @@ -178599,14 +179466,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 @@ -178614,11 +179481,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; } @@ -178643,7 +179510,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetSuccess(); } else { - setSuccess((GetFileMetadataResult)value); + setSuccess((PutFileMetadataResult)value); } break; @@ -178676,12 +179543,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; @@ -178710,7 +179577,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()); } @@ -178744,7 +179611,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:"); @@ -178782,15 +179649,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) @@ -178802,7 +179669,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 { @@ -178818,7 +179685,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); @@ -178833,16 +179700,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()) { @@ -178855,11 +179722,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); } @@ -178868,18 +179735,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 { @@ -178944,16 +179811,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; @@ -178962,14 +179829,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 @@ -178977,11 +179844,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; } @@ -179006,7 +179873,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetReq(); } else { - setReq((PutFileMetadataRequest)value); + setReq((ClearFileMetadataRequest)value); } break; @@ -179039,12 +179906,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; @@ -179073,7 +179940,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()); } @@ -179107,7 +179974,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:"); @@ -179145,15 +180012,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) @@ -179165,7 +180032,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 { @@ -179181,7 +180048,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); @@ -179196,16 +180063,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()) { @@ -179218,11 +180085,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); } @@ -179231,18 +180098,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 { @@ -179307,16 +180174,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; @@ -179325,14 +180192,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 @@ -179340,11 +180207,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; } @@ -179369,7 +180236,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetSuccess(); } else { - setSuccess((PutFileMetadataResult)value); + setSuccess((ClearFileMetadataResult)value); } break; @@ -179402,12 +180269,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; @@ -179436,7 +180303,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()); } @@ -179470,7 +180337,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:"); @@ -179508,15 +180375,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) @@ -179528,7 +180395,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 { @@ -179544,7 +180411,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); @@ -179559,16 +180426,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()) { @@ -179581,11 +180448,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); } @@ -179594,18 +180461,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 { @@ -179670,16 +180537,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; @@ -179688,14 +180555,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 @@ -179703,11 +180570,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; } @@ -179732,7 +180599,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetReq(); } else { - setReq((ClearFileMetadataRequest)value); + setReq((CacheFileMetadataRequest)value); } break; @@ -179765,12 +180632,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; @@ -179799,7 +180666,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()); } @@ -179833,7 +180700,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:"); @@ -179871,15 +180738,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) @@ -179891,7 +180758,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 { @@ -179907,7 +180774,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); @@ -179922,16 +180789,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()) { @@ -179944,11 +180811,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); } @@ -179957,18 +180824,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 { @@ -180033,16 +180900,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; @@ -180051,14 +180918,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 @@ -180066,11 +180933,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; } @@ -180095,7 +180962,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetSuccess(); } else { - setSuccess((ClearFileMetadataResult)value); + setSuccess((CacheFileMetadataResult)value); } break; @@ -180128,12 +180995,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; @@ -180162,7 +181029,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()); } @@ -180196,7 +181063,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:"); @@ -180234,15 +181101,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) @@ -180254,7 +181121,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 { @@ -180270,7 +181137,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); @@ -180285,16 +181152,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()) { @@ -180307,11 +181174,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); } @@ -180320,22 +181187,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_db_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_db_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_db_uuid_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new get_metastore_db_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(); @@ -180350,8 +181215,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; } @@ -180390,86 +181253,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_db_uuid_args.class, metaDataMap); } - public cache_file_metadata_args() { - } - - public cache_file_metadata_args( - CacheFileMetadataRequest req) - { - this(); - this.req = req; + public get_metastore_db_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_db_uuid_args(get_metastore_db_uuid_args other) { } - public cache_file_metadata_args deepCopy() { - return new cache_file_metadata_args(this); + public get_metastore_db_uuid_args deepCopy() { + return new get_metastore_db_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(); } @@ -180481,8 +181295,6 @@ public boolean isSet(_Fields field) { } switch (field) { - case REQ: - return isSetReq(); } throw new IllegalStateException(); } @@ -180491,24 +181303,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_db_uuid_args) + return this.equals((get_metastore_db_uuid_args)that); return false; } - public boolean equals(cache_file_metadata_args that) { + public boolean equals(get_metastore_db_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; } @@ -180516,32 +181319,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_db_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; } @@ -180559,16 +181347,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_db_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(); } @@ -180576,9 +181357,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 { @@ -180597,15 +181375,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_db_uuid_argsStandardSchemeFactory implements SchemeFactory { + public get_metastore_db_uuid_argsStandardScheme getScheme() { + return new get_metastore_db_uuid_argsStandardScheme(); } } - private static class cache_file_metadata_argsStandardScheme extends StandardScheme { + private static class get_metastore_db_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_db_uuid_args struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -180615,15 +181393,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); } @@ -180633,72 +181402,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_db_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_db_uuid_argsTupleSchemeFactory implements SchemeFactory { + public get_metastore_db_uuid_argsTupleScheme getScheme() { + return new get_metastore_db_uuid_argsTupleScheme(); } } - private static class cache_file_metadata_argsTupleScheme extends TupleScheme { + private static class get_metastore_db_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_db_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_db_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_db_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_db_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_db_uuid_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new get_metastore_db_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(); @@ -180715,6 +181468,8 @@ public static _Fields findByThriftId(int fieldId) { switch(fieldId) { case 0: // SUCCESS return SUCCESS; + case 1: // O1 + return O1; default: return null; } @@ -180759,44 +181514,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_db_uuid_result.class, metaDataMap); } - public cache_file_metadata_result() { + public get_metastore_db_uuid_result() { } - public cache_file_metadata_result( - CacheFileMetadataResult success) + public get_metastore_db_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_db_uuid_result(get_metastore_db_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_db_uuid_result deepCopy() { + return new get_metastore_db_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; } @@ -180815,13 +181578,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; @@ -180833,6 +181627,9 @@ public Object getFieldValue(_Fields field) { case SUCCESS: return getSuccess(); + case O1: + return getO1(); + } throw new IllegalStateException(); } @@ -180846,6 +181643,8 @@ public boolean isSet(_Fields field) { switch (field) { case SUCCESS: return isSetSuccess(); + case O1: + return isSetO1(); } throw new IllegalStateException(); } @@ -180854,12 +181653,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_db_uuid_result) + return this.equals((get_metastore_db_uuid_result)that); return false; } - public boolean equals(cache_file_metadata_result that) { + public boolean equals(get_metastore_db_uuid_result that) { if (that == null) return false; @@ -180872,6 +181671,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; } @@ -180884,11 +181692,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_db_uuid_result other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -180905,6 +181718,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; } @@ -180922,7 +181745,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_db_uuid_result("); boolean first = true; sb.append("success:"); @@ -180932,6 +181755,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(); } @@ -180939,9 +181770,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 { @@ -180960,15 +181788,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_db_uuid_resultStandardSchemeFactory implements SchemeFactory { + public get_metastore_db_uuid_resultStandardScheme getScheme() { + return new get_metastore_db_uuid_resultStandardScheme(); } } - private static class cache_file_metadata_resultStandardScheme extends StandardScheme { + private static class get_metastore_db_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_db_uuid_result struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -180979,14 +181807,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); } @@ -180996,13 +181832,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_db_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(); @@ -181011,36 +181852,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_db_uuid_resultTupleSchemeFactory implements SchemeFactory { + public get_metastore_db_uuid_resultTupleScheme getScheme() { + return new get_metastore_db_uuid_resultTupleScheme(); } } - private static class cache_file_metadata_resultTupleScheme extends TupleScheme { + private static class get_metastore_db_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_db_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_db_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 metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php index 4fb71839471a1a7b8b8ebd9573212c7d40e9f39d..2bb4755c6ef8930ed70b35003a1e2a8f113338fc 100644 --- metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php +++ metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php @@ -1195,6 +1195,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_db_uuid(); } class ThriftHiveMetastoreClient extends \FacebookServiceClient implements \metastore\ThriftHiveMetastoreIf { @@ -9941,6 +9946,59 @@ class ThriftHiveMetastoreClient extends \FacebookServiceClient implements \metas throw new \Exception("cache_file_metadata failed: unknown result"); } + public function get_metastore_db_uuid() + { + $this->send_get_metastore_db_uuid(); + return $this->recv_get_metastore_db_uuid(); + } + + public function send_get_metastore_db_uuid() + { + $args = new \metastore\ThriftHiveMetastore_get_metastore_db_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_db_uuid', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite()); + } + else + { + $this->output_->writeMessageBegin('get_metastore_db_uuid', TMessageType::CALL, $this->seqid_); + $args->write($this->output_); + $this->output_->writeMessageEnd(); + $this->output_->getTransport()->flush(); + } + } + + public function recv_get_metastore_db_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_db_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_db_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_db_uuid failed: unknown result"); + } + } // HELPER FUNCTIONS AND STRUCTURES @@ -45318,4 +45376,154 @@ class ThriftHiveMetastore_cache_file_metadata_result { } +class ThriftHiveMetastore_get_metastore_db_uuid_args { + static $_TSPEC; + + + public function __construct() { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + ); + } + } + + public function getName() { + return 'ThriftHiveMetastore_get_metastore_db_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_db_uuid_args'); + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class ThriftHiveMetastore_get_metastore_db_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_db_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_db_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 metastore/src/gen/thrift/gen-php/metastore/Types.php metastore/src/gen/thrift/gen-php/metastore/Types.php index 74f0028c4124c729385eeee954537e4fdaf992eb..397d622370a863a6a7ffbb8f7faa6b6d8a768cc6 100644 --- metastore/src/gen/thrift/gen-php/metastore/Types.php +++ 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 metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote index f2a97997a4aaaf0ed07dc094ee8303717e01284d..9faf830cb4fc3efddee1650c74ba934006e09466 100755 --- metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote +++ metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote @@ -178,6 +178,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_db_uuid()') print(' string getName()') print(' string getVersion()') print(' fb_status getStatus()') @@ -1171,6 +1172,12 @@ elif cmd == 'cache_file_metadata': sys.exit(1) pp.pprint(client.cache_file_metadata(eval(args[0]),)) +elif cmd == 'get_metastore_db_uuid': + if len(args) != 0: + print('get_metastore_db_uuid requires 0 args') + sys.exit(1) + pp.pprint(client.get_metastore_db_uuid()) + elif cmd == 'getName': if len(args) != 0: print('getName requires 0 args') diff --git metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py index 8ee84af14f87b23956b6bee268c0092e439c17e0..b6306f060bf37821f5c5d1bee9cab1eae5805c86 100644 --- metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py +++ metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py @@ -1239,6 +1239,9 @@ def cache_file_metadata(self, req): """ pass + def get_metastore_db_uuid(self): + pass + class Client(fb303.FacebookService.Client, Iface): """ @@ -6804,6 +6807,34 @@ def recv_cache_file_metadata(self): return result.success raise TApplicationException(TApplicationException.MISSING_RESULT, "cache_file_metadata failed: unknown result") + def get_metastore_db_uuid(self): + self.send_get_metastore_db_uuid() + return self.recv_get_metastore_db_uuid() + + def send_get_metastore_db_uuid(self): + self._oprot.writeMessageBegin('get_metastore_db_uuid', TMessageType.CALL, self._seqid) + args = get_metastore_db_uuid_args() + args.write(self._oprot) + self._oprot.writeMessageEnd() + self._oprot.trans.flush() + + def recv_get_metastore_db_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_db_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_db_uuid failed: unknown result") + class Processor(fb303.FacebookService.Processor, Iface, TProcessor): def __init__(self, handler): @@ -6962,6 +6993,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_db_uuid"] = Processor.process_get_metastore_db_uuid def process(self, iprot, oprot): (name, type, seqid) = iprot.readMessageBegin() @@ -10732,6 +10764,28 @@ def process_cache_file_metadata(self, seqid, iprot, oprot): oprot.writeMessageEnd() oprot.trans.flush() + def process_get_metastore_db_uuid(self, seqid, iprot, oprot): + args = get_metastore_db_uuid_args() + args.read(iprot) + iprot.readMessageEnd() + result = get_metastore_db_uuid_result() + try: + result.success = self._handler.get_metastore_db_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_db_uuid", msg_type, seqid) + result.write(oprot) + oprot.writeMessageEnd() + oprot.trans.flush() + # HELPER FUNCTIONS AND STRUCTURES @@ -36796,3 +36850,127 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) + +class get_metastore_db_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_db_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_db_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_db_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 metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py index f26cb5b185cf6ae4b79786e6911f1b052822011a..8d115048c5c32295800371210a74e3dad022e23c 100644 --- metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py +++ 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 metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb index f1aa9a6a9738d8a2d544c15aaa5c1348a6e2ce6c..18f3abbe666385df4262bbc3b2d5f605d296b503 100644 --- metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb +++ 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 metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb index 04e63f3a9b858d79bfa4883c36c2ccce69bf55c4..b9d0fa2cd3f4ba9da39c55042b3c715a417924c9 100644 --- metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb +++ metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb @@ -2562,6 +2562,22 @@ module ThriftHiveMetastore raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'cache_file_metadata failed: unknown result') end + def get_metastore_db_uuid() + send_get_metastore_db_uuid() + return recv_get_metastore_db_uuid() + end + + def send_get_metastore_db_uuid() + send_message('get_metastore_db_uuid', Get_metastore_db_uuid_args) + end + + def recv_get_metastore_db_uuid() + result = receive_message(Get_metastore_db_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_db_uuid failed: unknown result') + end + end class Processor < ::FacebookService::Processor @@ -4457,6 +4473,17 @@ module ThriftHiveMetastore write_result(result, oprot, 'cache_file_metadata', seqid) end + def process_get_metastore_db_uuid(seqid, iprot, oprot) + args = read_args(iprot, Get_metastore_db_uuid_args) + result = Get_metastore_db_uuid_result.new() + begin + result.success = @handler.get_metastore_db_uuid() + rescue ::MetaException => o1 + result.o1 = o1 + end + write_result(result, oprot, 'get_metastore_db_uuid', seqid) + end + end # HELPER FUNCTIONS AND STRUCTURES @@ -10231,5 +10258,38 @@ module ThriftHiveMetastore ::Thrift::Struct.generate_accessors self end + class Get_metastore_db_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_db_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 metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java index cbcfc72ac73ccfe48dd9b57eb9722ae092e7094b..bf5e14ebbb91801b3654aa355af25118c5422ac3 100644 --- metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java +++ metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java @@ -6970,6 +6970,16 @@ public ForeignKeysResponse get_foreign_keys(ForeignKeysRequest request) throws M } return new ForeignKeysResponse(ret); } + + @Override + public String get_metastore_db_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 metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java index 53f81188c1cda13f20bdf757391024e0c289d9f9..27dffa04d3bf874efa619f924ec1cf7d137ed8bc 100644 --- metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java +++ metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java @@ -2536,4 +2536,10 @@ public boolean cacheFileMetadata( CacheFileMetadataResult result = client.cache_file_metadata(req); return result.isIsSupported(); } + + @Override + public String getMetastoreDbUuid() throws TException { + String uuid = client.get_metastore_db_uuid(); + return uuid; + } } diff --git metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java index 023a2893c3b046999981cccf8e7ff21227601f6b..f618e90dc9a8623c7d32474c2b3a2c8b07ca30c2 100644 --- metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java +++ metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java @@ -1664,4 +1664,6 @@ void addPrimaryKey(List primaryKeyCols) throws void addForeignKey(List foreignKeyCols) throws MetaException, NoSuchObjectException, TException; + + String getMetastoreDbUuid() throws MetaException, TException; } diff --git metastore/src/java/org/apache/hadoop/hive/metastore/ObjectStore.java metastore/src/java/org/apache/hadoop/hive/metastore/ObjectStore.java index a83e12e8f3e3a2f3149e4bbc09524998d0e8928f..86de4febe7957bf879cc97cb4806b9ef1dcb0268 100644 --- metastore/src/java/org/apache/hadoop/hive/metastore/ObjectStore.java +++ 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; @@ -3505,6 +3507,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 metastore/src/java/org/apache/hadoop/hive/metastore/RawStore.java metastore/src/java/org/apache/hadoop/hive/metastore/RawStore.java index c22a1db046814bf987de0df33b79e718b8fd6dc6..1c9d48b885647852e364383acd929ac8328d66db 100644 --- metastore/src/java/org/apache/hadoop/hive/metastore/RawStore.java +++ metastore/src/java/org/apache/hadoop/hive/metastore/RawStore.java @@ -708,4 +708,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 metastore/src/java/org/apache/hadoop/hive/metastore/cache/CachedStore.java metastore/src/java/org/apache/hadoop/hive/metastore/cache/CachedStore.java index 39b1676eb9d3c344a6e66f06f096f3a9fb1931ca..1b88ad36c7b7403e5ecff7ce64b8de7e161a66fb 100644 --- metastore/src/java/org/apache/hadoop/hive/metastore/cache/CachedStore.java +++ metastore/src/java/org/apache/hadoop/hive/metastore/cache/CachedStore.java @@ -1576,4 +1576,9 @@ public RawStore getRawStore() { public void setRawStore(RawStore rawStore) { this.rawStore = rawStore; } + + @Override + public String getMetastoreUuid() throws MetaException { + return rawStore.getMetastoreUuid(); + } } diff --git metastore/src/java/org/apache/hadoop/hive/metastore/hbase/HBaseStore.java metastore/src/java/org/apache/hadoop/hive/metastore/hbase/HBaseStore.java index f6420f5b99fc49df8675afdddd9718871b6c01bb..ac0e6a6da6b2d007751a1aeea02a7ea84918d958 100644 --- metastore/src/java/org/apache/hadoop/hive/metastore/hbase/HBaseStore.java +++ metastore/src/java/org/apache/hadoop/hive/metastore/hbase/HBaseStore.java @@ -2859,4 +2859,9 @@ public void addForeignKeys(List fks) throws InvalidObjectExceptio // TODO: see if it makes sense to implement this here return null; } + + @Override + public String getMetastoreUuid() throws MetaException { + throw new MetaException("getMetastoreUUID is not implemented for HBasestore"); + } } diff --git metastore/src/model/org/apache/hadoop/hive/metastore/model/MMetastoreDBProperties.java metastore/src/model/org/apache/hadoop/hive/metastore/model/MMetastoreDBProperties.java new file mode 100644 index 0000000000000000000000000000000000000000..c0a2485df44e2298eddbada8b23f9928d18de2bb --- /dev/null +++ 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 metastore/src/model/package.jdo metastore/src/model/package.jdo index 969e19912791b5f5a2b9c5fa4c43800310f5080c..4db1d625bb326d0922bffe9063c65d08c8fd097c 100644 --- metastore/src/model/package.jdo +++ metastore/src/model/package.jdo @@ -971,6 +971,24 @@ + + + + + + + + + + + + + + + + + + diff --git metastore/src/test/org/apache/hadoop/hive/metastore/DummyRawStoreControlledCommit.java metastore/src/test/org/apache/hadoop/hive/metastore/DummyRawStoreControlledCommit.java index 3e3fd20de069503fcedacf60fa1df90279af26b2..1372ec7bf3f9376c4b5730377954386ee569b61f 100644 --- metastore/src/test/org/apache/hadoop/hive/metastore/DummyRawStoreControlledCommit.java +++ metastore/src/test/org/apache/hadoop/hive/metastore/DummyRawStoreControlledCommit.java @@ -877,4 +877,9 @@ public void addForeignKeys(List fks) // TODO Auto-generated method stub return null; } + + @Override + public String getMetastoreUuid() throws MetaException { + throw new MetaException("Get metastore uuid is not implemented"); + } } diff --git metastore/src/test/org/apache/hadoop/hive/metastore/DummyRawStoreForJdoConnection.java metastore/src/test/org/apache/hadoop/hive/metastore/DummyRawStoreForJdoConnection.java index 91d8c2af67ae1e49f8d41f16d8eee361b3b2abf9..61b1ae34e2c1c6196c0847d22eab4e5edf6dbca2 100644 --- metastore/src/test/org/apache/hadoop/hive/metastore/DummyRawStoreForJdoConnection.java +++ metastore/src/test/org/apache/hadoop/hive/metastore/DummyRawStoreForJdoConnection.java @@ -893,6 +893,9 @@ public void addForeignKeys(List fks) // TODO Auto-generated method stub return null; } -} - + @Override + public String getMetastoreUuid() throws MetaException { + throw new MetaException("Get metastore uuid is not implemented"); + } +}