diff --git a/itests/hive-unit/src/test/java/org/apache/hadoop/hive/ql/parse/TestReplicationScenarios.java b/itests/hive-unit/src/test/java/org/apache/hadoop/hive/ql/parse/TestReplicationScenarios.java index 766d858..4d65fe0 100644 --- a/itests/hive-unit/src/test/java/org/apache/hadoop/hive/ql/parse/TestReplicationScenarios.java +++ b/itests/hive-unit/src/test/java/org/apache/hadoop/hive/ql/parse/TestReplicationScenarios.java @@ -1412,6 +1412,112 @@ public void testIncrementalInsertDropPartitionedTable() throws IOException { } @Test + public void testInsertOverwriteOnUnpartitionedTableWithCM() throws IOException { + String testName = "insertOverwriteOnUnpartitionedTableWithCM"; + LOG.info("Testing " + testName); + String dbName = testName + "_" + tid; + + run("CREATE DATABASE " + dbName); + run("CREATE TABLE " + dbName + ".unptned(a string) STORED AS TEXTFILE"); + + advanceDumpDir(); + run("REPL DUMP " + dbName); + String replDumpLocn = getResult(0, 0); + String replDumpId = getResult(0, 1, true); + LOG.info("Bootstrap-Dump: Dumped to {} with id {}", replDumpLocn, replDumpId); + run("REPL LOAD " + dbName + "_dupe FROM '" + replDumpLocn + "'"); + + // After INSERT INTO operation, get the last Repl ID + String[] unptn_data = new String[] { "thirteen" }; + run("INSERT INTO TABLE " + dbName + ".unptned values('" + unptn_data[0] + "')"); + run("REPL DUMP " + dbName + " FROM " + replDumpId); + String insertDumpId = getResult(0, 1, false); + + // Insert overwrite on unpartitioned table + String[] data_after_ovwrite = new String[] { "hundred" }; + run("INSERT OVERWRITE TABLE " + dbName + ".unptned values('" + data_after_ovwrite[0] + "')"); + + // Dump only one INSERT INTO operation on the table. + advanceDumpDir(); + run("REPL DUMP " + dbName + " FROM " + replDumpId + " TO " + insertDumpId); + String incrementalDumpLocn = getResult(0, 0); + String incrementalDumpId = getResult(0, 1, true); + LOG.info("Incremental-Dump: Dumped to {} with id {} from {}", incrementalDumpLocn, incrementalDumpId, replDumpId); + replDumpId = incrementalDumpId; + + // After Load from this dump, all target tables/partitions will have initial set of data but source will have latest data. + run("REPL LOAD " + dbName + "_dupe FROM '" + incrementalDumpLocn + "'"); + verifyRun("SELECT a from " + dbName + "_dupe.unptned ORDER BY a", unptn_data); + + // Dump the remaining INSERT OVERWRITE operations on the table. + advanceDumpDir(); + run("REPL DUMP " + dbName + " FROM " + replDumpId); + incrementalDumpLocn = getResult(0, 0); + incrementalDumpId = getResult(0, 1, true); + LOG.info("Incremental-Dump: Dumped to {} with id {} from {}", incrementalDumpLocn, incrementalDumpId, replDumpId); + + // After load, shall see the overwritten data. + run("REPL LOAD " + dbName + "_dupe FROM '" + incrementalDumpLocn + "'"); + verifyRun("SELECT a from " + dbName + "_dupe.unptned ORDER BY a", data_after_ovwrite); + } + + @Test + public void testInsertOverwriteOnPartitionedTableWithCM() throws IOException { + String testName = "insertOverwriteOnPartitionedTableWithCM"; + LOG.info("Testing " + testName); + String dbName = testName + "_" + tid; + + run("CREATE DATABASE " + dbName); + run("CREATE TABLE " + dbName + ".ptned(a string) partitioned by (b int) STORED AS TEXTFILE"); + + advanceDumpDir(); + run("REPL DUMP " + dbName); + String replDumpLocn = getResult(0, 0); + String replDumpId = getResult(0, 1, true); + LOG.info("Bootstrap-Dump: Dumped to {} with id {}", replDumpLocn, replDumpId); + run("REPL LOAD " + dbName + "_dupe FROM '" + replDumpLocn + "'"); + + // INSERT INTO 2 partitions and get the last repl ID + String[] ptn_data_1 = new String[] { "fourteen" }; + String[] ptn_data_2 = new String[] { "fifteen", "sixteen" }; + run("INSERT INTO TABLE " + dbName + ".ptned partition(b=1) values('" + ptn_data_1[0] + "')"); + run("INSERT INTO TABLE " + dbName + ".ptned partition(b=2) values('" + ptn_data_2[0] + "')"); + run("INSERT INTO TABLE " + dbName + ".ptned partition(b=2) values('" + ptn_data_2[1] + "')"); + run("REPL DUMP " + dbName + " FROM " + replDumpId); + String insertDumpId = getResult(0, 1, false); + + // Insert overwrite on one partition with multiple files + String[] data_after_ovwrite = new String[] { "hundred" }; + run("INSERT OVERWRITE TABLE " + dbName + ".ptned partition(b=2) values('" + data_after_ovwrite[0] + "')"); + verifySetup("SELECT a from " + dbName + ".ptned where (b=2)", data_after_ovwrite); + + // Dump only 2 INSERT INTO operations. + advanceDumpDir(); + run("REPL DUMP " + dbName + " FROM " + replDumpId + " TO " + insertDumpId); + String incrementalDumpLocn = getResult(0, 0); + String incrementalDumpId = getResult(0, 1, true); + LOG.info("Incremental-Dump: Dumped to {} with id {} from {}", incrementalDumpLocn, incrementalDumpId, replDumpId); + replDumpId = incrementalDumpId; + + // After Load from this dump, all target tables/partitions will have initial set of data. + run("REPL LOAD " + dbName + "_dupe FROM '" + incrementalDumpLocn + "'"); + verifyRun("SELECT a from " + dbName + "_dupe.ptned where (b=1) ORDER BY a", ptn_data_1); + verifyRun("SELECT a from " + dbName + "_dupe.ptned where (b=2) ORDER BY a", ptn_data_2); + + // Dump the remaining INSERT OVERWRITE operation on the table. + advanceDumpDir(); + run("REPL DUMP " + dbName + " FROM " + replDumpId); + incrementalDumpLocn = getResult(0, 0); + incrementalDumpId = getResult(0, 1, true); + LOG.info("Incremental-Dump: Dumped to {} with id {} from {}", incrementalDumpLocn, incrementalDumpId, replDumpId); + + // After load, shall see the overwritten data. + run("REPL LOAD " + dbName + "_dupe FROM '" + incrementalDumpLocn + "'"); + verifyRun("SELECT a from " + dbName + "_dupe.ptned where (b=1) ORDER BY a", ptn_data_1); + verifyRun("SELECT a from " + dbName + "_dupe.ptned where (b=2) ORDER BY a", data_after_ovwrite); + } + + @Test public void testViewsReplication() throws IOException { String testName = "viewsReplication"; String dbName = createDB(testName); diff --git a/metastore/if/hive_metastore.thrift b/metastore/if/hive_metastore.thrift index 0573f0c..042a5d8 100755 --- a/metastore/if/hive_metastore.thrift +++ b/metastore/if/hive_metastore.thrift @@ -985,6 +985,16 @@ struct GetTablesResult { 1: required list tables } +// Request type for cm_recycle +struct CmRecycleRequest { + 1: required string dataPath, + 2: required bool purge +} + +// Response type for cm_recycle +struct CmRecycleResponse { +} + struct TableMeta { 1: required string dbName; 2: required string tableName; @@ -1136,11 +1146,8 @@ service ThriftHiveMetastore extends fb303.FacebookService Table get_table(1:string dbname, 2:string tbl_name) throws (1:MetaException o1, 2:NoSuchObjectException o2) list
get_table_objects_by_name(1:string dbname, 2:list tbl_names) - GetTableResult get_table_req(1:GetTableRequest req) - throws (1:MetaException o1, 2:NoSuchObjectException o2) + GetTableResult get_table_req(1:GetTableRequest req) throws (1:MetaException o1, 2:NoSuchObjectException o2) GetTablesResult get_table_objects_by_name_req(1:GetTablesRequest req) - - throws (1:MetaException o1, 2:InvalidOperationException o2, 3:UnknownDBException o3) // Get a list of table names that match a filter. @@ -1542,6 +1549,9 @@ service ThriftHiveMetastore extends fb303.FacebookService FireEventResponse fire_listener_event(1:FireEventRequest rqst) void flushCache() + // Repl Change Management api + CmRecycleResponse cm_recycle(1:CmRecycleRequest request) throws(1:MetaException o1) + GetFileMetadataByExprResult get_file_metadata_by_expr(1:GetFileMetadataByExprRequest req) GetFileMetadataResult get_file_metadata(1:GetFileMetadataRequest req) PutFileMetadataResult put_file_metadata(1:PutFileMetadataRequest req) diff --git a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp index 0d4fe5a..f4cc70f 100644 --- a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp +++ b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp @@ -1240,14 +1240,14 @@ uint32_t ThriftHiveMetastore_get_databases_result::read(::apache::thrift::protoc if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size857; - ::apache::thrift::protocol::TType _etype860; - xfer += iprot->readListBegin(_etype860, _size857); - this->success.resize(_size857); - uint32_t _i861; - for (_i861 = 0; _i861 < _size857; ++_i861) + uint32_t _size861; + ::apache::thrift::protocol::TType _etype864; + xfer += iprot->readListBegin(_etype864, _size861); + this->success.resize(_size861); + uint32_t _i865; + for (_i865 = 0; _i865 < _size861; ++_i865) { - xfer += iprot->readString(this->success[_i861]); + xfer += iprot->readString(this->success[_i865]); } 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 _iter862; - for (_iter862 = this->success.begin(); _iter862 != this->success.end(); ++_iter862) + std::vector ::const_iterator _iter866; + for (_iter866 = this->success.begin(); _iter866 != this->success.end(); ++_iter866) { - xfer += oprot->writeString((*_iter862)); + xfer += oprot->writeString((*_iter866)); } 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 _size863; - ::apache::thrift::protocol::TType _etype866; - xfer += iprot->readListBegin(_etype866, _size863); - (*(this->success)).resize(_size863); - uint32_t _i867; - for (_i867 = 0; _i867 < _size863; ++_i867) + 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 += iprot->readString((*(this->success))[_i867]); + xfer += iprot->readString((*(this->success))[_i871]); } 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 _size868; - ::apache::thrift::protocol::TType _etype871; - xfer += iprot->readListBegin(_etype871, _size868); - this->success.resize(_size868); - uint32_t _i872; - for (_i872 = 0; _i872 < _size868; ++_i872) + uint32_t _size872; + ::apache::thrift::protocol::TType _etype875; + xfer += iprot->readListBegin(_etype875, _size872); + this->success.resize(_size872); + uint32_t _i876; + for (_i876 = 0; _i876 < _size872; ++_i876) { - xfer += iprot->readString(this->success[_i872]); + xfer += iprot->readString(this->success[_i876]); } 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 _iter873; - for (_iter873 = this->success.begin(); _iter873 != this->success.end(); ++_iter873) + std::vector ::const_iterator _iter877; + for (_iter877 = this->success.begin(); _iter877 != this->success.end(); ++_iter877) { - xfer += oprot->writeString((*_iter873)); + xfer += oprot->writeString((*_iter877)); } 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 _size874; - ::apache::thrift::protocol::TType _etype877; - xfer += iprot->readListBegin(_etype877, _size874); - (*(this->success)).resize(_size874); - uint32_t _i878; - for (_i878 = 0; _i878 < _size874; ++_i878) + 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 += iprot->readString((*(this->success))[_i878]); + xfer += iprot->readString((*(this->success))[_i882]); } 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 _size879; - ::apache::thrift::protocol::TType _ktype880; - ::apache::thrift::protocol::TType _vtype881; - xfer += iprot->readMapBegin(_ktype880, _vtype881, _size879); - uint32_t _i883; - for (_i883 = 0; _i883 < _size879; ++_i883) + uint32_t _size883; + ::apache::thrift::protocol::TType _ktype884; + ::apache::thrift::protocol::TType _vtype885; + xfer += iprot->readMapBegin(_ktype884, _vtype885, _size883); + uint32_t _i887; + for (_i887 = 0; _i887 < _size883; ++_i887) { - std::string _key884; - xfer += iprot->readString(_key884); - Type& _val885 = this->success[_key884]; - xfer += _val885.read(iprot); + std::string _key888; + xfer += iprot->readString(_key888); + Type& _val889 = this->success[_key888]; + xfer += _val889.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 _iter886; - for (_iter886 = this->success.begin(); _iter886 != this->success.end(); ++_iter886) + std::map ::const_iterator _iter890; + for (_iter890 = this->success.begin(); _iter890 != this->success.end(); ++_iter890) { - xfer += oprot->writeString(_iter886->first); - xfer += _iter886->second.write(oprot); + xfer += oprot->writeString(_iter890->first); + xfer += _iter890->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 _size887; - ::apache::thrift::protocol::TType _ktype888; - ::apache::thrift::protocol::TType _vtype889; - xfer += iprot->readMapBegin(_ktype888, _vtype889, _size887); - uint32_t _i891; - for (_i891 = 0; _i891 < _size887; ++_i891) + uint32_t _size891; + ::apache::thrift::protocol::TType _ktype892; + ::apache::thrift::protocol::TType _vtype893; + xfer += iprot->readMapBegin(_ktype892, _vtype893, _size891); + uint32_t _i895; + for (_i895 = 0; _i895 < _size891; ++_i895) { - std::string _key892; - xfer += iprot->readString(_key892); - Type& _val893 = (*(this->success))[_key892]; - xfer += _val893.read(iprot); + std::string _key896; + xfer += iprot->readString(_key896); + Type& _val897 = (*(this->success))[_key896]; + xfer += _val897.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 _size894; - ::apache::thrift::protocol::TType _etype897; - xfer += iprot->readListBegin(_etype897, _size894); - this->success.resize(_size894); - uint32_t _i898; - for (_i898 = 0; _i898 < _size894; ++_i898) + uint32_t _size898; + ::apache::thrift::protocol::TType _etype901; + xfer += iprot->readListBegin(_etype901, _size898); + this->success.resize(_size898); + uint32_t _i902; + for (_i902 = 0; _i902 < _size898; ++_i902) { - xfer += this->success[_i898].read(iprot); + xfer += this->success[_i902].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 _iter899; - for (_iter899 = this->success.begin(); _iter899 != this->success.end(); ++_iter899) + std::vector ::const_iterator _iter903; + for (_iter903 = this->success.begin(); _iter903 != this->success.end(); ++_iter903) { - xfer += (*_iter899).write(oprot); + xfer += (*_iter903).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 _size900; - ::apache::thrift::protocol::TType _etype903; - xfer += iprot->readListBegin(_etype903, _size900); - (*(this->success)).resize(_size900); - uint32_t _i904; - for (_i904 = 0; _i904 < _size900; ++_i904) + uint32_t _size904; + ::apache::thrift::protocol::TType _etype907; + xfer += iprot->readListBegin(_etype907, _size904); + (*(this->success)).resize(_size904); + uint32_t _i908; + for (_i908 = 0; _i908 < _size904; ++_i908) { - xfer += (*(this->success))[_i904].read(iprot); + xfer += (*(this->success))[_i908].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 _size905; - ::apache::thrift::protocol::TType _etype908; - xfer += iprot->readListBegin(_etype908, _size905); - this->success.resize(_size905); - uint32_t _i909; - for (_i909 = 0; _i909 < _size905; ++_i909) + uint32_t _size909; + ::apache::thrift::protocol::TType _etype912; + xfer += iprot->readListBegin(_etype912, _size909); + this->success.resize(_size909); + uint32_t _i913; + for (_i913 = 0; _i913 < _size909; ++_i913) { - xfer += this->success[_i909].read(iprot); + xfer += this->success[_i913].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 _iter910; - for (_iter910 = this->success.begin(); _iter910 != this->success.end(); ++_iter910) + std::vector ::const_iterator _iter914; + for (_iter914 = this->success.begin(); _iter914 != this->success.end(); ++_iter914) { - xfer += (*_iter910).write(oprot); + xfer += (*_iter914).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 _size911; - ::apache::thrift::protocol::TType _etype914; - xfer += iprot->readListBegin(_etype914, _size911); - (*(this->success)).resize(_size911); - uint32_t _i915; - for (_i915 = 0; _i915 < _size911; ++_i915) + uint32_t _size915; + ::apache::thrift::protocol::TType _etype918; + xfer += iprot->readListBegin(_etype918, _size915); + (*(this->success)).resize(_size915); + uint32_t _i919; + for (_i919 = 0; _i919 < _size915; ++_i919) { - xfer += (*(this->success))[_i915].read(iprot); + xfer += (*(this->success))[_i919].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 _size916; - ::apache::thrift::protocol::TType _etype919; - xfer += iprot->readListBegin(_etype919, _size916); - this->success.resize(_size916); - uint32_t _i920; - for (_i920 = 0; _i920 < _size916; ++_i920) + uint32_t _size920; + ::apache::thrift::protocol::TType _etype923; + xfer += iprot->readListBegin(_etype923, _size920); + this->success.resize(_size920); + uint32_t _i924; + for (_i924 = 0; _i924 < _size920; ++_i924) { - xfer += this->success[_i920].read(iprot); + xfer += this->success[_i924].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 _iter921; - for (_iter921 = this->success.begin(); _iter921 != this->success.end(); ++_iter921) + std::vector ::const_iterator _iter925; + for (_iter925 = this->success.begin(); _iter925 != this->success.end(); ++_iter925) { - xfer += (*_iter921).write(oprot); + xfer += (*_iter925).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 _size922; - ::apache::thrift::protocol::TType _etype925; - xfer += iprot->readListBegin(_etype925, _size922); - (*(this->success)).resize(_size922); - uint32_t _i926; - for (_i926 = 0; _i926 < _size922; ++_i926) + uint32_t _size926; + ::apache::thrift::protocol::TType _etype929; + xfer += iprot->readListBegin(_etype929, _size926); + (*(this->success)).resize(_size926); + uint32_t _i930; + for (_i930 = 0; _i930 < _size926; ++_i930) { - xfer += (*(this->success))[_i926].read(iprot); + xfer += (*(this->success))[_i930].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 _size927; - ::apache::thrift::protocol::TType _etype930; - xfer += iprot->readListBegin(_etype930, _size927); - this->success.resize(_size927); - uint32_t _i931; - for (_i931 = 0; _i931 < _size927; ++_i931) + uint32_t _size931; + ::apache::thrift::protocol::TType _etype934; + xfer += iprot->readListBegin(_etype934, _size931); + this->success.resize(_size931); + uint32_t _i935; + for (_i935 = 0; _i935 < _size931; ++_i935) { - xfer += this->success[_i931].read(iprot); + xfer += this->success[_i935].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 _iter932; - for (_iter932 = this->success.begin(); _iter932 != this->success.end(); ++_iter932) + std::vector ::const_iterator _iter936; + for (_iter936 = this->success.begin(); _iter936 != this->success.end(); ++_iter936) { - xfer += (*_iter932).write(oprot); + xfer += (*_iter936).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 _size933; - ::apache::thrift::protocol::TType _etype936; - xfer += iprot->readListBegin(_etype936, _size933); - (*(this->success)).resize(_size933); - uint32_t _i937; - for (_i937 = 0; _i937 < _size933; ++_i937) + uint32_t _size937; + ::apache::thrift::protocol::TType _etype940; + xfer += iprot->readListBegin(_etype940, _size937); + (*(this->success)).resize(_size937); + uint32_t _i941; + for (_i941 = 0; _i941 < _size937; ++_i941) { - xfer += (*(this->success))[_i937].read(iprot); + xfer += (*(this->success))[_i941].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 _size938; - ::apache::thrift::protocol::TType _etype941; - xfer += iprot->readListBegin(_etype941, _size938); - this->primaryKeys.resize(_size938); - uint32_t _i942; - for (_i942 = 0; _i942 < _size938; ++_i942) + uint32_t _size942; + ::apache::thrift::protocol::TType _etype945; + xfer += iprot->readListBegin(_etype945, _size942); + this->primaryKeys.resize(_size942); + uint32_t _i946; + for (_i946 = 0; _i946 < _size942; ++_i946) { - xfer += this->primaryKeys[_i942].read(iprot); + xfer += this->primaryKeys[_i946].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 _size943; - ::apache::thrift::protocol::TType _etype946; - xfer += iprot->readListBegin(_etype946, _size943); - this->foreignKeys.resize(_size943); - uint32_t _i947; - for (_i947 = 0; _i947 < _size943; ++_i947) + uint32_t _size947; + ::apache::thrift::protocol::TType _etype950; + xfer += iprot->readListBegin(_etype950, _size947); + this->foreignKeys.resize(_size947); + uint32_t _i951; + for (_i951 = 0; _i951 < _size947; ++_i951) { - xfer += this->foreignKeys[_i947].read(iprot); + xfer += this->foreignKeys[_i951].read(iprot); } xfer += iprot->readListEnd(); } @@ -4558,14 +4558,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->uniqueConstraints.clear(); - uint32_t _size948; - ::apache::thrift::protocol::TType _etype951; - xfer += iprot->readListBegin(_etype951, _size948); - this->uniqueConstraints.resize(_size948); - uint32_t _i952; - for (_i952 = 0; _i952 < _size948; ++_i952) + uint32_t _size952; + ::apache::thrift::protocol::TType _etype955; + xfer += iprot->readListBegin(_etype955, _size952); + this->uniqueConstraints.resize(_size952); + uint32_t _i956; + for (_i956 = 0; _i956 < _size952; ++_i956) { - xfer += this->uniqueConstraints[_i952].read(iprot); + xfer += this->uniqueConstraints[_i956].read(iprot); } xfer += iprot->readListEnd(); } @@ -4578,14 +4578,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->notNullConstraints.clear(); - uint32_t _size953; - ::apache::thrift::protocol::TType _etype956; - xfer += iprot->readListBegin(_etype956, _size953); - this->notNullConstraints.resize(_size953); - uint32_t _i957; - for (_i957 = 0; _i957 < _size953; ++_i957) + uint32_t _size957; + ::apache::thrift::protocol::TType _etype960; + xfer += iprot->readListBegin(_etype960, _size957); + this->notNullConstraints.resize(_size957); + uint32_t _i961; + for (_i961 = 0; _i961 < _size957; ++_i961) { - xfer += this->notNullConstraints[_i957].read(iprot); + xfer += this->notNullConstraints[_i961].read(iprot); } xfer += iprot->readListEnd(); } @@ -4618,10 +4618,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache: xfer += oprot->writeFieldBegin("primaryKeys", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->primaryKeys.size())); - std::vector ::const_iterator _iter958; - for (_iter958 = this->primaryKeys.begin(); _iter958 != this->primaryKeys.end(); ++_iter958) + std::vector ::const_iterator _iter962; + for (_iter962 = this->primaryKeys.begin(); _iter962 != this->primaryKeys.end(); ++_iter962) { - xfer += (*_iter958).write(oprot); + xfer += (*_iter962).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4630,10 +4630,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache: xfer += oprot->writeFieldBegin("foreignKeys", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->foreignKeys.size())); - std::vector ::const_iterator _iter959; - for (_iter959 = this->foreignKeys.begin(); _iter959 != this->foreignKeys.end(); ++_iter959) + std::vector ::const_iterator _iter963; + for (_iter963 = this->foreignKeys.begin(); _iter963 != this->foreignKeys.end(); ++_iter963) { - xfer += (*_iter959).write(oprot); + xfer += (*_iter963).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4642,10 +4642,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache: xfer += oprot->writeFieldBegin("uniqueConstraints", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->uniqueConstraints.size())); - std::vector ::const_iterator _iter960; - for (_iter960 = this->uniqueConstraints.begin(); _iter960 != this->uniqueConstraints.end(); ++_iter960) + std::vector ::const_iterator _iter964; + for (_iter964 = this->uniqueConstraints.begin(); _iter964 != this->uniqueConstraints.end(); ++_iter964) { - xfer += (*_iter960).write(oprot); + xfer += (*_iter964).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4654,10 +4654,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache: xfer += oprot->writeFieldBegin("notNullConstraints", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->notNullConstraints.size())); - std::vector ::const_iterator _iter961; - for (_iter961 = this->notNullConstraints.begin(); _iter961 != this->notNullConstraints.end(); ++_iter961) + std::vector ::const_iterator _iter965; + for (_iter965 = this->notNullConstraints.begin(); _iter965 != this->notNullConstraints.end(); ++_iter965) { - xfer += (*_iter961).write(oprot); + xfer += (*_iter965).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4685,10 +4685,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache xfer += oprot->writeFieldBegin("primaryKeys", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->primaryKeys)).size())); - std::vector ::const_iterator _iter962; - for (_iter962 = (*(this->primaryKeys)).begin(); _iter962 != (*(this->primaryKeys)).end(); ++_iter962) + std::vector ::const_iterator _iter966; + for (_iter966 = (*(this->primaryKeys)).begin(); _iter966 != (*(this->primaryKeys)).end(); ++_iter966) { - xfer += (*_iter962).write(oprot); + xfer += (*_iter966).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4697,10 +4697,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache xfer += oprot->writeFieldBegin("foreignKeys", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->foreignKeys)).size())); - std::vector ::const_iterator _iter963; - for (_iter963 = (*(this->foreignKeys)).begin(); _iter963 != (*(this->foreignKeys)).end(); ++_iter963) + std::vector ::const_iterator _iter967; + for (_iter967 = (*(this->foreignKeys)).begin(); _iter967 != (*(this->foreignKeys)).end(); ++_iter967) { - xfer += (*_iter963).write(oprot); + xfer += (*_iter967).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4709,10 +4709,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache xfer += oprot->writeFieldBegin("uniqueConstraints", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->uniqueConstraints)).size())); - std::vector ::const_iterator _iter964; - for (_iter964 = (*(this->uniqueConstraints)).begin(); _iter964 != (*(this->uniqueConstraints)).end(); ++_iter964) + std::vector ::const_iterator _iter968; + for (_iter968 = (*(this->uniqueConstraints)).begin(); _iter968 != (*(this->uniqueConstraints)).end(); ++_iter968) { - xfer += (*_iter964).write(oprot); + xfer += (*_iter968).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4721,10 +4721,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache xfer += oprot->writeFieldBegin("notNullConstraints", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->notNullConstraints)).size())); - std::vector ::const_iterator _iter965; - for (_iter965 = (*(this->notNullConstraints)).begin(); _iter965 != (*(this->notNullConstraints)).end(); ++_iter965) + std::vector ::const_iterator _iter969; + for (_iter969 = (*(this->notNullConstraints)).begin(); _iter969 != (*(this->notNullConstraints)).end(); ++_iter969) { - xfer += (*_iter965).write(oprot); + xfer += (*_iter969).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6478,14 +6478,14 @@ uint32_t ThriftHiveMetastore_truncate_table_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partNames.clear(); - uint32_t _size966; - ::apache::thrift::protocol::TType _etype969; - xfer += iprot->readListBegin(_etype969, _size966); - this->partNames.resize(_size966); - uint32_t _i970; - for (_i970 = 0; _i970 < _size966; ++_i970) + uint32_t _size970; + ::apache::thrift::protocol::TType _etype973; + xfer += iprot->readListBegin(_etype973, _size970); + this->partNames.resize(_size970); + uint32_t _i974; + for (_i974 = 0; _i974 < _size970; ++_i974) { - xfer += iprot->readString(this->partNames[_i970]); + xfer += iprot->readString(this->partNames[_i974]); } xfer += iprot->readListEnd(); } @@ -6522,10 +6522,10 @@ uint32_t ThriftHiveMetastore_truncate_table_args::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("partNames", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partNames.size())); - std::vector ::const_iterator _iter971; - for (_iter971 = this->partNames.begin(); _iter971 != this->partNames.end(); ++_iter971) + std::vector ::const_iterator _iter975; + for (_iter975 = this->partNames.begin(); _iter975 != this->partNames.end(); ++_iter975) { - xfer += oprot->writeString((*_iter971)); + xfer += oprot->writeString((*_iter975)); } xfer += oprot->writeListEnd(); } @@ -6557,10 +6557,10 @@ uint32_t ThriftHiveMetastore_truncate_table_pargs::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("partNames", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->partNames)).size())); - std::vector ::const_iterator _iter972; - for (_iter972 = (*(this->partNames)).begin(); _iter972 != (*(this->partNames)).end(); ++_iter972) + std::vector ::const_iterator _iter976; + for (_iter976 = (*(this->partNames)).begin(); _iter976 != (*(this->partNames)).end(); ++_iter976) { - xfer += oprot->writeString((*_iter972)); + xfer += oprot->writeString((*_iter976)); } xfer += oprot->writeListEnd(); } @@ -6804,14 +6804,14 @@ uint32_t ThriftHiveMetastore_get_tables_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size973; - ::apache::thrift::protocol::TType _etype976; - xfer += iprot->readListBegin(_etype976, _size973); - this->success.resize(_size973); - uint32_t _i977; - for (_i977 = 0; _i977 < _size973; ++_i977) + uint32_t _size977; + ::apache::thrift::protocol::TType _etype980; + xfer += iprot->readListBegin(_etype980, _size977); + this->success.resize(_size977); + uint32_t _i981; + for (_i981 = 0; _i981 < _size977; ++_i981) { - xfer += iprot->readString(this->success[_i977]); + xfer += iprot->readString(this->success[_i981]); } xfer += iprot->readListEnd(); } @@ -6850,10 +6850,10 @@ uint32_t ThriftHiveMetastore_get_tables_result::write(::apache::thrift::protocol xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter978; - for (_iter978 = this->success.begin(); _iter978 != this->success.end(); ++_iter978) + std::vector ::const_iterator _iter982; + for (_iter982 = this->success.begin(); _iter982 != this->success.end(); ++_iter982) { - xfer += oprot->writeString((*_iter978)); + xfer += oprot->writeString((*_iter982)); } xfer += oprot->writeListEnd(); } @@ -6898,14 +6898,14 @@ uint32_t ThriftHiveMetastore_get_tables_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size979; - ::apache::thrift::protocol::TType _etype982; - xfer += iprot->readListBegin(_etype982, _size979); - (*(this->success)).resize(_size979); - uint32_t _i983; - for (_i983 = 0; _i983 < _size979; ++_i983) + 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) { - xfer += iprot->readString((*(this->success))[_i983]); + xfer += iprot->readString((*(this->success))[_i987]); } xfer += iprot->readListEnd(); } @@ -7075,14 +7075,14 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_result::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size984; - ::apache::thrift::protocol::TType _etype987; - xfer += iprot->readListBegin(_etype987, _size984); - this->success.resize(_size984); - uint32_t _i988; - for (_i988 = 0; _i988 < _size984; ++_i988) + uint32_t _size988; + ::apache::thrift::protocol::TType _etype991; + xfer += iprot->readListBegin(_etype991, _size988); + this->success.resize(_size988); + uint32_t _i992; + for (_i992 = 0; _i992 < _size988; ++_i992) { - xfer += iprot->readString(this->success[_i988]); + xfer += iprot->readString(this->success[_i992]); } xfer += iprot->readListEnd(); } @@ -7121,10 +7121,10 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_result::write(::apache::thrift:: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter989; - for (_iter989 = this->success.begin(); _iter989 != this->success.end(); ++_iter989) + std::vector ::const_iterator _iter993; + for (_iter993 = this->success.begin(); _iter993 != this->success.end(); ++_iter993) { - xfer += oprot->writeString((*_iter989)); + xfer += oprot->writeString((*_iter993)); } xfer += oprot->writeListEnd(); } @@ -7169,14 +7169,14 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_presult::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size990; - ::apache::thrift::protocol::TType _etype993; - xfer += iprot->readListBegin(_etype993, _size990); - (*(this->success)).resize(_size990); - uint32_t _i994; - for (_i994 = 0; _i994 < _size990; ++_i994) + 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) { - xfer += iprot->readString((*(this->success))[_i994]); + xfer += iprot->readString((*(this->success))[_i998]); } xfer += iprot->readListEnd(); } @@ -7251,14 +7251,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tbl_types.clear(); - uint32_t _size995; - ::apache::thrift::protocol::TType _etype998; - xfer += iprot->readListBegin(_etype998, _size995); - this->tbl_types.resize(_size995); - uint32_t _i999; - for (_i999 = 0; _i999 < _size995; ++_i999) + uint32_t _size999; + ::apache::thrift::protocol::TType _etype1002; + xfer += iprot->readListBegin(_etype1002, _size999); + this->tbl_types.resize(_size999); + uint32_t _i1003; + for (_i1003 = 0; _i1003 < _size999; ++_i1003) { - xfer += iprot->readString(this->tbl_types[_i999]); + xfer += iprot->readString(this->tbl_types[_i1003]); } xfer += iprot->readListEnd(); } @@ -7295,10 +7295,10 @@ uint32_t ThriftHiveMetastore_get_table_meta_args::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("tbl_types", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->tbl_types.size())); - std::vector ::const_iterator _iter1000; - for (_iter1000 = this->tbl_types.begin(); _iter1000 != this->tbl_types.end(); ++_iter1000) + std::vector ::const_iterator _iter1004; + for (_iter1004 = this->tbl_types.begin(); _iter1004 != this->tbl_types.end(); ++_iter1004) { - xfer += oprot->writeString((*_iter1000)); + xfer += oprot->writeString((*_iter1004)); } xfer += oprot->writeListEnd(); } @@ -7330,10 +7330,10 @@ uint32_t ThriftHiveMetastore_get_table_meta_pargs::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("tbl_types", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->tbl_types)).size())); - std::vector ::const_iterator _iter1001; - for (_iter1001 = (*(this->tbl_types)).begin(); _iter1001 != (*(this->tbl_types)).end(); ++_iter1001) + std::vector ::const_iterator _iter1005; + for (_iter1005 = (*(this->tbl_types)).begin(); _iter1005 != (*(this->tbl_types)).end(); ++_iter1005) { - xfer += oprot->writeString((*_iter1001)); + xfer += oprot->writeString((*_iter1005)); } xfer += oprot->writeListEnd(); } @@ -7374,14 +7374,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1002; - ::apache::thrift::protocol::TType _etype1005; - xfer += iprot->readListBegin(_etype1005, _size1002); - this->success.resize(_size1002); - uint32_t _i1006; - for (_i1006 = 0; _i1006 < _size1002; ++_i1006) + uint32_t _size1006; + ::apache::thrift::protocol::TType _etype1009; + xfer += iprot->readListBegin(_etype1009, _size1006); + this->success.resize(_size1006); + uint32_t _i1010; + for (_i1010 = 0; _i1010 < _size1006; ++_i1010) { - xfer += this->success[_i1006].read(iprot); + xfer += this->success[_i1010].read(iprot); } xfer += iprot->readListEnd(); } @@ -7420,10 +7420,10 @@ uint32_t ThriftHiveMetastore_get_table_meta_result::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1007; - for (_iter1007 = this->success.begin(); _iter1007 != this->success.end(); ++_iter1007) + std::vector ::const_iterator _iter1011; + for (_iter1011 = this->success.begin(); _iter1011 != this->success.end(); ++_iter1011) { - xfer += (*_iter1007).write(oprot); + xfer += (*_iter1011).write(oprot); } xfer += oprot->writeListEnd(); } @@ -7468,14 +7468,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1008; - ::apache::thrift::protocol::TType _etype1011; - xfer += iprot->readListBegin(_etype1011, _size1008); - (*(this->success)).resize(_size1008); - uint32_t _i1012; - for (_i1012 = 0; _i1012 < _size1008; ++_i1012) + uint32_t _size1012; + ::apache::thrift::protocol::TType _etype1015; + xfer += iprot->readListBegin(_etype1015, _size1012); + (*(this->success)).resize(_size1012); + uint32_t _i1016; + for (_i1016 = 0; _i1016 < _size1012; ++_i1016) { - xfer += (*(this->success))[_i1012].read(iprot); + xfer += (*(this->success))[_i1016].read(iprot); } xfer += iprot->readListEnd(); } @@ -7613,14 +7613,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1013; - ::apache::thrift::protocol::TType _etype1016; - xfer += iprot->readListBegin(_etype1016, _size1013); - this->success.resize(_size1013); - uint32_t _i1017; - for (_i1017 = 0; _i1017 < _size1013; ++_i1017) + uint32_t _size1017; + ::apache::thrift::protocol::TType _etype1020; + xfer += iprot->readListBegin(_etype1020, _size1017); + this->success.resize(_size1017); + uint32_t _i1021; + for (_i1021 = 0; _i1021 < _size1017; ++_i1021) { - xfer += iprot->readString(this->success[_i1017]); + xfer += iprot->readString(this->success[_i1021]); } xfer += iprot->readListEnd(); } @@ -7659,10 +7659,10 @@ uint32_t ThriftHiveMetastore_get_all_tables_result::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1018; - for (_iter1018 = this->success.begin(); _iter1018 != this->success.end(); ++_iter1018) + std::vector ::const_iterator _iter1022; + for (_iter1022 = this->success.begin(); _iter1022 != this->success.end(); ++_iter1022) { - xfer += oprot->writeString((*_iter1018)); + xfer += oprot->writeString((*_iter1022)); } xfer += oprot->writeListEnd(); } @@ -7707,14 +7707,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1019; - ::apache::thrift::protocol::TType _etype1022; - xfer += iprot->readListBegin(_etype1022, _size1019); - (*(this->success)).resize(_size1019); - uint32_t _i1023; - for (_i1023 = 0; _i1023 < _size1019; ++_i1023) + uint32_t _size1023; + ::apache::thrift::protocol::TType _etype1026; + xfer += iprot->readListBegin(_etype1026, _size1023); + (*(this->success)).resize(_size1023); + uint32_t _i1027; + for (_i1027 = 0; _i1027 < _size1023; ++_i1027) { - xfer += iprot->readString((*(this->success))[_i1023]); + xfer += iprot->readString((*(this->success))[_i1027]); } xfer += iprot->readListEnd(); } @@ -8024,14 +8024,14 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_args::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tbl_names.clear(); - uint32_t _size1024; - ::apache::thrift::protocol::TType _etype1027; - xfer += iprot->readListBegin(_etype1027, _size1024); - this->tbl_names.resize(_size1024); - uint32_t _i1028; - for (_i1028 = 0; _i1028 < _size1024; ++_i1028) + uint32_t _size1028; + ::apache::thrift::protocol::TType _etype1031; + xfer += iprot->readListBegin(_etype1031, _size1028); + this->tbl_names.resize(_size1028); + uint32_t _i1032; + for (_i1032 = 0; _i1032 < _size1028; ++_i1032) { - xfer += iprot->readString(this->tbl_names[_i1028]); + xfer += iprot->readString(this->tbl_names[_i1032]); } xfer += iprot->readListEnd(); } @@ -8064,10 +8064,10 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_args::write(::apache::thr xfer += oprot->writeFieldBegin("tbl_names", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->tbl_names.size())); - std::vector ::const_iterator _iter1029; - for (_iter1029 = this->tbl_names.begin(); _iter1029 != this->tbl_names.end(); ++_iter1029) + std::vector ::const_iterator _iter1033; + for (_iter1033 = this->tbl_names.begin(); _iter1033 != this->tbl_names.end(); ++_iter1033) { - xfer += oprot->writeString((*_iter1029)); + xfer += oprot->writeString((*_iter1033)); } xfer += oprot->writeListEnd(); } @@ -8095,10 +8095,10 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_pargs::write(::apache::th xfer += oprot->writeFieldBegin("tbl_names", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->tbl_names)).size())); - std::vector ::const_iterator _iter1030; - for (_iter1030 = (*(this->tbl_names)).begin(); _iter1030 != (*(this->tbl_names)).end(); ++_iter1030) + std::vector ::const_iterator _iter1034; + for (_iter1034 = (*(this->tbl_names)).begin(); _iter1034 != (*(this->tbl_names)).end(); ++_iter1034) { - xfer += oprot->writeString((*_iter1030)); + xfer += oprot->writeString((*_iter1034)); } xfer += oprot->writeListEnd(); } @@ -8139,14 +8139,14 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_result::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1031; - ::apache::thrift::protocol::TType _etype1034; - xfer += iprot->readListBegin(_etype1034, _size1031); - this->success.resize(_size1031); - uint32_t _i1035; - for (_i1035 = 0; _i1035 < _size1031; ++_i1035) + uint32_t _size1035; + ::apache::thrift::protocol::TType _etype1038; + xfer += iprot->readListBegin(_etype1038, _size1035); + this->success.resize(_size1035); + uint32_t _i1039; + for (_i1039 = 0; _i1039 < _size1035; ++_i1039) { - xfer += this->success[_i1035].read(iprot); + xfer += this->success[_i1039].read(iprot); } xfer += iprot->readListEnd(); } @@ -8177,10 +8177,10 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_result::write(::apache::t xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector
::const_iterator _iter1036; - for (_iter1036 = this->success.begin(); _iter1036 != this->success.end(); ++_iter1036) + std::vector
::const_iterator _iter1040; + for (_iter1040 = this->success.begin(); _iter1040 != this->success.end(); ++_iter1040) { - xfer += (*_iter1036).write(oprot); + xfer += (*_iter1040).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8221,14 +8221,14 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_presult::read(::apache::t if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1037; - ::apache::thrift::protocol::TType _etype1040; - xfer += iprot->readListBegin(_etype1040, _size1037); - (*(this->success)).resize(_size1037); - uint32_t _i1041; - for (_i1041 = 0; _i1041 < _size1037; ++_i1041) + uint32_t _size1041; + ::apache::thrift::protocol::TType _etype1044; + xfer += iprot->readListBegin(_etype1044, _size1041); + (*(this->success)).resize(_size1041); + uint32_t _i1045; + for (_i1045 = 0; _i1045 < _size1041; ++_i1045) { - xfer += (*(this->success))[_i1041].read(iprot); + xfer += (*(this->success))[_i1045].read(iprot); } xfer += iprot->readListEnd(); } @@ -8864,14 +8864,14 @@ uint32_t ThriftHiveMetastore_get_table_names_by_filter_result::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1042; - ::apache::thrift::protocol::TType _etype1045; - xfer += iprot->readListBegin(_etype1045, _size1042); - this->success.resize(_size1042); - uint32_t _i1046; - for (_i1046 = 0; _i1046 < _size1042; ++_i1046) + uint32_t _size1046; + ::apache::thrift::protocol::TType _etype1049; + xfer += iprot->readListBegin(_etype1049, _size1046); + this->success.resize(_size1046); + uint32_t _i1050; + for (_i1050 = 0; _i1050 < _size1046; ++_i1050) { - xfer += iprot->readString(this->success[_i1046]); + xfer += iprot->readString(this->success[_i1050]); } xfer += iprot->readListEnd(); } @@ -8926,10 +8926,10 @@ uint32_t ThriftHiveMetastore_get_table_names_by_filter_result::write(::apache::t xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1047; - for (_iter1047 = this->success.begin(); _iter1047 != this->success.end(); ++_iter1047) + std::vector ::const_iterator _iter1051; + for (_iter1051 = this->success.begin(); _iter1051 != this->success.end(); ++_iter1051) { - xfer += oprot->writeString((*_iter1047)); + xfer += oprot->writeString((*_iter1051)); } xfer += oprot->writeListEnd(); } @@ -8982,14 +8982,14 @@ uint32_t ThriftHiveMetastore_get_table_names_by_filter_presult::read(::apache::t if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1048; - ::apache::thrift::protocol::TType _etype1051; - xfer += iprot->readListBegin(_etype1051, _size1048); - (*(this->success)).resize(_size1048); - uint32_t _i1052; - for (_i1052 = 0; _i1052 < _size1048; ++_i1052) + uint32_t _size1052; + ::apache::thrift::protocol::TType _etype1055; + xfer += iprot->readListBegin(_etype1055, _size1052); + (*(this->success)).resize(_size1052); + uint32_t _i1056; + for (_i1056 = 0; _i1056 < _size1052; ++_i1056) { - xfer += iprot->readString((*(this->success))[_i1052]); + xfer += iprot->readString((*(this->success))[_i1056]); } xfer += iprot->readListEnd(); } @@ -10323,14 +10323,14 @@ uint32_t ThriftHiveMetastore_add_partitions_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size1053; - ::apache::thrift::protocol::TType _etype1056; - xfer += iprot->readListBegin(_etype1056, _size1053); - this->new_parts.resize(_size1053); - uint32_t _i1057; - for (_i1057 = 0; _i1057 < _size1053; ++_i1057) + uint32_t _size1057; + ::apache::thrift::protocol::TType _etype1060; + xfer += iprot->readListBegin(_etype1060, _size1057); + this->new_parts.resize(_size1057); + uint32_t _i1061; + for (_i1061 = 0; _i1061 < _size1057; ++_i1061) { - xfer += this->new_parts[_i1057].read(iprot); + xfer += this->new_parts[_i1061].read(iprot); } xfer += iprot->readListEnd(); } @@ -10359,10 +10359,10 @@ uint32_t ThriftHiveMetastore_add_partitions_args::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->new_parts.size())); - std::vector ::const_iterator _iter1058; - for (_iter1058 = this->new_parts.begin(); _iter1058 != this->new_parts.end(); ++_iter1058) + std::vector ::const_iterator _iter1062; + for (_iter1062 = this->new_parts.begin(); _iter1062 != this->new_parts.end(); ++_iter1062) { - xfer += (*_iter1058).write(oprot); + xfer += (*_iter1062).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10386,10 +10386,10 @@ uint32_t ThriftHiveMetastore_add_partitions_pargs::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->new_parts)).size())); - std::vector ::const_iterator _iter1059; - for (_iter1059 = (*(this->new_parts)).begin(); _iter1059 != (*(this->new_parts)).end(); ++_iter1059) + std::vector ::const_iterator _iter1063; + for (_iter1063 = (*(this->new_parts)).begin(); _iter1063 != (*(this->new_parts)).end(); ++_iter1063) { - xfer += (*_iter1059).write(oprot); + xfer += (*_iter1063).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10598,14 +10598,14 @@ uint32_t ThriftHiveMetastore_add_partitions_pspec_args::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size1060; - ::apache::thrift::protocol::TType _etype1063; - xfer += iprot->readListBegin(_etype1063, _size1060); - this->new_parts.resize(_size1060); - uint32_t _i1064; - for (_i1064 = 0; _i1064 < _size1060; ++_i1064) + uint32_t _size1064; + ::apache::thrift::protocol::TType _etype1067; + xfer += iprot->readListBegin(_etype1067, _size1064); + this->new_parts.resize(_size1064); + uint32_t _i1068; + for (_i1068 = 0; _i1068 < _size1064; ++_i1068) { - xfer += this->new_parts[_i1064].read(iprot); + xfer += this->new_parts[_i1068].read(iprot); } xfer += iprot->readListEnd(); } @@ -10634,10 +10634,10 @@ uint32_t ThriftHiveMetastore_add_partitions_pspec_args::write(::apache::thrift:: xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->new_parts.size())); - std::vector ::const_iterator _iter1065; - for (_iter1065 = this->new_parts.begin(); _iter1065 != this->new_parts.end(); ++_iter1065) + std::vector ::const_iterator _iter1069; + for (_iter1069 = this->new_parts.begin(); _iter1069 != this->new_parts.end(); ++_iter1069) { - xfer += (*_iter1065).write(oprot); + xfer += (*_iter1069).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10661,10 +10661,10 @@ uint32_t ThriftHiveMetastore_add_partitions_pspec_pargs::write(::apache::thrift: xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->new_parts)).size())); - std::vector ::const_iterator _iter1066; - for (_iter1066 = (*(this->new_parts)).begin(); _iter1066 != (*(this->new_parts)).end(); ++_iter1066) + std::vector ::const_iterator _iter1070; + for (_iter1070 = (*(this->new_parts)).begin(); _iter1070 != (*(this->new_parts)).end(); ++_iter1070) { - xfer += (*_iter1066).write(oprot); + xfer += (*_iter1070).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10889,14 +10889,14 @@ uint32_t ThriftHiveMetastore_append_partition_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1067; - ::apache::thrift::protocol::TType _etype1070; - xfer += iprot->readListBegin(_etype1070, _size1067); - this->part_vals.resize(_size1067); - uint32_t _i1071; - for (_i1071 = 0; _i1071 < _size1067; ++_i1071) + uint32_t _size1071; + ::apache::thrift::protocol::TType _etype1074; + xfer += iprot->readListBegin(_etype1074, _size1071); + this->part_vals.resize(_size1071); + uint32_t _i1075; + for (_i1075 = 0; _i1075 < _size1071; ++_i1075) { - xfer += iprot->readString(this->part_vals[_i1071]); + xfer += iprot->readString(this->part_vals[_i1075]); } xfer += iprot->readListEnd(); } @@ -10933,10 +10933,10 @@ uint32_t ThriftHiveMetastore_append_partition_args::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter1072; - for (_iter1072 = this->part_vals.begin(); _iter1072 != this->part_vals.end(); ++_iter1072) + std::vector ::const_iterator _iter1076; + for (_iter1076 = this->part_vals.begin(); _iter1076 != this->part_vals.end(); ++_iter1076) { - xfer += oprot->writeString((*_iter1072)); + xfer += oprot->writeString((*_iter1076)); } xfer += oprot->writeListEnd(); } @@ -10968,10 +10968,10 @@ uint32_t ThriftHiveMetastore_append_partition_pargs::write(::apache::thrift::pro xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter1073; - for (_iter1073 = (*(this->part_vals)).begin(); _iter1073 != (*(this->part_vals)).end(); ++_iter1073) + std::vector ::const_iterator _iter1077; + for (_iter1077 = (*(this->part_vals)).begin(); _iter1077 != (*(this->part_vals)).end(); ++_iter1077) { - xfer += oprot->writeString((*_iter1073)); + xfer += oprot->writeString((*_iter1077)); } xfer += oprot->writeListEnd(); } @@ -11443,14 +11443,14 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::rea if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1074; - ::apache::thrift::protocol::TType _etype1077; - xfer += iprot->readListBegin(_etype1077, _size1074); - this->part_vals.resize(_size1074); - uint32_t _i1078; - for (_i1078 = 0; _i1078 < _size1074; ++_i1078) + uint32_t _size1078; + ::apache::thrift::protocol::TType _etype1081; + xfer += iprot->readListBegin(_etype1081, _size1078); + this->part_vals.resize(_size1078); + uint32_t _i1082; + for (_i1082 = 0; _i1082 < _size1078; ++_i1082) { - xfer += iprot->readString(this->part_vals[_i1078]); + xfer += iprot->readString(this->part_vals[_i1082]); } xfer += iprot->readListEnd(); } @@ -11495,10 +11495,10 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::wri xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter1079; - for (_iter1079 = this->part_vals.begin(); _iter1079 != this->part_vals.end(); ++_iter1079) + std::vector ::const_iterator _iter1083; + for (_iter1083 = this->part_vals.begin(); _iter1083 != this->part_vals.end(); ++_iter1083) { - xfer += oprot->writeString((*_iter1079)); + xfer += oprot->writeString((*_iter1083)); } xfer += oprot->writeListEnd(); } @@ -11534,10 +11534,10 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_pargs::wr xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter1080; - for (_iter1080 = (*(this->part_vals)).begin(); _iter1080 != (*(this->part_vals)).end(); ++_iter1080) + std::vector ::const_iterator _iter1084; + for (_iter1084 = (*(this->part_vals)).begin(); _iter1084 != (*(this->part_vals)).end(); ++_iter1084) { - xfer += oprot->writeString((*_iter1080)); + xfer += oprot->writeString((*_iter1084)); } xfer += oprot->writeListEnd(); } @@ -12340,14 +12340,14 @@ uint32_t ThriftHiveMetastore_drop_partition_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1081; - ::apache::thrift::protocol::TType _etype1084; - xfer += iprot->readListBegin(_etype1084, _size1081); - this->part_vals.resize(_size1081); - uint32_t _i1085; - for (_i1085 = 0; _i1085 < _size1081; ++_i1085) + uint32_t _size1085; + ::apache::thrift::protocol::TType _etype1088; + xfer += iprot->readListBegin(_etype1088, _size1085); + this->part_vals.resize(_size1085); + uint32_t _i1089; + for (_i1089 = 0; _i1089 < _size1085; ++_i1089) { - xfer += iprot->readString(this->part_vals[_i1085]); + xfer += iprot->readString(this->part_vals[_i1089]); } xfer += iprot->readListEnd(); } @@ -12392,10 +12392,10 @@ uint32_t ThriftHiveMetastore_drop_partition_args::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter1086; - for (_iter1086 = this->part_vals.begin(); _iter1086 != this->part_vals.end(); ++_iter1086) + std::vector ::const_iterator _iter1090; + for (_iter1090 = this->part_vals.begin(); _iter1090 != this->part_vals.end(); ++_iter1090) { - xfer += oprot->writeString((*_iter1086)); + xfer += oprot->writeString((*_iter1090)); } xfer += oprot->writeListEnd(); } @@ -12431,10 +12431,10 @@ uint32_t ThriftHiveMetastore_drop_partition_pargs::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter1087; - for (_iter1087 = (*(this->part_vals)).begin(); _iter1087 != (*(this->part_vals)).end(); ++_iter1087) + std::vector ::const_iterator _iter1091; + for (_iter1091 = (*(this->part_vals)).begin(); _iter1091 != (*(this->part_vals)).end(); ++_iter1091) { - xfer += oprot->writeString((*_iter1087)); + xfer += oprot->writeString((*_iter1091)); } xfer += oprot->writeListEnd(); } @@ -12643,14 +12643,14 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::read( if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1088; - ::apache::thrift::protocol::TType _etype1091; - xfer += iprot->readListBegin(_etype1091, _size1088); - this->part_vals.resize(_size1088); - uint32_t _i1092; - for (_i1092 = 0; _i1092 < _size1088; ++_i1092) + uint32_t _size1092; + ::apache::thrift::protocol::TType _etype1095; + xfer += iprot->readListBegin(_etype1095, _size1092); + this->part_vals.resize(_size1092); + uint32_t _i1096; + for (_i1096 = 0; _i1096 < _size1092; ++_i1096) { - xfer += iprot->readString(this->part_vals[_i1092]); + xfer += iprot->readString(this->part_vals[_i1096]); } xfer += iprot->readListEnd(); } @@ -12703,10 +12703,10 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::write xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter1093; - for (_iter1093 = this->part_vals.begin(); _iter1093 != this->part_vals.end(); ++_iter1093) + std::vector ::const_iterator _iter1097; + for (_iter1097 = this->part_vals.begin(); _iter1097 != this->part_vals.end(); ++_iter1097) { - xfer += oprot->writeString((*_iter1093)); + xfer += oprot->writeString((*_iter1097)); } xfer += oprot->writeListEnd(); } @@ -12746,10 +12746,10 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_pargs::writ xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter1094; - for (_iter1094 = (*(this->part_vals)).begin(); _iter1094 != (*(this->part_vals)).end(); ++_iter1094) + std::vector ::const_iterator _iter1098; + for (_iter1098 = (*(this->part_vals)).begin(); _iter1098 != (*(this->part_vals)).end(); ++_iter1098) { - xfer += oprot->writeString((*_iter1094)); + xfer += oprot->writeString((*_iter1098)); } xfer += oprot->writeListEnd(); } @@ -13755,14 +13755,14 @@ uint32_t ThriftHiveMetastore_get_partition_args::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1095; - ::apache::thrift::protocol::TType _etype1098; - xfer += iprot->readListBegin(_etype1098, _size1095); - this->part_vals.resize(_size1095); - uint32_t _i1099; - for (_i1099 = 0; _i1099 < _size1095; ++_i1099) + uint32_t _size1099; + ::apache::thrift::protocol::TType _etype1102; + xfer += iprot->readListBegin(_etype1102, _size1099); + this->part_vals.resize(_size1099); + uint32_t _i1103; + for (_i1103 = 0; _i1103 < _size1099; ++_i1103) { - xfer += iprot->readString(this->part_vals[_i1099]); + xfer += iprot->readString(this->part_vals[_i1103]); } xfer += iprot->readListEnd(); } @@ -13799,10 +13799,10 @@ uint32_t ThriftHiveMetastore_get_partition_args::write(::apache::thrift::protoco xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter1100; - for (_iter1100 = this->part_vals.begin(); _iter1100 != this->part_vals.end(); ++_iter1100) + std::vector ::const_iterator _iter1104; + for (_iter1104 = this->part_vals.begin(); _iter1104 != this->part_vals.end(); ++_iter1104) { - xfer += oprot->writeString((*_iter1100)); + xfer += oprot->writeString((*_iter1104)); } xfer += oprot->writeListEnd(); } @@ -13834,10 +13834,10 @@ uint32_t ThriftHiveMetastore_get_partition_pargs::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter1101; - for (_iter1101 = (*(this->part_vals)).begin(); _iter1101 != (*(this->part_vals)).end(); ++_iter1101) + std::vector ::const_iterator _iter1105; + for (_iter1105 = (*(this->part_vals)).begin(); _iter1105 != (*(this->part_vals)).end(); ++_iter1105) { - xfer += oprot->writeString((*_iter1101)); + xfer += oprot->writeString((*_iter1105)); } xfer += oprot->writeListEnd(); } @@ -14026,17 +14026,17 @@ uint32_t ThriftHiveMetastore_exchange_partition_args::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size1102; - ::apache::thrift::protocol::TType _ktype1103; - ::apache::thrift::protocol::TType _vtype1104; - xfer += iprot->readMapBegin(_ktype1103, _vtype1104, _size1102); - uint32_t _i1106; - for (_i1106 = 0; _i1106 < _size1102; ++_i1106) + uint32_t _size1106; + ::apache::thrift::protocol::TType _ktype1107; + ::apache::thrift::protocol::TType _vtype1108; + xfer += iprot->readMapBegin(_ktype1107, _vtype1108, _size1106); + uint32_t _i1110; + for (_i1110 = 0; _i1110 < _size1106; ++_i1110) { - std::string _key1107; - xfer += iprot->readString(_key1107); - std::string& _val1108 = this->partitionSpecs[_key1107]; - xfer += iprot->readString(_val1108); + std::string _key1111; + xfer += iprot->readString(_key1111); + std::string& _val1112 = this->partitionSpecs[_key1111]; + xfer += iprot->readString(_val1112); } xfer += iprot->readMapEnd(); } @@ -14097,11 +14097,11 @@ uint32_t ThriftHiveMetastore_exchange_partition_args::write(::apache::thrift::pr xfer += oprot->writeFieldBegin("partitionSpecs", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->partitionSpecs.size())); - std::map ::const_iterator _iter1109; - for (_iter1109 = this->partitionSpecs.begin(); _iter1109 != this->partitionSpecs.end(); ++_iter1109) + std::map ::const_iterator _iter1113; + for (_iter1113 = this->partitionSpecs.begin(); _iter1113 != this->partitionSpecs.end(); ++_iter1113) { - xfer += oprot->writeString(_iter1109->first); - xfer += oprot->writeString(_iter1109->second); + xfer += oprot->writeString(_iter1113->first); + xfer += oprot->writeString(_iter1113->second); } xfer += oprot->writeMapEnd(); } @@ -14141,11 +14141,11 @@ uint32_t ThriftHiveMetastore_exchange_partition_pargs::write(::apache::thrift::p xfer += oprot->writeFieldBegin("partitionSpecs", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast((*(this->partitionSpecs)).size())); - std::map ::const_iterator _iter1110; - for (_iter1110 = (*(this->partitionSpecs)).begin(); _iter1110 != (*(this->partitionSpecs)).end(); ++_iter1110) + std::map ::const_iterator _iter1114; + for (_iter1114 = (*(this->partitionSpecs)).begin(); _iter1114 != (*(this->partitionSpecs)).end(); ++_iter1114) { - xfer += oprot->writeString(_iter1110->first); - xfer += oprot->writeString(_iter1110->second); + xfer += oprot->writeString(_iter1114->first); + xfer += oprot->writeString(_iter1114->second); } xfer += oprot->writeMapEnd(); } @@ -14390,17 +14390,17 @@ uint32_t ThriftHiveMetastore_exchange_partitions_args::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size1111; - ::apache::thrift::protocol::TType _ktype1112; - ::apache::thrift::protocol::TType _vtype1113; - xfer += iprot->readMapBegin(_ktype1112, _vtype1113, _size1111); - uint32_t _i1115; - for (_i1115 = 0; _i1115 < _size1111; ++_i1115) + uint32_t _size1115; + ::apache::thrift::protocol::TType _ktype1116; + ::apache::thrift::protocol::TType _vtype1117; + xfer += iprot->readMapBegin(_ktype1116, _vtype1117, _size1115); + uint32_t _i1119; + for (_i1119 = 0; _i1119 < _size1115; ++_i1119) { - std::string _key1116; - xfer += iprot->readString(_key1116); - std::string& _val1117 = this->partitionSpecs[_key1116]; - xfer += iprot->readString(_val1117); + std::string _key1120; + xfer += iprot->readString(_key1120); + std::string& _val1121 = this->partitionSpecs[_key1120]; + xfer += iprot->readString(_val1121); } xfer += iprot->readMapEnd(); } @@ -14461,11 +14461,11 @@ uint32_t ThriftHiveMetastore_exchange_partitions_args::write(::apache::thrift::p xfer += oprot->writeFieldBegin("partitionSpecs", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->partitionSpecs.size())); - std::map ::const_iterator _iter1118; - for (_iter1118 = this->partitionSpecs.begin(); _iter1118 != this->partitionSpecs.end(); ++_iter1118) + std::map ::const_iterator _iter1122; + for (_iter1122 = this->partitionSpecs.begin(); _iter1122 != this->partitionSpecs.end(); ++_iter1122) { - xfer += oprot->writeString(_iter1118->first); - xfer += oprot->writeString(_iter1118->second); + xfer += oprot->writeString(_iter1122->first); + xfer += oprot->writeString(_iter1122->second); } xfer += oprot->writeMapEnd(); } @@ -14505,11 +14505,11 @@ uint32_t ThriftHiveMetastore_exchange_partitions_pargs::write(::apache::thrift:: xfer += oprot->writeFieldBegin("partitionSpecs", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast((*(this->partitionSpecs)).size())); - std::map ::const_iterator _iter1119; - for (_iter1119 = (*(this->partitionSpecs)).begin(); _iter1119 != (*(this->partitionSpecs)).end(); ++_iter1119) + std::map ::const_iterator _iter1123; + for (_iter1123 = (*(this->partitionSpecs)).begin(); _iter1123 != (*(this->partitionSpecs)).end(); ++_iter1123) { - xfer += oprot->writeString(_iter1119->first); - xfer += oprot->writeString(_iter1119->second); + xfer += oprot->writeString(_iter1123->first); + xfer += oprot->writeString(_iter1123->second); } xfer += oprot->writeMapEnd(); } @@ -14566,14 +14566,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _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 _size1124; + ::apache::thrift::protocol::TType _etype1127; + xfer += iprot->readListBegin(_etype1127, _size1124); + this->success.resize(_size1124); + uint32_t _i1128; + for (_i1128 = 0; _i1128 < _size1124; ++_i1128) { - xfer += this->success[_i1124].read(iprot); + xfer += this->success[_i1128].read(iprot); } xfer += iprot->readListEnd(); } @@ -14636,10 +14636,10 @@ uint32_t ThriftHiveMetastore_exchange_partitions_result::write(::apache::thrift: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1125; - for (_iter1125 = this->success.begin(); _iter1125 != this->success.end(); ++_iter1125) + std::vector ::const_iterator _iter1129; + for (_iter1129 = this->success.begin(); _iter1129 != this->success.end(); ++_iter1129) { - xfer += (*_iter1125).write(oprot); + xfer += (*_iter1129).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14696,14 +14696,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _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 _size1130; + ::apache::thrift::protocol::TType _etype1133; + xfer += iprot->readListBegin(_etype1133, _size1130); + (*(this->success)).resize(_size1130); + uint32_t _i1134; + for (_i1134 = 0; _i1134 < _size1130; ++_i1134) { - xfer += (*(this->success))[_i1130].read(iprot); + xfer += (*(this->success))[_i1134].read(iprot); } xfer += iprot->readListEnd(); } @@ -14802,14 +14802,14 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_args::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1131; - ::apache::thrift::protocol::TType _etype1134; - xfer += iprot->readListBegin(_etype1134, _size1131); - this->part_vals.resize(_size1131); - uint32_t _i1135; - for (_i1135 = 0; _i1135 < _size1131; ++_i1135) + uint32_t _size1135; + ::apache::thrift::protocol::TType _etype1138; + xfer += iprot->readListBegin(_etype1138, _size1135); + this->part_vals.resize(_size1135); + uint32_t _i1139; + for (_i1139 = 0; _i1139 < _size1135; ++_i1139) { - xfer += iprot->readString(this->part_vals[_i1135]); + xfer += iprot->readString(this->part_vals[_i1139]); } xfer += iprot->readListEnd(); } @@ -14830,14 +14830,14 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_args::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size1136; - ::apache::thrift::protocol::TType _etype1139; - xfer += iprot->readListBegin(_etype1139, _size1136); - this->group_names.resize(_size1136); - uint32_t _i1140; - for (_i1140 = 0; _i1140 < _size1136; ++_i1140) + uint32_t _size1140; + ::apache::thrift::protocol::TType _etype1143; + xfer += iprot->readListBegin(_etype1143, _size1140); + this->group_names.resize(_size1140); + uint32_t _i1144; + for (_i1144 = 0; _i1144 < _size1140; ++_i1144) { - xfer += iprot->readString(this->group_names[_i1140]); + xfer += iprot->readString(this->group_names[_i1144]); } xfer += iprot->readListEnd(); } @@ -14874,10 +14874,10 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_args::write(::apache::thrif xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter1141; - for (_iter1141 = this->part_vals.begin(); _iter1141 != this->part_vals.end(); ++_iter1141) + std::vector ::const_iterator _iter1145; + for (_iter1145 = this->part_vals.begin(); _iter1145 != this->part_vals.end(); ++_iter1145) { - xfer += oprot->writeString((*_iter1141)); + xfer += oprot->writeString((*_iter1145)); } xfer += oprot->writeListEnd(); } @@ -14890,10 +14890,10 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_args::write(::apache::thrif xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->group_names.size())); - std::vector ::const_iterator _iter1142; - for (_iter1142 = this->group_names.begin(); _iter1142 != this->group_names.end(); ++_iter1142) + std::vector ::const_iterator _iter1146; + for (_iter1146 = this->group_names.begin(); _iter1146 != this->group_names.end(); ++_iter1146) { - xfer += oprot->writeString((*_iter1142)); + xfer += oprot->writeString((*_iter1146)); } xfer += oprot->writeListEnd(); } @@ -14925,10 +14925,10 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_pargs::write(::apache::thri xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter1143; - for (_iter1143 = (*(this->part_vals)).begin(); _iter1143 != (*(this->part_vals)).end(); ++_iter1143) + std::vector ::const_iterator _iter1147; + for (_iter1147 = (*(this->part_vals)).begin(); _iter1147 != (*(this->part_vals)).end(); ++_iter1147) { - xfer += oprot->writeString((*_iter1143)); + xfer += oprot->writeString((*_iter1147)); } xfer += oprot->writeListEnd(); } @@ -14941,10 +14941,10 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_pargs::write(::apache::thri xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->group_names)).size())); - std::vector ::const_iterator _iter1144; - for (_iter1144 = (*(this->group_names)).begin(); _iter1144 != (*(this->group_names)).end(); ++_iter1144) + std::vector ::const_iterator _iter1148; + for (_iter1148 = (*(this->group_names)).begin(); _iter1148 != (*(this->group_names)).end(); ++_iter1148) { - xfer += oprot->writeString((*_iter1144)); + xfer += oprot->writeString((*_iter1148)); } xfer += oprot->writeListEnd(); } @@ -15503,14 +15503,14 @@ uint32_t ThriftHiveMetastore_get_partitions_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1145; - ::apache::thrift::protocol::TType _etype1148; - xfer += iprot->readListBegin(_etype1148, _size1145); - this->success.resize(_size1145); - uint32_t _i1149; - for (_i1149 = 0; _i1149 < _size1145; ++_i1149) + 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) { - xfer += this->success[_i1149].read(iprot); + xfer += this->success[_i1153].read(iprot); } xfer += iprot->readListEnd(); } @@ -15557,10 +15557,10 @@ uint32_t ThriftHiveMetastore_get_partitions_result::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1150; - for (_iter1150 = this->success.begin(); _iter1150 != this->success.end(); ++_iter1150) + std::vector ::const_iterator _iter1154; + for (_iter1154 = this->success.begin(); _iter1154 != this->success.end(); ++_iter1154) { - xfer += (*_iter1150).write(oprot); + xfer += (*_iter1154).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15609,14 +15609,14 @@ uint32_t ThriftHiveMetastore_get_partitions_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1151; - ::apache::thrift::protocol::TType _etype1154; - xfer += iprot->readListBegin(_etype1154, _size1151); - (*(this->success)).resize(_size1151); - uint32_t _i1155; - for (_i1155 = 0; _i1155 < _size1151; ++_i1155) + 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) { - xfer += (*(this->success))[_i1155].read(iprot); + xfer += (*(this->success))[_i1159].read(iprot); } xfer += iprot->readListEnd(); } @@ -15715,14 +15715,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_args::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size1156; - ::apache::thrift::protocol::TType _etype1159; - xfer += iprot->readListBegin(_etype1159, _size1156); - this->group_names.resize(_size1156); - uint32_t _i1160; - for (_i1160 = 0; _i1160 < _size1156; ++_i1160) + uint32_t _size1160; + ::apache::thrift::protocol::TType _etype1163; + xfer += iprot->readListBegin(_etype1163, _size1160); + this->group_names.resize(_size1160); + uint32_t _i1164; + for (_i1164 = 0; _i1164 < _size1160; ++_i1164) { - xfer += iprot->readString(this->group_names[_i1160]); + xfer += iprot->readString(this->group_names[_i1164]); } xfer += iprot->readListEnd(); } @@ -15767,10 +15767,10 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_args::write(::apache::thri xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->group_names.size())); - std::vector ::const_iterator _iter1161; - for (_iter1161 = this->group_names.begin(); _iter1161 != this->group_names.end(); ++_iter1161) + std::vector ::const_iterator _iter1165; + for (_iter1165 = this->group_names.begin(); _iter1165 != this->group_names.end(); ++_iter1165) { - xfer += oprot->writeString((*_iter1161)); + xfer += oprot->writeString((*_iter1165)); } xfer += oprot->writeListEnd(); } @@ -15810,10 +15810,10 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_pargs::write(::apache::thr xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->group_names)).size())); - std::vector ::const_iterator _iter1162; - for (_iter1162 = (*(this->group_names)).begin(); _iter1162 != (*(this->group_names)).end(); ++_iter1162) + std::vector ::const_iterator _iter1166; + for (_iter1166 = (*(this->group_names)).begin(); _iter1166 != (*(this->group_names)).end(); ++_iter1166) { - xfer += oprot->writeString((*_iter1162)); + xfer += oprot->writeString((*_iter1166)); } xfer += oprot->writeListEnd(); } @@ -15854,14 +15854,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1163; - ::apache::thrift::protocol::TType _etype1166; - xfer += iprot->readListBegin(_etype1166, _size1163); - this->success.resize(_size1163); - uint32_t _i1167; - for (_i1167 = 0; _i1167 < _size1163; ++_i1167) + uint32_t _size1167; + ::apache::thrift::protocol::TType _etype1170; + xfer += iprot->readListBegin(_etype1170, _size1167); + this->success.resize(_size1167); + uint32_t _i1171; + for (_i1171 = 0; _i1171 < _size1167; ++_i1171) { - xfer += this->success[_i1167].read(iprot); + xfer += this->success[_i1171].read(iprot); } xfer += iprot->readListEnd(); } @@ -15908,10 +15908,10 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_result::write(::apache::th xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1168; - for (_iter1168 = this->success.begin(); _iter1168 != this->success.end(); ++_iter1168) + std::vector ::const_iterator _iter1172; + for (_iter1172 = this->success.begin(); _iter1172 != this->success.end(); ++_iter1172) { - xfer += (*_iter1168).write(oprot); + xfer += (*_iter1172).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15960,14 +15960,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1169; - ::apache::thrift::protocol::TType _etype1172; - xfer += iprot->readListBegin(_etype1172, _size1169); - (*(this->success)).resize(_size1169); - uint32_t _i1173; - for (_i1173 = 0; _i1173 < _size1169; ++_i1173) + uint32_t _size1173; + ::apache::thrift::protocol::TType _etype1176; + xfer += iprot->readListBegin(_etype1176, _size1173); + (*(this->success)).resize(_size1173); + uint32_t _i1177; + for (_i1177 = 0; _i1177 < _size1173; ++_i1177) { - xfer += (*(this->success))[_i1173].read(iprot); + xfer += (*(this->success))[_i1177].read(iprot); } xfer += iprot->readListEnd(); } @@ -16145,14 +16145,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_result::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _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 _size1178; + ::apache::thrift::protocol::TType _etype1181; + xfer += iprot->readListBegin(_etype1181, _size1178); + this->success.resize(_size1178); + uint32_t _i1182; + for (_i1182 = 0; _i1182 < _size1178; ++_i1182) { - xfer += this->success[_i1178].read(iprot); + xfer += this->success[_i1182].read(iprot); } xfer += iprot->readListEnd(); } @@ -16199,10 +16199,10 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_result::write(::apache::thrift xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1179; - for (_iter1179 = this->success.begin(); _iter1179 != this->success.end(); ++_iter1179) + std::vector ::const_iterator _iter1183; + for (_iter1183 = this->success.begin(); _iter1183 != this->success.end(); ++_iter1183) { - xfer += (*_iter1179).write(oprot); + xfer += (*_iter1183).write(oprot); } xfer += oprot->writeListEnd(); } @@ -16251,14 +16251,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_presult::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _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 _size1184; + ::apache::thrift::protocol::TType _etype1187; + xfer += iprot->readListBegin(_etype1187, _size1184); + (*(this->success)).resize(_size1184); + uint32_t _i1188; + for (_i1188 = 0; _i1188 < _size1184; ++_i1188) { - xfer += (*(this->success))[_i1184].read(iprot); + xfer += (*(this->success))[_i1188].read(iprot); } xfer += iprot->readListEnd(); } @@ -16436,14 +16436,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1185; - ::apache::thrift::protocol::TType _etype1188; - xfer += iprot->readListBegin(_etype1188, _size1185); - this->success.resize(_size1185); - uint32_t _i1189; - for (_i1189 = 0; _i1189 < _size1185; ++_i1189) + uint32_t _size1189; + ::apache::thrift::protocol::TType _etype1192; + xfer += iprot->readListBegin(_etype1192, _size1189); + this->success.resize(_size1189); + uint32_t _i1193; + for (_i1193 = 0; _i1193 < _size1189; ++_i1193) { - xfer += iprot->readString(this->success[_i1189]); + xfer += iprot->readString(this->success[_i1193]); } xfer += iprot->readListEnd(); } @@ -16482,10 +16482,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 _iter1190; - for (_iter1190 = this->success.begin(); _iter1190 != this->success.end(); ++_iter1190) + std::vector ::const_iterator _iter1194; + for (_iter1194 = this->success.begin(); _iter1194 != this->success.end(); ++_iter1194) { - xfer += oprot->writeString((*_iter1190)); + xfer += oprot->writeString((*_iter1194)); } xfer += oprot->writeListEnd(); } @@ -16530,14 +16530,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1191; - ::apache::thrift::protocol::TType _etype1194; - xfer += iprot->readListBegin(_etype1194, _size1191); - (*(this->success)).resize(_size1191); - uint32_t _i1195; - for (_i1195 = 0; _i1195 < _size1191; ++_i1195) + uint32_t _size1195; + ::apache::thrift::protocol::TType _etype1198; + xfer += iprot->readListBegin(_etype1198, _size1195); + (*(this->success)).resize(_size1195); + uint32_t _i1199; + for (_i1199 = 0; _i1199 < _size1195; ++_i1199) { - xfer += iprot->readString((*(this->success))[_i1195]); + xfer += iprot->readString((*(this->success))[_i1199]); } xfer += iprot->readListEnd(); } @@ -16612,14 +16612,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 _size1196; - ::apache::thrift::protocol::TType _etype1199; - xfer += iprot->readListBegin(_etype1199, _size1196); - this->part_vals.resize(_size1196); - uint32_t _i1200; - for (_i1200 = 0; _i1200 < _size1196; ++_i1200) + uint32_t _size1200; + ::apache::thrift::protocol::TType _etype1203; + xfer += iprot->readListBegin(_etype1203, _size1200); + this->part_vals.resize(_size1200); + uint32_t _i1204; + for (_i1204 = 0; _i1204 < _size1200; ++_i1204) { - xfer += iprot->readString(this->part_vals[_i1200]); + xfer += iprot->readString(this->part_vals[_i1204]); } xfer += iprot->readListEnd(); } @@ -16664,10 +16664,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 _iter1201; - for (_iter1201 = this->part_vals.begin(); _iter1201 != this->part_vals.end(); ++_iter1201) + std::vector ::const_iterator _iter1205; + for (_iter1205 = this->part_vals.begin(); _iter1205 != this->part_vals.end(); ++_iter1205) { - xfer += oprot->writeString((*_iter1201)); + xfer += oprot->writeString((*_iter1205)); } xfer += oprot->writeListEnd(); } @@ -16703,10 +16703,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 _iter1202; - for (_iter1202 = (*(this->part_vals)).begin(); _iter1202 != (*(this->part_vals)).end(); ++_iter1202) + std::vector ::const_iterator _iter1206; + for (_iter1206 = (*(this->part_vals)).begin(); _iter1206 != (*(this->part_vals)).end(); ++_iter1206) { - xfer += oprot->writeString((*_iter1202)); + xfer += oprot->writeString((*_iter1206)); } xfer += oprot->writeListEnd(); } @@ -16751,14 +16751,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_result::read(::apache::thrift::pr 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 _size1207; + ::apache::thrift::protocol::TType _etype1210; + xfer += iprot->readListBegin(_etype1210, _size1207); + this->success.resize(_size1207); + uint32_t _i1211; + for (_i1211 = 0; _i1211 < _size1207; ++_i1211) { - xfer += this->success[_i1207].read(iprot); + xfer += this->success[_i1211].read(iprot); } xfer += iprot->readListEnd(); } @@ -16805,10 +16805,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 _iter1208; - for (_iter1208 = this->success.begin(); _iter1208 != this->success.end(); ++_iter1208) + std::vector ::const_iterator _iter1212; + for (_iter1212 = this->success.begin(); _iter1212 != this->success.end(); ++_iter1212) { - xfer += (*_iter1208).write(oprot); + xfer += (*_iter1212).write(oprot); } xfer += oprot->writeListEnd(); } @@ -16857,14 +16857,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_presult::read(::apache::thrift::p 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 _size1213; + ::apache::thrift::protocol::TType _etype1216; + xfer += iprot->readListBegin(_etype1216, _size1213); + (*(this->success)).resize(_size1213); + uint32_t _i1217; + for (_i1217 = 0; _i1217 < _size1213; ++_i1217) { - xfer += (*(this->success))[_i1213].read(iprot); + xfer += (*(this->success))[_i1217].read(iprot); } xfer += iprot->readListEnd(); } @@ -16947,14 +16947,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 _size1214; - ::apache::thrift::protocol::TType _etype1217; - xfer += iprot->readListBegin(_etype1217, _size1214); - this->part_vals.resize(_size1214); - uint32_t _i1218; - for (_i1218 = 0; _i1218 < _size1214; ++_i1218) + uint32_t _size1218; + ::apache::thrift::protocol::TType _etype1221; + xfer += iprot->readListBegin(_etype1221, _size1218); + this->part_vals.resize(_size1218); + uint32_t _i1222; + for (_i1222 = 0; _i1222 < _size1218; ++_i1222) { - xfer += iprot->readString(this->part_vals[_i1218]); + xfer += iprot->readString(this->part_vals[_i1222]); } xfer += iprot->readListEnd(); } @@ -16983,14 +16983,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 _size1219; - ::apache::thrift::protocol::TType _etype1222; - xfer += iprot->readListBegin(_etype1222, _size1219); - this->group_names.resize(_size1219); - uint32_t _i1223; - for (_i1223 = 0; _i1223 < _size1219; ++_i1223) + uint32_t _size1223; + ::apache::thrift::protocol::TType _etype1226; + xfer += iprot->readListBegin(_etype1226, _size1223); + this->group_names.resize(_size1223); + uint32_t _i1227; + for (_i1227 = 0; _i1227 < _size1223; ++_i1227) { - xfer += iprot->readString(this->group_names[_i1223]); + xfer += iprot->readString(this->group_names[_i1227]); } xfer += iprot->readListEnd(); } @@ -17027,10 +17027,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 _iter1224; - for (_iter1224 = this->part_vals.begin(); _iter1224 != this->part_vals.end(); ++_iter1224) + std::vector ::const_iterator _iter1228; + for (_iter1228 = this->part_vals.begin(); _iter1228 != this->part_vals.end(); ++_iter1228) { - xfer += oprot->writeString((*_iter1224)); + xfer += oprot->writeString((*_iter1228)); } xfer += oprot->writeListEnd(); } @@ -17047,10 +17047,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 _iter1225; - for (_iter1225 = this->group_names.begin(); _iter1225 != this->group_names.end(); ++_iter1225) + std::vector ::const_iterator _iter1229; + for (_iter1229 = this->group_names.begin(); _iter1229 != this->group_names.end(); ++_iter1229) { - xfer += oprot->writeString((*_iter1225)); + xfer += oprot->writeString((*_iter1229)); } xfer += oprot->writeListEnd(); } @@ -17082,10 +17082,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 _iter1226; - for (_iter1226 = (*(this->part_vals)).begin(); _iter1226 != (*(this->part_vals)).end(); ++_iter1226) + std::vector ::const_iterator _iter1230; + for (_iter1230 = (*(this->part_vals)).begin(); _iter1230 != (*(this->part_vals)).end(); ++_iter1230) { - xfer += oprot->writeString((*_iter1226)); + xfer += oprot->writeString((*_iter1230)); } xfer += oprot->writeListEnd(); } @@ -17102,10 +17102,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 _iter1227; - for (_iter1227 = (*(this->group_names)).begin(); _iter1227 != (*(this->group_names)).end(); ++_iter1227) + std::vector ::const_iterator _iter1231; + for (_iter1231 = (*(this->group_names)).begin(); _iter1231 != (*(this->group_names)).end(); ++_iter1231) { - xfer += oprot->writeString((*_iter1227)); + xfer += oprot->writeString((*_iter1231)); } xfer += oprot->writeListEnd(); } @@ -17146,14 +17146,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_result::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1228; - ::apache::thrift::protocol::TType _etype1231; - xfer += iprot->readListBegin(_etype1231, _size1228); - this->success.resize(_size1228); - uint32_t _i1232; - for (_i1232 = 0; _i1232 < _size1228; ++_i1232) + uint32_t _size1232; + ::apache::thrift::protocol::TType _etype1235; + xfer += iprot->readListBegin(_etype1235, _size1232); + this->success.resize(_size1232); + uint32_t _i1236; + for (_i1236 = 0; _i1236 < _size1232; ++_i1236) { - xfer += this->success[_i1232].read(iprot); + xfer += this->success[_i1236].read(iprot); } xfer += iprot->readListEnd(); } @@ -17200,10 +17200,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 _iter1233; - for (_iter1233 = this->success.begin(); _iter1233 != this->success.end(); ++_iter1233) + std::vector ::const_iterator _iter1237; + for (_iter1237 = this->success.begin(); _iter1237 != this->success.end(); ++_iter1237) { - xfer += (*_iter1233).write(oprot); + xfer += (*_iter1237).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17252,14 +17252,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_presult::read(::apache: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - 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) + 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) { - xfer += (*(this->success))[_i1238].read(iprot); + xfer += (*(this->success))[_i1242].read(iprot); } xfer += iprot->readListEnd(); } @@ -17342,14 +17342,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 _size1239; - ::apache::thrift::protocol::TType _etype1242; - xfer += iprot->readListBegin(_etype1242, _size1239); - this->part_vals.resize(_size1239); - uint32_t _i1243; - for (_i1243 = 0; _i1243 < _size1239; ++_i1243) + uint32_t _size1243; + ::apache::thrift::protocol::TType _etype1246; + xfer += iprot->readListBegin(_etype1246, _size1243); + this->part_vals.resize(_size1243); + uint32_t _i1247; + for (_i1247 = 0; _i1247 < _size1243; ++_i1247) { - xfer += iprot->readString(this->part_vals[_i1243]); + xfer += iprot->readString(this->part_vals[_i1247]); } xfer += iprot->readListEnd(); } @@ -17394,10 +17394,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 _iter1244; - for (_iter1244 = this->part_vals.begin(); _iter1244 != this->part_vals.end(); ++_iter1244) + std::vector ::const_iterator _iter1248; + for (_iter1248 = this->part_vals.begin(); _iter1248 != this->part_vals.end(); ++_iter1248) { - xfer += oprot->writeString((*_iter1244)); + xfer += oprot->writeString((*_iter1248)); } xfer += oprot->writeListEnd(); } @@ -17433,10 +17433,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 _iter1245; - for (_iter1245 = (*(this->part_vals)).begin(); _iter1245 != (*(this->part_vals)).end(); ++_iter1245) + std::vector ::const_iterator _iter1249; + for (_iter1249 = (*(this->part_vals)).begin(); _iter1249 != (*(this->part_vals)).end(); ++_iter1249) { - xfer += oprot->writeString((*_iter1245)); + xfer += oprot->writeString((*_iter1249)); } xfer += oprot->writeListEnd(); } @@ -17481,14 +17481,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1246; - ::apache::thrift::protocol::TType _etype1249; - xfer += iprot->readListBegin(_etype1249, _size1246); - this->success.resize(_size1246); - uint32_t _i1250; - for (_i1250 = 0; _i1250 < _size1246; ++_i1250) + uint32_t _size1250; + ::apache::thrift::protocol::TType _etype1253; + xfer += iprot->readListBegin(_etype1253, _size1250); + this->success.resize(_size1250); + uint32_t _i1254; + for (_i1254 = 0; _i1254 < _size1250; ++_i1254) { - xfer += iprot->readString(this->success[_i1250]); + xfer += iprot->readString(this->success[_i1254]); } xfer += iprot->readListEnd(); } @@ -17535,10 +17535,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 _iter1251; - for (_iter1251 = this->success.begin(); _iter1251 != this->success.end(); ++_iter1251) + std::vector ::const_iterator _iter1255; + for (_iter1255 = this->success.begin(); _iter1255 != this->success.end(); ++_iter1255) { - xfer += oprot->writeString((*_iter1251)); + xfer += oprot->writeString((*_iter1255)); } xfer += oprot->writeListEnd(); } @@ -17587,14 +17587,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1252; - ::apache::thrift::protocol::TType _etype1255; - xfer += iprot->readListBegin(_etype1255, _size1252); - (*(this->success)).resize(_size1252); - uint32_t _i1256; - for (_i1256 = 0; _i1256 < _size1252; ++_i1256) + uint32_t _size1256; + ::apache::thrift::protocol::TType _etype1259; + xfer += iprot->readListBegin(_etype1259, _size1256); + (*(this->success)).resize(_size1256); + uint32_t _i1260; + for (_i1260 = 0; _i1260 < _size1256; ++_i1260) { - xfer += iprot->readString((*(this->success))[_i1256]); + xfer += iprot->readString((*(this->success))[_i1260]); } xfer += iprot->readListEnd(); } @@ -17788,14 +17788,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1257; - ::apache::thrift::protocol::TType _etype1260; - xfer += iprot->readListBegin(_etype1260, _size1257); - this->success.resize(_size1257); - uint32_t _i1261; - for (_i1261 = 0; _i1261 < _size1257; ++_i1261) + uint32_t _size1261; + ::apache::thrift::protocol::TType _etype1264; + xfer += iprot->readListBegin(_etype1264, _size1261); + this->success.resize(_size1261); + uint32_t _i1265; + for (_i1265 = 0; _i1265 < _size1261; ++_i1265) { - xfer += this->success[_i1261].read(iprot); + xfer += this->success[_i1265].read(iprot); } xfer += iprot->readListEnd(); } @@ -17842,10 +17842,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 _iter1262; - for (_iter1262 = this->success.begin(); _iter1262 != this->success.end(); ++_iter1262) + std::vector ::const_iterator _iter1266; + for (_iter1266 = this->success.begin(); _iter1266 != this->success.end(); ++_iter1266) { - xfer += (*_iter1262).write(oprot); + xfer += (*_iter1266).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17894,14 +17894,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1263; - ::apache::thrift::protocol::TType _etype1266; - xfer += iprot->readListBegin(_etype1266, _size1263); - (*(this->success)).resize(_size1263); - uint32_t _i1267; - for (_i1267 = 0; _i1267 < _size1263; ++_i1267) + uint32_t _size1267; + ::apache::thrift::protocol::TType _etype1270; + xfer += iprot->readListBegin(_etype1270, _size1267); + (*(this->success)).resize(_size1267); + uint32_t _i1271; + for (_i1271 = 0; _i1271 < _size1267; ++_i1271) { - xfer += (*(this->success))[_i1267].read(iprot); + xfer += (*(this->success))[_i1271].read(iprot); } xfer += iprot->readListEnd(); } @@ -18095,14 +18095,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 _size1268; - ::apache::thrift::protocol::TType _etype1271; - xfer += iprot->readListBegin(_etype1271, _size1268); - this->success.resize(_size1268); - uint32_t _i1272; - for (_i1272 = 0; _i1272 < _size1268; ++_i1272) + uint32_t _size1272; + ::apache::thrift::protocol::TType _etype1275; + xfer += iprot->readListBegin(_etype1275, _size1272); + this->success.resize(_size1272); + uint32_t _i1276; + for (_i1276 = 0; _i1276 < _size1272; ++_i1276) { - xfer += this->success[_i1272].read(iprot); + xfer += this->success[_i1276].read(iprot); } xfer += iprot->readListEnd(); } @@ -18149,10 +18149,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 _iter1273; - for (_iter1273 = this->success.begin(); _iter1273 != this->success.end(); ++_iter1273) + std::vector ::const_iterator _iter1277; + for (_iter1277 = this->success.begin(); _iter1277 != this->success.end(); ++_iter1277) { - xfer += (*_iter1273).write(oprot); + xfer += (*_iter1277).write(oprot); } xfer += oprot->writeListEnd(); } @@ -18201,14 +18201,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 _size1274; - ::apache::thrift::protocol::TType _etype1277; - xfer += iprot->readListBegin(_etype1277, _size1274); - (*(this->success)).resize(_size1274); - uint32_t _i1278; - for (_i1278 = 0; _i1278 < _size1274; ++_i1278) + uint32_t _size1278; + ::apache::thrift::protocol::TType _etype1281; + xfer += iprot->readListBegin(_etype1281, _size1278); + (*(this->success)).resize(_size1278); + uint32_t _i1282; + for (_i1282 = 0; _i1282 < _size1278; ++_i1282) { - xfer += (*(this->success))[_i1278].read(iprot); + xfer += (*(this->success))[_i1282].read(iprot); } xfer += iprot->readListEnd(); } @@ -18777,14 +18777,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_args::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { this->names.clear(); - uint32_t _size1279; - ::apache::thrift::protocol::TType _etype1282; - xfer += iprot->readListBegin(_etype1282, _size1279); - this->names.resize(_size1279); - uint32_t _i1283; - for (_i1283 = 0; _i1283 < _size1279; ++_i1283) + uint32_t _size1283; + ::apache::thrift::protocol::TType _etype1286; + xfer += iprot->readListBegin(_etype1286, _size1283); + this->names.resize(_size1283); + uint32_t _i1287; + for (_i1287 = 0; _i1287 < _size1283; ++_i1287) { - xfer += iprot->readString(this->names[_i1283]); + xfer += iprot->readString(this->names[_i1287]); } xfer += iprot->readListEnd(); } @@ -18821,10 +18821,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 _iter1284; - for (_iter1284 = this->names.begin(); _iter1284 != this->names.end(); ++_iter1284) + std::vector ::const_iterator _iter1288; + for (_iter1288 = this->names.begin(); _iter1288 != this->names.end(); ++_iter1288) { - xfer += oprot->writeString((*_iter1284)); + xfer += oprot->writeString((*_iter1288)); } xfer += oprot->writeListEnd(); } @@ -18856,10 +18856,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 _iter1285; - for (_iter1285 = (*(this->names)).begin(); _iter1285 != (*(this->names)).end(); ++_iter1285) + std::vector ::const_iterator _iter1289; + for (_iter1289 = (*(this->names)).begin(); _iter1289 != (*(this->names)).end(); ++_iter1289) { - xfer += oprot->writeString((*_iter1285)); + xfer += oprot->writeString((*_iter1289)); } xfer += oprot->writeListEnd(); } @@ -18900,14 +18900,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_result::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1286; - ::apache::thrift::protocol::TType _etype1289; - xfer += iprot->readListBegin(_etype1289, _size1286); - this->success.resize(_size1286); - uint32_t _i1290; - for (_i1290 = 0; _i1290 < _size1286; ++_i1290) + uint32_t _size1290; + ::apache::thrift::protocol::TType _etype1293; + xfer += iprot->readListBegin(_etype1293, _size1290); + this->success.resize(_size1290); + uint32_t _i1294; + for (_i1294 = 0; _i1294 < _size1290; ++_i1294) { - xfer += this->success[_i1290].read(iprot); + xfer += this->success[_i1294].read(iprot); } xfer += iprot->readListEnd(); } @@ -18954,10 +18954,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 _iter1291; - for (_iter1291 = this->success.begin(); _iter1291 != this->success.end(); ++_iter1291) + std::vector ::const_iterator _iter1295; + for (_iter1295 = this->success.begin(); _iter1295 != this->success.end(); ++_iter1295) { - xfer += (*_iter1291).write(oprot); + xfer += (*_iter1295).write(oprot); } xfer += oprot->writeListEnd(); } @@ -19006,14 +19006,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_presult::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1292; - ::apache::thrift::protocol::TType _etype1295; - xfer += iprot->readListBegin(_etype1295, _size1292); - (*(this->success)).resize(_size1292); - uint32_t _i1296; - for (_i1296 = 0; _i1296 < _size1292; ++_i1296) + uint32_t _size1296; + ::apache::thrift::protocol::TType _etype1299; + xfer += iprot->readListBegin(_etype1299, _size1296); + (*(this->success)).resize(_size1296); + uint32_t _i1300; + for (_i1300 = 0; _i1300 < _size1296; ++_i1300) { - xfer += (*(this->success))[_i1296].read(iprot); + xfer += (*(this->success))[_i1300].read(iprot); } xfer += iprot->readListEnd(); } @@ -19335,14 +19335,14 @@ uint32_t ThriftHiveMetastore_alter_partitions_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size1297; - ::apache::thrift::protocol::TType _etype1300; - xfer += iprot->readListBegin(_etype1300, _size1297); - this->new_parts.resize(_size1297); - uint32_t _i1301; - for (_i1301 = 0; _i1301 < _size1297; ++_i1301) + uint32_t _size1301; + ::apache::thrift::protocol::TType _etype1304; + xfer += iprot->readListBegin(_etype1304, _size1301); + this->new_parts.resize(_size1301); + uint32_t _i1305; + for (_i1305 = 0; _i1305 < _size1301; ++_i1305) { - xfer += this->new_parts[_i1301].read(iprot); + xfer += this->new_parts[_i1305].read(iprot); } xfer += iprot->readListEnd(); } @@ -19379,10 +19379,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 _iter1302; - for (_iter1302 = this->new_parts.begin(); _iter1302 != this->new_parts.end(); ++_iter1302) + std::vector ::const_iterator _iter1306; + for (_iter1306 = this->new_parts.begin(); _iter1306 != this->new_parts.end(); ++_iter1306) { - xfer += (*_iter1302).write(oprot); + xfer += (*_iter1306).write(oprot); } xfer += oprot->writeListEnd(); } @@ -19414,10 +19414,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 _iter1303; - for (_iter1303 = (*(this->new_parts)).begin(); _iter1303 != (*(this->new_parts)).end(); ++_iter1303) + std::vector ::const_iterator _iter1307; + for (_iter1307 = (*(this->new_parts)).begin(); _iter1307 != (*(this->new_parts)).end(); ++_iter1307) { - xfer += (*_iter1303).write(oprot); + xfer += (*_iter1307).write(oprot); } xfer += oprot->writeListEnd(); } @@ -19602,14 +19602,14 @@ uint32_t ThriftHiveMetastore_alter_partitions_with_environment_context_args::rea if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size1304; - ::apache::thrift::protocol::TType _etype1307; - xfer += iprot->readListBegin(_etype1307, _size1304); - this->new_parts.resize(_size1304); - uint32_t _i1308; - for (_i1308 = 0; _i1308 < _size1304; ++_i1308) + uint32_t _size1308; + ::apache::thrift::protocol::TType _etype1311; + xfer += iprot->readListBegin(_etype1311, _size1308); + this->new_parts.resize(_size1308); + uint32_t _i1312; + for (_i1312 = 0; _i1312 < _size1308; ++_i1312) { - xfer += this->new_parts[_i1308].read(iprot); + xfer += this->new_parts[_i1312].read(iprot); } xfer += iprot->readListEnd(); } @@ -19654,10 +19654,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 _iter1309; - for (_iter1309 = this->new_parts.begin(); _iter1309 != this->new_parts.end(); ++_iter1309) + std::vector ::const_iterator _iter1313; + for (_iter1313 = this->new_parts.begin(); _iter1313 != this->new_parts.end(); ++_iter1313) { - xfer += (*_iter1309).write(oprot); + xfer += (*_iter1313).write(oprot); } xfer += oprot->writeListEnd(); } @@ -19693,10 +19693,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 _iter1310; - for (_iter1310 = (*(this->new_parts)).begin(); _iter1310 != (*(this->new_parts)).end(); ++_iter1310) + std::vector ::const_iterator _iter1314; + for (_iter1314 = (*(this->new_parts)).begin(); _iter1314 != (*(this->new_parts)).end(); ++_iter1314) { - xfer += (*_iter1310).write(oprot); + xfer += (*_iter1314).write(oprot); } xfer += oprot->writeListEnd(); } @@ -20140,14 +20140,14 @@ uint32_t ThriftHiveMetastore_rename_partition_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1311; - ::apache::thrift::protocol::TType _etype1314; - xfer += iprot->readListBegin(_etype1314, _size1311); - this->part_vals.resize(_size1311); - uint32_t _i1315; - for (_i1315 = 0; _i1315 < _size1311; ++_i1315) + uint32_t _size1315; + ::apache::thrift::protocol::TType _etype1318; + xfer += iprot->readListBegin(_etype1318, _size1315); + this->part_vals.resize(_size1315); + uint32_t _i1319; + for (_i1319 = 0; _i1319 < _size1315; ++_i1319) { - xfer += iprot->readString(this->part_vals[_i1315]); + xfer += iprot->readString(this->part_vals[_i1319]); } xfer += iprot->readListEnd(); } @@ -20192,10 +20192,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 _iter1316; - for (_iter1316 = this->part_vals.begin(); _iter1316 != this->part_vals.end(); ++_iter1316) + std::vector ::const_iterator _iter1320; + for (_iter1320 = this->part_vals.begin(); _iter1320 != this->part_vals.end(); ++_iter1320) { - xfer += oprot->writeString((*_iter1316)); + xfer += oprot->writeString((*_iter1320)); } xfer += oprot->writeListEnd(); } @@ -20231,10 +20231,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 _iter1317; - for (_iter1317 = (*(this->part_vals)).begin(); _iter1317 != (*(this->part_vals)).end(); ++_iter1317) + std::vector ::const_iterator _iter1321; + for (_iter1321 = (*(this->part_vals)).begin(); _iter1321 != (*(this->part_vals)).end(); ++_iter1321) { - xfer += oprot->writeString((*_iter1317)); + xfer += oprot->writeString((*_iter1321)); } xfer += oprot->writeListEnd(); } @@ -20407,14 +20407,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 _size1318; - ::apache::thrift::protocol::TType _etype1321; - xfer += iprot->readListBegin(_etype1321, _size1318); - this->part_vals.resize(_size1318); - uint32_t _i1322; - for (_i1322 = 0; _i1322 < _size1318; ++_i1322) + uint32_t _size1322; + ::apache::thrift::protocol::TType _etype1325; + xfer += iprot->readListBegin(_etype1325, _size1322); + this->part_vals.resize(_size1322); + uint32_t _i1326; + for (_i1326 = 0; _i1326 < _size1322; ++_i1326) { - xfer += iprot->readString(this->part_vals[_i1322]); + xfer += iprot->readString(this->part_vals[_i1326]); } xfer += iprot->readListEnd(); } @@ -20451,10 +20451,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 _iter1323; - for (_iter1323 = this->part_vals.begin(); _iter1323 != this->part_vals.end(); ++_iter1323) + std::vector ::const_iterator _iter1327; + for (_iter1327 = this->part_vals.begin(); _iter1327 != this->part_vals.end(); ++_iter1327) { - xfer += oprot->writeString((*_iter1323)); + xfer += oprot->writeString((*_iter1327)); } xfer += oprot->writeListEnd(); } @@ -20482,10 +20482,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 _iter1324; - for (_iter1324 = (*(this->part_vals)).begin(); _iter1324 != (*(this->part_vals)).end(); ++_iter1324) + std::vector ::const_iterator _iter1328; + for (_iter1328 = (*(this->part_vals)).begin(); _iter1328 != (*(this->part_vals)).end(); ++_iter1328) { - xfer += oprot->writeString((*_iter1324)); + xfer += oprot->writeString((*_iter1328)); } xfer += oprot->writeListEnd(); } @@ -20960,14 +20960,14 @@ uint32_t ThriftHiveMetastore_partition_name_to_vals_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - 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) + uint32_t _size1329; + ::apache::thrift::protocol::TType _etype1332; + xfer += iprot->readListBegin(_etype1332, _size1329); + this->success.resize(_size1329); + uint32_t _i1333; + for (_i1333 = 0; _i1333 < _size1329; ++_i1333) { - xfer += iprot->readString(this->success[_i1329]); + xfer += iprot->readString(this->success[_i1333]); } xfer += iprot->readListEnd(); } @@ -21006,10 +21006,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 _iter1330; - for (_iter1330 = this->success.begin(); _iter1330 != this->success.end(); ++_iter1330) + std::vector ::const_iterator _iter1334; + for (_iter1334 = this->success.begin(); _iter1334 != this->success.end(); ++_iter1334) { - xfer += oprot->writeString((*_iter1330)); + xfer += oprot->writeString((*_iter1334)); } xfer += oprot->writeListEnd(); } @@ -21054,14 +21054,14 @@ uint32_t ThriftHiveMetastore_partition_name_to_vals_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1331; - ::apache::thrift::protocol::TType _etype1334; - xfer += iprot->readListBegin(_etype1334, _size1331); - (*(this->success)).resize(_size1331); - uint32_t _i1335; - for (_i1335 = 0; _i1335 < _size1331; ++_i1335) + uint32_t _size1335; + ::apache::thrift::protocol::TType _etype1338; + xfer += iprot->readListBegin(_etype1338, _size1335); + (*(this->success)).resize(_size1335); + uint32_t _i1339; + for (_i1339 = 0; _i1339 < _size1335; ++_i1339) { - xfer += iprot->readString((*(this->success))[_i1335]); + xfer += iprot->readString((*(this->success))[_i1339]); } xfer += iprot->readListEnd(); } @@ -21199,17 +21199,17 @@ uint32_t ThriftHiveMetastore_partition_name_to_spec_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_MAP) { { this->success.clear(); - uint32_t _size1336; - ::apache::thrift::protocol::TType _ktype1337; - ::apache::thrift::protocol::TType _vtype1338; - xfer += iprot->readMapBegin(_ktype1337, _vtype1338, _size1336); - uint32_t _i1340; - for (_i1340 = 0; _i1340 < _size1336; ++_i1340) + uint32_t _size1340; + ::apache::thrift::protocol::TType _ktype1341; + ::apache::thrift::protocol::TType _vtype1342; + xfer += iprot->readMapBegin(_ktype1341, _vtype1342, _size1340); + uint32_t _i1344; + for (_i1344 = 0; _i1344 < _size1340; ++_i1344) { - std::string _key1341; - xfer += iprot->readString(_key1341); - std::string& _val1342 = this->success[_key1341]; - xfer += iprot->readString(_val1342); + std::string _key1345; + xfer += iprot->readString(_key1345); + std::string& _val1346 = this->success[_key1345]; + xfer += iprot->readString(_val1346); } xfer += iprot->readMapEnd(); } @@ -21248,11 +21248,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 _iter1343; - for (_iter1343 = this->success.begin(); _iter1343 != this->success.end(); ++_iter1343) + std::map ::const_iterator _iter1347; + for (_iter1347 = this->success.begin(); _iter1347 != this->success.end(); ++_iter1347) { - xfer += oprot->writeString(_iter1343->first); - xfer += oprot->writeString(_iter1343->second); + xfer += oprot->writeString(_iter1347->first); + xfer += oprot->writeString(_iter1347->second); } xfer += oprot->writeMapEnd(); } @@ -21297,17 +21297,17 @@ uint32_t ThriftHiveMetastore_partition_name_to_spec_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_MAP) { { (*(this->success)).clear(); - uint32_t _size1344; - ::apache::thrift::protocol::TType _ktype1345; - ::apache::thrift::protocol::TType _vtype1346; - xfer += iprot->readMapBegin(_ktype1345, _vtype1346, _size1344); - uint32_t _i1348; - for (_i1348 = 0; _i1348 < _size1344; ++_i1348) + uint32_t _size1348; + ::apache::thrift::protocol::TType _ktype1349; + ::apache::thrift::protocol::TType _vtype1350; + xfer += iprot->readMapBegin(_ktype1349, _vtype1350, _size1348); + uint32_t _i1352; + for (_i1352 = 0; _i1352 < _size1348; ++_i1352) { - std::string _key1349; - xfer += iprot->readString(_key1349); - std::string& _val1350 = (*(this->success))[_key1349]; - xfer += iprot->readString(_val1350); + std::string _key1353; + xfer += iprot->readString(_key1353); + std::string& _val1354 = (*(this->success))[_key1353]; + xfer += iprot->readString(_val1354); } xfer += iprot->readMapEnd(); } @@ -21382,17 +21382,17 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_args::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_MAP) { { this->part_vals.clear(); - uint32_t _size1351; - ::apache::thrift::protocol::TType _ktype1352; - ::apache::thrift::protocol::TType _vtype1353; - xfer += iprot->readMapBegin(_ktype1352, _vtype1353, _size1351); - uint32_t _i1355; - for (_i1355 = 0; _i1355 < _size1351; ++_i1355) + uint32_t _size1355; + ::apache::thrift::protocol::TType _ktype1356; + ::apache::thrift::protocol::TType _vtype1357; + xfer += iprot->readMapBegin(_ktype1356, _vtype1357, _size1355); + uint32_t _i1359; + for (_i1359 = 0; _i1359 < _size1355; ++_i1359) { - std::string _key1356; - xfer += iprot->readString(_key1356); - std::string& _val1357 = this->part_vals[_key1356]; - xfer += iprot->readString(_val1357); + std::string _key1360; + xfer += iprot->readString(_key1360); + std::string& _val1361 = this->part_vals[_key1360]; + xfer += iprot->readString(_val1361); } xfer += iprot->readMapEnd(); } @@ -21403,9 +21403,9 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_args::read(::apache::thrift:: break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1358; - xfer += iprot->readI32(ecast1358); - this->eventType = (PartitionEventType::type)ecast1358; + int32_t ecast1362; + xfer += iprot->readI32(ecast1362); + this->eventType = (PartitionEventType::type)ecast1362; this->__isset.eventType = true; } else { xfer += iprot->skip(ftype); @@ -21439,11 +21439,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 _iter1359; - for (_iter1359 = this->part_vals.begin(); _iter1359 != this->part_vals.end(); ++_iter1359) + std::map ::const_iterator _iter1363; + for (_iter1363 = this->part_vals.begin(); _iter1363 != this->part_vals.end(); ++_iter1363) { - xfer += oprot->writeString(_iter1359->first); - xfer += oprot->writeString(_iter1359->second); + xfer += oprot->writeString(_iter1363->first); + xfer += oprot->writeString(_iter1363->second); } xfer += oprot->writeMapEnd(); } @@ -21479,11 +21479,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 _iter1360; - for (_iter1360 = (*(this->part_vals)).begin(); _iter1360 != (*(this->part_vals)).end(); ++_iter1360) + std::map ::const_iterator _iter1364; + for (_iter1364 = (*(this->part_vals)).begin(); _iter1364 != (*(this->part_vals)).end(); ++_iter1364) { - xfer += oprot->writeString(_iter1360->first); - xfer += oprot->writeString(_iter1360->second); + xfer += oprot->writeString(_iter1364->first); + xfer += oprot->writeString(_iter1364->second); } xfer += oprot->writeMapEnd(); } @@ -21752,17 +21752,17 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_MAP) { { this->part_vals.clear(); - uint32_t _size1361; - ::apache::thrift::protocol::TType _ktype1362; - ::apache::thrift::protocol::TType _vtype1363; - xfer += iprot->readMapBegin(_ktype1362, _vtype1363, _size1361); - uint32_t _i1365; - for (_i1365 = 0; _i1365 < _size1361; ++_i1365) + uint32_t _size1365; + ::apache::thrift::protocol::TType _ktype1366; + ::apache::thrift::protocol::TType _vtype1367; + xfer += iprot->readMapBegin(_ktype1366, _vtype1367, _size1365); + uint32_t _i1369; + for (_i1369 = 0; _i1369 < _size1365; ++_i1369) { - std::string _key1366; - xfer += iprot->readString(_key1366); - std::string& _val1367 = this->part_vals[_key1366]; - xfer += iprot->readString(_val1367); + std::string _key1370; + xfer += iprot->readString(_key1370); + std::string& _val1371 = this->part_vals[_key1370]; + xfer += iprot->readString(_val1371); } xfer += iprot->readMapEnd(); } @@ -21773,9 +21773,9 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::read(::apache::thri break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1368; - xfer += iprot->readI32(ecast1368); - this->eventType = (PartitionEventType::type)ecast1368; + int32_t ecast1372; + xfer += iprot->readI32(ecast1372); + this->eventType = (PartitionEventType::type)ecast1372; this->__isset.eventType = true; } else { xfer += iprot->skip(ftype); @@ -21809,11 +21809,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 _iter1369; - for (_iter1369 = this->part_vals.begin(); _iter1369 != this->part_vals.end(); ++_iter1369) + std::map ::const_iterator _iter1373; + for (_iter1373 = this->part_vals.begin(); _iter1373 != this->part_vals.end(); ++_iter1373) { - xfer += oprot->writeString(_iter1369->first); - xfer += oprot->writeString(_iter1369->second); + xfer += oprot->writeString(_iter1373->first); + xfer += oprot->writeString(_iter1373->second); } xfer += oprot->writeMapEnd(); } @@ -21849,11 +21849,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 _iter1370; - for (_iter1370 = (*(this->part_vals)).begin(); _iter1370 != (*(this->part_vals)).end(); ++_iter1370) + std::map ::const_iterator _iter1374; + for (_iter1374 = (*(this->part_vals)).begin(); _iter1374 != (*(this->part_vals)).end(); ++_iter1374) { - xfer += oprot->writeString(_iter1370->first); - xfer += oprot->writeString(_iter1370->second); + xfer += oprot->writeString(_iter1374->first); + xfer += oprot->writeString(_iter1374->second); } xfer += oprot->writeMapEnd(); } @@ -23289,14 +23289,14 @@ uint32_t ThriftHiveMetastore_get_indexes_result::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 _size1375; + ::apache::thrift::protocol::TType _etype1378; + xfer += iprot->readListBegin(_etype1378, _size1375); + this->success.resize(_size1375); + uint32_t _i1379; + for (_i1379 = 0; _i1379 < _size1375; ++_i1379) { - xfer += this->success[_i1375].read(iprot); + xfer += this->success[_i1379].read(iprot); } xfer += iprot->readListEnd(); } @@ -23343,10 +23343,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 _iter1376; - for (_iter1376 = this->success.begin(); _iter1376 != this->success.end(); ++_iter1376) + std::vector ::const_iterator _iter1380; + for (_iter1380 = this->success.begin(); _iter1380 != this->success.end(); ++_iter1380) { - xfer += (*_iter1376).write(oprot); + xfer += (*_iter1380).write(oprot); } xfer += oprot->writeListEnd(); } @@ -23395,14 +23395,14 @@ uint32_t ThriftHiveMetastore_get_indexes_presult::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1377; - ::apache::thrift::protocol::TType _etype1380; - xfer += iprot->readListBegin(_etype1380, _size1377); - (*(this->success)).resize(_size1377); - uint32_t _i1381; - for (_i1381 = 0; _i1381 < _size1377; ++_i1381) + uint32_t _size1381; + ::apache::thrift::protocol::TType _etype1384; + xfer += iprot->readListBegin(_etype1384, _size1381); + (*(this->success)).resize(_size1381); + uint32_t _i1385; + for (_i1385 = 0; _i1385 < _size1381; ++_i1385) { - xfer += (*(this->success))[_i1381].read(iprot); + xfer += (*(this->success))[_i1385].read(iprot); } xfer += iprot->readListEnd(); } @@ -23580,14 +23580,14 @@ uint32_t ThriftHiveMetastore_get_index_names_result::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1382; - ::apache::thrift::protocol::TType _etype1385; - xfer += iprot->readListBegin(_etype1385, _size1382); - this->success.resize(_size1382); - uint32_t _i1386; - for (_i1386 = 0; _i1386 < _size1382; ++_i1386) + 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 += iprot->readString(this->success[_i1386]); + xfer += iprot->readString(this->success[_i1390]); } xfer += iprot->readListEnd(); } @@ -23626,10 +23626,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 _iter1387; - for (_iter1387 = this->success.begin(); _iter1387 != this->success.end(); ++_iter1387) + std::vector ::const_iterator _iter1391; + for (_iter1391 = this->success.begin(); _iter1391 != this->success.end(); ++_iter1391) { - xfer += oprot->writeString((*_iter1387)); + xfer += oprot->writeString((*_iter1391)); } xfer += oprot->writeListEnd(); } @@ -23674,14 +23674,14 @@ uint32_t ThriftHiveMetastore_get_index_names_presult::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1388; - ::apache::thrift::protocol::TType _etype1391; - xfer += iprot->readListBegin(_etype1391, _size1388); - (*(this->success)).resize(_size1388); - uint32_t _i1392; - for (_i1392 = 0; _i1392 < _size1388; ++_i1392) + 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 += iprot->readString((*(this->success))[_i1392]); + xfer += iprot->readString((*(this->success))[_i1396]); } xfer += iprot->readListEnd(); } @@ -28162,14 +28162,14 @@ uint32_t ThriftHiveMetastore_get_functions_result::read(::apache::thrift::protoc if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1393; - ::apache::thrift::protocol::TType _etype1396; - xfer += iprot->readListBegin(_etype1396, _size1393); - this->success.resize(_size1393); - uint32_t _i1397; - for (_i1397 = 0; _i1397 < _size1393; ++_i1397) + uint32_t _size1397; + ::apache::thrift::protocol::TType _etype1400; + xfer += iprot->readListBegin(_etype1400, _size1397); + this->success.resize(_size1397); + uint32_t _i1401; + for (_i1401 = 0; _i1401 < _size1397; ++_i1401) { - xfer += iprot->readString(this->success[_i1397]); + xfer += iprot->readString(this->success[_i1401]); } xfer += iprot->readListEnd(); } @@ -28208,10 +28208,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 _iter1398; - for (_iter1398 = this->success.begin(); _iter1398 != this->success.end(); ++_iter1398) + std::vector ::const_iterator _iter1402; + for (_iter1402 = this->success.begin(); _iter1402 != this->success.end(); ++_iter1402) { - xfer += oprot->writeString((*_iter1398)); + xfer += oprot->writeString((*_iter1402)); } xfer += oprot->writeListEnd(); } @@ -28256,14 +28256,14 @@ uint32_t ThriftHiveMetastore_get_functions_presult::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1399; - ::apache::thrift::protocol::TType _etype1402; - xfer += iprot->readListBegin(_etype1402, _size1399); - (*(this->success)).resize(_size1399); - uint32_t _i1403; - for (_i1403 = 0; _i1403 < _size1399; ++_i1403) + uint32_t _size1403; + ::apache::thrift::protocol::TType _etype1406; + xfer += iprot->readListBegin(_etype1406, _size1403); + (*(this->success)).resize(_size1403); + uint32_t _i1407; + for (_i1407 = 0; _i1407 < _size1403; ++_i1407) { - xfer += iprot->readString((*(this->success))[_i1403]); + xfer += iprot->readString((*(this->success))[_i1407]); } xfer += iprot->readListEnd(); } @@ -29223,14 +29223,14 @@ uint32_t ThriftHiveMetastore_get_role_names_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - 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) + 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) { - xfer += iprot->readString(this->success[_i1408]); + xfer += iprot->readString(this->success[_i1412]); } xfer += iprot->readListEnd(); } @@ -29269,10 +29269,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 _iter1409; - for (_iter1409 = this->success.begin(); _iter1409 != this->success.end(); ++_iter1409) + std::vector ::const_iterator _iter1413; + for (_iter1413 = this->success.begin(); _iter1413 != this->success.end(); ++_iter1413) { - xfer += oprot->writeString((*_iter1409)); + xfer += oprot->writeString((*_iter1413)); } xfer += oprot->writeListEnd(); } @@ -29317,14 +29317,14 @@ uint32_t ThriftHiveMetastore_get_role_names_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - 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) + uint32_t _size1414; + ::apache::thrift::protocol::TType _etype1417; + xfer += iprot->readListBegin(_etype1417, _size1414); + (*(this->success)).resize(_size1414); + uint32_t _i1418; + for (_i1418 = 0; _i1418 < _size1414; ++_i1418) { - xfer += iprot->readString((*(this->success))[_i1414]); + xfer += iprot->readString((*(this->success))[_i1418]); } xfer += iprot->readListEnd(); } @@ -29397,9 +29397,9 @@ uint32_t ThriftHiveMetastore_grant_role_args::read(::apache::thrift::protocol::T break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1415; - xfer += iprot->readI32(ecast1415); - this->principal_type = (PrincipalType::type)ecast1415; + int32_t ecast1419; + xfer += iprot->readI32(ecast1419); + this->principal_type = (PrincipalType::type)ecast1419; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -29415,9 +29415,9 @@ uint32_t ThriftHiveMetastore_grant_role_args::read(::apache::thrift::protocol::T break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1416; - xfer += iprot->readI32(ecast1416); - this->grantorType = (PrincipalType::type)ecast1416; + int32_t ecast1420; + xfer += iprot->readI32(ecast1420); + this->grantorType = (PrincipalType::type)ecast1420; this->__isset.grantorType = true; } else { xfer += iprot->skip(ftype); @@ -29688,9 +29688,9 @@ uint32_t ThriftHiveMetastore_revoke_role_args::read(::apache::thrift::protocol:: break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1417; - xfer += iprot->readI32(ecast1417); - this->principal_type = (PrincipalType::type)ecast1417; + int32_t ecast1421; + xfer += iprot->readI32(ecast1421); + this->principal_type = (PrincipalType::type)ecast1421; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -29921,9 +29921,9 @@ uint32_t ThriftHiveMetastore_list_roles_args::read(::apache::thrift::protocol::T break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1418; - xfer += iprot->readI32(ecast1418); - this->principal_type = (PrincipalType::type)ecast1418; + int32_t ecast1422; + xfer += iprot->readI32(ecast1422); + this->principal_type = (PrincipalType::type)ecast1422; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -30012,14 +30012,14 @@ uint32_t ThriftHiveMetastore_list_roles_result::read(::apache::thrift::protocol: 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 _size1423; + ::apache::thrift::protocol::TType _etype1426; + xfer += iprot->readListBegin(_etype1426, _size1423); + this->success.resize(_size1423); + uint32_t _i1427; + for (_i1427 = 0; _i1427 < _size1423; ++_i1427) { - xfer += this->success[_i1423].read(iprot); + xfer += this->success[_i1427].read(iprot); } xfer += iprot->readListEnd(); } @@ -30058,10 +30058,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 _iter1424; - for (_iter1424 = this->success.begin(); _iter1424 != this->success.end(); ++_iter1424) + std::vector ::const_iterator _iter1428; + for (_iter1428 = this->success.begin(); _iter1428 != this->success.end(); ++_iter1428) { - xfer += (*_iter1424).write(oprot); + xfer += (*_iter1428).write(oprot); } xfer += oprot->writeListEnd(); } @@ -30106,14 +30106,14 @@ uint32_t ThriftHiveMetastore_list_roles_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1425; - ::apache::thrift::protocol::TType _etype1428; - xfer += iprot->readListBegin(_etype1428, _size1425); - (*(this->success)).resize(_size1425); - uint32_t _i1429; - for (_i1429 = 0; _i1429 < _size1425; ++_i1429) + uint32_t _size1429; + ::apache::thrift::protocol::TType _etype1432; + xfer += iprot->readListBegin(_etype1432, _size1429); + (*(this->success)).resize(_size1429); + uint32_t _i1433; + for (_i1433 = 0; _i1433 < _size1429; ++_i1433) { - xfer += (*(this->success))[_i1429].read(iprot); + xfer += (*(this->success))[_i1433].read(iprot); } xfer += iprot->readListEnd(); } @@ -30809,14 +30809,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 _size1430; - ::apache::thrift::protocol::TType _etype1433; - xfer += iprot->readListBegin(_etype1433, _size1430); - this->group_names.resize(_size1430); - uint32_t _i1434; - for (_i1434 = 0; _i1434 < _size1430; ++_i1434) + uint32_t _size1434; + ::apache::thrift::protocol::TType _etype1437; + xfer += iprot->readListBegin(_etype1437, _size1434); + this->group_names.resize(_size1434); + uint32_t _i1438; + for (_i1438 = 0; _i1438 < _size1434; ++_i1438) { - xfer += iprot->readString(this->group_names[_i1434]); + xfer += iprot->readString(this->group_names[_i1438]); } xfer += iprot->readListEnd(); } @@ -30853,10 +30853,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 _iter1435; - for (_iter1435 = this->group_names.begin(); _iter1435 != this->group_names.end(); ++_iter1435) + std::vector ::const_iterator _iter1439; + for (_iter1439 = this->group_names.begin(); _iter1439 != this->group_names.end(); ++_iter1439) { - xfer += oprot->writeString((*_iter1435)); + xfer += oprot->writeString((*_iter1439)); } xfer += oprot->writeListEnd(); } @@ -30888,10 +30888,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 _iter1436; - for (_iter1436 = (*(this->group_names)).begin(); _iter1436 != (*(this->group_names)).end(); ++_iter1436) + std::vector ::const_iterator _iter1440; + for (_iter1440 = (*(this->group_names)).begin(); _iter1440 != (*(this->group_names)).end(); ++_iter1440) { - xfer += oprot->writeString((*_iter1436)); + xfer += oprot->writeString((*_iter1440)); } xfer += oprot->writeListEnd(); } @@ -31066,9 +31066,9 @@ uint32_t ThriftHiveMetastore_list_privileges_args::read(::apache::thrift::protoc break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1437; - xfer += iprot->readI32(ecast1437); - this->principal_type = (PrincipalType::type)ecast1437; + int32_t ecast1441; + xfer += iprot->readI32(ecast1441); + this->principal_type = (PrincipalType::type)ecast1441; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -31173,14 +31173,14 @@ uint32_t ThriftHiveMetastore_list_privileges_result::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1438; - ::apache::thrift::protocol::TType _etype1441; - xfer += iprot->readListBegin(_etype1441, _size1438); - this->success.resize(_size1438); - uint32_t _i1442; - for (_i1442 = 0; _i1442 < _size1438; ++_i1442) + uint32_t _size1442; + ::apache::thrift::protocol::TType _etype1445; + xfer += iprot->readListBegin(_etype1445, _size1442); + this->success.resize(_size1442); + uint32_t _i1446; + for (_i1446 = 0; _i1446 < _size1442; ++_i1446) { - xfer += this->success[_i1442].read(iprot); + xfer += this->success[_i1446].read(iprot); } xfer += iprot->readListEnd(); } @@ -31219,10 +31219,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 _iter1443; - for (_iter1443 = this->success.begin(); _iter1443 != this->success.end(); ++_iter1443) + std::vector ::const_iterator _iter1447; + for (_iter1447 = this->success.begin(); _iter1447 != this->success.end(); ++_iter1447) { - xfer += (*_iter1443).write(oprot); + xfer += (*_iter1447).write(oprot); } xfer += oprot->writeListEnd(); } @@ -31267,14 +31267,14 @@ uint32_t ThriftHiveMetastore_list_privileges_presult::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1444; - ::apache::thrift::protocol::TType _etype1447; - xfer += iprot->readListBegin(_etype1447, _size1444); - (*(this->success)).resize(_size1444); - uint32_t _i1448; - for (_i1448 = 0; _i1448 < _size1444; ++_i1448) + uint32_t _size1448; + ::apache::thrift::protocol::TType _etype1451; + xfer += iprot->readListBegin(_etype1451, _size1448); + (*(this->success)).resize(_size1448); + uint32_t _i1452; + for (_i1452 = 0; _i1452 < _size1448; ++_i1452) { - xfer += (*(this->success))[_i1448].read(iprot); + xfer += (*(this->success))[_i1452].read(iprot); } xfer += iprot->readListEnd(); } @@ -31962,14 +31962,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 _size1449; - ::apache::thrift::protocol::TType _etype1452; - xfer += iprot->readListBegin(_etype1452, _size1449); - this->group_names.resize(_size1449); - uint32_t _i1453; - for (_i1453 = 0; _i1453 < _size1449; ++_i1453) + uint32_t _size1453; + ::apache::thrift::protocol::TType _etype1456; + xfer += iprot->readListBegin(_etype1456, _size1453); + this->group_names.resize(_size1453); + uint32_t _i1457; + for (_i1457 = 0; _i1457 < _size1453; ++_i1457) { - xfer += iprot->readString(this->group_names[_i1453]); + xfer += iprot->readString(this->group_names[_i1457]); } xfer += iprot->readListEnd(); } @@ -32002,10 +32002,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 _iter1454; - for (_iter1454 = this->group_names.begin(); _iter1454 != this->group_names.end(); ++_iter1454) + std::vector ::const_iterator _iter1458; + for (_iter1458 = this->group_names.begin(); _iter1458 != this->group_names.end(); ++_iter1458) { - xfer += oprot->writeString((*_iter1454)); + xfer += oprot->writeString((*_iter1458)); } xfer += oprot->writeListEnd(); } @@ -32033,10 +32033,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 _iter1455; - for (_iter1455 = (*(this->group_names)).begin(); _iter1455 != (*(this->group_names)).end(); ++_iter1455) + std::vector ::const_iterator _iter1459; + for (_iter1459 = (*(this->group_names)).begin(); _iter1459 != (*(this->group_names)).end(); ++_iter1459) { - xfer += oprot->writeString((*_iter1455)); + xfer += oprot->writeString((*_iter1459)); } xfer += oprot->writeListEnd(); } @@ -32077,14 +32077,14 @@ uint32_t ThriftHiveMetastore_set_ugi_result::read(::apache::thrift::protocol::TP if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1456; - ::apache::thrift::protocol::TType _etype1459; - xfer += iprot->readListBegin(_etype1459, _size1456); - this->success.resize(_size1456); - uint32_t _i1460; - for (_i1460 = 0; _i1460 < _size1456; ++_i1460) + uint32_t _size1460; + ::apache::thrift::protocol::TType _etype1463; + xfer += iprot->readListBegin(_etype1463, _size1460); + this->success.resize(_size1460); + uint32_t _i1464; + for (_i1464 = 0; _i1464 < _size1460; ++_i1464) { - xfer += iprot->readString(this->success[_i1460]); + xfer += iprot->readString(this->success[_i1464]); } xfer += iprot->readListEnd(); } @@ -32123,10 +32123,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 _iter1461; - for (_iter1461 = this->success.begin(); _iter1461 != this->success.end(); ++_iter1461) + std::vector ::const_iterator _iter1465; + for (_iter1465 = this->success.begin(); _iter1465 != this->success.end(); ++_iter1465) { - xfer += oprot->writeString((*_iter1461)); + xfer += oprot->writeString((*_iter1465)); } xfer += oprot->writeListEnd(); } @@ -32171,14 +32171,14 @@ uint32_t ThriftHiveMetastore_set_ugi_presult::read(::apache::thrift::protocol::T if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1462; - ::apache::thrift::protocol::TType _etype1465; - xfer += iprot->readListBegin(_etype1465, _size1462); - (*(this->success)).resize(_size1462); - uint32_t _i1466; - for (_i1466 = 0; _i1466 < _size1462; ++_i1466) + uint32_t _size1466; + ::apache::thrift::protocol::TType _etype1469; + xfer += iprot->readListBegin(_etype1469, _size1466); + (*(this->success)).resize(_size1466); + uint32_t _i1470; + for (_i1470 = 0; _i1470 < _size1466; ++_i1470) { - xfer += iprot->readString((*(this->success))[_i1466]); + xfer += iprot->readString((*(this->success))[_i1470]); } xfer += iprot->readListEnd(); } @@ -33489,14 +33489,14 @@ uint32_t ThriftHiveMetastore_get_all_token_identifiers_result::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1467; - ::apache::thrift::protocol::TType _etype1470; - xfer += iprot->readListBegin(_etype1470, _size1467); - this->success.resize(_size1467); - uint32_t _i1471; - for (_i1471 = 0; _i1471 < _size1467; ++_i1471) + uint32_t _size1471; + ::apache::thrift::protocol::TType _etype1474; + xfer += iprot->readListBegin(_etype1474, _size1471); + this->success.resize(_size1471); + uint32_t _i1475; + for (_i1475 = 0; _i1475 < _size1471; ++_i1475) { - xfer += iprot->readString(this->success[_i1471]); + xfer += iprot->readString(this->success[_i1475]); } xfer += iprot->readListEnd(); } @@ -33527,10 +33527,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 _iter1472; - for (_iter1472 = this->success.begin(); _iter1472 != this->success.end(); ++_iter1472) + std::vector ::const_iterator _iter1476; + for (_iter1476 = this->success.begin(); _iter1476 != this->success.end(); ++_iter1476) { - xfer += oprot->writeString((*_iter1472)); + xfer += oprot->writeString((*_iter1476)); } xfer += oprot->writeListEnd(); } @@ -33571,14 +33571,14 @@ uint32_t ThriftHiveMetastore_get_all_token_identifiers_presult::read(::apache::t if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1473; - ::apache::thrift::protocol::TType _etype1476; - xfer += iprot->readListBegin(_etype1476, _size1473); - (*(this->success)).resize(_size1473); - uint32_t _i1477; - for (_i1477 = 0; _i1477 < _size1473; ++_i1477) + uint32_t _size1477; + ::apache::thrift::protocol::TType _etype1480; + xfer += iprot->readListBegin(_etype1480, _size1477); + (*(this->success)).resize(_size1477); + uint32_t _i1481; + for (_i1481 = 0; _i1481 < _size1477; ++_i1481) { - xfer += iprot->readString((*(this->success))[_i1477]); + xfer += iprot->readString((*(this->success))[_i1481]); } xfer += iprot->readListEnd(); } @@ -34304,14 +34304,14 @@ uint32_t ThriftHiveMetastore_get_master_keys_result::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1478; - ::apache::thrift::protocol::TType _etype1481; - xfer += iprot->readListBegin(_etype1481, _size1478); - this->success.resize(_size1478); - uint32_t _i1482; - for (_i1482 = 0; _i1482 < _size1478; ++_i1482) + uint32_t _size1482; + ::apache::thrift::protocol::TType _etype1485; + xfer += iprot->readListBegin(_etype1485, _size1482); + this->success.resize(_size1482); + uint32_t _i1486; + for (_i1486 = 0; _i1486 < _size1482; ++_i1486) { - xfer += iprot->readString(this->success[_i1482]); + xfer += iprot->readString(this->success[_i1486]); } xfer += iprot->readListEnd(); } @@ -34342,10 +34342,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 _iter1483; - for (_iter1483 = this->success.begin(); _iter1483 != this->success.end(); ++_iter1483) + std::vector ::const_iterator _iter1487; + for (_iter1487 = this->success.begin(); _iter1487 != this->success.end(); ++_iter1487) { - xfer += oprot->writeString((*_iter1483)); + xfer += oprot->writeString((*_iter1487)); } xfer += oprot->writeListEnd(); } @@ -34386,14 +34386,14 @@ uint32_t ThriftHiveMetastore_get_master_keys_presult::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1484; - ::apache::thrift::protocol::TType _etype1487; - xfer += iprot->readListBegin(_etype1487, _size1484); - (*(this->success)).resize(_size1484); - uint32_t _i1488; - for (_i1488 = 0; _i1488 < _size1484; ++_i1488) + uint32_t _size1488; + ::apache::thrift::protocol::TType _etype1491; + xfer += iprot->readListBegin(_etype1491, _size1488); + (*(this->success)).resize(_size1488); + uint32_t _i1492; + for (_i1492 = 0; _i1492 < _size1488; ++_i1492) { - xfer += iprot->readString((*(this->success))[_i1488]); + xfer += iprot->readString((*(this->success))[_i1492]); } xfer += iprot->readListEnd(); } @@ -38209,6 +38209,213 @@ uint32_t ThriftHiveMetastore_flushCache_presult::read(::apache::thrift::protocol } +ThriftHiveMetastore_cm_recycle_args::~ThriftHiveMetastore_cm_recycle_args() throw() { +} + + +uint32_t ThriftHiveMetastore_cm_recycle_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_cm_recycle_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_cm_recycle_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_cm_recycle_pargs::~ThriftHiveMetastore_cm_recycle_pargs() throw() { +} + + +uint32_t ThriftHiveMetastore_cm_recycle_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_cm_recycle_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_cm_recycle_result::~ThriftHiveMetastore_cm_recycle_result() throw() { +} + + +uint32_t ThriftHiveMetastore_cm_recycle_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->success.read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_cm_recycle_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_cm_recycle_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_cm_recycle_presult::~ThriftHiveMetastore_cm_recycle_presult() throw() { +} + + +uint32_t ThriftHiveMetastore_cm_recycle_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += (*(this->success)).read(iprot); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + ThriftHiveMetastore_get_file_metadata_by_expr_args::~ThriftHiveMetastore_get_file_metadata_by_expr_args() throw() { } @@ -49032,6 +49239,67 @@ void ThriftHiveMetastoreClient::recv_flushCache() return; } +void ThriftHiveMetastoreClient::cm_recycle(CmRecycleResponse& _return, const CmRecycleRequest& request) +{ + send_cm_recycle(request); + recv_cm_recycle(_return); +} + +void ThriftHiveMetastoreClient::send_cm_recycle(const CmRecycleRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("cm_recycle", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_cm_recycle_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_cm_recycle(CmRecycleResponse& _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("cm_recycle") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_cm_recycle_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, "cm_recycle failed: unknown result"); +} + void ThriftHiveMetastoreClient::get_file_metadata_by_expr(GetFileMetadataByExprResult& _return, const GetFileMetadataByExprRequest& req) { send_get_file_metadata_by_expr(req); @@ -58468,6 +58736,63 @@ void ThriftHiveMetastoreProcessor::process_flushCache(int32_t seqid, ::apache::t } } +void ThriftHiveMetastoreProcessor::process_cm_recycle(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.cm_recycle", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.cm_recycle"); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.cm_recycle"); + } + + ThriftHiveMetastore_cm_recycle_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.cm_recycle", bytes); + } + + ThriftHiveMetastore_cm_recycle_result result; + try { + iface_->cm_recycle(result.success, args.request); + 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.cm_recycle"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("cm_recycle", ::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.cm_recycle"); + } + + oprot->writeMessageBegin("cm_recycle", ::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.cm_recycle", bytes); + } +} + void ThriftHiveMetastoreProcessor::process_get_file_metadata_by_expr(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) { void* ctx = NULL; @@ -72729,6 +73054,94 @@ void ThriftHiveMetastoreConcurrentClient::recv_flushCache(const int32_t seqid) } // end while(true) } +void ThriftHiveMetastoreConcurrentClient::cm_recycle(CmRecycleResponse& _return, const CmRecycleRequest& request) +{ + int32_t seqid = send_cm_recycle(request); + recv_cm_recycle(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_cm_recycle(const CmRecycleRequest& request) +{ + int32_t cseqid = this->sync_.generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); + oprot_->writeMessageBegin("cm_recycle", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_cm_recycle_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_cm_recycle(CmRecycleResponse& _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(&this->sync_, seqid); + + while(true) { + if(!this->sync_.getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("cm_recycle") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_cm_recycle_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + 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, "cm_recycle failed: unknown result"); + } + // seqid != rseqid + this->sync_.updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_.waitForWork(seqid); + } // end while(true) +} + void ThriftHiveMetastoreConcurrentClient::get_file_metadata_by_expr(GetFileMetadataByExprResult& _return, const GetFileMetadataByExprRequest& req) { int32_t seqid = send_get_file_metadata_by_expr(req); diff --git a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h index 47d9f1d..8406b42 100644 --- a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h +++ b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h @@ -175,6 +175,7 @@ class ThriftHiveMetastoreIf : virtual public ::facebook::fb303::FacebookService virtual void get_current_notificationEventId(CurrentNotificationEventId& _return) = 0; virtual void fire_listener_event(FireEventResponse& _return, const FireEventRequest& rqst) = 0; virtual void flushCache() = 0; + virtual void cm_recycle(CmRecycleResponse& _return, const CmRecycleRequest& request) = 0; virtual void get_file_metadata_by_expr(GetFileMetadataByExprResult& _return, const GetFileMetadataByExprRequest& req) = 0; virtual void get_file_metadata(GetFileMetadataResult& _return, const GetFileMetadataRequest& req) = 0; virtual void put_file_metadata(PutFileMetadataResult& _return, const PutFileMetadataRequest& req) = 0; @@ -697,6 +698,9 @@ class ThriftHiveMetastoreNull : virtual public ThriftHiveMetastoreIf , virtual p void flushCache() { return; } + void cm_recycle(CmRecycleResponse& /* _return */, const CmRecycleRequest& /* request */) { + return; + } void get_file_metadata_by_expr(GetFileMetadataByExprResult& /* _return */, const GetFileMetadataByExprRequest& /* req */) { return; } @@ -19701,6 +19705,118 @@ class ThriftHiveMetastore_flushCache_presult { }; +typedef struct _ThriftHiveMetastore_cm_recycle_args__isset { + _ThriftHiveMetastore_cm_recycle_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_cm_recycle_args__isset; + +class ThriftHiveMetastore_cm_recycle_args { + public: + + ThriftHiveMetastore_cm_recycle_args(const ThriftHiveMetastore_cm_recycle_args&); + ThriftHiveMetastore_cm_recycle_args& operator=(const ThriftHiveMetastore_cm_recycle_args&); + ThriftHiveMetastore_cm_recycle_args() { + } + + virtual ~ThriftHiveMetastore_cm_recycle_args() throw(); + CmRecycleRequest request; + + _ThriftHiveMetastore_cm_recycle_args__isset __isset; + + void __set_request(const CmRecycleRequest& val); + + bool operator == (const ThriftHiveMetastore_cm_recycle_args & rhs) const + { + if (!(request == rhs.request)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_cm_recycle_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_cm_recycle_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_cm_recycle_pargs { + public: + + + virtual ~ThriftHiveMetastore_cm_recycle_pargs() throw(); + const CmRecycleRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_cm_recycle_result__isset { + _ThriftHiveMetastore_cm_recycle_result__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_cm_recycle_result__isset; + +class ThriftHiveMetastore_cm_recycle_result { + public: + + ThriftHiveMetastore_cm_recycle_result(const ThriftHiveMetastore_cm_recycle_result&); + ThriftHiveMetastore_cm_recycle_result& operator=(const ThriftHiveMetastore_cm_recycle_result&); + ThriftHiveMetastore_cm_recycle_result() { + } + + virtual ~ThriftHiveMetastore_cm_recycle_result() throw(); + CmRecycleResponse success; + MetaException o1; + + _ThriftHiveMetastore_cm_recycle_result__isset __isset; + + void __set_success(const CmRecycleResponse& val); + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_cm_recycle_result & rhs) const + { + if (!(success == rhs.success)) + return false; + if (!(o1 == rhs.o1)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_cm_recycle_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_cm_recycle_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_cm_recycle_presult__isset { + _ThriftHiveMetastore_cm_recycle_presult__isset() : success(false), o1(false) {} + bool success :1; + bool o1 :1; +} _ThriftHiveMetastore_cm_recycle_presult__isset; + +class ThriftHiveMetastore_cm_recycle_presult { + public: + + + virtual ~ThriftHiveMetastore_cm_recycle_presult() throw(); + CmRecycleResponse* success; + MetaException o1; + + _ThriftHiveMetastore_cm_recycle_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + typedef struct _ThriftHiveMetastore_get_file_metadata_by_expr_args__isset { _ThriftHiveMetastore_get_file_metadata_by_expr_args__isset() : req(false) {} bool req :1; @@ -20791,6 +20907,9 @@ class ThriftHiveMetastoreClient : virtual public ThriftHiveMetastoreIf, public void flushCache(); void send_flushCache(); void recv_flushCache(); + void cm_recycle(CmRecycleResponse& _return, const CmRecycleRequest& request); + void send_cm_recycle(const CmRecycleRequest& request); + void recv_cm_recycle(CmRecycleResponse& _return); void get_file_metadata_by_expr(GetFileMetadataByExprResult& _return, const GetFileMetadataByExprRequest& req); void send_get_file_metadata_by_expr(const GetFileMetadataByExprRequest& req); void recv_get_file_metadata_by_expr(GetFileMetadataByExprResult& _return); @@ -20972,6 +21091,7 @@ class ThriftHiveMetastoreProcessor : public ::facebook::fb303::FacebookServiceP void process_get_current_notificationEventId(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_fire_listener_event(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_flushCache(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_cm_recycle(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_get_file_metadata_by_expr(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_get_file_metadata(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_put_file_metadata(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); @@ -21135,6 +21255,7 @@ class ThriftHiveMetastoreProcessor : public ::facebook::fb303::FacebookServiceP processMap_["get_current_notificationEventId"] = &ThriftHiveMetastoreProcessor::process_get_current_notificationEventId; processMap_["fire_listener_event"] = &ThriftHiveMetastoreProcessor::process_fire_listener_event; processMap_["flushCache"] = &ThriftHiveMetastoreProcessor::process_flushCache; + processMap_["cm_recycle"] = &ThriftHiveMetastoreProcessor::process_cm_recycle; processMap_["get_file_metadata_by_expr"] = &ThriftHiveMetastoreProcessor::process_get_file_metadata_by_expr; processMap_["get_file_metadata"] = &ThriftHiveMetastoreProcessor::process_get_file_metadata; processMap_["put_file_metadata"] = &ThriftHiveMetastoreProcessor::process_put_file_metadata; @@ -22638,6 +22759,16 @@ class ThriftHiveMetastoreMultiface : virtual public ThriftHiveMetastoreIf, publi ifaces_[i]->flushCache(); } + void cm_recycle(CmRecycleResponse& _return, const CmRecycleRequest& request) { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->cm_recycle(_return, request); + } + ifaces_[i]->cm_recycle(_return, request); + return; + } + void get_file_metadata_by_expr(GetFileMetadataByExprResult& _return, const GetFileMetadataByExprRequest& req) { size_t sz = ifaces_.size(); size_t i = 0; @@ -23173,6 +23304,9 @@ class ThriftHiveMetastoreConcurrentClient : virtual public ThriftHiveMetastoreIf void flushCache(); int32_t send_flushCache(); void recv_flushCache(const int32_t seqid); + void cm_recycle(CmRecycleResponse& _return, const CmRecycleRequest& request); + int32_t send_cm_recycle(const CmRecycleRequest& request); + void recv_cm_recycle(CmRecycleResponse& _return, const int32_t seqid); void get_file_metadata_by_expr(GetFileMetadataByExprResult& _return, const GetFileMetadataByExprRequest& req); int32_t send_get_file_metadata_by_expr(const GetFileMetadataByExprRequest& req); void recv_get_file_metadata_by_expr(GetFileMetadataByExprResult& _return, const int32_t seqid); diff --git a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp index 28f9af9..ec2071a 100644 --- a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp +++ b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp @@ -787,6 +787,11 @@ class ThriftHiveMetastoreHandler : virtual public ThriftHiveMetastoreIf { printf("flushCache\n"); } + void cm_recycle(CmRecycleResponse& _return, const CmRecycleRequest& request) { + // Your implementation goes here + printf("cm_recycle\n"); + } + void get_file_metadata_by_expr(GetFileMetadataByExprResult& _return, const GetFileMetadataByExprRequest& req) { // Your implementation goes here printf("get_file_metadata_by_expr\n"); diff --git a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp index 1e46ac4..d178f10 100644 --- a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp +++ b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp @@ -19740,6 +19740,177 @@ void GetTablesResult::printTo(std::ostream& out) const { } +CmRecycleRequest::~CmRecycleRequest() throw() { +} + + +void CmRecycleRequest::__set_dataPath(const std::string& val) { + this->dataPath = val; +} + +void CmRecycleRequest::__set_purge(const bool val) { + this->purge = val; +} + +uint32_t CmRecycleRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_dataPath = false; + bool isset_purge = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dataPath); + isset_dataPath = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->purge); + isset_purge = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_dataPath) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_purge) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t CmRecycleRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("CmRecycleRequest"); + + xfer += oprot->writeFieldBegin("dataPath", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dataPath); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("purge", ::apache::thrift::protocol::T_BOOL, 2); + xfer += oprot->writeBool(this->purge); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(CmRecycleRequest &a, CmRecycleRequest &b) { + using ::std::swap; + swap(a.dataPath, b.dataPath); + swap(a.purge, b.purge); +} + +CmRecycleRequest::CmRecycleRequest(const CmRecycleRequest& other823) { + dataPath = other823.dataPath; + purge = other823.purge; +} +CmRecycleRequest& CmRecycleRequest::operator=(const CmRecycleRequest& other824) { + dataPath = other824.dataPath; + purge = other824.purge; + return *this; +} +void CmRecycleRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "CmRecycleRequest("; + out << "dataPath=" << to_string(dataPath); + out << ", " << "purge=" << to_string(purge); + out << ")"; +} + + +CmRecycleResponse::~CmRecycleResponse() throw() { +} + + +uint32_t CmRecycleResponse::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 CmRecycleResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("CmRecycleResponse"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(CmRecycleResponse &a, CmRecycleResponse &b) { + using ::std::swap; + (void) a; + (void) b; +} + +CmRecycleResponse::CmRecycleResponse(const CmRecycleResponse& other825) { + (void) other825; +} +CmRecycleResponse& CmRecycleResponse::operator=(const CmRecycleResponse& other826) { + (void) other826; + return *this; +} +void CmRecycleResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "CmRecycleResponse("; + out << ")"; +} + + TableMeta::~TableMeta() throw() { } @@ -19871,19 +20042,19 @@ void swap(TableMeta &a, TableMeta &b) { swap(a.__isset, b.__isset); } -TableMeta::TableMeta(const TableMeta& other823) { - dbName = other823.dbName; - tableName = other823.tableName; - tableType = other823.tableType; - comments = other823.comments; - __isset = other823.__isset; +TableMeta::TableMeta(const TableMeta& other827) { + dbName = other827.dbName; + tableName = other827.tableName; + tableType = other827.tableType; + comments = other827.comments; + __isset = other827.__isset; } -TableMeta& TableMeta::operator=(const TableMeta& other824) { - dbName = other824.dbName; - tableName = other824.tableName; - tableType = other824.tableType; - comments = other824.comments; - __isset = other824.__isset; +TableMeta& TableMeta::operator=(const TableMeta& other828) { + dbName = other828.dbName; + tableName = other828.tableName; + tableType = other828.tableType; + comments = other828.comments; + __isset = other828.__isset; return *this; } void TableMeta::printTo(std::ostream& out) const { @@ -19966,13 +20137,13 @@ void swap(MetaException &a, MetaException &b) { swap(a.__isset, b.__isset); } -MetaException::MetaException(const MetaException& other825) : TException() { - message = other825.message; - __isset = other825.__isset; +MetaException::MetaException(const MetaException& other829) : TException() { + message = other829.message; + __isset = other829.__isset; } -MetaException& MetaException::operator=(const MetaException& other826) { - message = other826.message; - __isset = other826.__isset; +MetaException& MetaException::operator=(const MetaException& other830) { + message = other830.message; + __isset = other830.__isset; return *this; } void MetaException::printTo(std::ostream& out) const { @@ -20063,13 +20234,13 @@ void swap(UnknownTableException &a, UnknownTableException &b) { swap(a.__isset, b.__isset); } -UnknownTableException::UnknownTableException(const UnknownTableException& other827) : TException() { - message = other827.message; - __isset = other827.__isset; +UnknownTableException::UnknownTableException(const UnknownTableException& other831) : TException() { + message = other831.message; + __isset = other831.__isset; } -UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other828) { - message = other828.message; - __isset = other828.__isset; +UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other832) { + message = other832.message; + __isset = other832.__isset; return *this; } void UnknownTableException::printTo(std::ostream& out) const { @@ -20160,13 +20331,13 @@ void swap(UnknownDBException &a, UnknownDBException &b) { swap(a.__isset, b.__isset); } -UnknownDBException::UnknownDBException(const UnknownDBException& other829) : TException() { - message = other829.message; - __isset = other829.__isset; +UnknownDBException::UnknownDBException(const UnknownDBException& other833) : TException() { + message = other833.message; + __isset = other833.__isset; } -UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other830) { - message = other830.message; - __isset = other830.__isset; +UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other834) { + message = other834.message; + __isset = other834.__isset; return *this; } void UnknownDBException::printTo(std::ostream& out) const { @@ -20257,13 +20428,13 @@ void swap(AlreadyExistsException &a, AlreadyExistsException &b) { swap(a.__isset, b.__isset); } -AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other831) : TException() { - message = other831.message; - __isset = other831.__isset; +AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other835) : TException() { + message = other835.message; + __isset = other835.__isset; } -AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other832) { - message = other832.message; - __isset = other832.__isset; +AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other836) { + message = other836.message; + __isset = other836.__isset; return *this; } void AlreadyExistsException::printTo(std::ostream& out) const { @@ -20354,13 +20525,13 @@ void swap(InvalidPartitionException &a, InvalidPartitionException &b) { swap(a.__isset, b.__isset); } -InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other833) : TException() { - message = other833.message; - __isset = other833.__isset; +InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other837) : TException() { + message = other837.message; + __isset = other837.__isset; } -InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other834) { - message = other834.message; - __isset = other834.__isset; +InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other838) { + message = other838.message; + __isset = other838.__isset; return *this; } void InvalidPartitionException::printTo(std::ostream& out) const { @@ -20451,13 +20622,13 @@ void swap(UnknownPartitionException &a, UnknownPartitionException &b) { swap(a.__isset, b.__isset); } -UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other835) : TException() { - message = other835.message; - __isset = other835.__isset; +UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other839) : TException() { + message = other839.message; + __isset = other839.__isset; } -UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other836) { - message = other836.message; - __isset = other836.__isset; +UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other840) { + message = other840.message; + __isset = other840.__isset; return *this; } void UnknownPartitionException::printTo(std::ostream& out) const { @@ -20548,13 +20719,13 @@ void swap(InvalidObjectException &a, InvalidObjectException &b) { swap(a.__isset, b.__isset); } -InvalidObjectException::InvalidObjectException(const InvalidObjectException& other837) : TException() { - message = other837.message; - __isset = other837.__isset; +InvalidObjectException::InvalidObjectException(const InvalidObjectException& other841) : TException() { + message = other841.message; + __isset = other841.__isset; } -InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other838) { - message = other838.message; - __isset = other838.__isset; +InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other842) { + message = other842.message; + __isset = other842.__isset; return *this; } void InvalidObjectException::printTo(std::ostream& out) const { @@ -20645,13 +20816,13 @@ void swap(NoSuchObjectException &a, NoSuchObjectException &b) { swap(a.__isset, b.__isset); } -NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other839) : TException() { - message = other839.message; - __isset = other839.__isset; +NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other843) : TException() { + message = other843.message; + __isset = other843.__isset; } -NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other840) { - message = other840.message; - __isset = other840.__isset; +NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other844) { + message = other844.message; + __isset = other844.__isset; return *this; } void NoSuchObjectException::printTo(std::ostream& out) const { @@ -20742,13 +20913,13 @@ void swap(IndexAlreadyExistsException &a, IndexAlreadyExistsException &b) { swap(a.__isset, b.__isset); } -IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other841) : TException() { - message = other841.message; - __isset = other841.__isset; +IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other845) : TException() { + message = other845.message; + __isset = other845.__isset; } -IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other842) { - message = other842.message; - __isset = other842.__isset; +IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other846) { + message = other846.message; + __isset = other846.__isset; return *this; } void IndexAlreadyExistsException::printTo(std::ostream& out) const { @@ -20839,13 +21010,13 @@ void swap(InvalidOperationException &a, InvalidOperationException &b) { swap(a.__isset, b.__isset); } -InvalidOperationException::InvalidOperationException(const InvalidOperationException& other843) : TException() { - message = other843.message; - __isset = other843.__isset; +InvalidOperationException::InvalidOperationException(const InvalidOperationException& other847) : TException() { + message = other847.message; + __isset = other847.__isset; } -InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other844) { - message = other844.message; - __isset = other844.__isset; +InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other848) { + message = other848.message; + __isset = other848.__isset; return *this; } void InvalidOperationException::printTo(std::ostream& out) const { @@ -20936,13 +21107,13 @@ void swap(ConfigValSecurityException &a, ConfigValSecurityException &b) { swap(a.__isset, b.__isset); } -ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other845) : TException() { - message = other845.message; - __isset = other845.__isset; +ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other849) : TException() { + message = other849.message; + __isset = other849.__isset; } -ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other846) { - message = other846.message; - __isset = other846.__isset; +ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other850) { + message = other850.message; + __isset = other850.__isset; return *this; } void ConfigValSecurityException::printTo(std::ostream& out) const { @@ -21033,13 +21204,13 @@ void swap(InvalidInputException &a, InvalidInputException &b) { swap(a.__isset, b.__isset); } -InvalidInputException::InvalidInputException(const InvalidInputException& other847) : TException() { - message = other847.message; - __isset = other847.__isset; +InvalidInputException::InvalidInputException(const InvalidInputException& other851) : TException() { + message = other851.message; + __isset = other851.__isset; } -InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other848) { - message = other848.message; - __isset = other848.__isset; +InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other852) { + message = other852.message; + __isset = other852.__isset; return *this; } void InvalidInputException::printTo(std::ostream& out) const { @@ -21130,13 +21301,13 @@ void swap(NoSuchTxnException &a, NoSuchTxnException &b) { swap(a.__isset, b.__isset); } -NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other849) : TException() { - message = other849.message; - __isset = other849.__isset; +NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other853) : TException() { + message = other853.message; + __isset = other853.__isset; } -NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other850) { - message = other850.message; - __isset = other850.__isset; +NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other854) { + message = other854.message; + __isset = other854.__isset; return *this; } void NoSuchTxnException::printTo(std::ostream& out) const { @@ -21227,13 +21398,13 @@ void swap(TxnAbortedException &a, TxnAbortedException &b) { swap(a.__isset, b.__isset); } -TxnAbortedException::TxnAbortedException(const TxnAbortedException& other851) : TException() { - message = other851.message; - __isset = other851.__isset; +TxnAbortedException::TxnAbortedException(const TxnAbortedException& other855) : TException() { + message = other855.message; + __isset = other855.__isset; } -TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other852) { - message = other852.message; - __isset = other852.__isset; +TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other856) { + message = other856.message; + __isset = other856.__isset; return *this; } void TxnAbortedException::printTo(std::ostream& out) const { @@ -21324,13 +21495,13 @@ void swap(TxnOpenException &a, TxnOpenException &b) { swap(a.__isset, b.__isset); } -TxnOpenException::TxnOpenException(const TxnOpenException& other853) : TException() { - message = other853.message; - __isset = other853.__isset; +TxnOpenException::TxnOpenException(const TxnOpenException& other857) : TException() { + message = other857.message; + __isset = other857.__isset; } -TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other854) { - message = other854.message; - __isset = other854.__isset; +TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other858) { + message = other858.message; + __isset = other858.__isset; return *this; } void TxnOpenException::printTo(std::ostream& out) const { @@ -21421,13 +21592,13 @@ void swap(NoSuchLockException &a, NoSuchLockException &b) { swap(a.__isset, b.__isset); } -NoSuchLockException::NoSuchLockException(const NoSuchLockException& other855) : TException() { - message = other855.message; - __isset = other855.__isset; +NoSuchLockException::NoSuchLockException(const NoSuchLockException& other859) : TException() { + message = other859.message; + __isset = other859.__isset; } -NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other856) { - message = other856.message; - __isset = other856.__isset; +NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other860) { + message = other860.message; + __isset = other860.__isset; return *this; } void NoSuchLockException::printTo(std::ostream& out) const { diff --git a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h index 20aeb96..2bba534 100644 --- a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h +++ b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h @@ -422,6 +422,10 @@ class GetTablesRequest; class GetTablesResult; +class CmRecycleRequest; + +class CmRecycleResponse; + class TableMeta; class MetaException; @@ -8024,6 +8028,86 @@ inline std::ostream& operator<<(std::ostream& out, const GetTablesResult& obj) return out; } + +class CmRecycleRequest { + public: + + CmRecycleRequest(const CmRecycleRequest&); + CmRecycleRequest& operator=(const CmRecycleRequest&); + CmRecycleRequest() : dataPath(), purge(0) { + } + + virtual ~CmRecycleRequest() throw(); + std::string dataPath; + bool purge; + + void __set_dataPath(const std::string& val); + + void __set_purge(const bool val); + + bool operator == (const CmRecycleRequest & rhs) const + { + if (!(dataPath == rhs.dataPath)) + return false; + if (!(purge == rhs.purge)) + return false; + return true; + } + bool operator != (const CmRecycleRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const CmRecycleRequest & ) 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(CmRecycleRequest &a, CmRecycleRequest &b); + +inline std::ostream& operator<<(std::ostream& out, const CmRecycleRequest& obj) +{ + obj.printTo(out); + return out; +} + + +class CmRecycleResponse { + public: + + CmRecycleResponse(const CmRecycleResponse&); + CmRecycleResponse& operator=(const CmRecycleResponse&); + CmRecycleResponse() { + } + + virtual ~CmRecycleResponse() throw(); + + bool operator == (const CmRecycleResponse & /* rhs */) const + { + return true; + } + bool operator != (const CmRecycleResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const CmRecycleResponse & ) 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(CmRecycleResponse &a, CmRecycleResponse &b); + +inline std::ostream& operator<<(std::ostream& out, const CmRecycleResponse& obj) +{ + obj.printTo(out); + return out; +} + typedef struct _TableMeta__isset { _TableMeta__isset() : comments(false) {} bool comments :1; diff --git a/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/CmRecycleRequest.java b/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/CmRecycleRequest.java new file mode 100644 index 0000000..d84f236 --- /dev/null +++ b/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/CmRecycleRequest.java @@ -0,0 +1,488 @@ +/** + * 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 CmRecycleRequest 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("CmRecycleRequest"); + + private static final org.apache.thrift.protocol.TField DATA_PATH_FIELD_DESC = new org.apache.thrift.protocol.TField("dataPath", org.apache.thrift.protocol.TType.STRING, (short)1); + private static final org.apache.thrift.protocol.TField PURGE_FIELD_DESC = new org.apache.thrift.protocol.TField("purge", org.apache.thrift.protocol.TType.BOOL, (short)2); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new CmRecycleRequestStandardSchemeFactory()); + schemes.put(TupleScheme.class, new CmRecycleRequestTupleSchemeFactory()); + } + + private String dataPath; // required + private boolean purge; // 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 { + DATA_PATH((short)1, "dataPath"), + PURGE((short)2, "purge"); + + 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: // DATA_PATH + return DATA_PATH; + case 2: // PURGE + return PURGE; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + private static final int __PURGE_ISSET_ID = 0; + private byte __isset_bitfield = 0; + 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.DATA_PATH, new org.apache.thrift.meta_data.FieldMetaData("dataPath", org.apache.thrift.TFieldRequirementType.REQUIRED, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.PURGE, new org.apache.thrift.meta_data.FieldMetaData("purge", org.apache.thrift.TFieldRequirementType.REQUIRED, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(CmRecycleRequest.class, metaDataMap); + } + + public CmRecycleRequest() { + } + + public CmRecycleRequest( + String dataPath, + boolean purge) + { + this(); + this.dataPath = dataPath; + this.purge = purge; + setPurgeIsSet(true); + } + + /** + * Performs a deep copy on other. + */ + public CmRecycleRequest(CmRecycleRequest other) { + __isset_bitfield = other.__isset_bitfield; + if (other.isSetDataPath()) { + this.dataPath = other.dataPath; + } + this.purge = other.purge; + } + + public CmRecycleRequest deepCopy() { + return new CmRecycleRequest(this); + } + + @Override + public void clear() { + this.dataPath = null; + setPurgeIsSet(false); + this.purge = false; + } + + public String getDataPath() { + return this.dataPath; + } + + public void setDataPath(String dataPath) { + this.dataPath = dataPath; + } + + public void unsetDataPath() { + this.dataPath = null; + } + + /** Returns true if field dataPath is set (has been assigned a value) and false otherwise */ + public boolean isSetDataPath() { + return this.dataPath != null; + } + + public void setDataPathIsSet(boolean value) { + if (!value) { + this.dataPath = null; + } + } + + public boolean isPurge() { + return this.purge; + } + + public void setPurge(boolean purge) { + this.purge = purge; + setPurgeIsSet(true); + } + + public void unsetPurge() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __PURGE_ISSET_ID); + } + + /** Returns true if field purge is set (has been assigned a value) and false otherwise */ + public boolean isSetPurge() { + return EncodingUtils.testBit(__isset_bitfield, __PURGE_ISSET_ID); + } + + public void setPurgeIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __PURGE_ISSET_ID, value); + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case DATA_PATH: + if (value == null) { + unsetDataPath(); + } else { + setDataPath((String)value); + } + break; + + case PURGE: + if (value == null) { + unsetPurge(); + } else { + setPurge((Boolean)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case DATA_PATH: + return getDataPath(); + + case PURGE: + return isPurge(); + + } + 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 DATA_PATH: + return isSetDataPath(); + case PURGE: + return isSetPurge(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof CmRecycleRequest) + return this.equals((CmRecycleRequest)that); + return false; + } + + public boolean equals(CmRecycleRequest that) { + if (that == null) + return false; + + boolean this_present_dataPath = true && this.isSetDataPath(); + boolean that_present_dataPath = true && that.isSetDataPath(); + if (this_present_dataPath || that_present_dataPath) { + if (!(this_present_dataPath && that_present_dataPath)) + return false; + if (!this.dataPath.equals(that.dataPath)) + return false; + } + + boolean this_present_purge = true; + boolean that_present_purge = true; + if (this_present_purge || that_present_purge) { + if (!(this_present_purge && that_present_purge)) + return false; + if (this.purge != that.purge) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + boolean present_dataPath = true && (isSetDataPath()); + list.add(present_dataPath); + if (present_dataPath) + list.add(dataPath); + + boolean present_purge = true; + list.add(present_purge); + if (present_purge) + list.add(purge); + + return list.hashCode(); + } + + @Override + public int compareTo(CmRecycleRequest other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetDataPath()).compareTo(other.isSetDataPath()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetDataPath()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.dataPath, other.dataPath); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetPurge()).compareTo(other.isSetPurge()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPurge()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.purge, other.purge); + 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("CmRecycleRequest("); + boolean first = true; + + sb.append("dataPath:"); + if (this.dataPath == null) { + sb.append("null"); + } else { + sb.append(this.dataPath); + } + first = false; + if (!first) sb.append(", "); + sb.append("purge:"); + sb.append(this.purge); + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + if (!isSetDataPath()) { + throw new org.apache.thrift.protocol.TProtocolException("Required field 'dataPath' is unset! Struct:" + toString()); + } + + if (!isSetPurge()) { + throw new org.apache.thrift.protocol.TProtocolException("Required field 'purge' is unset! Struct:" + toString()); + } + + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_bitfield = 0; + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class CmRecycleRequestStandardSchemeFactory implements SchemeFactory { + public CmRecycleRequestStandardScheme getScheme() { + return new CmRecycleRequestStandardScheme(); + } + } + + private static class CmRecycleRequestStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, CmRecycleRequest 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: // DATA_PATH + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.dataPath = iprot.readString(); + struct.setDataPathIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // PURGE + if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) { + struct.purge = iprot.readBool(); + struct.setPurgeIsSet(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, CmRecycleRequest struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.dataPath != null) { + oprot.writeFieldBegin(DATA_PATH_FIELD_DESC); + oprot.writeString(struct.dataPath); + oprot.writeFieldEnd(); + } + oprot.writeFieldBegin(PURGE_FIELD_DESC); + oprot.writeBool(struct.purge); + oprot.writeFieldEnd(); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class CmRecycleRequestTupleSchemeFactory implements SchemeFactory { + public CmRecycleRequestTupleScheme getScheme() { + return new CmRecycleRequestTupleScheme(); + } + } + + private static class CmRecycleRequestTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, CmRecycleRequest struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + oprot.writeString(struct.dataPath); + oprot.writeBool(struct.purge); + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, CmRecycleRequest struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + struct.dataPath = iprot.readString(); + struct.setDataPathIsSet(true); + struct.purge = iprot.readBool(); + struct.setPurgeIsSet(true); + } + } + +} + diff --git a/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/CmRecycleResponse.java b/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/CmRecycleResponse.java new file mode 100644 index 0000000..313559a --- /dev/null +++ b/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/CmRecycleResponse.java @@ -0,0 +1,283 @@ +/** + * Autogenerated by Thrift Compiler (0.9.3) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +package org.apache.hadoop.hive.metastore.api; + +import org.apache.thrift.scheme.IScheme; +import org.apache.thrift.scheme.SchemeFactory; +import org.apache.thrift.scheme.StandardScheme; + +import org.apache.thrift.scheme.TupleScheme; +import org.apache.thrift.protocol.TTupleProtocol; +import org.apache.thrift.protocol.TProtocolException; +import org.apache.thrift.EncodingUtils; +import org.apache.thrift.TException; +import org.apache.thrift.async.AsyncMethodCallback; +import org.apache.thrift.server.AbstractNonblockingServer.*; +import java.util.List; +import java.util.ArrayList; +import java.util.Map; +import java.util.HashMap; +import java.util.EnumMap; +import java.util.Set; +import java.util.HashSet; +import java.util.EnumSet; +import java.util.Collections; +import java.util.BitSet; +import java.nio.ByteBuffer; +import java.util.Arrays; +import javax.annotation.Generated; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) +@Generated(value = "Autogenerated by Thrift Compiler (0.9.3)") +public class CmRecycleResponse 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("CmRecycleResponse"); + + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new CmRecycleResponseStandardSchemeFactory()); + schemes.put(TupleScheme.class, new CmRecycleResponseTupleSchemeFactory()); + } + + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { +; + + private static final Map byName = new HashMap(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(CmRecycleResponse.class, metaDataMap); + } + + public CmRecycleResponse() { + } + + /** + * Performs a deep copy on other. + */ + public CmRecycleResponse(CmRecycleResponse other) { + } + + public CmRecycleResponse deepCopy() { + return new CmRecycleResponse(this); + } + + @Override + public void clear() { + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof CmRecycleResponse) + return this.equals((CmRecycleResponse)that); + return false; + } + + public boolean equals(CmRecycleResponse that) { + if (that == null) + return false; + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + return list.hashCode(); + } + + @Override + public int compareTo(CmRecycleResponse other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("CmRecycleResponse("); + boolean first = true; + + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class CmRecycleResponseStandardSchemeFactory implements SchemeFactory { + public CmRecycleResponseStandardScheme getScheme() { + return new CmRecycleResponseStandardScheme(); + } + } + + private static class CmRecycleResponseStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, CmRecycleResponse struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField schemeField; + iprot.readStructBegin(); + while (true) + { + schemeField = iprot.readFieldBegin(); + if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (schemeField.id) { + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + struct.validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot, CmRecycleResponse struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class CmRecycleResponseTupleSchemeFactory implements SchemeFactory { + public CmRecycleResponseTupleScheme getScheme() { + return new CmRecycleResponseTupleScheme(); + } + } + + private static class CmRecycleResponseTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, CmRecycleResponse struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, CmRecycleResponse struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } + +} + diff --git a/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java b/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java index 89c59e1..541cbb9 100644 --- a/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java +++ b/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java @@ -348,6 +348,8 @@ public void flushCache() throws org.apache.thrift.TException; + public CmRecycleResponse cm_recycle(CmRecycleRequest request) throws MetaException, org.apache.thrift.TException; + public GetFileMetadataByExprResult get_file_metadata_by_expr(GetFileMetadataByExprRequest req) throws org.apache.thrift.TException; public GetFileMetadataResult get_file_metadata(GetFileMetadataRequest req) throws org.apache.thrift.TException; @@ -670,6 +672,8 @@ public void flushCache(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void cm_recycle(CmRecycleRequest request, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void get_file_metadata_by_expr(GetFileMetadataByExprRequest req, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; public void get_file_metadata(GetFileMetadataRequest req, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; @@ -5128,6 +5132,32 @@ public void recv_flushCache() throws org.apache.thrift.TException return; } + public CmRecycleResponse cm_recycle(CmRecycleRequest request) throws MetaException, org.apache.thrift.TException + { + send_cm_recycle(request); + return recv_cm_recycle(); + } + + public void send_cm_recycle(CmRecycleRequest request) throws org.apache.thrift.TException + { + cm_recycle_args args = new cm_recycle_args(); + args.setRequest(request); + sendBase("cm_recycle", args); + } + + public CmRecycleResponse recv_cm_recycle() throws MetaException, org.apache.thrift.TException + { + cm_recycle_result result = new cm_recycle_result(); + receiveBase(result, "cm_recycle"); + 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, "cm_recycle failed: unknown result"); + } + public GetFileMetadataByExprResult get_file_metadata_by_expr(GetFileMetadataByExprRequest req) throws org.apache.thrift.TException { send_get_file_metadata_by_expr(req); @@ -10683,6 +10713,38 @@ public void getResult() throws org.apache.thrift.TException { } } + public void cm_recycle(CmRecycleRequest request, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + cm_recycle_call method_call = new cm_recycle_call(request, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class cm_recycle_call extends org.apache.thrift.async.TAsyncMethodCall { + private CmRecycleRequest request; + public cm_recycle_call(CmRecycleRequest request, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.request = request; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("cm_recycle", org.apache.thrift.protocol.TMessageType.CALL, 0)); + cm_recycle_args args = new cm_recycle_args(); + args.setRequest(request); + args.write(prot); + prot.writeMessageEnd(); + } + + public CmRecycleResponse 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_cm_recycle(); + } + } + public void get_file_metadata_by_expr(GetFileMetadataByExprRequest req, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { checkReady(); get_file_metadata_by_expr_call method_call = new get_file_metadata_by_expr_call(req, resultHandler, this, ___protocolFactory, ___transport); @@ -11038,6 +11100,7 @@ protected Processor(I iface, Map extends org.apache.thrift.ProcessFunction { + public cm_recycle() { + super("cm_recycle"); + } + + public cm_recycle_args getEmptyArgsInstance() { + return new cm_recycle_args(); + } + + protected boolean isOneway() { + return false; + } + + public cm_recycle_result getResult(I iface, cm_recycle_args args) throws org.apache.thrift.TException { + cm_recycle_result result = new cm_recycle_result(); + try { + result.success = iface.cm_recycle(args.request); + } catch (MetaException o1) { + result.o1 = o1; + } + return result; + } + } + public static class get_file_metadata_by_expr extends org.apache.thrift.ProcessFunction { public get_file_metadata_by_expr() { super("get_file_metadata_by_expr"); @@ -15261,6 +15348,7 @@ protected AsyncProcessor(I iface, Map extends org.apache.thrift.AsyncProcessFunction { - public get_file_metadata_by_expr() { - super("get_file_metadata_by_expr"); - } - - public get_file_metadata_by_expr_args getEmptyArgsInstance() { - return new get_file_metadata_by_expr_args(); - } - - public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { - final org.apache.thrift.AsyncProcessFunction fcall = this; - return new AsyncMethodCallback() { - public void onComplete(GetFileMetadataByExprResult o) { - get_file_metadata_by_expr_result result = new get_file_metadata_by_expr_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_file_metadata_by_expr_result result = new get_file_metadata_by_expr_result(); - { - 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_file_metadata_by_expr_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { - iface.get_file_metadata_by_expr(args.req,resultHandler); - } - } - - public static class get_file_metadata extends org.apache.thrift.AsyncProcessFunction { - public get_file_metadata() { - super("get_file_metadata"); - } - - public get_file_metadata_args getEmptyArgsInstance() { - return new get_file_metadata_args(); - } - - public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { - final org.apache.thrift.AsyncProcessFunction fcall = this; - return new AsyncMethodCallback() { - public void onComplete(GetFileMetadataResult o) { - get_file_metadata_result result = new get_file_metadata_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_file_metadata_result result = new get_file_metadata_result(); - { - 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_file_metadata_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { - iface.get_file_metadata(args.req,resultHandler); - } - } - - public static class put_file_metadata extends org.apache.thrift.AsyncProcessFunction { - public put_file_metadata() { - super("put_file_metadata"); - } - - public put_file_metadata_args getEmptyArgsInstance() { - return new put_file_metadata_args(); - } - - public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { - final org.apache.thrift.AsyncProcessFunction fcall = this; - return new AsyncMethodCallback() { - public void onComplete(PutFileMetadataResult o) { - put_file_metadata_result result = new put_file_metadata_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; - put_file_metadata_result result = new put_file_metadata_result(); - { - 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, put_file_metadata_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { - iface.put_file_metadata(args.req,resultHandler); - } - } - - public static class clear_file_metadata extends org.apache.thrift.AsyncProcessFunction { - public clear_file_metadata() { - super("clear_file_metadata"); + public static class cm_recycle extends org.apache.thrift.AsyncProcessFunction { + public cm_recycle() { + super("cm_recycle"); } - public clear_file_metadata_args getEmptyArgsInstance() { - return new clear_file_metadata_args(); + public cm_recycle_args getEmptyArgsInstance() { + return new cm_recycle_args(); } - public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { final org.apache.thrift.AsyncProcessFunction fcall = this; - return new AsyncMethodCallback() { - public void onComplete(ClearFileMetadataResult o) { - clear_file_metadata_result result = new clear_file_metadata_result(); + return new AsyncMethodCallback() { + public void onComplete(CmRecycleResponse o) { + cm_recycle_result result = new cm_recycle_result(); result.success = o; try { fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); @@ -24796,109 +24731,319 @@ public void onComplete(ClearFileMetadataResult o) { public void onError(Exception e) { byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; org.apache.thrift.TBase msg; - clear_file_metadata_result result = new clear_file_metadata_result(); - { - 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, clear_file_metadata_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { - iface.clear_file_metadata(args.req,resultHandler); - } - } - - public static class cache_file_metadata extends org.apache.thrift.AsyncProcessFunction { - public cache_file_metadata() { - super("cache_file_metadata"); - } - - public cache_file_metadata_args getEmptyArgsInstance() { - return new cache_file_metadata_args(); - } - - public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { - final org.apache.thrift.AsyncProcessFunction fcall = this; - return new AsyncMethodCallback() { - public void onComplete(CacheFileMetadataResult o) { - cache_file_metadata_result result = new cache_file_metadata_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; - cache_file_metadata_result result = new cache_file_metadata_result(); - { - 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, cache_file_metadata_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { - iface.cache_file_metadata(args.req,resultHandler); - } - } - - public static class get_metastore_db_uuid 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(); + cm_recycle_result result = new cm_recycle_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, cm_recycle_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.cm_recycle(args.request,resultHandler); + } + } + + public static class get_file_metadata_by_expr extends org.apache.thrift.AsyncProcessFunction { + public get_file_metadata_by_expr() { + super("get_file_metadata_by_expr"); + } + + public get_file_metadata_by_expr_args getEmptyArgsInstance() { + return new get_file_metadata_by_expr_args(); + } + + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback() { + public void onComplete(GetFileMetadataByExprResult o) { + get_file_metadata_by_expr_result result = new get_file_metadata_by_expr_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_file_metadata_by_expr_result result = new get_file_metadata_by_expr_result(); + { + 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_file_metadata_by_expr_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.get_file_metadata_by_expr(args.req,resultHandler); + } + } + + public static class get_file_metadata extends org.apache.thrift.AsyncProcessFunction { + public get_file_metadata() { + super("get_file_metadata"); + } + + public get_file_metadata_args getEmptyArgsInstance() { + return new get_file_metadata_args(); + } + + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback() { + public void onComplete(GetFileMetadataResult o) { + get_file_metadata_result result = new get_file_metadata_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_file_metadata_result result = new get_file_metadata_result(); + { + 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_file_metadata_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.get_file_metadata(args.req,resultHandler); + } + } + + public static class put_file_metadata extends org.apache.thrift.AsyncProcessFunction { + public put_file_metadata() { + super("put_file_metadata"); + } + + public put_file_metadata_args getEmptyArgsInstance() { + return new put_file_metadata_args(); + } + + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback() { + public void onComplete(PutFileMetadataResult o) { + put_file_metadata_result result = new put_file_metadata_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; + put_file_metadata_result result = new put_file_metadata_result(); + { + 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, put_file_metadata_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.put_file_metadata(args.req,resultHandler); + } + } + + public static class clear_file_metadata extends org.apache.thrift.AsyncProcessFunction { + public clear_file_metadata() { + super("clear_file_metadata"); + } + + public clear_file_metadata_args getEmptyArgsInstance() { + return new clear_file_metadata_args(); + } + + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback() { + public void onComplete(ClearFileMetadataResult o) { + clear_file_metadata_result result = new clear_file_metadata_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; + clear_file_metadata_result result = new clear_file_metadata_result(); + { + 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, clear_file_metadata_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.clear_file_metadata(args.req,resultHandler); + } + } + + public static class cache_file_metadata extends org.apache.thrift.AsyncProcessFunction { + public cache_file_metadata() { + super("cache_file_metadata"); + } + + public cache_file_metadata_args getEmptyArgsInstance() { + return new cache_file_metadata_args(); + } + + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback() { + public void onComplete(CacheFileMetadataResult o) { + cache_file_metadata_result result = new cache_file_metadata_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; + cache_file_metadata_result result = new cache_file_metadata_result(); + { + 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, cache_file_metadata_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.cache_file_metadata(args.req,resultHandler); + } + } + + public static class get_metastore_db_uuid 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); @@ -182027,6 +182172,838 @@ public void read(org.apache.thrift.protocol.TProtocol prot, flushCache_result st } + public static class cm_recycle_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("cm_recycle_args"); + + private static final org.apache.thrift.protocol.TField REQUEST_FIELD_DESC = new org.apache.thrift.protocol.TField("request", org.apache.thrift.protocol.TType.STRUCT, (short)1); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new cm_recycle_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new cm_recycle_argsTupleSchemeFactory()); + } + + private CmRecycleRequest request; // required + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + REQUEST((short)1, "request"); + + private static final Map byName = new HashMap(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 1: // REQUEST + return REQUEST; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.REQUEST, new org.apache.thrift.meta_data.FieldMetaData("request", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, CmRecycleRequest.class))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(cm_recycle_args.class, metaDataMap); + } + + public cm_recycle_args() { + } + + public cm_recycle_args( + CmRecycleRequest request) + { + this(); + this.request = request; + } + + /** + * Performs a deep copy on other. + */ + public cm_recycle_args(cm_recycle_args other) { + if (other.isSetRequest()) { + this.request = new CmRecycleRequest(other.request); + } + } + + public cm_recycle_args deepCopy() { + return new cm_recycle_args(this); + } + + @Override + public void clear() { + this.request = null; + } + + public CmRecycleRequest getRequest() { + return this.request; + } + + public void setRequest(CmRecycleRequest request) { + this.request = request; + } + + public void unsetRequest() { + this.request = null; + } + + /** Returns true if field request is set (has been assigned a value) and false otherwise */ + public boolean isSetRequest() { + return this.request != null; + } + + public void setRequestIsSet(boolean value) { + if (!value) { + this.request = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case REQUEST: + if (value == null) { + unsetRequest(); + } else { + setRequest((CmRecycleRequest)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case REQUEST: + return getRequest(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case REQUEST: + return isSetRequest(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof cm_recycle_args) + return this.equals((cm_recycle_args)that); + return false; + } + + public boolean equals(cm_recycle_args that) { + if (that == null) + return false; + + boolean this_present_request = true && this.isSetRequest(); + boolean that_present_request = true && that.isSetRequest(); + if (this_present_request || that_present_request) { + if (!(this_present_request && that_present_request)) + return false; + if (!this.request.equals(that.request)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + boolean present_request = true && (isSetRequest()); + list.add(present_request); + if (present_request) + list.add(request); + + return list.hashCode(); + } + + @Override + public int compareTo(cm_recycle_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetRequest()).compareTo(other.isSetRequest()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetRequest()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.request, other.request); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("cm_recycle_args("); + boolean first = true; + + sb.append("request:"); + if (this.request == null) { + sb.append("null"); + } else { + sb.append(this.request); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + if (request != null) { + request.validate(); + } + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class cm_recycle_argsStandardSchemeFactory implements SchemeFactory { + public cm_recycle_argsStandardScheme getScheme() { + return new cm_recycle_argsStandardScheme(); + } + } + + private static class cm_recycle_argsStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, cm_recycle_args struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField schemeField; + iprot.readStructBegin(); + while (true) + { + schemeField = iprot.readFieldBegin(); + if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (schemeField.id) { + case 1: // REQUEST + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.request = new CmRecycleRequest(); + struct.request.read(iprot); + struct.setRequestIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + struct.validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot, cm_recycle_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.request != null) { + oprot.writeFieldBegin(REQUEST_FIELD_DESC); + struct.request.write(oprot); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class cm_recycle_argsTupleSchemeFactory implements SchemeFactory { + public cm_recycle_argsTupleScheme getScheme() { + return new cm_recycle_argsTupleScheme(); + } + } + + private static class cm_recycle_argsTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, cm_recycle_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetRequest()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetRequest()) { + struct.request.write(oprot); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, cm_recycle_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.request = new CmRecycleRequest(); + struct.request.read(iprot); + struct.setRequestIsSet(true); + } + } + } + + } + + public static class cm_recycle_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("cm_recycle_result"); + + private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0); + private static final org.apache.thrift.protocol.TField O1_FIELD_DESC = new org.apache.thrift.protocol.TField("o1", org.apache.thrift.protocol.TType.STRUCT, (short)1); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new cm_recycle_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new cm_recycle_resultTupleSchemeFactory()); + } + + private CmRecycleResponse success; // required + private MetaException o1; // required + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + SUCCESS((short)0, "success"), + O1((short)1, "o1"); + + private static final Map byName = new HashMap(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 0: // SUCCESS + return SUCCESS; + case 1: // O1 + return O1; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, CmRecycleResponse.class))); + tmpMap.put(_Fields.O1, new org.apache.thrift.meta_data.FieldMetaData("o1", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(cm_recycle_result.class, metaDataMap); + } + + public cm_recycle_result() { + } + + public cm_recycle_result( + CmRecycleResponse success, + MetaException o1) + { + this(); + this.success = success; + this.o1 = o1; + } + + /** + * Performs a deep copy on other. + */ + public cm_recycle_result(cm_recycle_result other) { + if (other.isSetSuccess()) { + this.success = new CmRecycleResponse(other.success); + } + if (other.isSetO1()) { + this.o1 = new MetaException(other.o1); + } + } + + public cm_recycle_result deepCopy() { + return new cm_recycle_result(this); + } + + @Override + public void clear() { + this.success = null; + this.o1 = null; + } + + public CmRecycleResponse getSuccess() { + return this.success; + } + + public void setSuccess(CmRecycleResponse success) { + this.success = success; + } + + public void unsetSuccess() { + this.success = null; + } + + /** Returns true if field success is set (has been assigned a value) and false otherwise */ + public boolean isSetSuccess() { + return this.success != null; + } + + public void setSuccessIsSet(boolean value) { + if (!value) { + this.success = null; + } + } + + public MetaException getO1() { + return this.o1; + } + + public void setO1(MetaException o1) { + this.o1 = o1; + } + + public void unsetO1() { + this.o1 = null; + } + + /** Returns true if field o1 is set (has been assigned a value) and false otherwise */ + public boolean isSetO1() { + return this.o1 != null; + } + + public void setO1IsSet(boolean value) { + if (!value) { + this.o1 = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((CmRecycleResponse)value); + } + break; + + case O1: + if (value == null) { + unsetO1(); + } else { + setO1((MetaException)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); + + case O1: + return getO1(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case SUCCESS: + return isSetSuccess(); + case O1: + return isSetO1(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof cm_recycle_result) + return this.equals((cm_recycle_result)that); + return false; + } + + public boolean equals(cm_recycle_result that) { + if (that == null) + return false; + + boolean this_present_success = true && this.isSetSuccess(); + boolean that_present_success = true && that.isSetSuccess(); + if (this_present_success || that_present_success) { + if (!(this_present_success && that_present_success)) + return false; + if (!this.success.equals(that.success)) + return false; + } + + boolean this_present_o1 = true && this.isSetO1(); + boolean that_present_o1 = true && that.isSetO1(); + if (this_present_o1 || that_present_o1) { + if (!(this_present_o1 && that_present_o1)) + return false; + if (!this.o1.equals(that.o1)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + boolean present_success = true && (isSetSuccess()); + list.add(present_success); + if (present_success) + list.add(success); + + boolean present_o1 = true && (isSetO1()); + list.add(present_o1); + if (present_o1) + list.add(o1); + + return list.hashCode(); + } + + @Override + public int compareTo(cm_recycle_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(other.isSetSuccess()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetSuccess()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetO1()).compareTo(other.isSetO1()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetO1()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.o1, other.o1); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("cm_recycle_result("); + boolean first = true; + + sb.append("success:"); + if (this.success == null) { + sb.append("null"); + } else { + sb.append(this.success); + } + first = false; + if (!first) sb.append(", "); + sb.append("o1:"); + if (this.o1 == null) { + sb.append("null"); + } else { + sb.append(this.o1); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + if (success != null) { + success.validate(); + } + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class cm_recycle_resultStandardSchemeFactory implements SchemeFactory { + public cm_recycle_resultStandardScheme getScheme() { + return new cm_recycle_resultStandardScheme(); + } + } + + private static class cm_recycle_resultStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, cm_recycle_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 CmRecycleResponse(); + struct.success.read(iprot); + struct.setSuccessIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 1: // O1 + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.o1 = new MetaException(); + struct.o1.read(iprot); + struct.setO1IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + struct.validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot, cm_recycle_result struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.success != null) { + oprot.writeFieldBegin(SUCCESS_FIELD_DESC); + struct.success.write(oprot); + oprot.writeFieldEnd(); + } + if (struct.o1 != null) { + oprot.writeFieldBegin(O1_FIELD_DESC); + struct.o1.write(oprot); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class cm_recycle_resultTupleSchemeFactory implements SchemeFactory { + public cm_recycle_resultTupleScheme getScheme() { + return new cm_recycle_resultTupleScheme(); + } + } + + private static class cm_recycle_resultTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, cm_recycle_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + if (struct.isSetO1()) { + optionals.set(1); + } + oprot.writeBitSet(optionals, 2); + if (struct.isSetSuccess()) { + struct.success.write(oprot); + } + if (struct.isSetO1()) { + struct.o1.write(oprot); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, cm_recycle_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(2); + if (incoming.get(0)) { + struct.success = new CmRecycleResponse(); + struct.success.read(iprot); + struct.setSuccessIsSet(true); + } + if (incoming.get(1)) { + struct.o1 = new MetaException(); + struct.o1.read(iprot); + struct.setO1IsSet(true); + } + } + } + + } + public static class get_file_metadata_by_expr_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_by_expr_args"); diff --git a/metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php b/metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php index 709eea9..cc5e120 100644 --- a/metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php +++ b/metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php @@ -1199,6 +1199,12 @@ interface ThriftHiveMetastoreIf extends \FacebookServiceIf { */ public function flushCache(); /** + * @param \metastore\CmRecycleRequest $request + * @return \metastore\CmRecycleResponse + * @throws \metastore\MetaException + */ + public function cm_recycle(\metastore\CmRecycleRequest $request); + /** * @param \metastore\GetFileMetadataByExprRequest $req * @return \metastore\GetFileMetadataByExprResult */ @@ -9943,6 +9949,60 @@ class ThriftHiveMetastoreClient extends \FacebookServiceClient implements \metas return; } + public function cm_recycle(\metastore\CmRecycleRequest $request) + { + $this->send_cm_recycle($request); + return $this->recv_cm_recycle(); + } + + public function send_cm_recycle(\metastore\CmRecycleRequest $request) + { + $args = new \metastore\ThriftHiveMetastore_cm_recycle_args(); + $args->request = $request; + $bin_accel = ($this->output_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_write_binary'); + if ($bin_accel) + { + thrift_protocol_write_binary($this->output_, 'cm_recycle', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite()); + } + else + { + $this->output_->writeMessageBegin('cm_recycle', TMessageType::CALL, $this->seqid_); + $args->write($this->output_); + $this->output_->writeMessageEnd(); + $this->output_->getTransport()->flush(); + } + } + + public function recv_cm_recycle() + { + $bin_accel = ($this->input_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_read_binary'); + if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\metastore\ThriftHiveMetastore_cm_recycle_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_cm_recycle_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("cm_recycle failed: unknown result"); + } + public function get_file_metadata_by_expr(\metastore\GetFileMetadataByExprRequest $req) { $this->send_get_file_metadata_by_expr($req); @@ -45714,6 +45774,191 @@ class ThriftHiveMetastore_flushCache_result { } +class ThriftHiveMetastore_cm_recycle_args { + static $_TSPEC; + + /** + * @var \metastore\CmRecycleRequest + */ + public $request = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'request', + 'type' => TType::STRUCT, + 'class' => '\metastore\CmRecycleRequest', + ), + ); + } + if (is_array($vals)) { + if (isset($vals['request'])) { + $this->request = $vals['request']; + } + } + } + + public function getName() { + return 'ThriftHiveMetastore_cm_recycle_args'; + } + + public function read($input) + { + $xfer = 0; + $fname = null; + $ftype = 0; + $fid = 0; + $xfer += $input->readStructBegin($fname); + while (true) + { + $xfer += $input->readFieldBegin($fname, $ftype, $fid); + if ($ftype == TType::STOP) { + break; + } + switch ($fid) + { + case 1: + if ($ftype == TType::STRUCT) { + $this->request = new \metastore\CmRecycleRequest(); + $xfer += $this->request->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + default: + $xfer += $input->skip($ftype); + break; + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; + } + + public function write($output) { + $xfer = 0; + $xfer += $output->writeStructBegin('ThriftHiveMetastore_cm_recycle_args'); + if ($this->request !== null) { + if (!is_object($this->request)) { + throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); + } + $xfer += $output->writeFieldBegin('request', TType::STRUCT, 1); + $xfer += $this->request->write($output); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class ThriftHiveMetastore_cm_recycle_result { + static $_TSPEC; + + /** + * @var \metastore\CmRecycleResponse + */ + public $success = null; + /** + * @var \metastore\MetaException + */ + public $o1 = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 0 => array( + 'var' => 'success', + 'type' => TType::STRUCT, + 'class' => '\metastore\CmRecycleResponse', + ), + 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_cm_recycle_result'; + } + + public function read($input) + { + $xfer = 0; + $fname = null; + $ftype = 0; + $fid = 0; + $xfer += $input->readStructBegin($fname); + while (true) + { + $xfer += $input->readFieldBegin($fname, $ftype, $fid); + if ($ftype == TType::STOP) { + break; + } + switch ($fid) + { + case 0: + if ($ftype == TType::STRUCT) { + $this->success = new \metastore\CmRecycleResponse(); + $xfer += $this->success->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + case 1: + if ($ftype == TType::STRUCT) { + $this->o1 = new \metastore\MetaException(); + $xfer += $this->o1->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + default: + $xfer += $input->skip($ftype); + break; + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; + } + + public function write($output) { + $xfer = 0; + $xfer += $output->writeStructBegin('ThriftHiveMetastore_cm_recycle_result'); + if ($this->success !== null) { + if (!is_object($this->success)) { + throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); + } + $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0); + $xfer += $this->success->write($output); + $xfer += $output->writeFieldEnd(); + } + if ($this->o1 !== null) { + $xfer += $output->writeFieldBegin('o1', TType::STRUCT, 1); + $xfer += $this->o1->write($output); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + class ThriftHiveMetastore_get_file_metadata_by_expr_args { static $_TSPEC; diff --git a/metastore/src/gen/thrift/gen-php/metastore/Types.php b/metastore/src/gen/thrift/gen-php/metastore/Types.php index 9321301..aff783e 100644 --- a/metastore/src/gen/thrift/gen-php/metastore/Types.php +++ b/metastore/src/gen/thrift/gen-php/metastore/Types.php @@ -19469,6 +19469,154 @@ class GetTablesResult { } +class CmRecycleRequest { + static $_TSPEC; + + /** + * @var string + */ + public $dataPath = null; + /** + * @var bool + */ + public $purge = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'dataPath', + 'type' => TType::STRING, + ), + 2 => array( + 'var' => 'purge', + 'type' => TType::BOOL, + ), + ); + } + if (is_array($vals)) { + if (isset($vals['dataPath'])) { + $this->dataPath = $vals['dataPath']; + } + if (isset($vals['purge'])) { + $this->purge = $vals['purge']; + } + } + } + + public function getName() { + return 'CmRecycleRequest'; + } + + 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->dataPath); + } else { + $xfer += $input->skip($ftype); + } + break; + case 2: + if ($ftype == TType::BOOL) { + $xfer += $input->readBool($this->purge); + } 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('CmRecycleRequest'); + if ($this->dataPath !== null) { + $xfer += $output->writeFieldBegin('dataPath', TType::STRING, 1); + $xfer += $output->writeString($this->dataPath); + $xfer += $output->writeFieldEnd(); + } + if ($this->purge !== null) { + $xfer += $output->writeFieldBegin('purge', TType::BOOL, 2); + $xfer += $output->writeBool($this->purge); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class CmRecycleResponse { + static $_TSPEC; + + + public function __construct() { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + ); + } + } + + public function getName() { + return 'CmRecycleResponse'; + } + + 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('CmRecycleResponse'); + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + class TableMeta { static $_TSPEC; diff --git a/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote b/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote index 67e9422..46dcac9 100755 --- a/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote +++ b/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote @@ -177,6 +177,7 @@ if len(sys.argv) <= 1 or sys.argv[1] == '--help': print(' CurrentNotificationEventId get_current_notificationEventId()') print(' FireEventResponse fire_listener_event(FireEventRequest rqst)') print(' void flushCache()') + print(' CmRecycleResponse cm_recycle(CmRecycleRequest request)') print(' GetFileMetadataByExprResult get_file_metadata_by_expr(GetFileMetadataByExprRequest req)') print(' GetFileMetadataResult get_file_metadata(GetFileMetadataRequest req)') print(' PutFileMetadataResult put_file_metadata(PutFileMetadataRequest req)') @@ -1170,6 +1171,12 @@ elif cmd == 'flushCache': sys.exit(1) pp.pprint(client.flushCache()) +elif cmd == 'cm_recycle': + if len(args) != 1: + print('cm_recycle requires 1 args') + sys.exit(1) + pp.pprint(client.cm_recycle(eval(args[0]),)) + elif cmd == 'get_file_metadata_by_expr': if len(args) != 1: print('get_file_metadata_by_expr requires 1 args') diff --git a/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py b/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py index a4937e2..2ecf555 100644 --- a/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py +++ b/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py @@ -1234,6 +1234,13 @@ def fire_listener_event(self, rqst): def flushCache(self): pass + def cm_recycle(self, request): + """ + Parameters: + - request + """ + pass + def get_file_metadata_by_expr(self, req): """ Parameters: @@ -6822,6 +6829,39 @@ def recv_flushCache(self): iprot.readMessageEnd() return + def cm_recycle(self, request): + """ + Parameters: + - request + """ + self.send_cm_recycle(request) + return self.recv_cm_recycle() + + def send_cm_recycle(self, request): + self._oprot.writeMessageBegin('cm_recycle', TMessageType.CALL, self._seqid) + args = cm_recycle_args() + args.request = request + args.write(self._oprot) + self._oprot.writeMessageEnd() + self._oprot.trans.flush() + + def recv_cm_recycle(self): + iprot = self._iprot + (fname, mtype, rseqid) = iprot.readMessageBegin() + if mtype == TMessageType.EXCEPTION: + x = TApplicationException() + x.read(iprot) + iprot.readMessageEnd() + raise x + result = cm_recycle_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, "cm_recycle failed: unknown result") + def get_file_metadata_by_expr(self, req): """ Parameters: @@ -7162,6 +7202,7 @@ def __init__(self, handler): self._processMap["get_current_notificationEventId"] = Processor.process_get_current_notificationEventId self._processMap["fire_listener_event"] = Processor.process_fire_listener_event self._processMap["flushCache"] = Processor.process_flushCache + self._processMap["cm_recycle"] = Processor.process_cm_recycle self._processMap["get_file_metadata_by_expr"] = Processor.process_get_file_metadata_by_expr self._processMap["get_file_metadata"] = Processor.process_get_file_metadata self._processMap["put_file_metadata"] = Processor.process_put_file_metadata @@ -10943,6 +10984,28 @@ def process_flushCache(self, seqid, iprot, oprot): oprot.writeMessageEnd() oprot.trans.flush() + def process_cm_recycle(self, seqid, iprot, oprot): + args = cm_recycle_args() + args.read(iprot) + iprot.readMessageEnd() + result = cm_recycle_result() + try: + result.success = self._handler.cm_recycle(args.request) + 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("cm_recycle", msg_type, seqid) + result.write(oprot) + oprot.writeMessageEnd() + oprot.trans.flush() + def process_get_file_metadata_by_expr(self, seqid, iprot, oprot): args = get_file_metadata_by_expr_args() args.read(iprot) @@ -37124,6 +37187,151 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) +class cm_recycle_args: + """ + Attributes: + - request + """ + + thrift_spec = ( + None, # 0 + (1, TType.STRUCT, 'request', (CmRecycleRequest, CmRecycleRequest.thrift_spec), None, ), # 1 + ) + + def __init__(self, request=None,): + self.request = request + + def read(self, iprot): + if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: + fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) + return + iprot.readStructBegin() + while True: + (fname, ftype, fid) = iprot.readFieldBegin() + if ftype == TType.STOP: + break + if fid == 1: + if ftype == TType.STRUCT: + self.request = CmRecycleRequest() + self.request.read(iprot) + else: + iprot.skip(ftype) + else: + iprot.skip(ftype) + iprot.readFieldEnd() + iprot.readStructEnd() + + def write(self, oprot): + if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: + oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) + return + oprot.writeStructBegin('cm_recycle_args') + if self.request is not None: + oprot.writeFieldBegin('request', TType.STRUCT, 1) + self.request.write(oprot) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.request) + return value + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + +class cm_recycle_result: + """ + Attributes: + - success + - o1 + """ + + thrift_spec = ( + (0, TType.STRUCT, 'success', (CmRecycleResponse, CmRecycleResponse.thrift_spec), None, ), # 0 + (1, TType.STRUCT, 'o1', (MetaException, MetaException.thrift_spec), None, ), # 1 + ) + + def __init__(self, success=None, o1=None,): + self.success = success + self.o1 = o1 + + def read(self, iprot): + if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: + fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) + return + iprot.readStructBegin() + while True: + (fname, ftype, fid) = iprot.readFieldBegin() + if ftype == TType.STOP: + break + if fid == 0: + if ftype == TType.STRUCT: + self.success = CmRecycleResponse() + self.success.read(iprot) + else: + iprot.skip(ftype) + elif fid == 1: + if ftype == TType.STRUCT: + self.o1 = MetaException() + self.o1.read(iprot) + else: + iprot.skip(ftype) + else: + iprot.skip(ftype) + iprot.readFieldEnd() + 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('cm_recycle_result') + if self.success is not None: + oprot.writeFieldBegin('success', TType.STRUCT, 0) + self.success.write(oprot) + oprot.writeFieldEnd() + if self.o1 is not None: + oprot.writeFieldBegin('o1', TType.STRUCT, 1) + self.o1.write(oprot) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.success) + value = (value * 31) ^ hash(self.o1) + return value + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + class get_file_metadata_by_expr_args: """ Attributes: diff --git a/metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py b/metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py index 1e2b890..53671e3 100644 --- a/metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py +++ b/metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py @@ -13684,6 +13684,134 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) +class CmRecycleRequest: + """ + Attributes: + - dataPath + - purge + """ + + thrift_spec = ( + None, # 0 + (1, TType.STRING, 'dataPath', None, None, ), # 1 + (2, TType.BOOL, 'purge', None, None, ), # 2 + ) + + def __init__(self, dataPath=None, purge=None,): + self.dataPath = dataPath + self.purge = purge + + 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.dataPath = iprot.readString() + else: + iprot.skip(ftype) + elif fid == 2: + if ftype == TType.BOOL: + self.purge = iprot.readBool() + else: + iprot.skip(ftype) + else: + iprot.skip(ftype) + iprot.readFieldEnd() + iprot.readStructEnd() + + def write(self, oprot): + if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: + oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) + return + oprot.writeStructBegin('CmRecycleRequest') + if self.dataPath is not None: + oprot.writeFieldBegin('dataPath', TType.STRING, 1) + oprot.writeString(self.dataPath) + oprot.writeFieldEnd() + if self.purge is not None: + oprot.writeFieldBegin('purge', TType.BOOL, 2) + oprot.writeBool(self.purge) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + if self.dataPath is None: + raise TProtocol.TProtocolException(message='Required field dataPath is unset!') + if self.purge is None: + raise TProtocol.TProtocolException(message='Required field purge is unset!') + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.dataPath) + value = (value * 31) ^ hash(self.purge) + 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 CmRecycleResponse: + + 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('CmRecycleResponse') + 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 TableMeta: """ Attributes: diff --git a/metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb b/metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb index 2cf38b5..02c5717 100644 --- a/metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb +++ b/metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb @@ -3080,6 +3080,41 @@ class GetTablesResult ::Thrift::Struct.generate_accessors self end +class CmRecycleRequest + include ::Thrift::Struct, ::Thrift::Struct_Union + DATAPATH = 1 + PURGE = 2 + + FIELDS = { + DATAPATH => {:type => ::Thrift::Types::STRING, :name => 'dataPath'}, + PURGE => {:type => ::Thrift::Types::BOOL, :name => 'purge'} + } + + def struct_fields; FIELDS; end + + def validate + raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Required field dataPath is unset!') unless @dataPath + raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Required field purge is unset!') if @purge.nil? + end + + ::Thrift::Struct.generate_accessors self +end + +class CmRecycleResponse + include ::Thrift::Struct, ::Thrift::Struct_Union + + FIELDS = { + + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self +end + class TableMeta include ::Thrift::Struct, ::Thrift::Struct_Union DBNAME = 1 diff --git a/metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb b/metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb index 2711381..cfe08f6 100644 --- a/metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb +++ b/metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb @@ -2553,6 +2553,22 @@ module ThriftHiveMetastore return end + def cm_recycle(request) + send_cm_recycle(request) + return recv_cm_recycle() + end + + def send_cm_recycle(request) + send_message('cm_recycle', Cm_recycle_args, :request => request) + end + + def recv_cm_recycle() + result = receive_message(Cm_recycle_result) + return result.success unless result.success.nil? + raise result.o1 unless result.o1.nil? + raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'cm_recycle failed: unknown result') + end + def get_file_metadata_by_expr(req) send_get_file_metadata_by_expr(req) return recv_get_file_metadata_by_expr() @@ -4556,6 +4572,17 @@ module ThriftHiveMetastore write_result(result, oprot, 'flushCache', seqid) end + def process_cm_recycle(seqid, iprot, oprot) + args = read_args(iprot, Cm_recycle_args) + result = Cm_recycle_result.new() + begin + result.success = @handler.cm_recycle(args.request) + rescue ::MetaException => o1 + result.o1 = o1 + end + write_result(result, oprot, 'cm_recycle', seqid) + end + def process_get_file_metadata_by_expr(seqid, iprot, oprot) args = read_args(iprot, Get_file_metadata_by_expr_args) result = Get_file_metadata_by_expr_result.new() @@ -10360,6 +10387,40 @@ module ThriftHiveMetastore ::Thrift::Struct.generate_accessors self end + class Cm_recycle_args + include ::Thrift::Struct, ::Thrift::Struct_Union + REQUEST = 1 + + FIELDS = { + REQUEST => {:type => ::Thrift::Types::STRUCT, :name => 'request', :class => ::CmRecycleRequest} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Cm_recycle_result + include ::Thrift::Struct, ::Thrift::Struct_Union + SUCCESS = 0 + O1 = 1 + + FIELDS = { + SUCCESS => {:type => ::Thrift::Types::STRUCT, :name => 'success', :class => ::CmRecycleResponse}, + O1 => {:type => ::Thrift::Types::STRUCT, :name => 'o1', :class => ::MetaException} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + class Get_file_metadata_by_expr_args include ::Thrift::Struct, ::Thrift::Struct_Union REQ = 1 diff --git a/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java b/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java index e886540..4938fef 100644 --- a/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java +++ b/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java @@ -2066,6 +2066,12 @@ private void alterTableStatsForTruncate(final RawStore ms, } @Override + public CmRecycleResponse cm_recycle(final CmRecycleRequest request) throws MetaException { + wh.recycleDirToCmPath(new Path(request.getDataPath()), request.isPurge()); + return new CmRecycleResponse(); + } + + @Override public void truncate_table(final String dbName, final String tableName, List partNames) throws NoSuchObjectException, MetaException { try { diff --git a/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java b/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java index 0ff4c11..2a3dcc4 100644 --- a/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java +++ b/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java @@ -1125,6 +1125,18 @@ public void truncateTable(String dbName, String tableName, List partName } /** + * Recycles the files recursively from the input path to the cmroot directory either by copying or moving it. + * + * @param request Inputs for path of the data files to be recycled to cmroot and + * isPurge flag when set to true files which needs to be recycled are not moved to Trash + * @return Response which is currently void + */ + @Override + public CmRecycleResponse recycleDirToCmPath(CmRecycleRequest request) throws MetaException, TException { + return client.cm_recycle(request); + } + + /** * @param type * @return true if the type is dropped * @throws MetaException diff --git a/metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java b/metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java index 3663305..64a71df 100644 --- a/metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java +++ b/metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java @@ -32,10 +32,11 @@ import org.apache.hadoop.hive.common.classification.InterfaceStability.Evolving; import org.apache.hadoop.hive.common.classification.RetrySemantics; import org.apache.hadoop.hive.conf.HiveConf; -import org.apache.hadoop.hive.metastore.TableType; import org.apache.hadoop.hive.metastore.annotation.NoReconnect; import org.apache.hadoop.hive.metastore.api.AggrStats; import org.apache.hadoop.hive.metastore.api.AlreadyExistsException; +import org.apache.hadoop.hive.metastore.api.CmRecycleRequest; +import org.apache.hadoop.hive.metastore.api.CmRecycleResponse; import org.apache.hadoop.hive.metastore.api.ColumnStatistics; import org.apache.hadoop.hive.metastore.api.ColumnStatisticsObj; import org.apache.hadoop.hive.metastore.api.CompactionResponse; @@ -322,6 +323,15 @@ void dropTable(String dbname, String tableName) */ void truncateTable(String dbName, String tableName, List partNames) throws MetaException, TException; + /** + * Recycles the files recursively from the input path to the cmroot directory either by copying or moving it. + * + * @param request Inputs for path of the data files to be recycled to cmroot and + * isPurge flag when set to true files which needs to be recycled are not moved to Trash + * @return Response which is currently void + */ + CmRecycleResponse recycleDirToCmPath(CmRecycleRequest request) throws MetaException, TException; + boolean tableExists(String databaseName, String tableName) throws MetaException, TException, UnknownDBException; diff --git a/metastore/src/java/org/apache/hadoop/hive/metastore/Warehouse.java b/metastore/src/java/org/apache/hadoop/hive/metastore/Warehouse.java index 053a0de..fcbcf62 100755 --- a/metastore/src/java/org/apache/hadoop/hive/metastore/Warehouse.java +++ b/metastore/src/java/org/apache/hadoop/hive/metastore/Warehouse.java @@ -220,6 +220,11 @@ public boolean deleteDir(Path f, boolean recursive, boolean ifPurge) throws Meta return fsHandler.deleteDir(fs, f, recursive, ifPurge, conf); } + public void recycleDirToCmPath(Path f, boolean ifPurge) throws MetaException { + cm.recycle(f, ifPurge); + return; + } + public boolean isEmpty(Path path) throws IOException, MetaException { ContentSummary contents = getFs(path).getContentSummary(path); if (contents != null && contents.getFileCount() == 0 && contents.getDirectoryCount() == 1) { diff --git a/ql/src/java/org/apache/hadoop/hive/ql/metadata/Hive.java b/ql/src/java/org/apache/hadoop/hive/ql/metadata/Hive.java index ceb8079..5dbcfde 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/metadata/Hive.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/metadata/Hive.java @@ -84,6 +84,7 @@ import org.apache.hadoop.hive.metastore.Warehouse; import org.apache.hadoop.hive.metastore.api.AggrStats; import org.apache.hadoop.hive.metastore.api.AlreadyExistsException; +import org.apache.hadoop.hive.metastore.api.CmRecycleRequest; import org.apache.hadoop.hive.metastore.api.ColumnStatisticsObj; import org.apache.hadoop.hive.metastore.api.CompactionResponse; import org.apache.hadoop.hive.metastore.api.CompactionType; @@ -3171,6 +3172,22 @@ public static void listNewFilesRecursively(final FileSystem destFs, Path dest, } } + /** + * Recycles the files recursively from the input path to the cmroot directory either by copying or moving it. + * + * @param dataPath Path of the data files to be recycled to cmroot + * @param isPurge + * When set to true files which needs to be recycled are not moved to Trash + */ + public void recycleDirToCmPath(Path dataPath, boolean isPurge) throws HiveException { + try { + CmRecycleRequest request = new CmRecycleRequest(dataPath.toString(), isPurge); + getMSC().recycleDirToCmPath(request); + } catch (Exception e) { + throw new HiveException(e); + } + } + //it is assumed that parent directory of the destf should already exist when this //method is called. when the replace value is true, this method works a little different //from mv command if the destf is a directory, it replaces the destf instead of moving under @@ -3447,7 +3464,6 @@ private static void moveAcidDeltaFiles(String deltaFileType, PathFilter pathFilt } } - /** * Replaces files in the partition with new data set specified by srcf. Works * by renaming directory of srcf to the destination file. @@ -3496,7 +3512,7 @@ protected void replaceFiles(Path tablePath, Path srcf, Path destf, Path oldPath, FileStatus[] statuses = null; try { FileSystem oldFs = oldPath.getFileSystem(conf); - statuses = oldFs.listStatus(oldPath, FileUtils.HIDDEN_FILES_PATH_FILTER); + // Do not delete oldPath if: // - destf is subdir of oldPath isOldPathUnderDestf = isSubDir(oldPath, destf, oldFs, destFs, false); @@ -3505,6 +3521,10 @@ protected void replaceFiles(Path tablePath, Path srcf, Path destf, Path oldPath, // existing content might result in incorrect (extra) data. // But not sure why we changed not to delete the oldPath in HIVE-8750 if it is // not the destf or its subdir? + if (conf.getBoolVar(HiveConf.ConfVars.REPLCMENABLED)) { + recycleDirToCmPath(oldPath, purge); + } + statuses = oldFs.listStatus(oldPath, FileUtils.HIDDEN_FILES_PATH_FILTER); oldPathDeleted = trashFiles(oldFs, statuses, conf, purge); } } catch (IOException e) { @@ -3518,7 +3538,7 @@ protected void replaceFiles(Path tablePath, Path srcf, Path destf, Path oldPath, } } if (statuses != null && statuses.length > 0) { - if (isOldPathUnderDestf && !oldPathDeleted) { + if (!oldPathDeleted) { throw new HiveException("Destination directory " + destf + " has not be cleaned up."); } }