From d0be36c9921a530571b925ec8c718d7a0486a3d9 Mon Sep 17 00:00:00 2001 From: Sankar Hariappan Date: Fri, 24 Mar 2017 13:28:30 +0530 Subject: [PATCH] HIVE-16171: Support replication of truncate table --- .../listener/DbNotificationListener.java | 4 +- .../hive/ql/TestReplicationScenarios.java | 210 ++ metastore/if/hive_metastore.thrift | 2 + .../thrift/gen-cpp/ThriftHiveMetastore.cpp | 2195 +++++++----- .../gen/thrift/gen-cpp/ThriftHiveMetastore.h | 139 + .../ThriftHiveMetastore_server.skeleton.cpp | 5 + .../metastore/api/ThriftHiveMetastore.java | 3116 +++++++++++------ .../gen-php/metastore/ThriftHiveMetastore.php | 1350 ++++--- .../hive_metastore/ThriftHiveMetastore-remote | 7 + .../hive_metastore/ThriftHiveMetastore.py | 948 +++-- .../thrift/gen-rb/thrift_hive_metastore.rb | 62 + .../hive/metastore/HiveAlterHandler.java | 10 +- .../hadoop/hive/metastore/HiveMetaStore.java | 153 +- .../hive/metastore/HiveMetaStoreClient.java | 17 + .../hive/metastore/IMetaStoreClient.java | 14 + .../metastore/MetaStoreEventListener.java | 12 +- .../metastore/events/AlterPartitionEvent.java | 14 +- .../metastore/events/AlterTableEvent.java | 12 +- .../messaging/AlterPartitionMessage.java | 2 + .../messaging/AlterTableMessage.java | 2 + .../metastore/messaging/MessageFactory.java | 6 +- .../json/JSONAlterPartitionMessage.java | 9 +- .../messaging/json/JSONAlterTableMessage.java | 9 +- .../messaging/json/JSONMessageFactory.java | 13 +- .../apache/hadoop/hive/ql/exec/DDLTask.java | 78 +- .../apache/hadoop/hive/ql/metadata/Hive.java | 21 + .../hive/ql/parse/ImportSemanticAnalyzer.java | 2 +- .../ql/parse/ReplicationSemanticAnalyzer.java | 55 + .../repl/events/AlterPartitionHandler.java | 13 +- .../parse/repl/events/AlterTableHandler.java | 21 +- ...columnStatsUpdateForStatsOptimizer_2.q.out | 8 +- 31 files changed, 5629 insertions(+), 2880 deletions(-) diff --git a/hcatalog/server-extensions/src/main/java/org/apache/hive/hcatalog/listener/DbNotificationListener.java b/hcatalog/server-extensions/src/main/java/org/apache/hive/hcatalog/listener/DbNotificationListener.java index df423f0ec80c..6f96e1d0269e 100644 --- a/hcatalog/server-extensions/src/main/java/org/apache/hive/hcatalog/listener/DbNotificationListener.java +++ b/hcatalog/server-extensions/src/main/java/org/apache/hive/hcatalog/listener/DbNotificationListener.java @@ -166,7 +166,7 @@ public void onAlterTable(AlterTableEvent tableEvent) throws MetaException { Table after = tableEvent.getNewTable(); NotificationEvent event = new NotificationEvent(0, now(), EventType.ALTER_TABLE.toString(), msgFactory - .buildAlterTableMessage(before, after).toString()); + .buildAlterTableMessage(before, after, tableEvent.getIsTruncateOp()).toString()); event.setDbName(after.getDbName()); event.setTableName(after.getTableName()); process(event, tableEvent); @@ -305,7 +305,7 @@ public void onAlterPartition(AlterPartitionEvent partitionEvent) throws MetaExce Partition after = partitionEvent.getNewPartition(); NotificationEvent event = new NotificationEvent(0, now(), EventType.ALTER_PARTITION.toString(), msgFactory - .buildAlterPartitionMessage(partitionEvent.getTable(), before, after).toString()); + .buildAlterPartitionMessage(partitionEvent.getTable(), before, after, partitionEvent.getIsTruncateOp()).toString()); event.setDbName(before.getDbName()); event.setTableName(before.getTableName()); process(event, partitionEvent); diff --git a/itests/hive-unit/src/test/java/org/apache/hadoop/hive/ql/TestReplicationScenarios.java b/itests/hive-unit/src/test/java/org/apache/hadoop/hive/ql/TestReplicationScenarios.java index ec238d272914..9b8563be08ff 100644 --- a/itests/hive-unit/src/test/java/org/apache/hadoop/hive/ql/TestReplicationScenarios.java +++ b/itests/hive-unit/src/test/java/org/apache/hadoop/hive/ql/TestReplicationScenarios.java @@ -1240,6 +1240,216 @@ public void testExchangePartition() throws IOException { verifyRun("SELECT a from " + dbName + "_dupe.ptned_dest where (b=2 and c=3) ORDER BY a", ptn_data_2); } + @Test + public void testTruncateTable() throws IOException { + String testName = "truncateTable"; + 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 + "'"); + + String[] unptn_data = new String[] { "eleven", "twelve" }; + String[] empty = new String[] {}; + run("INSERT INTO TABLE " + dbName + ".unptned values('" + unptn_data[0] + "')"); + run("INSERT INTO TABLE " + dbName + ".unptned values('" + unptn_data[1] + "')"); + verifyRun("SELECT a from " + dbName + ".unptned ORDER BY a", unptn_data); + + advanceDumpDir(); + run("REPL DUMP " + dbName + " FROM " + replDumpId); + 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; + run("EXPLAIN REPL LOAD " + dbName + "_dupe FROM '" + incrementalDumpLocn + "'"); + printOutput(); + run("REPL LOAD " + dbName + "_dupe FROM '" + incrementalDumpLocn + "'"); + verifyRun("SELECT a from " + dbName + ".unptned ORDER BY a", unptn_data); + verifyRun("SELECT a from " + dbName + "_dupe.unptned ORDER BY a", unptn_data); + + run("TRUNCATE TABLE " + dbName + ".unptned"); + verifySetup("SELECT a from " + dbName + ".unptned", empty); + + 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); + replDumpId = incrementalDumpId; + run("REPL LOAD " + dbName + "_dupe FROM '" + incrementalDumpLocn + "'"); + verifyRun("SELECT a from " + dbName + ".unptned", empty); + verifyRun("SELECT a from " + dbName + "_dupe.unptned", empty); + + String[] unptn_data_after_ins = new String[] { "thirteen" }; + run("INSERT INTO TABLE " + dbName + ".unptned values('" + unptn_data_after_ins[0] + "')"); + verifySetup("SELECT a from " + dbName + ".unptned ORDER BY a", unptn_data_after_ins); + + 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); + replDumpId = incrementalDumpId; + run("REPL LOAD " + dbName + "_dupe FROM '" + incrementalDumpLocn + "'"); + verifyRun("SELECT a from " + dbName + ".unptned ORDER BY a", unptn_data_after_ins); + verifyRun("SELECT a from " + dbName + "_dupe.unptned ORDER BY a", unptn_data_after_ins); + } + + @Test + public void testTruncatePartitionedTable() throws IOException { + String testName = "truncatePartitionedTable"; + LOG.info("Testing " + testName); + String dbName = testName + "_" + tid; + + run("CREATE DATABASE " + dbName); + run("CREATE TABLE " + dbName + ".ptned_1(a string) PARTITIONED BY (b int) STORED AS TEXTFILE"); + run("CREATE TABLE " + dbName + ".ptned_2(a string) PARTITIONED BY (b int) STORED AS TEXTFILE"); + + String[] ptn_data_1 = new String[] { "fifteen", "fourteen", "thirteen" }; + String[] ptn_data_2 = new String[] { "fifteen", "seventeen", "sixteen" }; + String[] empty = new String[] {}; + run("INSERT INTO TABLE " + dbName + ".ptned_1 PARTITION(b=1) values('" + ptn_data_1[0] + "')"); + run("INSERT INTO TABLE " + dbName + ".ptned_1 PARTITION(b=1) values('" + ptn_data_1[1] + "')"); + run("INSERT INTO TABLE " + dbName + ".ptned_1 PARTITION(b=1) values('" + ptn_data_1[2] + "')"); + run("INSERT INTO TABLE " + dbName + ".ptned_1 PARTITION(b=2) values('" + ptn_data_2[0] + "')"); + run("INSERT INTO TABLE " + dbName + ".ptned_1 PARTITION(b=2) values('" + ptn_data_2[1] + "')"); + run("INSERT INTO TABLE " + dbName + ".ptned_1 PARTITION(b=2) values('" + ptn_data_2[2] + "')"); + + run("INSERT INTO TABLE " + dbName + ".ptned_2 PARTITION(b=10) values('" + ptn_data_1[0] + "')"); + run("INSERT INTO TABLE " + dbName + ".ptned_2 PARTITION(b=10) values('" + ptn_data_1[1] + "')"); + run("INSERT INTO TABLE " + dbName + ".ptned_2 PARTITION(b=10) values('" + ptn_data_1[2] + "')"); + run("INSERT INTO TABLE " + dbName + ".ptned_2 PARTITION(b=20) values('" + ptn_data_2[0] + "')"); + run("INSERT INTO TABLE " + dbName + ".ptned_2 PARTITION(b=20) values('" + ptn_data_2[1] + "')"); + run("INSERT INTO TABLE " + dbName + ".ptned_2 PARTITION(b=20) values('" + ptn_data_2[2] + "')"); + + verifyRun("SELECT a from " + dbName + ".ptned_1 where (b=1) ORDER BY a", ptn_data_1); + verifyRun("SELECT a from " + dbName + ".ptned_1 where (b=2) ORDER BY a", ptn_data_2); + verifyRun("SELECT a from " + dbName + ".ptned_2 where (b=10) ORDER BY a", ptn_data_1); + verifyRun("SELECT a from " + dbName + ".ptned_2 where (b=20) ORDER BY a", ptn_data_2); + + 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 + "'"); + verifyRun("SELECT a from " + dbName + "_dupe.ptned_1 where (b=1) ORDER BY a", ptn_data_1); + verifyRun("SELECT a from " + dbName + "_dupe.ptned_1 where (b=2) ORDER BY a", ptn_data_2); + verifyRun("SELECT a from " + dbName + "_dupe.ptned_2 where (b=10) ORDER BY a", ptn_data_1); + verifyRun("SELECT a from " + dbName + "_dupe.ptned_2 where (b=20) ORDER BY a", ptn_data_2); + + run("TRUNCATE TABLE " + dbName + ".ptned_1 PARTITION(b=2)"); + verifySetup("SELECT a from " + dbName + ".ptned_1 where (b=1) ORDER BY a", ptn_data_1); + verifySetup("SELECT a from " + dbName + ".ptned_1 where (b=2)", empty); + + run("TRUNCATE TABLE " + dbName + ".ptned_2"); + verifySetup("SELECT a from " + dbName + ".ptned_2 where (b=10)", empty); + verifySetup("SELECT a from " + dbName + ".ptned_2 where (b=20)", empty); + + advanceDumpDir(); + run("REPL DUMP " + dbName + " FROM " + replDumpId); + 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; + run("REPL LOAD " + dbName + "_dupe FROM '" + incrementalDumpLocn + "'"); + verifySetup("SELECT a from " + dbName + "_dupe.ptned_1 where (b=1) ORDER BY a", ptn_data_1); + verifySetup("SELECT a from " + dbName + "_dupe.ptned_1 where (b=2)", empty); + verifySetup("SELECT a from " + dbName + "_dupe.ptned_2 where (b=10)", empty); + verifySetup("SELECT a from " + dbName + "_dupe.ptned_2 where (b=20)", empty); + } + + @Test + public void testTruncateWithCM() throws IOException { + String testName = "truncateWithCM"; + 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); + + String[] empty = new String[] {}; + String[] unptn_data = new String[] { "eleven", "thirteen" }; + String[] unptn_data_load1 = new String[] { "eleven" }; + String[] unptn_data_load2 = new String[] { "eleven", "thirteen" }; + + // 3 events to insert, last repl ID: replDumpId+3 + run("INSERT INTO TABLE " + dbName + ".unptned values('" + unptn_data[0] + "')"); + // 3 events to insert, last repl ID: replDumpId+6 + run("INSERT INTO TABLE " + dbName + ".unptned values('" + unptn_data[1] + "')"); + verifyRun("SELECT a from " + dbName + ".unptned ORDER BY a", unptn_data); + // 1 event to truncate, last repl ID: replDumpId+8 + run("TRUNCATE TABLE " + dbName + ".unptned"); + verifyRun("SELECT a from " + dbName + ".unptned ORDER BY a", empty); + // 3 events to insert, last repl ID: replDumpId+11 + run("INSERT INTO TABLE " + dbName + ".unptned values('" + unptn_data_load1[0] + "')"); + verifyRun("SELECT a from " + dbName + ".unptned ORDER BY a", unptn_data_load1); + + run("REPL LOAD " + dbName + "_dupe FROM '" + replDumpLocn + "'"); + + // Dump and load only first insert (1 record) + advanceDumpDir(); + run("REPL DUMP " + dbName + " FROM " + replDumpId + " LIMIT 3"); + 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; + + run("REPL LOAD " + dbName + "_dupe FROM '" + incrementalDumpLocn + "'"); + verifyRun("SELECT a from " + dbName + ".unptned ORDER BY a", unptn_data_load1); + verifyRun("SELECT a from " + dbName + "_dupe.unptned ORDER BY a", unptn_data_load1); + + // Dump and load only second insert (2 records) + advanceDumpDir(); + Integer lastReplID = Integer.valueOf(replDumpId); + lastReplID += 1000; + String toReplID = String.valueOf(lastReplID); + + run("REPL DUMP " + dbName + " FROM " + replDumpId + " TO " + toReplID + " LIMIT 3"); + incrementalDumpLocn = getResult(0, 0); + incrementalDumpId = getResult(0, 1, true); + LOG.info("Incremental-Dump: Dumped to {} with id {} from {}", incrementalDumpLocn, incrementalDumpId, replDumpId); + replDumpId = incrementalDumpId; + run("REPL LOAD " + dbName + "_dupe FROM '" + incrementalDumpLocn + "'"); + + verifyRun("SELECT a from " + dbName + "_dupe.unptned ORDER BY a", unptn_data_load2); + + // Dump and load only truncate (0 records) + advanceDumpDir(); + run("REPL DUMP " + dbName + " FROM " + replDumpId + " LIMIT 2"); + incrementalDumpLocn = getResult(0, 0); + incrementalDumpId = getResult(0, 1, true); + LOG.info("Incremental-Dump: Dumped to {} with id {} from {}", incrementalDumpLocn, incrementalDumpId, replDumpId); + replDumpId = incrementalDumpId; + run("REPL LOAD " + dbName + "_dupe FROM '" + incrementalDumpLocn + "'"); + + verifyRun("SELECT a from " + dbName + "_dupe.unptned ORDER BY a", empty); + + // Dump and load insert after truncate (1 record) + 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); + replDumpId = incrementalDumpId; + run("REPL LOAD " + dbName + "_dupe FROM '" + incrementalDumpLocn + "'"); + + verifyRun("SELECT a from " + dbName + "_dupe.unptned ORDER BY a", unptn_data_load1); + } + @Test public void testStatus() throws IOException { // first test ReplStateMap functionality diff --git a/metastore/if/hive_metastore.thrift b/metastore/if/hive_metastore.thrift index a1bdc30bed81..ff66836620db 100755 --- a/metastore/if/hive_metastore.thrift +++ b/metastore/if/hive_metastore.thrift @@ -1072,6 +1072,8 @@ service ThriftHiveMetastore extends fb303.FacebookService void drop_table_with_environment_context(1:string dbname, 2:string name, 3:bool deleteData, 4:EnvironmentContext environment_context) throws(1:NoSuchObjectException o1, 2:MetaException o3) + void truncate_table(1:string dbName, 2:string tableName, 3:list partNames) + throws(1:MetaException o1) list get_tables(1: string db_name, 2: string pattern) throws (1: MetaException o1) list get_tables_by_type(1: string db_name, 2: string pattern, 3: string tableType) throws (1: MetaException o1) list get_table_meta(1: string db_patterns, 2: string tbl_patterns, 3: list tbl_types) diff --git a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp index 42de24e3ed73..54d6438f1e78 100644 --- a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp +++ b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp @@ -5931,6 +5931,253 @@ uint32_t ThriftHiveMetastore_drop_table_with_environment_context_presult::read(: } +ThriftHiveMetastore_truncate_table_args::~ThriftHiveMetastore_truncate_table_args() throw() { +} + + +uint32_t ThriftHiveMetastore_truncate_table_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + this->__isset.dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tableName); + this->__isset.tableName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partNames.clear(); + uint32_t _size913; + ::apache::thrift::protocol::TType _etype916; + xfer += iprot->readListBegin(_etype916, _size913); + this->partNames.resize(_size913); + uint32_t _i917; + for (_i917 = 0; _i917 < _size913; ++_i917) + { + xfer += iprot->readString(this->partNames[_i917]); + } + xfer += iprot->readListEnd(); + } + this->__isset.partNames = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_truncate_table_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_truncate_table_args"); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tableName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("partNames", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partNames.size())); + std::vector ::const_iterator _iter918; + for (_iter918 = this->partNames.begin(); _iter918 != this->partNames.end(); ++_iter918) + { + xfer += oprot->writeString((*_iter918)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_truncate_table_pargs::~ThriftHiveMetastore_truncate_table_pargs() throw() { +} + + +uint32_t ThriftHiveMetastore_truncate_table_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_truncate_table_pargs"); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->dbName))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tableName))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("partNames", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->partNames)).size())); + std::vector ::const_iterator _iter919; + for (_iter919 = (*(this->partNames)).begin(); _iter919 != (*(this->partNames)).end(); ++_iter919) + { + xfer += oprot->writeString((*_iter919)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_truncate_table_result::~ThriftHiveMetastore_truncate_table_result() throw() { +} + + +uint32_t ThriftHiveMetastore_truncate_table_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_truncate_table_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_truncate_table_result"); + + 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_truncate_table_presult::~ThriftHiveMetastore_truncate_table_presult() throw() { +} + + +uint32_t ThriftHiveMetastore_truncate_table_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + ThriftHiveMetastore_get_tables_args::~ThriftHiveMetastore_get_tables_args() throw() { } @@ -6055,14 +6302,14 @@ uint32_t ThriftHiveMetastore_get_tables_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size913; - ::apache::thrift::protocol::TType _etype916; - xfer += iprot->readListBegin(_etype916, _size913); - this->success.resize(_size913); - uint32_t _i917; - for (_i917 = 0; _i917 < _size913; ++_i917) + uint32_t _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 += iprot->readString(this->success[_i917]); + xfer += iprot->readString(this->success[_i924]); } xfer += iprot->readListEnd(); } @@ -6101,10 +6348,10 @@ uint32_t ThriftHiveMetastore_get_tables_result::write(::apache::thrift::protocol xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter918; - for (_iter918 = this->success.begin(); _iter918 != this->success.end(); ++_iter918) + std::vector ::const_iterator _iter925; + for (_iter925 = this->success.begin(); _iter925 != this->success.end(); ++_iter925) { - xfer += oprot->writeString((*_iter918)); + xfer += oprot->writeString((*_iter925)); } xfer += oprot->writeListEnd(); } @@ -6149,14 +6396,14 @@ uint32_t ThriftHiveMetastore_get_tables_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size919; - ::apache::thrift::protocol::TType _etype922; - xfer += iprot->readListBegin(_etype922, _size919); - (*(this->success)).resize(_size919); - uint32_t _i923; - for (_i923 = 0; _i923 < _size919; ++_i923) + uint32_t _size926; + ::apache::thrift::protocol::TType _etype929; + xfer += iprot->readListBegin(_etype929, _size926); + (*(this->success)).resize(_size926); + uint32_t _i930; + for (_i930 = 0; _i930 < _size926; ++_i930) { - xfer += iprot->readString((*(this->success))[_i923]); + xfer += iprot->readString((*(this->success))[_i930]); } xfer += iprot->readListEnd(); } @@ -6326,14 +6573,14 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_result::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size924; - ::apache::thrift::protocol::TType _etype927; - xfer += iprot->readListBegin(_etype927, _size924); - this->success.resize(_size924); - uint32_t _i928; - for (_i928 = 0; _i928 < _size924; ++_i928) + uint32_t _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 += iprot->readString(this->success[_i928]); + xfer += iprot->readString(this->success[_i935]); } xfer += iprot->readListEnd(); } @@ -6372,10 +6619,10 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_result::write(::apache::thrift:: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter929; - for (_iter929 = this->success.begin(); _iter929 != this->success.end(); ++_iter929) + std::vector ::const_iterator _iter936; + for (_iter936 = this->success.begin(); _iter936 != this->success.end(); ++_iter936) { - xfer += oprot->writeString((*_iter929)); + xfer += oprot->writeString((*_iter936)); } xfer += oprot->writeListEnd(); } @@ -6420,14 +6667,14 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_presult::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size930; - ::apache::thrift::protocol::TType _etype933; - xfer += iprot->readListBegin(_etype933, _size930); - (*(this->success)).resize(_size930); - uint32_t _i934; - for (_i934 = 0; _i934 < _size930; ++_i934) + uint32_t _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 += iprot->readString((*(this->success))[_i934]); + xfer += iprot->readString((*(this->success))[_i941]); } xfer += iprot->readListEnd(); } @@ -6502,14 +6749,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tbl_types.clear(); - uint32_t _size935; - ::apache::thrift::protocol::TType _etype938; - xfer += iprot->readListBegin(_etype938, _size935); - this->tbl_types.resize(_size935); - uint32_t _i939; - for (_i939 = 0; _i939 < _size935; ++_i939) + uint32_t _size942; + ::apache::thrift::protocol::TType _etype945; + xfer += iprot->readListBegin(_etype945, _size942); + this->tbl_types.resize(_size942); + uint32_t _i946; + for (_i946 = 0; _i946 < _size942; ++_i946) { - xfer += iprot->readString(this->tbl_types[_i939]); + xfer += iprot->readString(this->tbl_types[_i946]); } xfer += iprot->readListEnd(); } @@ -6546,10 +6793,10 @@ uint32_t ThriftHiveMetastore_get_table_meta_args::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("tbl_types", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->tbl_types.size())); - std::vector ::const_iterator _iter940; - for (_iter940 = this->tbl_types.begin(); _iter940 != this->tbl_types.end(); ++_iter940) + std::vector ::const_iterator _iter947; + for (_iter947 = this->tbl_types.begin(); _iter947 != this->tbl_types.end(); ++_iter947) { - xfer += oprot->writeString((*_iter940)); + xfer += oprot->writeString((*_iter947)); } xfer += oprot->writeListEnd(); } @@ -6581,10 +6828,10 @@ uint32_t ThriftHiveMetastore_get_table_meta_pargs::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("tbl_types", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->tbl_types)).size())); - std::vector ::const_iterator _iter941; - for (_iter941 = (*(this->tbl_types)).begin(); _iter941 != (*(this->tbl_types)).end(); ++_iter941) + std::vector ::const_iterator _iter948; + for (_iter948 = (*(this->tbl_types)).begin(); _iter948 != (*(this->tbl_types)).end(); ++_iter948) { - xfer += oprot->writeString((*_iter941)); + xfer += oprot->writeString((*_iter948)); } xfer += oprot->writeListEnd(); } @@ -6625,14 +6872,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size942; - ::apache::thrift::protocol::TType _etype945; - xfer += iprot->readListBegin(_etype945, _size942); - this->success.resize(_size942); - uint32_t _i946; - for (_i946 = 0; _i946 < _size942; ++_i946) + uint32_t _size949; + ::apache::thrift::protocol::TType _etype952; + xfer += iprot->readListBegin(_etype952, _size949); + this->success.resize(_size949); + uint32_t _i953; + for (_i953 = 0; _i953 < _size949; ++_i953) { - xfer += this->success[_i946].read(iprot); + xfer += this->success[_i953].read(iprot); } xfer += iprot->readListEnd(); } @@ -6671,10 +6918,10 @@ uint32_t ThriftHiveMetastore_get_table_meta_result::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter947; - for (_iter947 = this->success.begin(); _iter947 != this->success.end(); ++_iter947) + std::vector ::const_iterator _iter954; + for (_iter954 = this->success.begin(); _iter954 != this->success.end(); ++_iter954) { - xfer += (*_iter947).write(oprot); + xfer += (*_iter954).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6719,14 +6966,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size948; - ::apache::thrift::protocol::TType _etype951; - xfer += iprot->readListBegin(_etype951, _size948); - (*(this->success)).resize(_size948); - uint32_t _i952; - for (_i952 = 0; _i952 < _size948; ++_i952) + uint32_t _size955; + ::apache::thrift::protocol::TType _etype958; + xfer += iprot->readListBegin(_etype958, _size955); + (*(this->success)).resize(_size955); + uint32_t _i959; + for (_i959 = 0; _i959 < _size955; ++_i959) { - xfer += (*(this->success))[_i952].read(iprot); + xfer += (*(this->success))[_i959].read(iprot); } xfer += iprot->readListEnd(); } @@ -6864,14 +7111,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size953; - ::apache::thrift::protocol::TType _etype956; - xfer += iprot->readListBegin(_etype956, _size953); - this->success.resize(_size953); - uint32_t _i957; - for (_i957 = 0; _i957 < _size953; ++_i957) + uint32_t _size960; + ::apache::thrift::protocol::TType _etype963; + xfer += iprot->readListBegin(_etype963, _size960); + this->success.resize(_size960); + uint32_t _i964; + for (_i964 = 0; _i964 < _size960; ++_i964) { - xfer += iprot->readString(this->success[_i957]); + xfer += iprot->readString(this->success[_i964]); } xfer += iprot->readListEnd(); } @@ -6910,10 +7157,10 @@ uint32_t ThriftHiveMetastore_get_all_tables_result::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter958; - for (_iter958 = this->success.begin(); _iter958 != this->success.end(); ++_iter958) + std::vector ::const_iterator _iter965; + for (_iter965 = this->success.begin(); _iter965 != this->success.end(); ++_iter965) { - xfer += oprot->writeString((*_iter958)); + xfer += oprot->writeString((*_iter965)); } xfer += oprot->writeListEnd(); } @@ -6958,14 +7205,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size959; - ::apache::thrift::protocol::TType _etype962; - xfer += iprot->readListBegin(_etype962, _size959); - (*(this->success)).resize(_size959); - uint32_t _i963; - for (_i963 = 0; _i963 < _size959; ++_i963) + uint32_t _size966; + ::apache::thrift::protocol::TType _etype969; + xfer += iprot->readListBegin(_etype969, _size966); + (*(this->success)).resize(_size966); + uint32_t _i970; + for (_i970 = 0; _i970 < _size966; ++_i970) { - xfer += iprot->readString((*(this->success))[_i963]); + xfer += iprot->readString((*(this->success))[_i970]); } xfer += iprot->readListEnd(); } @@ -7275,14 +7522,14 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_args::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tbl_names.clear(); - uint32_t _size964; - ::apache::thrift::protocol::TType _etype967; - xfer += iprot->readListBegin(_etype967, _size964); - this->tbl_names.resize(_size964); - uint32_t _i968; - for (_i968 = 0; _i968 < _size964; ++_i968) + uint32_t _size971; + ::apache::thrift::protocol::TType _etype974; + xfer += iprot->readListBegin(_etype974, _size971); + this->tbl_names.resize(_size971); + uint32_t _i975; + for (_i975 = 0; _i975 < _size971; ++_i975) { - xfer += iprot->readString(this->tbl_names[_i968]); + xfer += iprot->readString(this->tbl_names[_i975]); } xfer += iprot->readListEnd(); } @@ -7315,10 +7562,10 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_args::write(::apache::thr xfer += oprot->writeFieldBegin("tbl_names", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->tbl_names.size())); - std::vector ::const_iterator _iter969; - for (_iter969 = this->tbl_names.begin(); _iter969 != this->tbl_names.end(); ++_iter969) + std::vector ::const_iterator _iter976; + for (_iter976 = this->tbl_names.begin(); _iter976 != this->tbl_names.end(); ++_iter976) { - xfer += oprot->writeString((*_iter969)); + xfer += oprot->writeString((*_iter976)); } xfer += oprot->writeListEnd(); } @@ -7346,10 +7593,10 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_pargs::write(::apache::th xfer += oprot->writeFieldBegin("tbl_names", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->tbl_names)).size())); - std::vector ::const_iterator _iter970; - for (_iter970 = (*(this->tbl_names)).begin(); _iter970 != (*(this->tbl_names)).end(); ++_iter970) + std::vector ::const_iterator _iter977; + for (_iter977 = (*(this->tbl_names)).begin(); _iter977 != (*(this->tbl_names)).end(); ++_iter977) { - xfer += oprot->writeString((*_iter970)); + xfer += oprot->writeString((*_iter977)); } xfer += oprot->writeListEnd(); } @@ -7390,14 +7637,14 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_result::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size971; - ::apache::thrift::protocol::TType _etype974; - xfer += iprot->readListBegin(_etype974, _size971); - this->success.resize(_size971); - uint32_t _i975; - for (_i975 = 0; _i975 < _size971; ++_i975) + uint32_t _size978; + ::apache::thrift::protocol::TType _etype981; + xfer += iprot->readListBegin(_etype981, _size978); + this->success.resize(_size978); + uint32_t _i982; + for (_i982 = 0; _i982 < _size978; ++_i982) { - xfer += this->success[_i975].read(iprot); + xfer += this->success[_i982].read(iprot); } xfer += iprot->readListEnd(); } @@ -7428,10 +7675,10 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_result::write(::apache::t xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter976; - for (_iter976 = this->success.begin(); _iter976 != this->success.end(); ++_iter976) + std::vector
::const_iterator _iter983; + for (_iter983 = this->success.begin(); _iter983 != this->success.end(); ++_iter983) { - xfer += (*_iter976).write(oprot); + xfer += (*_iter983).write(oprot); } xfer += oprot->writeListEnd(); } @@ -7472,14 +7719,14 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_presult::read(::apache::t if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size977; - ::apache::thrift::protocol::TType _etype980; - xfer += iprot->readListBegin(_etype980, _size977); - (*(this->success)).resize(_size977); - uint32_t _i981; - for (_i981 = 0; _i981 < _size977; ++_i981) + uint32_t _size984; + ::apache::thrift::protocol::TType _etype987; + xfer += iprot->readListBegin(_etype987, _size984); + (*(this->success)).resize(_size984); + uint32_t _i988; + for (_i988 = 0; _i988 < _size984; ++_i988) { - xfer += (*(this->success))[_i981].read(iprot); + xfer += (*(this->success))[_i988].read(iprot); } xfer += iprot->readListEnd(); } @@ -8115,14 +8362,14 @@ uint32_t ThriftHiveMetastore_get_table_names_by_filter_result::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size982; - ::apache::thrift::protocol::TType _etype985; - xfer += iprot->readListBegin(_etype985, _size982); - this->success.resize(_size982); - uint32_t _i986; - for (_i986 = 0; _i986 < _size982; ++_i986) + uint32_t _size989; + ::apache::thrift::protocol::TType _etype992; + xfer += iprot->readListBegin(_etype992, _size989); + this->success.resize(_size989); + uint32_t _i993; + for (_i993 = 0; _i993 < _size989; ++_i993) { - xfer += iprot->readString(this->success[_i986]); + xfer += iprot->readString(this->success[_i993]); } xfer += iprot->readListEnd(); } @@ -8177,10 +8424,10 @@ uint32_t ThriftHiveMetastore_get_table_names_by_filter_result::write(::apache::t xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter987; - for (_iter987 = this->success.begin(); _iter987 != this->success.end(); ++_iter987) + std::vector ::const_iterator _iter994; + for (_iter994 = this->success.begin(); _iter994 != this->success.end(); ++_iter994) { - xfer += oprot->writeString((*_iter987)); + xfer += oprot->writeString((*_iter994)); } xfer += oprot->writeListEnd(); } @@ -8233,14 +8480,14 @@ uint32_t ThriftHiveMetastore_get_table_names_by_filter_presult::read(::apache::t if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size988; - ::apache::thrift::protocol::TType _etype991; - xfer += iprot->readListBegin(_etype991, _size988); - (*(this->success)).resize(_size988); - uint32_t _i992; - for (_i992 = 0; _i992 < _size988; ++_i992) + uint32_t _size995; + ::apache::thrift::protocol::TType _etype998; + xfer += iprot->readListBegin(_etype998, _size995); + (*(this->success)).resize(_size995); + uint32_t _i999; + for (_i999 = 0; _i999 < _size995; ++_i999) { - xfer += iprot->readString((*(this->success))[_i992]); + xfer += iprot->readString((*(this->success))[_i999]); } xfer += iprot->readListEnd(); } @@ -9574,14 +9821,14 @@ uint32_t ThriftHiveMetastore_add_partitions_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size993; - ::apache::thrift::protocol::TType _etype996; - xfer += iprot->readListBegin(_etype996, _size993); - this->new_parts.resize(_size993); - uint32_t _i997; - for (_i997 = 0; _i997 < _size993; ++_i997) + uint32_t _size1000; + ::apache::thrift::protocol::TType _etype1003; + xfer += iprot->readListBegin(_etype1003, _size1000); + this->new_parts.resize(_size1000); + uint32_t _i1004; + for (_i1004 = 0; _i1004 < _size1000; ++_i1004) { - xfer += this->new_parts[_i997].read(iprot); + xfer += this->new_parts[_i1004].read(iprot); } xfer += iprot->readListEnd(); } @@ -9610,10 +9857,10 @@ uint32_t ThriftHiveMetastore_add_partitions_args::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->new_parts.size())); - std::vector ::const_iterator _iter998; - for (_iter998 = this->new_parts.begin(); _iter998 != this->new_parts.end(); ++_iter998) + std::vector ::const_iterator _iter1005; + for (_iter1005 = this->new_parts.begin(); _iter1005 != this->new_parts.end(); ++_iter1005) { - xfer += (*_iter998).write(oprot); + xfer += (*_iter1005).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9637,10 +9884,10 @@ uint32_t ThriftHiveMetastore_add_partitions_pargs::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->new_parts)).size())); - std::vector ::const_iterator _iter999; - for (_iter999 = (*(this->new_parts)).begin(); _iter999 != (*(this->new_parts)).end(); ++_iter999) + std::vector ::const_iterator _iter1006; + for (_iter1006 = (*(this->new_parts)).begin(); _iter1006 != (*(this->new_parts)).end(); ++_iter1006) { - xfer += (*_iter999).write(oprot); + xfer += (*_iter1006).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9849,14 +10096,14 @@ uint32_t ThriftHiveMetastore_add_partitions_pspec_args::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size1000; - ::apache::thrift::protocol::TType _etype1003; - xfer += iprot->readListBegin(_etype1003, _size1000); - this->new_parts.resize(_size1000); - uint32_t _i1004; - for (_i1004 = 0; _i1004 < _size1000; ++_i1004) + uint32_t _size1007; + ::apache::thrift::protocol::TType _etype1010; + xfer += iprot->readListBegin(_etype1010, _size1007); + this->new_parts.resize(_size1007); + uint32_t _i1011; + for (_i1011 = 0; _i1011 < _size1007; ++_i1011) { - xfer += this->new_parts[_i1004].read(iprot); + xfer += this->new_parts[_i1011].read(iprot); } xfer += iprot->readListEnd(); } @@ -9885,10 +10132,10 @@ uint32_t ThriftHiveMetastore_add_partitions_pspec_args::write(::apache::thrift:: xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->new_parts.size())); - std::vector ::const_iterator _iter1005; - for (_iter1005 = this->new_parts.begin(); _iter1005 != this->new_parts.end(); ++_iter1005) + std::vector ::const_iterator _iter1012; + for (_iter1012 = this->new_parts.begin(); _iter1012 != this->new_parts.end(); ++_iter1012) { - xfer += (*_iter1005).write(oprot); + xfer += (*_iter1012).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9912,10 +10159,10 @@ uint32_t ThriftHiveMetastore_add_partitions_pspec_pargs::write(::apache::thrift: xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->new_parts)).size())); - std::vector ::const_iterator _iter1006; - for (_iter1006 = (*(this->new_parts)).begin(); _iter1006 != (*(this->new_parts)).end(); ++_iter1006) + std::vector ::const_iterator _iter1013; + for (_iter1013 = (*(this->new_parts)).begin(); _iter1013 != (*(this->new_parts)).end(); ++_iter1013) { - xfer += (*_iter1006).write(oprot); + xfer += (*_iter1013).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10140,14 +10387,14 @@ uint32_t ThriftHiveMetastore_append_partition_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1007; - ::apache::thrift::protocol::TType _etype1010; - xfer += iprot->readListBegin(_etype1010, _size1007); - this->part_vals.resize(_size1007); - uint32_t _i1011; - for (_i1011 = 0; _i1011 < _size1007; ++_i1011) + uint32_t _size1014; + ::apache::thrift::protocol::TType _etype1017; + xfer += iprot->readListBegin(_etype1017, _size1014); + this->part_vals.resize(_size1014); + uint32_t _i1018; + for (_i1018 = 0; _i1018 < _size1014; ++_i1018) { - xfer += iprot->readString(this->part_vals[_i1011]); + xfer += iprot->readString(this->part_vals[_i1018]); } xfer += iprot->readListEnd(); } @@ -10184,10 +10431,10 @@ uint32_t ThriftHiveMetastore_append_partition_args::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter1012; - for (_iter1012 = this->part_vals.begin(); _iter1012 != this->part_vals.end(); ++_iter1012) + std::vector ::const_iterator _iter1019; + for (_iter1019 = this->part_vals.begin(); _iter1019 != this->part_vals.end(); ++_iter1019) { - xfer += oprot->writeString((*_iter1012)); + xfer += oprot->writeString((*_iter1019)); } xfer += oprot->writeListEnd(); } @@ -10219,10 +10466,10 @@ uint32_t ThriftHiveMetastore_append_partition_pargs::write(::apache::thrift::pro xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter1013; - for (_iter1013 = (*(this->part_vals)).begin(); _iter1013 != (*(this->part_vals)).end(); ++_iter1013) + std::vector ::const_iterator _iter1020; + for (_iter1020 = (*(this->part_vals)).begin(); _iter1020 != (*(this->part_vals)).end(); ++_iter1020) { - xfer += oprot->writeString((*_iter1013)); + xfer += oprot->writeString((*_iter1020)); } xfer += oprot->writeListEnd(); } @@ -10694,14 +10941,14 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::rea if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1014; - ::apache::thrift::protocol::TType _etype1017; - xfer += iprot->readListBegin(_etype1017, _size1014); - this->part_vals.resize(_size1014); - uint32_t _i1018; - for (_i1018 = 0; _i1018 < _size1014; ++_i1018) + uint32_t _size1021; + ::apache::thrift::protocol::TType _etype1024; + xfer += iprot->readListBegin(_etype1024, _size1021); + this->part_vals.resize(_size1021); + uint32_t _i1025; + for (_i1025 = 0; _i1025 < _size1021; ++_i1025) { - xfer += iprot->readString(this->part_vals[_i1018]); + xfer += iprot->readString(this->part_vals[_i1025]); } xfer += iprot->readListEnd(); } @@ -10746,10 +10993,10 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::wri xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter1019; - for (_iter1019 = this->part_vals.begin(); _iter1019 != this->part_vals.end(); ++_iter1019) + std::vector ::const_iterator _iter1026; + for (_iter1026 = this->part_vals.begin(); _iter1026 != this->part_vals.end(); ++_iter1026) { - xfer += oprot->writeString((*_iter1019)); + xfer += oprot->writeString((*_iter1026)); } xfer += oprot->writeListEnd(); } @@ -10785,10 +11032,10 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_pargs::wr xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter1020; - for (_iter1020 = (*(this->part_vals)).begin(); _iter1020 != (*(this->part_vals)).end(); ++_iter1020) + std::vector ::const_iterator _iter1027; + for (_iter1027 = (*(this->part_vals)).begin(); _iter1027 != (*(this->part_vals)).end(); ++_iter1027) { - xfer += oprot->writeString((*_iter1020)); + xfer += oprot->writeString((*_iter1027)); } xfer += oprot->writeListEnd(); } @@ -11591,14 +11838,14 @@ uint32_t ThriftHiveMetastore_drop_partition_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1021; - ::apache::thrift::protocol::TType _etype1024; - xfer += iprot->readListBegin(_etype1024, _size1021); - this->part_vals.resize(_size1021); - uint32_t _i1025; - for (_i1025 = 0; _i1025 < _size1021; ++_i1025) + uint32_t _size1028; + ::apache::thrift::protocol::TType _etype1031; + xfer += iprot->readListBegin(_etype1031, _size1028); + this->part_vals.resize(_size1028); + uint32_t _i1032; + for (_i1032 = 0; _i1032 < _size1028; ++_i1032) { - xfer += iprot->readString(this->part_vals[_i1025]); + xfer += iprot->readString(this->part_vals[_i1032]); } xfer += iprot->readListEnd(); } @@ -11643,10 +11890,10 @@ uint32_t ThriftHiveMetastore_drop_partition_args::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter1026; - for (_iter1026 = this->part_vals.begin(); _iter1026 != this->part_vals.end(); ++_iter1026) + std::vector ::const_iterator _iter1033; + for (_iter1033 = this->part_vals.begin(); _iter1033 != this->part_vals.end(); ++_iter1033) { - xfer += oprot->writeString((*_iter1026)); + xfer += oprot->writeString((*_iter1033)); } xfer += oprot->writeListEnd(); } @@ -11682,10 +11929,10 @@ uint32_t ThriftHiveMetastore_drop_partition_pargs::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter1027; - for (_iter1027 = (*(this->part_vals)).begin(); _iter1027 != (*(this->part_vals)).end(); ++_iter1027) + std::vector ::const_iterator _iter1034; + for (_iter1034 = (*(this->part_vals)).begin(); _iter1034 != (*(this->part_vals)).end(); ++_iter1034) { - xfer += oprot->writeString((*_iter1027)); + xfer += oprot->writeString((*_iter1034)); } xfer += oprot->writeListEnd(); } @@ -11894,14 +12141,14 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::read( if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1028; - ::apache::thrift::protocol::TType _etype1031; - xfer += iprot->readListBegin(_etype1031, _size1028); - this->part_vals.resize(_size1028); - uint32_t _i1032; - for (_i1032 = 0; _i1032 < _size1028; ++_i1032) + uint32_t _size1035; + ::apache::thrift::protocol::TType _etype1038; + xfer += iprot->readListBegin(_etype1038, _size1035); + this->part_vals.resize(_size1035); + uint32_t _i1039; + for (_i1039 = 0; _i1039 < _size1035; ++_i1039) { - xfer += iprot->readString(this->part_vals[_i1032]); + xfer += iprot->readString(this->part_vals[_i1039]); } xfer += iprot->readListEnd(); } @@ -11954,10 +12201,10 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::write xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter1033; - for (_iter1033 = this->part_vals.begin(); _iter1033 != this->part_vals.end(); ++_iter1033) + std::vector ::const_iterator _iter1040; + for (_iter1040 = this->part_vals.begin(); _iter1040 != this->part_vals.end(); ++_iter1040) { - xfer += oprot->writeString((*_iter1033)); + xfer += oprot->writeString((*_iter1040)); } xfer += oprot->writeListEnd(); } @@ -11997,10 +12244,10 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_pargs::writ xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter1034; - for (_iter1034 = (*(this->part_vals)).begin(); _iter1034 != (*(this->part_vals)).end(); ++_iter1034) + std::vector ::const_iterator _iter1041; + for (_iter1041 = (*(this->part_vals)).begin(); _iter1041 != (*(this->part_vals)).end(); ++_iter1041) { - xfer += oprot->writeString((*_iter1034)); + xfer += oprot->writeString((*_iter1041)); } xfer += oprot->writeListEnd(); } @@ -13006,14 +13253,14 @@ uint32_t ThriftHiveMetastore_get_partition_args::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1035; - ::apache::thrift::protocol::TType _etype1038; - xfer += iprot->readListBegin(_etype1038, _size1035); - this->part_vals.resize(_size1035); - uint32_t _i1039; - for (_i1039 = 0; _i1039 < _size1035; ++_i1039) + uint32_t _size1042; + ::apache::thrift::protocol::TType _etype1045; + xfer += iprot->readListBegin(_etype1045, _size1042); + this->part_vals.resize(_size1042); + uint32_t _i1046; + for (_i1046 = 0; _i1046 < _size1042; ++_i1046) { - xfer += iprot->readString(this->part_vals[_i1039]); + xfer += iprot->readString(this->part_vals[_i1046]); } xfer += iprot->readListEnd(); } @@ -13050,10 +13297,10 @@ uint32_t ThriftHiveMetastore_get_partition_args::write(::apache::thrift::protoco xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter1040; - for (_iter1040 = this->part_vals.begin(); _iter1040 != this->part_vals.end(); ++_iter1040) + std::vector ::const_iterator _iter1047; + for (_iter1047 = this->part_vals.begin(); _iter1047 != this->part_vals.end(); ++_iter1047) { - xfer += oprot->writeString((*_iter1040)); + xfer += oprot->writeString((*_iter1047)); } xfer += oprot->writeListEnd(); } @@ -13085,10 +13332,10 @@ uint32_t ThriftHiveMetastore_get_partition_pargs::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter1041; - for (_iter1041 = (*(this->part_vals)).begin(); _iter1041 != (*(this->part_vals)).end(); ++_iter1041) + std::vector ::const_iterator _iter1048; + for (_iter1048 = (*(this->part_vals)).begin(); _iter1048 != (*(this->part_vals)).end(); ++_iter1048) { - xfer += oprot->writeString((*_iter1041)); + xfer += oprot->writeString((*_iter1048)); } xfer += oprot->writeListEnd(); } @@ -13277,17 +13524,17 @@ uint32_t ThriftHiveMetastore_exchange_partition_args::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size1042; - ::apache::thrift::protocol::TType _ktype1043; - ::apache::thrift::protocol::TType _vtype1044; - xfer += iprot->readMapBegin(_ktype1043, _vtype1044, _size1042); - uint32_t _i1046; - for (_i1046 = 0; _i1046 < _size1042; ++_i1046) + uint32_t _size1049; + ::apache::thrift::protocol::TType _ktype1050; + ::apache::thrift::protocol::TType _vtype1051; + xfer += iprot->readMapBegin(_ktype1050, _vtype1051, _size1049); + uint32_t _i1053; + for (_i1053 = 0; _i1053 < _size1049; ++_i1053) { - std::string _key1047; - xfer += iprot->readString(_key1047); - std::string& _val1048 = this->partitionSpecs[_key1047]; - xfer += iprot->readString(_val1048); + std::string _key1054; + xfer += iprot->readString(_key1054); + std::string& _val1055 = this->partitionSpecs[_key1054]; + xfer += iprot->readString(_val1055); } xfer += iprot->readMapEnd(); } @@ -13348,11 +13595,11 @@ uint32_t ThriftHiveMetastore_exchange_partition_args::write(::apache::thrift::pr xfer += oprot->writeFieldBegin("partitionSpecs", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->partitionSpecs.size())); - std::map ::const_iterator _iter1049; - for (_iter1049 = this->partitionSpecs.begin(); _iter1049 != this->partitionSpecs.end(); ++_iter1049) + std::map ::const_iterator _iter1056; + for (_iter1056 = this->partitionSpecs.begin(); _iter1056 != this->partitionSpecs.end(); ++_iter1056) { - xfer += oprot->writeString(_iter1049->first); - xfer += oprot->writeString(_iter1049->second); + xfer += oprot->writeString(_iter1056->first); + xfer += oprot->writeString(_iter1056->second); } xfer += oprot->writeMapEnd(); } @@ -13392,11 +13639,11 @@ uint32_t ThriftHiveMetastore_exchange_partition_pargs::write(::apache::thrift::p xfer += oprot->writeFieldBegin("partitionSpecs", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast((*(this->partitionSpecs)).size())); - std::map ::const_iterator _iter1050; - for (_iter1050 = (*(this->partitionSpecs)).begin(); _iter1050 != (*(this->partitionSpecs)).end(); ++_iter1050) + std::map ::const_iterator _iter1057; + for (_iter1057 = (*(this->partitionSpecs)).begin(); _iter1057 != (*(this->partitionSpecs)).end(); ++_iter1057) { - xfer += oprot->writeString(_iter1050->first); - xfer += oprot->writeString(_iter1050->second); + xfer += oprot->writeString(_iter1057->first); + xfer += oprot->writeString(_iter1057->second); } xfer += oprot->writeMapEnd(); } @@ -13641,17 +13888,17 @@ uint32_t ThriftHiveMetastore_exchange_partitions_args::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size1051; - ::apache::thrift::protocol::TType _ktype1052; - ::apache::thrift::protocol::TType _vtype1053; - xfer += iprot->readMapBegin(_ktype1052, _vtype1053, _size1051); - uint32_t _i1055; - for (_i1055 = 0; _i1055 < _size1051; ++_i1055) + uint32_t _size1058; + ::apache::thrift::protocol::TType _ktype1059; + ::apache::thrift::protocol::TType _vtype1060; + xfer += iprot->readMapBegin(_ktype1059, _vtype1060, _size1058); + uint32_t _i1062; + for (_i1062 = 0; _i1062 < _size1058; ++_i1062) { - std::string _key1056; - xfer += iprot->readString(_key1056); - std::string& _val1057 = this->partitionSpecs[_key1056]; - xfer += iprot->readString(_val1057); + std::string _key1063; + xfer += iprot->readString(_key1063); + std::string& _val1064 = this->partitionSpecs[_key1063]; + xfer += iprot->readString(_val1064); } xfer += iprot->readMapEnd(); } @@ -13712,11 +13959,11 @@ uint32_t ThriftHiveMetastore_exchange_partitions_args::write(::apache::thrift::p xfer += oprot->writeFieldBegin("partitionSpecs", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->partitionSpecs.size())); - std::map ::const_iterator _iter1058; - for (_iter1058 = this->partitionSpecs.begin(); _iter1058 != this->partitionSpecs.end(); ++_iter1058) + std::map ::const_iterator _iter1065; + for (_iter1065 = this->partitionSpecs.begin(); _iter1065 != this->partitionSpecs.end(); ++_iter1065) { - xfer += oprot->writeString(_iter1058->first); - xfer += oprot->writeString(_iter1058->second); + xfer += oprot->writeString(_iter1065->first); + xfer += oprot->writeString(_iter1065->second); } xfer += oprot->writeMapEnd(); } @@ -13756,11 +14003,11 @@ uint32_t ThriftHiveMetastore_exchange_partitions_pargs::write(::apache::thrift:: xfer += oprot->writeFieldBegin("partitionSpecs", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast((*(this->partitionSpecs)).size())); - std::map ::const_iterator _iter1059; - for (_iter1059 = (*(this->partitionSpecs)).begin(); _iter1059 != (*(this->partitionSpecs)).end(); ++_iter1059) + std::map ::const_iterator _iter1066; + for (_iter1066 = (*(this->partitionSpecs)).begin(); _iter1066 != (*(this->partitionSpecs)).end(); ++_iter1066) { - xfer += oprot->writeString(_iter1059->first); - xfer += oprot->writeString(_iter1059->second); + xfer += oprot->writeString(_iter1066->first); + xfer += oprot->writeString(_iter1066->second); } xfer += oprot->writeMapEnd(); } @@ -13817,14 +14064,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1060; - ::apache::thrift::protocol::TType _etype1063; - xfer += iprot->readListBegin(_etype1063, _size1060); - this->success.resize(_size1060); - uint32_t _i1064; - for (_i1064 = 0; _i1064 < _size1060; ++_i1064) + uint32_t _size1067; + ::apache::thrift::protocol::TType _etype1070; + xfer += iprot->readListBegin(_etype1070, _size1067); + this->success.resize(_size1067); + uint32_t _i1071; + for (_i1071 = 0; _i1071 < _size1067; ++_i1071) { - xfer += this->success[_i1064].read(iprot); + xfer += this->success[_i1071].read(iprot); } xfer += iprot->readListEnd(); } @@ -13887,10 +14134,10 @@ uint32_t ThriftHiveMetastore_exchange_partitions_result::write(::apache::thrift: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1065; - for (_iter1065 = this->success.begin(); _iter1065 != this->success.end(); ++_iter1065) + std::vector ::const_iterator _iter1072; + for (_iter1072 = this->success.begin(); _iter1072 != this->success.end(); ++_iter1072) { - xfer += (*_iter1065).write(oprot); + xfer += (*_iter1072).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13947,14 +14194,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1066; - ::apache::thrift::protocol::TType _etype1069; - xfer += iprot->readListBegin(_etype1069, _size1066); - (*(this->success)).resize(_size1066); - uint32_t _i1070; - for (_i1070 = 0; _i1070 < _size1066; ++_i1070) + uint32_t _size1073; + ::apache::thrift::protocol::TType _etype1076; + xfer += iprot->readListBegin(_etype1076, _size1073); + (*(this->success)).resize(_size1073); + uint32_t _i1077; + for (_i1077 = 0; _i1077 < _size1073; ++_i1077) { - xfer += (*(this->success))[_i1070].read(iprot); + xfer += (*(this->success))[_i1077].read(iprot); } xfer += iprot->readListEnd(); } @@ -14053,14 +14300,14 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_args::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1071; - ::apache::thrift::protocol::TType _etype1074; - xfer += iprot->readListBegin(_etype1074, _size1071); - this->part_vals.resize(_size1071); - uint32_t _i1075; - for (_i1075 = 0; _i1075 < _size1071; ++_i1075) + uint32_t _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[_i1075]); + xfer += iprot->readString(this->part_vals[_i1082]); } xfer += iprot->readListEnd(); } @@ -14081,14 +14328,14 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_args::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size1076; - ::apache::thrift::protocol::TType _etype1079; - xfer += iprot->readListBegin(_etype1079, _size1076); - this->group_names.resize(_size1076); - uint32_t _i1080; - for (_i1080 = 0; _i1080 < _size1076; ++_i1080) + uint32_t _size1083; + ::apache::thrift::protocol::TType _etype1086; + xfer += iprot->readListBegin(_etype1086, _size1083); + this->group_names.resize(_size1083); + uint32_t _i1087; + for (_i1087 = 0; _i1087 < _size1083; ++_i1087) { - xfer += iprot->readString(this->group_names[_i1080]); + xfer += iprot->readString(this->group_names[_i1087]); } xfer += iprot->readListEnd(); } @@ -14125,10 +14372,10 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_args::write(::apache::thrif xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter1081; - for (_iter1081 = this->part_vals.begin(); _iter1081 != this->part_vals.end(); ++_iter1081) + std::vector ::const_iterator _iter1088; + for (_iter1088 = this->part_vals.begin(); _iter1088 != this->part_vals.end(); ++_iter1088) { - xfer += oprot->writeString((*_iter1081)); + xfer += oprot->writeString((*_iter1088)); } xfer += oprot->writeListEnd(); } @@ -14141,10 +14388,10 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_args::write(::apache::thrif xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->group_names.size())); - std::vector ::const_iterator _iter1082; - for (_iter1082 = this->group_names.begin(); _iter1082 != this->group_names.end(); ++_iter1082) + std::vector ::const_iterator _iter1089; + for (_iter1089 = this->group_names.begin(); _iter1089 != this->group_names.end(); ++_iter1089) { - xfer += oprot->writeString((*_iter1082)); + xfer += oprot->writeString((*_iter1089)); } xfer += oprot->writeListEnd(); } @@ -14176,10 +14423,10 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_pargs::write(::apache::thri xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter1083; - for (_iter1083 = (*(this->part_vals)).begin(); _iter1083 != (*(this->part_vals)).end(); ++_iter1083) + std::vector ::const_iterator _iter1090; + for (_iter1090 = (*(this->part_vals)).begin(); _iter1090 != (*(this->part_vals)).end(); ++_iter1090) { - xfer += oprot->writeString((*_iter1083)); + xfer += oprot->writeString((*_iter1090)); } xfer += oprot->writeListEnd(); } @@ -14192,10 +14439,10 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_pargs::write(::apache::thri xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->group_names)).size())); - std::vector ::const_iterator _iter1084; - for (_iter1084 = (*(this->group_names)).begin(); _iter1084 != (*(this->group_names)).end(); ++_iter1084) + std::vector ::const_iterator _iter1091; + for (_iter1091 = (*(this->group_names)).begin(); _iter1091 != (*(this->group_names)).end(); ++_iter1091) { - xfer += oprot->writeString((*_iter1084)); + xfer += oprot->writeString((*_iter1091)); } xfer += oprot->writeListEnd(); } @@ -14754,14 +15001,14 @@ uint32_t ThriftHiveMetastore_get_partitions_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1085; - ::apache::thrift::protocol::TType _etype1088; - xfer += iprot->readListBegin(_etype1088, _size1085); - this->success.resize(_size1085); - uint32_t _i1089; - for (_i1089 = 0; _i1089 < _size1085; ++_i1089) + uint32_t _size1092; + ::apache::thrift::protocol::TType _etype1095; + xfer += iprot->readListBegin(_etype1095, _size1092); + this->success.resize(_size1092); + uint32_t _i1096; + for (_i1096 = 0; _i1096 < _size1092; ++_i1096) { - xfer += this->success[_i1089].read(iprot); + xfer += this->success[_i1096].read(iprot); } xfer += iprot->readListEnd(); } @@ -14808,10 +15055,10 @@ uint32_t ThriftHiveMetastore_get_partitions_result::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1090; - for (_iter1090 = this->success.begin(); _iter1090 != this->success.end(); ++_iter1090) + std::vector ::const_iterator _iter1097; + for (_iter1097 = this->success.begin(); _iter1097 != this->success.end(); ++_iter1097) { - xfer += (*_iter1090).write(oprot); + xfer += (*_iter1097).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14860,14 +15107,14 @@ uint32_t ThriftHiveMetastore_get_partitions_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1091; - ::apache::thrift::protocol::TType _etype1094; - xfer += iprot->readListBegin(_etype1094, _size1091); - (*(this->success)).resize(_size1091); - uint32_t _i1095; - for (_i1095 = 0; _i1095 < _size1091; ++_i1095) + uint32_t _size1098; + ::apache::thrift::protocol::TType _etype1101; + xfer += iprot->readListBegin(_etype1101, _size1098); + (*(this->success)).resize(_size1098); + uint32_t _i1102; + for (_i1102 = 0; _i1102 < _size1098; ++_i1102) { - xfer += (*(this->success))[_i1095].read(iprot); + xfer += (*(this->success))[_i1102].read(iprot); } xfer += iprot->readListEnd(); } @@ -14966,14 +15213,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_args::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size1096; - ::apache::thrift::protocol::TType _etype1099; - xfer += iprot->readListBegin(_etype1099, _size1096); - this->group_names.resize(_size1096); - uint32_t _i1100; - for (_i1100 = 0; _i1100 < _size1096; ++_i1100) + uint32_t _size1103; + ::apache::thrift::protocol::TType _etype1106; + xfer += iprot->readListBegin(_etype1106, _size1103); + this->group_names.resize(_size1103); + uint32_t _i1107; + for (_i1107 = 0; _i1107 < _size1103; ++_i1107) { - xfer += iprot->readString(this->group_names[_i1100]); + xfer += iprot->readString(this->group_names[_i1107]); } xfer += iprot->readListEnd(); } @@ -15018,10 +15265,10 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_args::write(::apache::thri xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->group_names.size())); - std::vector ::const_iterator _iter1101; - for (_iter1101 = this->group_names.begin(); _iter1101 != this->group_names.end(); ++_iter1101) + std::vector ::const_iterator _iter1108; + for (_iter1108 = this->group_names.begin(); _iter1108 != this->group_names.end(); ++_iter1108) { - xfer += oprot->writeString((*_iter1101)); + xfer += oprot->writeString((*_iter1108)); } xfer += oprot->writeListEnd(); } @@ -15061,10 +15308,10 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_pargs::write(::apache::thr xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->group_names)).size())); - std::vector ::const_iterator _iter1102; - for (_iter1102 = (*(this->group_names)).begin(); _iter1102 != (*(this->group_names)).end(); ++_iter1102) + std::vector ::const_iterator _iter1109; + for (_iter1109 = (*(this->group_names)).begin(); _iter1109 != (*(this->group_names)).end(); ++_iter1109) { - xfer += oprot->writeString((*_iter1102)); + xfer += oprot->writeString((*_iter1109)); } xfer += oprot->writeListEnd(); } @@ -15105,14 +15352,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1103; - ::apache::thrift::protocol::TType _etype1106; - xfer += iprot->readListBegin(_etype1106, _size1103); - this->success.resize(_size1103); - uint32_t _i1107; - for (_i1107 = 0; _i1107 < _size1103; ++_i1107) + uint32_t _size1110; + ::apache::thrift::protocol::TType _etype1113; + xfer += iprot->readListBegin(_etype1113, _size1110); + this->success.resize(_size1110); + uint32_t _i1114; + for (_i1114 = 0; _i1114 < _size1110; ++_i1114) { - xfer += this->success[_i1107].read(iprot); + xfer += this->success[_i1114].read(iprot); } xfer += iprot->readListEnd(); } @@ -15159,10 +15406,10 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_result::write(::apache::th xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1108; - for (_iter1108 = this->success.begin(); _iter1108 != this->success.end(); ++_iter1108) + std::vector ::const_iterator _iter1115; + for (_iter1115 = this->success.begin(); _iter1115 != this->success.end(); ++_iter1115) { - xfer += (*_iter1108).write(oprot); + xfer += (*_iter1115).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15211,14 +15458,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1109; - ::apache::thrift::protocol::TType _etype1112; - xfer += iprot->readListBegin(_etype1112, _size1109); - (*(this->success)).resize(_size1109); - uint32_t _i1113; - for (_i1113 = 0; _i1113 < _size1109; ++_i1113) + uint32_t _size1116; + ::apache::thrift::protocol::TType _etype1119; + xfer += iprot->readListBegin(_etype1119, _size1116); + (*(this->success)).resize(_size1116); + uint32_t _i1120; + for (_i1120 = 0; _i1120 < _size1116; ++_i1120) { - xfer += (*(this->success))[_i1113].read(iprot); + xfer += (*(this->success))[_i1120].read(iprot); } xfer += iprot->readListEnd(); } @@ -15396,14 +15643,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_result::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1114; - ::apache::thrift::protocol::TType _etype1117; - xfer += iprot->readListBegin(_etype1117, _size1114); - this->success.resize(_size1114); - uint32_t _i1118; - for (_i1118 = 0; _i1118 < _size1114; ++_i1118) + uint32_t _size1121; + ::apache::thrift::protocol::TType _etype1124; + xfer += iprot->readListBegin(_etype1124, _size1121); + this->success.resize(_size1121); + uint32_t _i1125; + for (_i1125 = 0; _i1125 < _size1121; ++_i1125) { - xfer += this->success[_i1118].read(iprot); + xfer += this->success[_i1125].read(iprot); } xfer += iprot->readListEnd(); } @@ -15450,10 +15697,10 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_result::write(::apache::thrift xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1119; - for (_iter1119 = this->success.begin(); _iter1119 != this->success.end(); ++_iter1119) + std::vector ::const_iterator _iter1126; + for (_iter1126 = this->success.begin(); _iter1126 != this->success.end(); ++_iter1126) { - xfer += (*_iter1119).write(oprot); + xfer += (*_iter1126).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15502,14 +15749,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_presult::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _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 _size1127; + ::apache::thrift::protocol::TType _etype1130; + xfer += iprot->readListBegin(_etype1130, _size1127); + (*(this->success)).resize(_size1127); + uint32_t _i1131; + for (_i1131 = 0; _i1131 < _size1127; ++_i1131) { - xfer += (*(this->success))[_i1124].read(iprot); + xfer += (*(this->success))[_i1131].read(iprot); } xfer += iprot->readListEnd(); } @@ -15687,14 +15934,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1125; - ::apache::thrift::protocol::TType _etype1128; - xfer += iprot->readListBegin(_etype1128, _size1125); - this->success.resize(_size1125); - uint32_t _i1129; - for (_i1129 = 0; _i1129 < _size1125; ++_i1129) + uint32_t _size1132; + ::apache::thrift::protocol::TType _etype1135; + xfer += iprot->readListBegin(_etype1135, _size1132); + this->success.resize(_size1132); + uint32_t _i1136; + for (_i1136 = 0; _i1136 < _size1132; ++_i1136) { - xfer += iprot->readString(this->success[_i1129]); + xfer += iprot->readString(this->success[_i1136]); } xfer += iprot->readListEnd(); } @@ -15733,10 +15980,10 @@ uint32_t ThriftHiveMetastore_get_partition_names_result::write(::apache::thrift: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1130; - for (_iter1130 = this->success.begin(); _iter1130 != this->success.end(); ++_iter1130) + std::vector ::const_iterator _iter1137; + for (_iter1137 = this->success.begin(); _iter1137 != this->success.end(); ++_iter1137) { - xfer += oprot->writeString((*_iter1130)); + xfer += oprot->writeString((*_iter1137)); } xfer += oprot->writeListEnd(); } @@ -15781,14 +16028,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1131; - ::apache::thrift::protocol::TType _etype1134; - xfer += iprot->readListBegin(_etype1134, _size1131); - (*(this->success)).resize(_size1131); - uint32_t _i1135; - for (_i1135 = 0; _i1135 < _size1131; ++_i1135) + uint32_t _size1138; + ::apache::thrift::protocol::TType _etype1141; + xfer += iprot->readListBegin(_etype1141, _size1138); + (*(this->success)).resize(_size1138); + uint32_t _i1142; + for (_i1142 = 0; _i1142 < _size1138; ++_i1142) { - xfer += iprot->readString((*(this->success))[_i1135]); + xfer += iprot->readString((*(this->success))[_i1142]); } xfer += iprot->readListEnd(); } @@ -15863,14 +16110,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_args::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1136; - ::apache::thrift::protocol::TType _etype1139; - xfer += iprot->readListBegin(_etype1139, _size1136); - this->part_vals.resize(_size1136); - uint32_t _i1140; - for (_i1140 = 0; _i1140 < _size1136; ++_i1140) + uint32_t _size1143; + ::apache::thrift::protocol::TType _etype1146; + xfer += iprot->readListBegin(_etype1146, _size1143); + this->part_vals.resize(_size1143); + uint32_t _i1147; + for (_i1147 = 0; _i1147 < _size1143; ++_i1147) { - xfer += iprot->readString(this->part_vals[_i1140]); + xfer += iprot->readString(this->part_vals[_i1147]); } xfer += iprot->readListEnd(); } @@ -15915,10 +16162,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_args::write(::apache::thrift::pro xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter1141; - for (_iter1141 = this->part_vals.begin(); _iter1141 != this->part_vals.end(); ++_iter1141) + std::vector ::const_iterator _iter1148; + for (_iter1148 = this->part_vals.begin(); _iter1148 != this->part_vals.end(); ++_iter1148) { - xfer += oprot->writeString((*_iter1141)); + xfer += oprot->writeString((*_iter1148)); } xfer += oprot->writeListEnd(); } @@ -15954,10 +16201,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_pargs::write(::apache::thrift::pr xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter1142; - for (_iter1142 = (*(this->part_vals)).begin(); _iter1142 != (*(this->part_vals)).end(); ++_iter1142) + std::vector ::const_iterator _iter1149; + for (_iter1149 = (*(this->part_vals)).begin(); _iter1149 != (*(this->part_vals)).end(); ++_iter1149) { - xfer += oprot->writeString((*_iter1142)); + xfer += oprot->writeString((*_iter1149)); } xfer += oprot->writeListEnd(); } @@ -16002,14 +16249,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_result::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1143; - ::apache::thrift::protocol::TType _etype1146; - xfer += iprot->readListBegin(_etype1146, _size1143); - this->success.resize(_size1143); - uint32_t _i1147; - for (_i1147 = 0; _i1147 < _size1143; ++_i1147) + uint32_t _size1150; + ::apache::thrift::protocol::TType _etype1153; + xfer += iprot->readListBegin(_etype1153, _size1150); + this->success.resize(_size1150); + uint32_t _i1154; + for (_i1154 = 0; _i1154 < _size1150; ++_i1154) { - xfer += this->success[_i1147].read(iprot); + xfer += this->success[_i1154].read(iprot); } xfer += iprot->readListEnd(); } @@ -16056,10 +16303,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_result::write(::apache::thrift::p xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1148; - for (_iter1148 = this->success.begin(); _iter1148 != this->success.end(); ++_iter1148) + std::vector ::const_iterator _iter1155; + for (_iter1155 = this->success.begin(); _iter1155 != this->success.end(); ++_iter1155) { - xfer += (*_iter1148).write(oprot); + xfer += (*_iter1155).write(oprot); } xfer += oprot->writeListEnd(); } @@ -16108,14 +16355,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_presult::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1149; - ::apache::thrift::protocol::TType _etype1152; - xfer += iprot->readListBegin(_etype1152, _size1149); - (*(this->success)).resize(_size1149); - uint32_t _i1153; - for (_i1153 = 0; _i1153 < _size1149; ++_i1153) + uint32_t _size1156; + ::apache::thrift::protocol::TType _etype1159; + xfer += iprot->readListBegin(_etype1159, _size1156); + (*(this->success)).resize(_size1156); + uint32_t _i1160; + for (_i1160 = 0; _i1160 < _size1156; ++_i1160) { - xfer += (*(this->success))[_i1153].read(iprot); + xfer += (*(this->success))[_i1160].read(iprot); } xfer += iprot->readListEnd(); } @@ -16198,14 +16445,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1154; - ::apache::thrift::protocol::TType _etype1157; - xfer += iprot->readListBegin(_etype1157, _size1154); - this->part_vals.resize(_size1154); - uint32_t _i1158; - for (_i1158 = 0; _i1158 < _size1154; ++_i1158) + uint32_t _size1161; + ::apache::thrift::protocol::TType _etype1164; + xfer += iprot->readListBegin(_etype1164, _size1161); + this->part_vals.resize(_size1161); + uint32_t _i1165; + for (_i1165 = 0; _i1165 < _size1161; ++_i1165) { - xfer += iprot->readString(this->part_vals[_i1158]); + xfer += iprot->readString(this->part_vals[_i1165]); } xfer += iprot->readListEnd(); } @@ -16234,14 +16481,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size1159; - ::apache::thrift::protocol::TType _etype1162; - xfer += iprot->readListBegin(_etype1162, _size1159); - this->group_names.resize(_size1159); - uint32_t _i1163; - for (_i1163 = 0; _i1163 < _size1159; ++_i1163) + uint32_t _size1166; + ::apache::thrift::protocol::TType _etype1169; + xfer += iprot->readListBegin(_etype1169, _size1166); + this->group_names.resize(_size1166); + uint32_t _i1170; + for (_i1170 = 0; _i1170 < _size1166; ++_i1170) { - xfer += iprot->readString(this->group_names[_i1163]); + xfer += iprot->readString(this->group_names[_i1170]); } xfer += iprot->readListEnd(); } @@ -16278,10 +16525,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::write(::apache::t xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter1164; - for (_iter1164 = this->part_vals.begin(); _iter1164 != this->part_vals.end(); ++_iter1164) + std::vector ::const_iterator _iter1171; + for (_iter1171 = this->part_vals.begin(); _iter1171 != this->part_vals.end(); ++_iter1171) { - xfer += oprot->writeString((*_iter1164)); + xfer += oprot->writeString((*_iter1171)); } xfer += oprot->writeListEnd(); } @@ -16298,10 +16545,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::write(::apache::t xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 6); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->group_names.size())); - std::vector ::const_iterator _iter1165; - for (_iter1165 = this->group_names.begin(); _iter1165 != this->group_names.end(); ++_iter1165) + std::vector ::const_iterator _iter1172; + for (_iter1172 = this->group_names.begin(); _iter1172 != this->group_names.end(); ++_iter1172) { - xfer += oprot->writeString((*_iter1165)); + xfer += oprot->writeString((*_iter1172)); } xfer += oprot->writeListEnd(); } @@ -16333,10 +16580,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_pargs::write(::apache:: xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter1166; - for (_iter1166 = (*(this->part_vals)).begin(); _iter1166 != (*(this->part_vals)).end(); ++_iter1166) + std::vector ::const_iterator _iter1173; + for (_iter1173 = (*(this->part_vals)).begin(); _iter1173 != (*(this->part_vals)).end(); ++_iter1173) { - xfer += oprot->writeString((*_iter1166)); + xfer += oprot->writeString((*_iter1173)); } xfer += oprot->writeListEnd(); } @@ -16353,10 +16600,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_pargs::write(::apache:: xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 6); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->group_names)).size())); - std::vector ::const_iterator _iter1167; - for (_iter1167 = (*(this->group_names)).begin(); _iter1167 != (*(this->group_names)).end(); ++_iter1167) + std::vector ::const_iterator _iter1174; + for (_iter1174 = (*(this->group_names)).begin(); _iter1174 != (*(this->group_names)).end(); ++_iter1174) { - xfer += oprot->writeString((*_iter1167)); + xfer += oprot->writeString((*_iter1174)); } xfer += oprot->writeListEnd(); } @@ -16397,14 +16644,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_result::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1168; - ::apache::thrift::protocol::TType _etype1171; - xfer += iprot->readListBegin(_etype1171, _size1168); - this->success.resize(_size1168); - uint32_t _i1172; - for (_i1172 = 0; _i1172 < _size1168; ++_i1172) + uint32_t _size1175; + ::apache::thrift::protocol::TType _etype1178; + xfer += iprot->readListBegin(_etype1178, _size1175); + this->success.resize(_size1175); + uint32_t _i1179; + for (_i1179 = 0; _i1179 < _size1175; ++_i1179) { - xfer += this->success[_i1172].read(iprot); + xfer += this->success[_i1179].read(iprot); } xfer += iprot->readListEnd(); } @@ -16451,10 +16698,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_result::write(::apache: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1173; - for (_iter1173 = this->success.begin(); _iter1173 != this->success.end(); ++_iter1173) + std::vector ::const_iterator _iter1180; + for (_iter1180 = this->success.begin(); _iter1180 != this->success.end(); ++_iter1180) { - xfer += (*_iter1173).write(oprot); + xfer += (*_iter1180).write(oprot); } xfer += oprot->writeListEnd(); } @@ -16503,14 +16750,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_presult::read(::apache: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _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 _size1181; + ::apache::thrift::protocol::TType _etype1184; + xfer += iprot->readListBegin(_etype1184, _size1181); + (*(this->success)).resize(_size1181); + uint32_t _i1185; + for (_i1185 = 0; _i1185 < _size1181; ++_i1185) { - xfer += (*(this->success))[_i1178].read(iprot); + xfer += (*(this->success))[_i1185].read(iprot); } xfer += iprot->readListEnd(); } @@ -16593,14 +16840,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_args::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1179; - ::apache::thrift::protocol::TType _etype1182; - xfer += iprot->readListBegin(_etype1182, _size1179); - this->part_vals.resize(_size1179); - uint32_t _i1183; - for (_i1183 = 0; _i1183 < _size1179; ++_i1183) + uint32_t _size1186; + ::apache::thrift::protocol::TType _etype1189; + xfer += iprot->readListBegin(_etype1189, _size1186); + this->part_vals.resize(_size1186); + uint32_t _i1190; + for (_i1190 = 0; _i1190 < _size1186; ++_i1190) { - xfer += iprot->readString(this->part_vals[_i1183]); + xfer += iprot->readString(this->part_vals[_i1190]); } xfer += iprot->readListEnd(); } @@ -16645,10 +16892,10 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_args::write(::apache::thrift xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter1184; - for (_iter1184 = this->part_vals.begin(); _iter1184 != this->part_vals.end(); ++_iter1184) + std::vector ::const_iterator _iter1191; + for (_iter1191 = this->part_vals.begin(); _iter1191 != this->part_vals.end(); ++_iter1191) { - xfer += oprot->writeString((*_iter1184)); + xfer += oprot->writeString((*_iter1191)); } xfer += oprot->writeListEnd(); } @@ -16684,10 +16931,10 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_pargs::write(::apache::thrif xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter1185; - for (_iter1185 = (*(this->part_vals)).begin(); _iter1185 != (*(this->part_vals)).end(); ++_iter1185) + std::vector ::const_iterator _iter1192; + for (_iter1192 = (*(this->part_vals)).begin(); _iter1192 != (*(this->part_vals)).end(); ++_iter1192) { - xfer += oprot->writeString((*_iter1185)); + xfer += oprot->writeString((*_iter1192)); } xfer += oprot->writeListEnd(); } @@ -16732,14 +16979,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1186; - ::apache::thrift::protocol::TType _etype1189; - xfer += iprot->readListBegin(_etype1189, _size1186); - this->success.resize(_size1186); - uint32_t _i1190; - for (_i1190 = 0; _i1190 < _size1186; ++_i1190) + uint32_t _size1193; + ::apache::thrift::protocol::TType _etype1196; + xfer += iprot->readListBegin(_etype1196, _size1193); + this->success.resize(_size1193); + uint32_t _i1197; + for (_i1197 = 0; _i1197 < _size1193; ++_i1197) { - xfer += iprot->readString(this->success[_i1190]); + xfer += iprot->readString(this->success[_i1197]); } xfer += iprot->readListEnd(); } @@ -16786,10 +17033,10 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_result::write(::apache::thri xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1191; - for (_iter1191 = this->success.begin(); _iter1191 != this->success.end(); ++_iter1191) + std::vector ::const_iterator _iter1198; + for (_iter1198 = this->success.begin(); _iter1198 != this->success.end(); ++_iter1198) { - xfer += oprot->writeString((*_iter1191)); + xfer += oprot->writeString((*_iter1198)); } xfer += oprot->writeListEnd(); } @@ -16838,14 +17085,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1192; - ::apache::thrift::protocol::TType _etype1195; - xfer += iprot->readListBegin(_etype1195, _size1192); - (*(this->success)).resize(_size1192); - uint32_t _i1196; - for (_i1196 = 0; _i1196 < _size1192; ++_i1196) + uint32_t _size1199; + ::apache::thrift::protocol::TType _etype1202; + xfer += iprot->readListBegin(_etype1202, _size1199); + (*(this->success)).resize(_size1199); + uint32_t _i1203; + for (_i1203 = 0; _i1203 < _size1199; ++_i1203) { - xfer += iprot->readString((*(this->success))[_i1196]); + xfer += iprot->readString((*(this->success))[_i1203]); } xfer += iprot->readListEnd(); } @@ -17039,14 +17286,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1197; - ::apache::thrift::protocol::TType _etype1200; - xfer += iprot->readListBegin(_etype1200, _size1197); - this->success.resize(_size1197); - uint32_t _i1201; - for (_i1201 = 0; _i1201 < _size1197; ++_i1201) + uint32_t _size1204; + ::apache::thrift::protocol::TType _etype1207; + xfer += iprot->readListBegin(_etype1207, _size1204); + this->success.resize(_size1204); + uint32_t _i1208; + for (_i1208 = 0; _i1208 < _size1204; ++_i1208) { - xfer += this->success[_i1201].read(iprot); + xfer += this->success[_i1208].read(iprot); } xfer += iprot->readListEnd(); } @@ -17093,10 +17340,10 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_result::write(::apache::th xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1202; - for (_iter1202 = this->success.begin(); _iter1202 != this->success.end(); ++_iter1202) + std::vector ::const_iterator _iter1209; + for (_iter1209 = this->success.begin(); _iter1209 != this->success.end(); ++_iter1209) { - xfer += (*_iter1202).write(oprot); + xfer += (*_iter1209).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17145,14 +17392,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _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 _size1210; + ::apache::thrift::protocol::TType _etype1213; + xfer += iprot->readListBegin(_etype1213, _size1210); + (*(this->success)).resize(_size1210); + uint32_t _i1214; + for (_i1214 = 0; _i1214 < _size1210; ++_i1214) { - xfer += (*(this->success))[_i1207].read(iprot); + xfer += (*(this->success))[_i1214].read(iprot); } xfer += iprot->readListEnd(); } @@ -17346,14 +17593,14 @@ uint32_t ThriftHiveMetastore_get_part_specs_by_filter_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1208; - ::apache::thrift::protocol::TType _etype1211; - xfer += iprot->readListBegin(_etype1211, _size1208); - this->success.resize(_size1208); - uint32_t _i1212; - for (_i1212 = 0; _i1212 < _size1208; ++_i1212) + uint32_t _size1215; + ::apache::thrift::protocol::TType _etype1218; + xfer += iprot->readListBegin(_etype1218, _size1215); + this->success.resize(_size1215); + uint32_t _i1219; + for (_i1219 = 0; _i1219 < _size1215; ++_i1219) { - xfer += this->success[_i1212].read(iprot); + xfer += this->success[_i1219].read(iprot); } xfer += iprot->readListEnd(); } @@ -17400,10 +17647,10 @@ uint32_t ThriftHiveMetastore_get_part_specs_by_filter_result::write(::apache::th xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1213; - for (_iter1213 = this->success.begin(); _iter1213 != this->success.end(); ++_iter1213) + std::vector ::const_iterator _iter1220; + for (_iter1220 = this->success.begin(); _iter1220 != this->success.end(); ++_iter1220) { - xfer += (*_iter1213).write(oprot); + xfer += (*_iter1220).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17452,14 +17699,14 @@ uint32_t ThriftHiveMetastore_get_part_specs_by_filter_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1214; - ::apache::thrift::protocol::TType _etype1217; - xfer += iprot->readListBegin(_etype1217, _size1214); - (*(this->success)).resize(_size1214); - uint32_t _i1218; - for (_i1218 = 0; _i1218 < _size1214; ++_i1218) + uint32_t _size1221; + ::apache::thrift::protocol::TType _etype1224; + xfer += iprot->readListBegin(_etype1224, _size1221); + (*(this->success)).resize(_size1221); + uint32_t _i1225; + for (_i1225 = 0; _i1225 < _size1221; ++_i1225) { - xfer += (*(this->success))[_i1218].read(iprot); + xfer += (*(this->success))[_i1225].read(iprot); } xfer += iprot->readListEnd(); } @@ -18028,14 +18275,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_args::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { this->names.clear(); - uint32_t _size1219; - ::apache::thrift::protocol::TType _etype1222; - xfer += iprot->readListBegin(_etype1222, _size1219); - this->names.resize(_size1219); - uint32_t _i1223; - for (_i1223 = 0; _i1223 < _size1219; ++_i1223) + uint32_t _size1226; + ::apache::thrift::protocol::TType _etype1229; + xfer += iprot->readListBegin(_etype1229, _size1226); + this->names.resize(_size1226); + uint32_t _i1230; + for (_i1230 = 0; _i1230 < _size1226; ++_i1230) { - xfer += iprot->readString(this->names[_i1223]); + xfer += iprot->readString(this->names[_i1230]); } xfer += iprot->readListEnd(); } @@ -18072,10 +18319,10 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_args::write(::apache::thrif xfer += oprot->writeFieldBegin("names", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->names.size())); - std::vector ::const_iterator _iter1224; - for (_iter1224 = this->names.begin(); _iter1224 != this->names.end(); ++_iter1224) + std::vector ::const_iterator _iter1231; + for (_iter1231 = this->names.begin(); _iter1231 != this->names.end(); ++_iter1231) { - xfer += oprot->writeString((*_iter1224)); + xfer += oprot->writeString((*_iter1231)); } xfer += oprot->writeListEnd(); } @@ -18107,10 +18354,10 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_pargs::write(::apache::thri xfer += oprot->writeFieldBegin("names", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->names)).size())); - std::vector ::const_iterator _iter1225; - for (_iter1225 = (*(this->names)).begin(); _iter1225 != (*(this->names)).end(); ++_iter1225) + std::vector ::const_iterator _iter1232; + for (_iter1232 = (*(this->names)).begin(); _iter1232 != (*(this->names)).end(); ++_iter1232) { - xfer += oprot->writeString((*_iter1225)); + xfer += oprot->writeString((*_iter1232)); } xfer += oprot->writeListEnd(); } @@ -18151,14 +18398,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_result::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1226; - ::apache::thrift::protocol::TType _etype1229; - xfer += iprot->readListBegin(_etype1229, _size1226); - this->success.resize(_size1226); - uint32_t _i1230; - for (_i1230 = 0; _i1230 < _size1226; ++_i1230) + uint32_t _size1233; + ::apache::thrift::protocol::TType _etype1236; + xfer += iprot->readListBegin(_etype1236, _size1233); + this->success.resize(_size1233); + uint32_t _i1237; + for (_i1237 = 0; _i1237 < _size1233; ++_i1237) { - xfer += this->success[_i1230].read(iprot); + xfer += this->success[_i1237].read(iprot); } xfer += iprot->readListEnd(); } @@ -18205,10 +18452,10 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_result::write(::apache::thr xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1231; - for (_iter1231 = this->success.begin(); _iter1231 != this->success.end(); ++_iter1231) + std::vector ::const_iterator _iter1238; + for (_iter1238 = this->success.begin(); _iter1238 != this->success.end(); ++_iter1238) { - xfer += (*_iter1231).write(oprot); + xfer += (*_iter1238).write(oprot); } xfer += oprot->writeListEnd(); } @@ -18257,14 +18504,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_presult::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1232; - ::apache::thrift::protocol::TType _etype1235; - xfer += iprot->readListBegin(_etype1235, _size1232); - (*(this->success)).resize(_size1232); - uint32_t _i1236; - for (_i1236 = 0; _i1236 < _size1232; ++_i1236) + uint32_t _size1239; + ::apache::thrift::protocol::TType _etype1242; + xfer += iprot->readListBegin(_etype1242, _size1239); + (*(this->success)).resize(_size1239); + uint32_t _i1243; + for (_i1243 = 0; _i1243 < _size1239; ++_i1243) { - xfer += (*(this->success))[_i1236].read(iprot); + xfer += (*(this->success))[_i1243].read(iprot); } xfer += iprot->readListEnd(); } @@ -18586,14 +18833,14 @@ uint32_t ThriftHiveMetastore_alter_partitions_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size1237; - ::apache::thrift::protocol::TType _etype1240; - xfer += iprot->readListBegin(_etype1240, _size1237); - this->new_parts.resize(_size1237); - uint32_t _i1241; - for (_i1241 = 0; _i1241 < _size1237; ++_i1241) + uint32_t _size1244; + ::apache::thrift::protocol::TType _etype1247; + xfer += iprot->readListBegin(_etype1247, _size1244); + this->new_parts.resize(_size1244); + uint32_t _i1248; + for (_i1248 = 0; _i1248 < _size1244; ++_i1248) { - xfer += this->new_parts[_i1241].read(iprot); + xfer += this->new_parts[_i1248].read(iprot); } xfer += iprot->readListEnd(); } @@ -18630,10 +18877,10 @@ uint32_t ThriftHiveMetastore_alter_partitions_args::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->new_parts.size())); - std::vector ::const_iterator _iter1242; - for (_iter1242 = this->new_parts.begin(); _iter1242 != this->new_parts.end(); ++_iter1242) + std::vector ::const_iterator _iter1249; + for (_iter1249 = this->new_parts.begin(); _iter1249 != this->new_parts.end(); ++_iter1249) { - xfer += (*_iter1242).write(oprot); + xfer += (*_iter1249).write(oprot); } xfer += oprot->writeListEnd(); } @@ -18665,10 +18912,10 @@ uint32_t ThriftHiveMetastore_alter_partitions_pargs::write(::apache::thrift::pro xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->new_parts)).size())); - std::vector ::const_iterator _iter1243; - for (_iter1243 = (*(this->new_parts)).begin(); _iter1243 != (*(this->new_parts)).end(); ++_iter1243) + std::vector ::const_iterator _iter1250; + for (_iter1250 = (*(this->new_parts)).begin(); _iter1250 != (*(this->new_parts)).end(); ++_iter1250) { - xfer += (*_iter1243).write(oprot); + xfer += (*_iter1250).write(oprot); } xfer += oprot->writeListEnd(); } @@ -18853,14 +19100,14 @@ uint32_t ThriftHiveMetastore_alter_partitions_with_environment_context_args::rea if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size1244; - ::apache::thrift::protocol::TType _etype1247; - xfer += iprot->readListBegin(_etype1247, _size1244); - this->new_parts.resize(_size1244); - uint32_t _i1248; - for (_i1248 = 0; _i1248 < _size1244; ++_i1248) + uint32_t _size1251; + ::apache::thrift::protocol::TType _etype1254; + xfer += iprot->readListBegin(_etype1254, _size1251); + this->new_parts.resize(_size1251); + uint32_t _i1255; + for (_i1255 = 0; _i1255 < _size1251; ++_i1255) { - xfer += this->new_parts[_i1248].read(iprot); + xfer += this->new_parts[_i1255].read(iprot); } xfer += iprot->readListEnd(); } @@ -18905,10 +19152,10 @@ uint32_t ThriftHiveMetastore_alter_partitions_with_environment_context_args::wri xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->new_parts.size())); - std::vector ::const_iterator _iter1249; - for (_iter1249 = this->new_parts.begin(); _iter1249 != this->new_parts.end(); ++_iter1249) + std::vector ::const_iterator _iter1256; + for (_iter1256 = this->new_parts.begin(); _iter1256 != this->new_parts.end(); ++_iter1256) { - xfer += (*_iter1249).write(oprot); + xfer += (*_iter1256).write(oprot); } xfer += oprot->writeListEnd(); } @@ -18944,10 +19191,10 @@ uint32_t ThriftHiveMetastore_alter_partitions_with_environment_context_pargs::wr xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->new_parts)).size())); - std::vector ::const_iterator _iter1250; - for (_iter1250 = (*(this->new_parts)).begin(); _iter1250 != (*(this->new_parts)).end(); ++_iter1250) + std::vector ::const_iterator _iter1257; + for (_iter1257 = (*(this->new_parts)).begin(); _iter1257 != (*(this->new_parts)).end(); ++_iter1257) { - xfer += (*_iter1250).write(oprot); + xfer += (*_iter1257).write(oprot); } xfer += oprot->writeListEnd(); } @@ -19391,14 +19638,14 @@ uint32_t ThriftHiveMetastore_rename_partition_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1251; - ::apache::thrift::protocol::TType _etype1254; - xfer += iprot->readListBegin(_etype1254, _size1251); - this->part_vals.resize(_size1251); - uint32_t _i1255; - for (_i1255 = 0; _i1255 < _size1251; ++_i1255) + uint32_t _size1258; + ::apache::thrift::protocol::TType _etype1261; + xfer += iprot->readListBegin(_etype1261, _size1258); + this->part_vals.resize(_size1258); + uint32_t _i1262; + for (_i1262 = 0; _i1262 < _size1258; ++_i1262) { - xfer += iprot->readString(this->part_vals[_i1255]); + xfer += iprot->readString(this->part_vals[_i1262]); } xfer += iprot->readListEnd(); } @@ -19443,10 +19690,10 @@ uint32_t ThriftHiveMetastore_rename_partition_args::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter1256; - for (_iter1256 = this->part_vals.begin(); _iter1256 != this->part_vals.end(); ++_iter1256) + std::vector ::const_iterator _iter1263; + for (_iter1263 = this->part_vals.begin(); _iter1263 != this->part_vals.end(); ++_iter1263) { - xfer += oprot->writeString((*_iter1256)); + xfer += oprot->writeString((*_iter1263)); } xfer += oprot->writeListEnd(); } @@ -19482,10 +19729,10 @@ uint32_t ThriftHiveMetastore_rename_partition_pargs::write(::apache::thrift::pro xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter1257; - for (_iter1257 = (*(this->part_vals)).begin(); _iter1257 != (*(this->part_vals)).end(); ++_iter1257) + std::vector ::const_iterator _iter1264; + for (_iter1264 = (*(this->part_vals)).begin(); _iter1264 != (*(this->part_vals)).end(); ++_iter1264) { - xfer += oprot->writeString((*_iter1257)); + xfer += oprot->writeString((*_iter1264)); } xfer += oprot->writeListEnd(); } @@ -19658,14 +19905,14 @@ uint32_t ThriftHiveMetastore_partition_name_has_valid_characters_args::read(::ap if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1258; - ::apache::thrift::protocol::TType _etype1261; - xfer += iprot->readListBegin(_etype1261, _size1258); - this->part_vals.resize(_size1258); - uint32_t _i1262; - for (_i1262 = 0; _i1262 < _size1258; ++_i1262) + uint32_t _size1265; + ::apache::thrift::protocol::TType _etype1268; + xfer += iprot->readListBegin(_etype1268, _size1265); + this->part_vals.resize(_size1265); + uint32_t _i1269; + for (_i1269 = 0; _i1269 < _size1265; ++_i1269) { - xfer += iprot->readString(this->part_vals[_i1262]); + xfer += iprot->readString(this->part_vals[_i1269]); } xfer += iprot->readListEnd(); } @@ -19702,10 +19949,10 @@ uint32_t ThriftHiveMetastore_partition_name_has_valid_characters_args::write(::a xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter1263; - for (_iter1263 = this->part_vals.begin(); _iter1263 != this->part_vals.end(); ++_iter1263) + std::vector ::const_iterator _iter1270; + for (_iter1270 = this->part_vals.begin(); _iter1270 != this->part_vals.end(); ++_iter1270) { - xfer += oprot->writeString((*_iter1263)); + xfer += oprot->writeString((*_iter1270)); } xfer += oprot->writeListEnd(); } @@ -19733,10 +19980,10 @@ uint32_t ThriftHiveMetastore_partition_name_has_valid_characters_pargs::write(:: xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter1264; - for (_iter1264 = (*(this->part_vals)).begin(); _iter1264 != (*(this->part_vals)).end(); ++_iter1264) + std::vector ::const_iterator _iter1271; + for (_iter1271 = (*(this->part_vals)).begin(); _iter1271 != (*(this->part_vals)).end(); ++_iter1271) { - xfer += oprot->writeString((*_iter1264)); + xfer += oprot->writeString((*_iter1271)); } xfer += oprot->writeListEnd(); } @@ -20211,14 +20458,14 @@ uint32_t ThriftHiveMetastore_partition_name_to_vals_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1265; - ::apache::thrift::protocol::TType _etype1268; - xfer += iprot->readListBegin(_etype1268, _size1265); - this->success.resize(_size1265); - uint32_t _i1269; - for (_i1269 = 0; _i1269 < _size1265; ++_i1269) + uint32_t _size1272; + ::apache::thrift::protocol::TType _etype1275; + xfer += iprot->readListBegin(_etype1275, _size1272); + this->success.resize(_size1272); + uint32_t _i1276; + for (_i1276 = 0; _i1276 < _size1272; ++_i1276) { - xfer += iprot->readString(this->success[_i1269]); + xfer += iprot->readString(this->success[_i1276]); } xfer += iprot->readListEnd(); } @@ -20257,10 +20504,10 @@ uint32_t ThriftHiveMetastore_partition_name_to_vals_result::write(::apache::thri xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1270; - for (_iter1270 = this->success.begin(); _iter1270 != this->success.end(); ++_iter1270) + std::vector ::const_iterator _iter1277; + for (_iter1277 = this->success.begin(); _iter1277 != this->success.end(); ++_iter1277) { - xfer += oprot->writeString((*_iter1270)); + xfer += oprot->writeString((*_iter1277)); } xfer += oprot->writeListEnd(); } @@ -20305,14 +20552,14 @@ uint32_t ThriftHiveMetastore_partition_name_to_vals_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1271; - ::apache::thrift::protocol::TType _etype1274; - xfer += iprot->readListBegin(_etype1274, _size1271); - (*(this->success)).resize(_size1271); - uint32_t _i1275; - for (_i1275 = 0; _i1275 < _size1271; ++_i1275) + uint32_t _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 += iprot->readString((*(this->success))[_i1275]); + xfer += iprot->readString((*(this->success))[_i1282]); } xfer += iprot->readListEnd(); } @@ -20450,17 +20697,17 @@ uint32_t ThriftHiveMetastore_partition_name_to_spec_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_MAP) { { this->success.clear(); - uint32_t _size1276; - ::apache::thrift::protocol::TType _ktype1277; - ::apache::thrift::protocol::TType _vtype1278; - xfer += iprot->readMapBegin(_ktype1277, _vtype1278, _size1276); - uint32_t _i1280; - for (_i1280 = 0; _i1280 < _size1276; ++_i1280) + uint32_t _size1283; + ::apache::thrift::protocol::TType _ktype1284; + ::apache::thrift::protocol::TType _vtype1285; + xfer += iprot->readMapBegin(_ktype1284, _vtype1285, _size1283); + uint32_t _i1287; + for (_i1287 = 0; _i1287 < _size1283; ++_i1287) { - std::string _key1281; - xfer += iprot->readString(_key1281); - std::string& _val1282 = this->success[_key1281]; - xfer += iprot->readString(_val1282); + std::string _key1288; + xfer += iprot->readString(_key1288); + std::string& _val1289 = this->success[_key1288]; + xfer += iprot->readString(_val1289); } xfer += iprot->readMapEnd(); } @@ -20499,11 +20746,11 @@ uint32_t ThriftHiveMetastore_partition_name_to_spec_result::write(::apache::thri xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_MAP, 0); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::map ::const_iterator _iter1283; - for (_iter1283 = this->success.begin(); _iter1283 != this->success.end(); ++_iter1283) + std::map ::const_iterator _iter1290; + for (_iter1290 = this->success.begin(); _iter1290 != this->success.end(); ++_iter1290) { - xfer += oprot->writeString(_iter1283->first); - xfer += oprot->writeString(_iter1283->second); + xfer += oprot->writeString(_iter1290->first); + xfer += oprot->writeString(_iter1290->second); } xfer += oprot->writeMapEnd(); } @@ -20548,17 +20795,17 @@ uint32_t ThriftHiveMetastore_partition_name_to_spec_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_MAP) { { (*(this->success)).clear(); - uint32_t _size1284; - ::apache::thrift::protocol::TType _ktype1285; - ::apache::thrift::protocol::TType _vtype1286; - xfer += iprot->readMapBegin(_ktype1285, _vtype1286, _size1284); - uint32_t _i1288; - for (_i1288 = 0; _i1288 < _size1284; ++_i1288) + uint32_t _size1291; + ::apache::thrift::protocol::TType _ktype1292; + ::apache::thrift::protocol::TType _vtype1293; + xfer += iprot->readMapBegin(_ktype1292, _vtype1293, _size1291); + uint32_t _i1295; + for (_i1295 = 0; _i1295 < _size1291; ++_i1295) { - std::string _key1289; - xfer += iprot->readString(_key1289); - std::string& _val1290 = (*(this->success))[_key1289]; - xfer += iprot->readString(_val1290); + std::string _key1296; + xfer += iprot->readString(_key1296); + std::string& _val1297 = (*(this->success))[_key1296]; + xfer += iprot->readString(_val1297); } xfer += iprot->readMapEnd(); } @@ -20633,17 +20880,17 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_args::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_MAP) { { this->part_vals.clear(); - uint32_t _size1291; - ::apache::thrift::protocol::TType _ktype1292; - ::apache::thrift::protocol::TType _vtype1293; - xfer += iprot->readMapBegin(_ktype1292, _vtype1293, _size1291); - uint32_t _i1295; - for (_i1295 = 0; _i1295 < _size1291; ++_i1295) + uint32_t _size1298; + ::apache::thrift::protocol::TType _ktype1299; + ::apache::thrift::protocol::TType _vtype1300; + xfer += iprot->readMapBegin(_ktype1299, _vtype1300, _size1298); + uint32_t _i1302; + for (_i1302 = 0; _i1302 < _size1298; ++_i1302) { - std::string _key1296; - xfer += iprot->readString(_key1296); - std::string& _val1297 = this->part_vals[_key1296]; - xfer += iprot->readString(_val1297); + std::string _key1303; + xfer += iprot->readString(_key1303); + std::string& _val1304 = this->part_vals[_key1303]; + xfer += iprot->readString(_val1304); } xfer += iprot->readMapEnd(); } @@ -20654,9 +20901,9 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_args::read(::apache::thrift:: break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1298; - xfer += iprot->readI32(ecast1298); - this->eventType = (PartitionEventType::type)ecast1298; + int32_t ecast1305; + xfer += iprot->readI32(ecast1305); + this->eventType = (PartitionEventType::type)ecast1305; this->__isset.eventType = true; } else { xfer += iprot->skip(ftype); @@ -20690,11 +20937,11 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_args::write(::apache::thrift: xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_MAP, 3); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::map ::const_iterator _iter1299; - for (_iter1299 = this->part_vals.begin(); _iter1299 != this->part_vals.end(); ++_iter1299) + std::map ::const_iterator _iter1306; + for (_iter1306 = this->part_vals.begin(); _iter1306 != this->part_vals.end(); ++_iter1306) { - xfer += oprot->writeString(_iter1299->first); - xfer += oprot->writeString(_iter1299->second); + xfer += oprot->writeString(_iter1306->first); + xfer += oprot->writeString(_iter1306->second); } xfer += oprot->writeMapEnd(); } @@ -20730,11 +20977,11 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_pargs::write(::apache::thrift xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_MAP, 3); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::map ::const_iterator _iter1300; - for (_iter1300 = (*(this->part_vals)).begin(); _iter1300 != (*(this->part_vals)).end(); ++_iter1300) + std::map ::const_iterator _iter1307; + for (_iter1307 = (*(this->part_vals)).begin(); _iter1307 != (*(this->part_vals)).end(); ++_iter1307) { - xfer += oprot->writeString(_iter1300->first); - xfer += oprot->writeString(_iter1300->second); + xfer += oprot->writeString(_iter1307->first); + xfer += oprot->writeString(_iter1307->second); } xfer += oprot->writeMapEnd(); } @@ -21003,17 +21250,17 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_MAP) { { this->part_vals.clear(); - uint32_t _size1301; - ::apache::thrift::protocol::TType _ktype1302; - ::apache::thrift::protocol::TType _vtype1303; - xfer += iprot->readMapBegin(_ktype1302, _vtype1303, _size1301); - uint32_t _i1305; - for (_i1305 = 0; _i1305 < _size1301; ++_i1305) + uint32_t _size1308; + ::apache::thrift::protocol::TType _ktype1309; + ::apache::thrift::protocol::TType _vtype1310; + xfer += iprot->readMapBegin(_ktype1309, _vtype1310, _size1308); + uint32_t _i1312; + for (_i1312 = 0; _i1312 < _size1308; ++_i1312) { - std::string _key1306; - xfer += iprot->readString(_key1306); - std::string& _val1307 = this->part_vals[_key1306]; - xfer += iprot->readString(_val1307); + std::string _key1313; + xfer += iprot->readString(_key1313); + std::string& _val1314 = this->part_vals[_key1313]; + xfer += iprot->readString(_val1314); } xfer += iprot->readMapEnd(); } @@ -21024,9 +21271,9 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::read(::apache::thri break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1308; - xfer += iprot->readI32(ecast1308); - this->eventType = (PartitionEventType::type)ecast1308; + int32_t ecast1315; + xfer += iprot->readI32(ecast1315); + this->eventType = (PartitionEventType::type)ecast1315; this->__isset.eventType = true; } else { xfer += iprot->skip(ftype); @@ -21060,11 +21307,11 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::write(::apache::thr xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_MAP, 3); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::map ::const_iterator _iter1309; - for (_iter1309 = this->part_vals.begin(); _iter1309 != this->part_vals.end(); ++_iter1309) + std::map ::const_iterator _iter1316; + for (_iter1316 = this->part_vals.begin(); _iter1316 != this->part_vals.end(); ++_iter1316) { - xfer += oprot->writeString(_iter1309->first); - xfer += oprot->writeString(_iter1309->second); + xfer += oprot->writeString(_iter1316->first); + xfer += oprot->writeString(_iter1316->second); } xfer += oprot->writeMapEnd(); } @@ -21100,11 +21347,11 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_pargs::write(::apache::th xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_MAP, 3); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::map ::const_iterator _iter1310; - for (_iter1310 = (*(this->part_vals)).begin(); _iter1310 != (*(this->part_vals)).end(); ++_iter1310) + std::map ::const_iterator _iter1317; + for (_iter1317 = (*(this->part_vals)).begin(); _iter1317 != (*(this->part_vals)).end(); ++_iter1317) { - xfer += oprot->writeString(_iter1310->first); - xfer += oprot->writeString(_iter1310->second); + xfer += oprot->writeString(_iter1317->first); + xfer += oprot->writeString(_iter1317->second); } xfer += oprot->writeMapEnd(); } @@ -22540,14 +22787,14 @@ uint32_t ThriftHiveMetastore_get_indexes_result::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1311; - ::apache::thrift::protocol::TType _etype1314; - xfer += iprot->readListBegin(_etype1314, _size1311); - this->success.resize(_size1311); - uint32_t _i1315; - for (_i1315 = 0; _i1315 < _size1311; ++_i1315) + uint32_t _size1318; + ::apache::thrift::protocol::TType _etype1321; + xfer += iprot->readListBegin(_etype1321, _size1318); + this->success.resize(_size1318); + uint32_t _i1322; + for (_i1322 = 0; _i1322 < _size1318; ++_i1322) { - xfer += this->success[_i1315].read(iprot); + xfer += this->success[_i1322].read(iprot); } xfer += iprot->readListEnd(); } @@ -22594,10 +22841,10 @@ uint32_t ThriftHiveMetastore_get_indexes_result::write(::apache::thrift::protoco xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1316; - for (_iter1316 = this->success.begin(); _iter1316 != this->success.end(); ++_iter1316) + std::vector ::const_iterator _iter1323; + for (_iter1323 = this->success.begin(); _iter1323 != this->success.end(); ++_iter1323) { - xfer += (*_iter1316).write(oprot); + xfer += (*_iter1323).write(oprot); } xfer += oprot->writeListEnd(); } @@ -22646,14 +22893,14 @@ uint32_t ThriftHiveMetastore_get_indexes_presult::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1317; - ::apache::thrift::protocol::TType _etype1320; - xfer += iprot->readListBegin(_etype1320, _size1317); - (*(this->success)).resize(_size1317); - uint32_t _i1321; - for (_i1321 = 0; _i1321 < _size1317; ++_i1321) + uint32_t _size1324; + ::apache::thrift::protocol::TType _etype1327; + xfer += iprot->readListBegin(_etype1327, _size1324); + (*(this->success)).resize(_size1324); + uint32_t _i1328; + for (_i1328 = 0; _i1328 < _size1324; ++_i1328) { - xfer += (*(this->success))[_i1321].read(iprot); + xfer += (*(this->success))[_i1328].read(iprot); } xfer += iprot->readListEnd(); } @@ -22831,14 +23078,14 @@ uint32_t ThriftHiveMetastore_get_index_names_result::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1322; - ::apache::thrift::protocol::TType _etype1325; - xfer += iprot->readListBegin(_etype1325, _size1322); - this->success.resize(_size1322); - uint32_t _i1326; - for (_i1326 = 0; _i1326 < _size1322; ++_i1326) + uint32_t _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[_i1326]); + xfer += iprot->readString(this->success[_i1333]); } xfer += iprot->readListEnd(); } @@ -22877,10 +23124,10 @@ uint32_t ThriftHiveMetastore_get_index_names_result::write(::apache::thrift::pro xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1327; - for (_iter1327 = this->success.begin(); _iter1327 != this->success.end(); ++_iter1327) + std::vector ::const_iterator _iter1334; + for (_iter1334 = this->success.begin(); _iter1334 != this->success.end(); ++_iter1334) { - xfer += oprot->writeString((*_iter1327)); + xfer += oprot->writeString((*_iter1334)); } xfer += oprot->writeListEnd(); } @@ -22925,14 +23172,14 @@ uint32_t ThriftHiveMetastore_get_index_names_presult::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1328; - ::apache::thrift::protocol::TType _etype1331; - xfer += iprot->readListBegin(_etype1331, _size1328); - (*(this->success)).resize(_size1328); - uint32_t _i1332; - for (_i1332 = 0; _i1332 < _size1328; ++_i1332) + uint32_t _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))[_i1332]); + xfer += iprot->readString((*(this->success))[_i1339]); } xfer += iprot->readListEnd(); } @@ -26959,14 +27206,14 @@ uint32_t ThriftHiveMetastore_get_functions_result::read(::apache::thrift::protoc if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1333; - ::apache::thrift::protocol::TType _etype1336; - xfer += iprot->readListBegin(_etype1336, _size1333); - this->success.resize(_size1333); - uint32_t _i1337; - for (_i1337 = 0; _i1337 < _size1333; ++_i1337) + uint32_t _size1340; + ::apache::thrift::protocol::TType _etype1343; + xfer += iprot->readListBegin(_etype1343, _size1340); + this->success.resize(_size1340); + uint32_t _i1344; + for (_i1344 = 0; _i1344 < _size1340; ++_i1344) { - xfer += iprot->readString(this->success[_i1337]); + xfer += iprot->readString(this->success[_i1344]); } xfer += iprot->readListEnd(); } @@ -27005,10 +27252,10 @@ uint32_t ThriftHiveMetastore_get_functions_result::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1338; - for (_iter1338 = this->success.begin(); _iter1338 != this->success.end(); ++_iter1338) + std::vector ::const_iterator _iter1345; + for (_iter1345 = this->success.begin(); _iter1345 != this->success.end(); ++_iter1345) { - xfer += oprot->writeString((*_iter1338)); + xfer += oprot->writeString((*_iter1345)); } xfer += oprot->writeListEnd(); } @@ -27053,14 +27300,14 @@ uint32_t ThriftHiveMetastore_get_functions_presult::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1339; - ::apache::thrift::protocol::TType _etype1342; - xfer += iprot->readListBegin(_etype1342, _size1339); - (*(this->success)).resize(_size1339); - uint32_t _i1343; - for (_i1343 = 0; _i1343 < _size1339; ++_i1343) + uint32_t _size1346; + ::apache::thrift::protocol::TType _etype1349; + xfer += iprot->readListBegin(_etype1349, _size1346); + (*(this->success)).resize(_size1346); + uint32_t _i1350; + for (_i1350 = 0; _i1350 < _size1346; ++_i1350) { - xfer += iprot->readString((*(this->success))[_i1343]); + xfer += iprot->readString((*(this->success))[_i1350]); } xfer += iprot->readListEnd(); } @@ -28020,14 +28267,14 @@ uint32_t ThriftHiveMetastore_get_role_names_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1344; - ::apache::thrift::protocol::TType _etype1347; - xfer += iprot->readListBegin(_etype1347, _size1344); - this->success.resize(_size1344); - uint32_t _i1348; - for (_i1348 = 0; _i1348 < _size1344; ++_i1348) + uint32_t _size1351; + ::apache::thrift::protocol::TType _etype1354; + xfer += iprot->readListBegin(_etype1354, _size1351); + this->success.resize(_size1351); + uint32_t _i1355; + for (_i1355 = 0; _i1355 < _size1351; ++_i1355) { - xfer += iprot->readString(this->success[_i1348]); + xfer += iprot->readString(this->success[_i1355]); } xfer += iprot->readListEnd(); } @@ -28066,10 +28313,10 @@ uint32_t ThriftHiveMetastore_get_role_names_result::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1349; - for (_iter1349 = this->success.begin(); _iter1349 != this->success.end(); ++_iter1349) + std::vector ::const_iterator _iter1356; + for (_iter1356 = this->success.begin(); _iter1356 != this->success.end(); ++_iter1356) { - xfer += oprot->writeString((*_iter1349)); + xfer += oprot->writeString((*_iter1356)); } xfer += oprot->writeListEnd(); } @@ -28114,14 +28361,14 @@ uint32_t ThriftHiveMetastore_get_role_names_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1350; - ::apache::thrift::protocol::TType _etype1353; - xfer += iprot->readListBegin(_etype1353, _size1350); - (*(this->success)).resize(_size1350); - uint32_t _i1354; - for (_i1354 = 0; _i1354 < _size1350; ++_i1354) + uint32_t _size1357; + ::apache::thrift::protocol::TType _etype1360; + xfer += iprot->readListBegin(_etype1360, _size1357); + (*(this->success)).resize(_size1357); + uint32_t _i1361; + for (_i1361 = 0; _i1361 < _size1357; ++_i1361) { - xfer += iprot->readString((*(this->success))[_i1354]); + xfer += iprot->readString((*(this->success))[_i1361]); } xfer += iprot->readListEnd(); } @@ -28194,9 +28441,9 @@ uint32_t ThriftHiveMetastore_grant_role_args::read(::apache::thrift::protocol::T break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1355; - xfer += iprot->readI32(ecast1355); - this->principal_type = (PrincipalType::type)ecast1355; + int32_t ecast1362; + xfer += iprot->readI32(ecast1362); + this->principal_type = (PrincipalType::type)ecast1362; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -28212,9 +28459,9 @@ uint32_t ThriftHiveMetastore_grant_role_args::read(::apache::thrift::protocol::T break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1356; - xfer += iprot->readI32(ecast1356); - this->grantorType = (PrincipalType::type)ecast1356; + int32_t ecast1363; + xfer += iprot->readI32(ecast1363); + this->grantorType = (PrincipalType::type)ecast1363; this->__isset.grantorType = true; } else { xfer += iprot->skip(ftype); @@ -28485,9 +28732,9 @@ uint32_t ThriftHiveMetastore_revoke_role_args::read(::apache::thrift::protocol:: break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1357; - xfer += iprot->readI32(ecast1357); - this->principal_type = (PrincipalType::type)ecast1357; + int32_t ecast1364; + xfer += iprot->readI32(ecast1364); + this->principal_type = (PrincipalType::type)ecast1364; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -28718,9 +28965,9 @@ uint32_t ThriftHiveMetastore_list_roles_args::read(::apache::thrift::protocol::T break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1358; - xfer += iprot->readI32(ecast1358); - this->principal_type = (PrincipalType::type)ecast1358; + int32_t ecast1365; + xfer += iprot->readI32(ecast1365); + this->principal_type = (PrincipalType::type)ecast1365; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -28809,14 +29056,14 @@ uint32_t ThriftHiveMetastore_list_roles_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1359; - ::apache::thrift::protocol::TType _etype1362; - xfer += iprot->readListBegin(_etype1362, _size1359); - this->success.resize(_size1359); - uint32_t _i1363; - for (_i1363 = 0; _i1363 < _size1359; ++_i1363) + uint32_t _size1366; + ::apache::thrift::protocol::TType _etype1369; + xfer += iprot->readListBegin(_etype1369, _size1366); + this->success.resize(_size1366); + uint32_t _i1370; + for (_i1370 = 0; _i1370 < _size1366; ++_i1370) { - xfer += this->success[_i1363].read(iprot); + xfer += this->success[_i1370].read(iprot); } xfer += iprot->readListEnd(); } @@ -28855,10 +29102,10 @@ uint32_t ThriftHiveMetastore_list_roles_result::write(::apache::thrift::protocol xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1364; - for (_iter1364 = this->success.begin(); _iter1364 != this->success.end(); ++_iter1364) + std::vector ::const_iterator _iter1371; + for (_iter1371 = this->success.begin(); _iter1371 != this->success.end(); ++_iter1371) { - xfer += (*_iter1364).write(oprot); + xfer += (*_iter1371).write(oprot); } xfer += oprot->writeListEnd(); } @@ -28903,14 +29150,14 @@ uint32_t ThriftHiveMetastore_list_roles_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1365; - ::apache::thrift::protocol::TType _etype1368; - xfer += iprot->readListBegin(_etype1368, _size1365); - (*(this->success)).resize(_size1365); - uint32_t _i1369; - for (_i1369 = 0; _i1369 < _size1365; ++_i1369) + uint32_t _size1372; + ::apache::thrift::protocol::TType _etype1375; + xfer += iprot->readListBegin(_etype1375, _size1372); + (*(this->success)).resize(_size1372); + uint32_t _i1376; + for (_i1376 = 0; _i1376 < _size1372; ++_i1376) { - xfer += (*(this->success))[_i1369].read(iprot); + xfer += (*(this->success))[_i1376].read(iprot); } xfer += iprot->readListEnd(); } @@ -29606,14 +29853,14 @@ uint32_t ThriftHiveMetastore_get_privilege_set_args::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size1370; - ::apache::thrift::protocol::TType _etype1373; - xfer += iprot->readListBegin(_etype1373, _size1370); - this->group_names.resize(_size1370); - uint32_t _i1374; - for (_i1374 = 0; _i1374 < _size1370; ++_i1374) + uint32_t _size1377; + ::apache::thrift::protocol::TType _etype1380; + xfer += iprot->readListBegin(_etype1380, _size1377); + this->group_names.resize(_size1377); + uint32_t _i1381; + for (_i1381 = 0; _i1381 < _size1377; ++_i1381) { - xfer += iprot->readString(this->group_names[_i1374]); + xfer += iprot->readString(this->group_names[_i1381]); } xfer += iprot->readListEnd(); } @@ -29650,10 +29897,10 @@ uint32_t ThriftHiveMetastore_get_privilege_set_args::write(::apache::thrift::pro xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->group_names.size())); - std::vector ::const_iterator _iter1375; - for (_iter1375 = this->group_names.begin(); _iter1375 != this->group_names.end(); ++_iter1375) + std::vector ::const_iterator _iter1382; + for (_iter1382 = this->group_names.begin(); _iter1382 != this->group_names.end(); ++_iter1382) { - xfer += oprot->writeString((*_iter1375)); + xfer += oprot->writeString((*_iter1382)); } xfer += oprot->writeListEnd(); } @@ -29685,10 +29932,10 @@ uint32_t ThriftHiveMetastore_get_privilege_set_pargs::write(::apache::thrift::pr xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->group_names)).size())); - std::vector ::const_iterator _iter1376; - for (_iter1376 = (*(this->group_names)).begin(); _iter1376 != (*(this->group_names)).end(); ++_iter1376) + std::vector ::const_iterator _iter1383; + for (_iter1383 = (*(this->group_names)).begin(); _iter1383 != (*(this->group_names)).end(); ++_iter1383) { - xfer += oprot->writeString((*_iter1376)); + xfer += oprot->writeString((*_iter1383)); } xfer += oprot->writeListEnd(); } @@ -29863,9 +30110,9 @@ uint32_t ThriftHiveMetastore_list_privileges_args::read(::apache::thrift::protoc break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1377; - xfer += iprot->readI32(ecast1377); - this->principal_type = (PrincipalType::type)ecast1377; + int32_t ecast1384; + xfer += iprot->readI32(ecast1384); + this->principal_type = (PrincipalType::type)ecast1384; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -29970,14 +30217,14 @@ uint32_t ThriftHiveMetastore_list_privileges_result::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1378; - ::apache::thrift::protocol::TType _etype1381; - xfer += iprot->readListBegin(_etype1381, _size1378); - this->success.resize(_size1378); - uint32_t _i1382; - for (_i1382 = 0; _i1382 < _size1378; ++_i1382) + uint32_t _size1385; + ::apache::thrift::protocol::TType _etype1388; + xfer += iprot->readListBegin(_etype1388, _size1385); + this->success.resize(_size1385); + uint32_t _i1389; + for (_i1389 = 0; _i1389 < _size1385; ++_i1389) { - xfer += this->success[_i1382].read(iprot); + xfer += this->success[_i1389].read(iprot); } xfer += iprot->readListEnd(); } @@ -30016,10 +30263,10 @@ uint32_t ThriftHiveMetastore_list_privileges_result::write(::apache::thrift::pro xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1383; - for (_iter1383 = this->success.begin(); _iter1383 != this->success.end(); ++_iter1383) + std::vector ::const_iterator _iter1390; + for (_iter1390 = this->success.begin(); _iter1390 != this->success.end(); ++_iter1390) { - xfer += (*_iter1383).write(oprot); + xfer += (*_iter1390).write(oprot); } xfer += oprot->writeListEnd(); } @@ -30064,14 +30311,14 @@ uint32_t ThriftHiveMetastore_list_privileges_presult::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1384; - ::apache::thrift::protocol::TType _etype1387; - xfer += iprot->readListBegin(_etype1387, _size1384); - (*(this->success)).resize(_size1384); - uint32_t _i1388; - for (_i1388 = 0; _i1388 < _size1384; ++_i1388) + uint32_t _size1391; + ::apache::thrift::protocol::TType _etype1394; + xfer += iprot->readListBegin(_etype1394, _size1391); + (*(this->success)).resize(_size1391); + uint32_t _i1395; + for (_i1395 = 0; _i1395 < _size1391; ++_i1395) { - xfer += (*(this->success))[_i1388].read(iprot); + xfer += (*(this->success))[_i1395].read(iprot); } xfer += iprot->readListEnd(); } @@ -30759,14 +31006,14 @@ uint32_t ThriftHiveMetastore_set_ugi_args::read(::apache::thrift::protocol::TPro if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size1389; - ::apache::thrift::protocol::TType _etype1392; - xfer += iprot->readListBegin(_etype1392, _size1389); - this->group_names.resize(_size1389); - uint32_t _i1393; - for (_i1393 = 0; _i1393 < _size1389; ++_i1393) + uint32_t _size1396; + ::apache::thrift::protocol::TType _etype1399; + xfer += iprot->readListBegin(_etype1399, _size1396); + this->group_names.resize(_size1396); + uint32_t _i1400; + for (_i1400 = 0; _i1400 < _size1396; ++_i1400) { - xfer += iprot->readString(this->group_names[_i1393]); + xfer += iprot->readString(this->group_names[_i1400]); } xfer += iprot->readListEnd(); } @@ -30799,10 +31046,10 @@ uint32_t ThriftHiveMetastore_set_ugi_args::write(::apache::thrift::protocol::TPr xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->group_names.size())); - std::vector ::const_iterator _iter1394; - for (_iter1394 = this->group_names.begin(); _iter1394 != this->group_names.end(); ++_iter1394) + std::vector ::const_iterator _iter1401; + for (_iter1401 = this->group_names.begin(); _iter1401 != this->group_names.end(); ++_iter1401) { - xfer += oprot->writeString((*_iter1394)); + xfer += oprot->writeString((*_iter1401)); } xfer += oprot->writeListEnd(); } @@ -30830,10 +31077,10 @@ uint32_t ThriftHiveMetastore_set_ugi_pargs::write(::apache::thrift::protocol::TP xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->group_names)).size())); - std::vector ::const_iterator _iter1395; - for (_iter1395 = (*(this->group_names)).begin(); _iter1395 != (*(this->group_names)).end(); ++_iter1395) + std::vector ::const_iterator _iter1402; + for (_iter1402 = (*(this->group_names)).begin(); _iter1402 != (*(this->group_names)).end(); ++_iter1402) { - xfer += oprot->writeString((*_iter1395)); + xfer += oprot->writeString((*_iter1402)); } xfer += oprot->writeListEnd(); } @@ -30874,14 +31121,14 @@ uint32_t ThriftHiveMetastore_set_ugi_result::read(::apache::thrift::protocol::TP if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1396; - ::apache::thrift::protocol::TType _etype1399; - xfer += iprot->readListBegin(_etype1399, _size1396); - this->success.resize(_size1396); - uint32_t _i1400; - for (_i1400 = 0; _i1400 < _size1396; ++_i1400) + uint32_t _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[_i1400]); + xfer += iprot->readString(this->success[_i1407]); } xfer += iprot->readListEnd(); } @@ -30920,10 +31167,10 @@ uint32_t ThriftHiveMetastore_set_ugi_result::write(::apache::thrift::protocol::T xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1401; - for (_iter1401 = this->success.begin(); _iter1401 != this->success.end(); ++_iter1401) + std::vector ::const_iterator _iter1408; + for (_iter1408 = this->success.begin(); _iter1408 != this->success.end(); ++_iter1408) { - xfer += oprot->writeString((*_iter1401)); + xfer += oprot->writeString((*_iter1408)); } xfer += oprot->writeListEnd(); } @@ -30968,14 +31215,14 @@ uint32_t ThriftHiveMetastore_set_ugi_presult::read(::apache::thrift::protocol::T if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1402; - ::apache::thrift::protocol::TType _etype1405; - xfer += iprot->readListBegin(_etype1405, _size1402); - (*(this->success)).resize(_size1402); - uint32_t _i1406; - for (_i1406 = 0; _i1406 < _size1402; ++_i1406) + uint32_t _size1409; + ::apache::thrift::protocol::TType _etype1412; + xfer += iprot->readListBegin(_etype1412, _size1409); + (*(this->success)).resize(_size1409); + uint32_t _i1413; + for (_i1413 = 0; _i1413 < _size1409; ++_i1413) { - xfer += iprot->readString((*(this->success))[_i1406]); + xfer += iprot->readString((*(this->success))[_i1413]); } xfer += iprot->readListEnd(); } @@ -32286,14 +32533,14 @@ uint32_t ThriftHiveMetastore_get_all_token_identifiers_result::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1407; - ::apache::thrift::protocol::TType _etype1410; - xfer += iprot->readListBegin(_etype1410, _size1407); - this->success.resize(_size1407); - uint32_t _i1411; - for (_i1411 = 0; _i1411 < _size1407; ++_i1411) + uint32_t _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[_i1411]); + xfer += iprot->readString(this->success[_i1418]); } xfer += iprot->readListEnd(); } @@ -32324,10 +32571,10 @@ uint32_t ThriftHiveMetastore_get_all_token_identifiers_result::write(::apache::t xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1412; - for (_iter1412 = this->success.begin(); _iter1412 != this->success.end(); ++_iter1412) + std::vector ::const_iterator _iter1419; + for (_iter1419 = this->success.begin(); _iter1419 != this->success.end(); ++_iter1419) { - xfer += oprot->writeString((*_iter1412)); + xfer += oprot->writeString((*_iter1419)); } xfer += oprot->writeListEnd(); } @@ -32368,14 +32615,14 @@ uint32_t ThriftHiveMetastore_get_all_token_identifiers_presult::read(::apache::t if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1413; - ::apache::thrift::protocol::TType _etype1416; - xfer += iprot->readListBegin(_etype1416, _size1413); - (*(this->success)).resize(_size1413); - uint32_t _i1417; - for (_i1417 = 0; _i1417 < _size1413; ++_i1417) + uint32_t _size1420; + ::apache::thrift::protocol::TType _etype1423; + xfer += iprot->readListBegin(_etype1423, _size1420); + (*(this->success)).resize(_size1420); + uint32_t _i1424; + for (_i1424 = 0; _i1424 < _size1420; ++_i1424) { - xfer += iprot->readString((*(this->success))[_i1417]); + xfer += iprot->readString((*(this->success))[_i1424]); } xfer += iprot->readListEnd(); } @@ -33101,14 +33348,14 @@ uint32_t ThriftHiveMetastore_get_master_keys_result::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1418; - ::apache::thrift::protocol::TType _etype1421; - xfer += iprot->readListBegin(_etype1421, _size1418); - this->success.resize(_size1418); - uint32_t _i1422; - for (_i1422 = 0; _i1422 < _size1418; ++_i1422) + uint32_t _size1425; + ::apache::thrift::protocol::TType _etype1428; + xfer += iprot->readListBegin(_etype1428, _size1425); + this->success.resize(_size1425); + uint32_t _i1429; + for (_i1429 = 0; _i1429 < _size1425; ++_i1429) { - xfer += iprot->readString(this->success[_i1422]); + xfer += iprot->readString(this->success[_i1429]); } xfer += iprot->readListEnd(); } @@ -33139,10 +33386,10 @@ uint32_t ThriftHiveMetastore_get_master_keys_result::write(::apache::thrift::pro xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1423; - for (_iter1423 = this->success.begin(); _iter1423 != this->success.end(); ++_iter1423) + std::vector ::const_iterator _iter1430; + for (_iter1430 = this->success.begin(); _iter1430 != this->success.end(); ++_iter1430) { - xfer += oprot->writeString((*_iter1423)); + xfer += oprot->writeString((*_iter1430)); } xfer += oprot->writeListEnd(); } @@ -33183,14 +33430,14 @@ uint32_t ThriftHiveMetastore_get_master_keys_presult::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1424; - ::apache::thrift::protocol::TType _etype1427; - xfer += iprot->readListBegin(_etype1427, _size1424); - (*(this->success)).resize(_size1424); - uint32_t _i1428; - for (_i1428 = 0; _i1428 < _size1424; ++_i1428) + uint32_t _size1431; + ::apache::thrift::protocol::TType _etype1434; + xfer += iprot->readListBegin(_etype1434, _size1431); + (*(this->success)).resize(_size1431); + uint32_t _i1435; + for (_i1435 = 0; _i1435 < _size1431; ++_i1435) { - xfer += iprot->readString((*(this->success))[_i1428]); + xfer += iprot->readString((*(this->success))[_i1435]); } xfer += iprot->readListEnd(); } @@ -39457,6 +39704,64 @@ void ThriftHiveMetastoreClient::recv_drop_table_with_environment_context() return; } +void ThriftHiveMetastoreClient::truncate_table(const std::string& dbName, const std::string& tableName, const std::vector & partNames) +{ + send_truncate_table(dbName, tableName, partNames); + recv_truncate_table(); +} + +void ThriftHiveMetastoreClient::send_truncate_table(const std::string& dbName, const std::string& tableName, const std::vector & partNames) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("truncate_table", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_truncate_table_pargs args; + args.dbName = &dbName; + args.tableName = &tableName; + args.partNames = &partNames; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_truncate_table() +{ + + 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("truncate_table") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_truncate_table_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + return; +} + void ThriftHiveMetastoreClient::get_tables(std::vector & _return, const std::string& db_name, const std::string& pattern) { send_get_tables(db_name, pattern); @@ -49089,6 +49394,62 @@ void ThriftHiveMetastoreProcessor::process_drop_table_with_environment_context(i } } +void ThriftHiveMetastoreProcessor::process_truncate_table(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.truncate_table", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.truncate_table"); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.truncate_table"); + } + + ThriftHiveMetastore_truncate_table_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.truncate_table", bytes); + } + + ThriftHiveMetastore_truncate_table_result result; + try { + iface_->truncate_table(args.dbName, args.tableName, args.partNames); + } 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.truncate_table"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("truncate_table", ::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.truncate_table"); + } + + oprot->writeMessageBegin("truncate_table", ::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.truncate_table", bytes); + } +} + void ThriftHiveMetastoreProcessor::process_get_tables(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) { void* ctx = NULL; @@ -58881,6 +59242,90 @@ void ThriftHiveMetastoreConcurrentClient::recv_drop_table_with_environment_conte } // end while(true) } +void ThriftHiveMetastoreConcurrentClient::truncate_table(const std::string& dbName, const std::string& tableName, const std::vector & partNames) +{ + int32_t seqid = send_truncate_table(dbName, tableName, partNames); + recv_truncate_table(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_truncate_table(const std::string& dbName, const std::string& tableName, const std::vector & partNames) +{ + int32_t cseqid = this->sync_.generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); + oprot_->writeMessageBegin("truncate_table", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_truncate_table_pargs args; + args.dbName = &dbName; + args.tableName = &tableName; + args.partNames = &partNames; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_truncate_table(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("truncate_table") != 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_truncate_table_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_.updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_.waitForWork(seqid); + } // end while(true) +} + void ThriftHiveMetastoreConcurrentClient::get_tables(std::vector & _return, const std::string& db_name, const std::string& pattern) { int32_t seqid = send_get_tables(db_name, pattern); diff --git a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h index fca5ae5cb5fb..ca71711e09de 100644 --- a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h +++ b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h @@ -46,6 +46,7 @@ class ThriftHiveMetastoreIf : virtual public ::facebook::fb303::FacebookService virtual void add_foreign_key(const AddForeignKeyRequest& req) = 0; virtual void drop_table(const std::string& dbname, const std::string& name, const bool deleteData) = 0; virtual void drop_table_with_environment_context(const std::string& dbname, const std::string& name, const bool deleteData, const EnvironmentContext& environment_context) = 0; + virtual void truncate_table(const std::string& dbName, const std::string& tableName, const std::vector & partNames) = 0; virtual void get_tables(std::vector & _return, const std::string& db_name, const std::string& pattern) = 0; virtual void get_tables_by_type(std::vector & _return, const std::string& db_name, const std::string& pattern, const std::string& tableType) = 0; virtual void get_table_meta(std::vector & _return, const std::string& db_patterns, const std::string& tbl_patterns, const std::vector & tbl_types) = 0; @@ -278,6 +279,9 @@ class ThriftHiveMetastoreNull : virtual public ThriftHiveMetastoreIf , virtual p void drop_table_with_environment_context(const std::string& /* dbname */, const std::string& /* name */, const bool /* deleteData */, const EnvironmentContext& /* environment_context */) { return; } + void truncate_table(const std::string& /* dbName */, const std::string& /* tableName */, const std::vector & /* partNames */) { + return; + } void get_tables(std::vector & /* _return */, const std::string& /* db_name */, const std::string& /* pattern */) { return; } @@ -3655,6 +3659,124 @@ class ThriftHiveMetastore_drop_table_with_environment_context_presult { }; +typedef struct _ThriftHiveMetastore_truncate_table_args__isset { + _ThriftHiveMetastore_truncate_table_args__isset() : dbName(false), tableName(false), partNames(false) {} + bool dbName :1; + bool tableName :1; + bool partNames :1; +} _ThriftHiveMetastore_truncate_table_args__isset; + +class ThriftHiveMetastore_truncate_table_args { + public: + + ThriftHiveMetastore_truncate_table_args(const ThriftHiveMetastore_truncate_table_args&); + ThriftHiveMetastore_truncate_table_args& operator=(const ThriftHiveMetastore_truncate_table_args&); + ThriftHiveMetastore_truncate_table_args() : dbName(), tableName() { + } + + virtual ~ThriftHiveMetastore_truncate_table_args() throw(); + std::string dbName; + std::string tableName; + std::vector partNames; + + _ThriftHiveMetastore_truncate_table_args__isset __isset; + + void __set_dbName(const std::string& val); + + void __set_tableName(const std::string& val); + + void __set_partNames(const std::vector & val); + + bool operator == (const ThriftHiveMetastore_truncate_table_args & rhs) const + { + if (!(dbName == rhs.dbName)) + return false; + if (!(tableName == rhs.tableName)) + return false; + if (!(partNames == rhs.partNames)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_truncate_table_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_truncate_table_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_truncate_table_pargs { + public: + + + virtual ~ThriftHiveMetastore_truncate_table_pargs() throw(); + const std::string* dbName; + const std::string* tableName; + const std::vector * partNames; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_truncate_table_result__isset { + _ThriftHiveMetastore_truncate_table_result__isset() : o1(false) {} + bool o1 :1; +} _ThriftHiveMetastore_truncate_table_result__isset; + +class ThriftHiveMetastore_truncate_table_result { + public: + + ThriftHiveMetastore_truncate_table_result(const ThriftHiveMetastore_truncate_table_result&); + ThriftHiveMetastore_truncate_table_result& operator=(const ThriftHiveMetastore_truncate_table_result&); + ThriftHiveMetastore_truncate_table_result() { + } + + virtual ~ThriftHiveMetastore_truncate_table_result() throw(); + MetaException o1; + + _ThriftHiveMetastore_truncate_table_result__isset __isset; + + void __set_o1(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_truncate_table_result & rhs) const + { + if (!(o1 == rhs.o1)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_truncate_table_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_truncate_table_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_truncate_table_presult__isset { + _ThriftHiveMetastore_truncate_table_presult__isset() : o1(false) {} + bool o1 :1; +} _ThriftHiveMetastore_truncate_table_presult__isset; + +class ThriftHiveMetastore_truncate_table_presult { + public: + + + virtual ~ThriftHiveMetastore_truncate_table_presult() throw(); + MetaException o1; + + _ThriftHiveMetastore_truncate_table_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + typedef struct _ThriftHiveMetastore_get_tables_args__isset { _ThriftHiveMetastore_get_tables_args__isset() : db_name(false), pattern(false) {} bool db_name :1; @@ -19684,6 +19806,9 @@ class ThriftHiveMetastoreClient : virtual public ThriftHiveMetastoreIf, public void drop_table_with_environment_context(const std::string& dbname, const std::string& name, const bool deleteData, const EnvironmentContext& environment_context); void send_drop_table_with_environment_context(const std::string& dbname, const std::string& name, const bool deleteData, const EnvironmentContext& environment_context); void recv_drop_table_with_environment_context(); + void truncate_table(const std::string& dbName, const std::string& tableName, const std::vector & partNames); + void send_truncate_table(const std::string& dbName, const std::string& tableName, const std::vector & partNames); + void recv_truncate_table(); void get_tables(std::vector & _return, const std::string& db_name, const std::string& pattern); void send_get_tables(const std::string& db_name, const std::string& pattern); void recv_get_tables(std::vector & _return); @@ -20105,6 +20230,7 @@ class ThriftHiveMetastoreProcessor : public ::facebook::fb303::FacebookServiceP void process_add_foreign_key(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_drop_table(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_drop_table_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_truncate_table(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_get_tables(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_get_tables_by_type(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_get_table_meta(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); @@ -20262,6 +20388,7 @@ class ThriftHiveMetastoreProcessor : public ::facebook::fb303::FacebookServiceP processMap_["add_foreign_key"] = &ThriftHiveMetastoreProcessor::process_add_foreign_key; processMap_["drop_table"] = &ThriftHiveMetastoreProcessor::process_drop_table; processMap_["drop_table_with_environment_context"] = &ThriftHiveMetastoreProcessor::process_drop_table_with_environment_context; + processMap_["truncate_table"] = &ThriftHiveMetastoreProcessor::process_truncate_table; processMap_["get_tables"] = &ThriftHiveMetastoreProcessor::process_get_tables; processMap_["get_tables_by_type"] = &ThriftHiveMetastoreProcessor::process_get_tables_by_type; processMap_["get_table_meta"] = &ThriftHiveMetastoreProcessor::process_get_table_meta; @@ -20650,6 +20777,15 @@ class ThriftHiveMetastoreMultiface : virtual public ThriftHiveMetastoreIf, publi ifaces_[i]->drop_table_with_environment_context(dbname, name, deleteData, environment_context); } + void truncate_table(const std::string& dbName, const std::string& tableName, const std::vector & partNames) { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->truncate_table(dbName, tableName, partNames); + } + ifaces_[i]->truncate_table(dbName, tableName, partNames); + } + void get_tables(std::vector & _return, const std::string& db_name, const std::string& pattern) { size_t sz = ifaces_.size(); size_t i = 0; @@ -21979,6 +22115,9 @@ class ThriftHiveMetastoreConcurrentClient : virtual public ThriftHiveMetastoreIf void drop_table_with_environment_context(const std::string& dbname, const std::string& name, const bool deleteData, const EnvironmentContext& environment_context); int32_t send_drop_table_with_environment_context(const std::string& dbname, const std::string& name, const bool deleteData, const EnvironmentContext& environment_context); void recv_drop_table_with_environment_context(const int32_t seqid); + void truncate_table(const std::string& dbName, const std::string& tableName, const std::vector & partNames); + int32_t send_truncate_table(const std::string& dbName, const std::string& tableName, const std::vector & partNames); + void recv_truncate_table(const int32_t seqid); void get_tables(std::vector & _return, const std::string& db_name, const std::string& pattern); int32_t send_get_tables(const std::string& db_name, const std::string& pattern); void recv_get_tables(std::vector & _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 dfa462d6bbd9..b4a2a926428d 100644 --- a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp +++ b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp @@ -142,6 +142,11 @@ class ThriftHiveMetastoreHandler : virtual public ThriftHiveMetastoreIf { printf("drop_table_with_environment_context\n"); } + void truncate_table(const std::string& dbName, const std::string& tableName, const std::vector & partNames) { + // Your implementation goes here + printf("truncate_table\n"); + } + void get_tables(std::vector & _return, const std::string& db_name, const std::string& pattern) { // Your implementation goes here printf("get_tables\n"); 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 b7b7da728eff..19151507cae1 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 @@ -90,6 +90,8 @@ public interface Iface extends com.facebook.fb303.FacebookService.Iface { public void drop_table_with_environment_context(String dbname, String name, boolean deleteData, EnvironmentContext environment_context) throws NoSuchObjectException, MetaException, org.apache.thrift.TException; + public void truncate_table(String dbName, String tableName, List partNames) throws MetaException, org.apache.thrift.TException; + public List get_tables(String db_name, String pattern) throws MetaException, org.apache.thrift.TException; public List get_tables_by_type(String db_name, String pattern, String tableType) throws MetaException, org.apache.thrift.TException; @@ -400,6 +402,8 @@ public interface AsyncIface extends com.facebook.fb303.FacebookService .AsyncIfa public void drop_table_with_environment_context(String dbname, String name, boolean deleteData, EnvironmentContext environment_context, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void truncate_table(String dbName, String tableName, List partNames, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void get_tables(String db_name, String pattern, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; public void get_tables_by_type(String db_name, String pattern, String tableType, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; @@ -1381,6 +1385,31 @@ public void recv_drop_table_with_environment_context() throws NoSuchObjectExcept return; } + public void truncate_table(String dbName, String tableName, List partNames) throws MetaException, org.apache.thrift.TException + { + send_truncate_table(dbName, tableName, partNames); + recv_truncate_table(); + } + + public void send_truncate_table(String dbName, String tableName, List partNames) throws org.apache.thrift.TException + { + truncate_table_args args = new truncate_table_args(); + args.setDbName(dbName); + args.setTableName(tableName); + args.setPartNames(partNames); + sendBase("truncate_table", args); + } + + public void recv_truncate_table() throws MetaException, org.apache.thrift.TException + { + truncate_table_result result = new truncate_table_result(); + receiveBase(result, "truncate_table"); + if (result.o1 != null) { + throw result.o1; + } + return; + } + public List get_tables(String db_name, String pattern) throws MetaException, org.apache.thrift.TException { send_get_tables(db_name, pattern); @@ -5919,6 +5948,44 @@ public void getResult() throws NoSuchObjectException, MetaException, org.apache. } } + public void truncate_table(String dbName, String tableName, List partNames, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + truncate_table_call method_call = new truncate_table_call(dbName, tableName, partNames, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class truncate_table_call extends org.apache.thrift.async.TAsyncMethodCall { + private String dbName; + private String tableName; + private List partNames; + public truncate_table_call(String dbName, String tableName, List partNames, 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.dbName = dbName; + this.tableName = tableName; + this.partNames = partNames; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("truncate_table", org.apache.thrift.protocol.TMessageType.CALL, 0)); + truncate_table_args args = new truncate_table_args(); + args.setDbName(dbName); + args.setTableName(tableName); + args.setPartNames(partNames); + args.write(prot); + prot.writeMessageEnd(); + } + + public void 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); + (new Client(prot)).recv_truncate_table(); + } + } + public void get_tables(String db_name, String pattern, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { checkReady(); get_tables_call method_call = new get_tables_call(db_name, pattern, resultHandler, this, ___protocolFactory, ___transport); @@ -10522,6 +10589,7 @@ protected Processor(I iface, Map extends org.apache.thrift.ProcessFunction { + public truncate_table() { + super("truncate_table"); + } + + public truncate_table_args getEmptyArgsInstance() { + return new truncate_table_args(); + } + + protected boolean isOneway() { + return false; + } + + public truncate_table_result getResult(I iface, truncate_table_args args) throws org.apache.thrift.TException { + truncate_table_result result = new truncate_table_result(); + try { + iface.truncate_table(args.dbName, args.tableName, args.partNames); + } catch (MetaException o1) { + result.o1 = o1; + } + return result; + } + } + public static class get_tables extends org.apache.thrift.ProcessFunction { public get_tables() { super("get_tables"); @@ -14587,6 +14679,7 @@ protected AsyncProcessor(I iface, Map extends org.apache.thrift.AsyncProcessFunction { + public truncate_table() { + super("truncate_table"); + } + + public truncate_table_args getEmptyArgsInstance() { + return new truncate_table_args(); + } + + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback() { + public void onComplete(Void o) { + truncate_table_result result = new truncate_table_result(); + 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; + truncate_table_result result = new truncate_table_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, truncate_table_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.truncate_table(args.dbName, args.tableName, args.partNames,resultHandler); + } + } + public static class get_tables extends org.apache.thrift.AsyncProcessFunction> { public get_tables() { super("get_tables"); @@ -48049,7 +48198,1015 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("drop_table_with_environment_context_result("); + StringBuilder sb = new StringBuilder("drop_table_with_environment_context_result("); + boolean first = true; + + sb.append("o1:"); + if (this.o1 == null) { + sb.append("null"); + } else { + sb.append(this.o1); + } + first = false; + if (!first) sb.append(", "); + sb.append("o3:"); + if (this.o3 == null) { + sb.append("null"); + } else { + sb.append(this.o3); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class drop_table_with_environment_context_resultStandardSchemeFactory implements SchemeFactory { + public drop_table_with_environment_context_resultStandardScheme getScheme() { + return new drop_table_with_environment_context_resultStandardScheme(); + } + } + + private static class drop_table_with_environment_context_resultStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, drop_table_with_environment_context_result struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField schemeField; + iprot.readStructBegin(); + while (true) + { + schemeField = iprot.readFieldBegin(); + if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (schemeField.id) { + case 1: // O1 + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.o1 = new NoSuchObjectException(); + struct.o1.read(iprot); + struct.setO1IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // O3 + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.o3 = new MetaException(); + struct.o3.read(iprot); + struct.setO3IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + struct.validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot, drop_table_with_environment_context_result struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.o1 != null) { + oprot.writeFieldBegin(O1_FIELD_DESC); + struct.o1.write(oprot); + oprot.writeFieldEnd(); + } + if (struct.o3 != null) { + oprot.writeFieldBegin(O3_FIELD_DESC); + struct.o3.write(oprot); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class drop_table_with_environment_context_resultTupleSchemeFactory implements SchemeFactory { + public drop_table_with_environment_context_resultTupleScheme getScheme() { + return new drop_table_with_environment_context_resultTupleScheme(); + } + } + + private static class drop_table_with_environment_context_resultTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, drop_table_with_environment_context_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetO1()) { + optionals.set(0); + } + if (struct.isSetO3()) { + optionals.set(1); + } + oprot.writeBitSet(optionals, 2); + if (struct.isSetO1()) { + struct.o1.write(oprot); + } + if (struct.isSetO3()) { + struct.o3.write(oprot); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, drop_table_with_environment_context_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(2); + if (incoming.get(0)) { + struct.o1 = new NoSuchObjectException(); + struct.o1.read(iprot); + struct.setO1IsSet(true); + } + if (incoming.get(1)) { + struct.o3 = new MetaException(); + struct.o3.read(iprot); + struct.setO3IsSet(true); + } + } + } + + } + + public static class truncate_table_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("truncate_table_args"); + + private static final org.apache.thrift.protocol.TField DB_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("dbName", org.apache.thrift.protocol.TType.STRING, (short)1); + private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)2); + private static final org.apache.thrift.protocol.TField PART_NAMES_FIELD_DESC = new org.apache.thrift.protocol.TField("partNames", org.apache.thrift.protocol.TType.LIST, (short)3); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new truncate_table_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new truncate_table_argsTupleSchemeFactory()); + } + + private String dbName; // required + private String tableName; // required + private List partNames; // 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 { + DB_NAME((short)1, "dbName"), + TABLE_NAME((short)2, "tableName"), + PART_NAMES((short)3, "partNames"); + + 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: // DB_NAME + return DB_NAME; + case 2: // TABLE_NAME + return TABLE_NAME; + case 3: // PART_NAMES + return PART_NAMES; + 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.DB_NAME, new org.apache.thrift.meta_data.FieldMetaData("dbName", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.PART_NAMES, new org.apache.thrift.meta_data.FieldMetaData("partNames", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(truncate_table_args.class, metaDataMap); + } + + public truncate_table_args() { + } + + public truncate_table_args( + String dbName, + String tableName, + List partNames) + { + this(); + this.dbName = dbName; + this.tableName = tableName; + this.partNames = partNames; + } + + /** + * Performs a deep copy on other. + */ + public truncate_table_args(truncate_table_args other) { + if (other.isSetDbName()) { + this.dbName = other.dbName; + } + if (other.isSetTableName()) { + this.tableName = other.tableName; + } + if (other.isSetPartNames()) { + List __this__partNames = new ArrayList(other.partNames); + this.partNames = __this__partNames; + } + } + + public truncate_table_args deepCopy() { + return new truncate_table_args(this); + } + + @Override + public void clear() { + this.dbName = null; + this.tableName = null; + this.partNames = null; + } + + public String getDbName() { + return this.dbName; + } + + public void setDbName(String dbName) { + this.dbName = dbName; + } + + public void unsetDbName() { + this.dbName = null; + } + + /** Returns true if field dbName is set (has been assigned a value) and false otherwise */ + public boolean isSetDbName() { + return this.dbName != null; + } + + public void setDbNameIsSet(boolean value) { + if (!value) { + this.dbName = null; + } + } + + public String getTableName() { + return this.tableName; + } + + public void setTableName(String tableName) { + this.tableName = tableName; + } + + public void unsetTableName() { + this.tableName = null; + } + + /** Returns true if field tableName is set (has been assigned a value) and false otherwise */ + public boolean isSetTableName() { + return this.tableName != null; + } + + public void setTableNameIsSet(boolean value) { + if (!value) { + this.tableName = null; + } + } + + public int getPartNamesSize() { + return (this.partNames == null) ? 0 : this.partNames.size(); + } + + public java.util.Iterator getPartNamesIterator() { + return (this.partNames == null) ? null : this.partNames.iterator(); + } + + public void addToPartNames(String elem) { + if (this.partNames == null) { + this.partNames = new ArrayList(); + } + this.partNames.add(elem); + } + + public List getPartNames() { + return this.partNames; + } + + public void setPartNames(List partNames) { + this.partNames = partNames; + } + + public void unsetPartNames() { + this.partNames = null; + } + + /** Returns true if field partNames is set (has been assigned a value) and false otherwise */ + public boolean isSetPartNames() { + return this.partNames != null; + } + + public void setPartNamesIsSet(boolean value) { + if (!value) { + this.partNames = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case DB_NAME: + if (value == null) { + unsetDbName(); + } else { + setDbName((String)value); + } + break; + + case TABLE_NAME: + if (value == null) { + unsetTableName(); + } else { + setTableName((String)value); + } + break; + + case PART_NAMES: + if (value == null) { + unsetPartNames(); + } else { + setPartNames((List)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case DB_NAME: + return getDbName(); + + case TABLE_NAME: + return getTableName(); + + case PART_NAMES: + return getPartNames(); + + } + 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 DB_NAME: + return isSetDbName(); + case TABLE_NAME: + return isSetTableName(); + case PART_NAMES: + return isSetPartNames(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof truncate_table_args) + return this.equals((truncate_table_args)that); + return false; + } + + public boolean equals(truncate_table_args that) { + if (that == null) + return false; + + boolean this_present_dbName = true && this.isSetDbName(); + boolean that_present_dbName = true && that.isSetDbName(); + if (this_present_dbName || that_present_dbName) { + if (!(this_present_dbName && that_present_dbName)) + return false; + if (!this.dbName.equals(that.dbName)) + return false; + } + + boolean this_present_tableName = true && this.isSetTableName(); + boolean that_present_tableName = true && that.isSetTableName(); + if (this_present_tableName || that_present_tableName) { + if (!(this_present_tableName && that_present_tableName)) + return false; + if (!this.tableName.equals(that.tableName)) + return false; + } + + boolean this_present_partNames = true && this.isSetPartNames(); + boolean that_present_partNames = true && that.isSetPartNames(); + if (this_present_partNames || that_present_partNames) { + if (!(this_present_partNames && that_present_partNames)) + return false; + if (!this.partNames.equals(that.partNames)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + boolean present_dbName = true && (isSetDbName()); + list.add(present_dbName); + if (present_dbName) + list.add(dbName); + + boolean present_tableName = true && (isSetTableName()); + list.add(present_tableName); + if (present_tableName) + list.add(tableName); + + boolean present_partNames = true && (isSetPartNames()); + list.add(present_partNames); + if (present_partNames) + list.add(partNames); + + return list.hashCode(); + } + + @Override + public int compareTo(truncate_table_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetDbName()).compareTo(other.isSetDbName()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetDbName()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.dbName, other.dbName); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetTableName()).compareTo(other.isSetTableName()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetTableName()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetPartNames()).compareTo(other.isSetPartNames()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPartNames()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.partNames, other.partNames); + 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("truncate_table_args("); + boolean first = true; + + sb.append("dbName:"); + if (this.dbName == null) { + sb.append("null"); + } else { + sb.append(this.dbName); + } + first = false; + if (!first) sb.append(", "); + sb.append("tableName:"); + if (this.tableName == null) { + sb.append("null"); + } else { + sb.append(this.tableName); + } + first = false; + if (!first) sb.append(", "); + sb.append("partNames:"); + if (this.partNames == null) { + sb.append("null"); + } else { + sb.append(this.partNames); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class truncate_table_argsStandardSchemeFactory implements SchemeFactory { + public truncate_table_argsStandardScheme getScheme() { + return new truncate_table_argsStandardScheme(); + } + } + + private static class truncate_table_argsStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, truncate_table_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: // DB_NAME + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.dbName = iprot.readString(); + struct.setDbNameIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // TABLE_NAME + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.tableName = iprot.readString(); + struct.setTableNameIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 3: // PART_NAMES + if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { + { + org.apache.thrift.protocol.TList _list748 = iprot.readListBegin(); + struct.partNames = new ArrayList(_list748.size); + String _elem749; + for (int _i750 = 0; _i750 < _list748.size; ++_i750) + { + _elem749 = iprot.readString(); + struct.partNames.add(_elem749); + } + iprot.readListEnd(); + } + struct.setPartNamesIsSet(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, truncate_table_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.dbName != null) { + oprot.writeFieldBegin(DB_NAME_FIELD_DESC); + oprot.writeString(struct.dbName); + oprot.writeFieldEnd(); + } + if (struct.tableName != null) { + oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC); + oprot.writeString(struct.tableName); + oprot.writeFieldEnd(); + } + if (struct.partNames != null) { + oprot.writeFieldBegin(PART_NAMES_FIELD_DESC); + { + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.partNames.size())); + for (String _iter751 : struct.partNames) + { + oprot.writeString(_iter751); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class truncate_table_argsTupleSchemeFactory implements SchemeFactory { + public truncate_table_argsTupleScheme getScheme() { + return new truncate_table_argsTupleScheme(); + } + } + + private static class truncate_table_argsTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, truncate_table_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetDbName()) { + optionals.set(0); + } + if (struct.isSetTableName()) { + optionals.set(1); + } + if (struct.isSetPartNames()) { + optionals.set(2); + } + oprot.writeBitSet(optionals, 3); + if (struct.isSetDbName()) { + oprot.writeString(struct.dbName); + } + if (struct.isSetTableName()) { + oprot.writeString(struct.tableName); + } + if (struct.isSetPartNames()) { + { + oprot.writeI32(struct.partNames.size()); + for (String _iter752 : struct.partNames) + { + oprot.writeString(_iter752); + } + } + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, truncate_table_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(3); + if (incoming.get(0)) { + struct.dbName = iprot.readString(); + struct.setDbNameIsSet(true); + } + if (incoming.get(1)) { + struct.tableName = iprot.readString(); + struct.setTableNameIsSet(true); + } + if (incoming.get(2)) { + { + org.apache.thrift.protocol.TList _list753 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.partNames = new ArrayList(_list753.size); + String _elem754; + for (int _i755 = 0; _i755 < _list753.size; ++_i755) + { + _elem754 = iprot.readString(); + struct.partNames.add(_elem754); + } + } + struct.setPartNamesIsSet(true); + } + } + } + + } + + public static class truncate_table_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("truncate_table_result"); + + private static final org.apache.thrift.protocol.TField O1_FIELD_DESC = new org.apache.thrift.protocol.TField("o1", org.apache.thrift.protocol.TType.STRUCT, (short)1); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new truncate_table_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new truncate_table_resultTupleSchemeFactory()); + } + + 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 { + 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 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.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(truncate_table_result.class, metaDataMap); + } + + public truncate_table_result() { + } + + public truncate_table_result( + MetaException o1) + { + this(); + this.o1 = o1; + } + + /** + * Performs a deep copy on other. + */ + public truncate_table_result(truncate_table_result other) { + if (other.isSetO1()) { + this.o1 = new MetaException(other.o1); + } + } + + public truncate_table_result deepCopy() { + return new truncate_table_result(this); + } + + @Override + public void clear() { + this.o1 = 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 O1: + if (value == null) { + unsetO1(); + } else { + setO1((MetaException)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + 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 O1: + return isSetO1(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof truncate_table_result) + return this.equals((truncate_table_result)that); + return false; + } + + public boolean equals(truncate_table_result that) { + if (that == null) + return false; + + boolean this_present_o1 = true && this.isSetO1(); + boolean that_present_o1 = true && that.isSetO1(); + if (this_present_o1 || that_present_o1) { + if (!(this_present_o1 && that_present_o1)) + return false; + if (!this.o1.equals(that.o1)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + boolean present_o1 = true && (isSetO1()); + list.add(present_o1); + if (present_o1) + list.add(o1); + + return list.hashCode(); + } + + @Override + public int compareTo(truncate_table_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetO1()).compareTo(other.isSetO1()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetO1()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.o1, other.o1); + if (lastComparison != 0) { + return lastComparison; + } + } + 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("truncate_table_result("); boolean first = true; sb.append("o1:"); @@ -48059,14 +49216,6 @@ public String toString() { sb.append(this.o1); } first = false; - if (!first) sb.append(", "); - sb.append("o3:"); - if (this.o3 == null) { - sb.append("null"); - } else { - sb.append(this.o3); - } - first = false; sb.append(")"); return sb.toString(); } @@ -48092,15 +49241,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class drop_table_with_environment_context_resultStandardSchemeFactory implements SchemeFactory { - public drop_table_with_environment_context_resultStandardScheme getScheme() { - return new drop_table_with_environment_context_resultStandardScheme(); + private static class truncate_table_resultStandardSchemeFactory implements SchemeFactory { + public truncate_table_resultStandardScheme getScheme() { + return new truncate_table_resultStandardScheme(); } } - private static class drop_table_with_environment_context_resultStandardScheme extends StandardScheme { + private static class truncate_table_resultStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, drop_table_with_environment_context_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, truncate_table_result struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -48112,22 +49261,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, drop_table_with_env switch (schemeField.id) { case 1: // O1 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.o1 = new NoSuchObjectException(); + struct.o1 = new MetaException(); struct.o1.read(iprot); struct.setO1IsSet(true); } else { org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } break; - case 2: // O3 - if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.o3 = new MetaException(); - struct.o3.read(iprot); - struct.setO3IsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; default: org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } @@ -48137,7 +49277,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, drop_table_with_env struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, drop_table_with_environment_context_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, truncate_table_result struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -48146,58 +49286,42 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, drop_table_with_en struct.o1.write(oprot); oprot.writeFieldEnd(); } - if (struct.o3 != null) { - oprot.writeFieldBegin(O3_FIELD_DESC); - struct.o3.write(oprot); - oprot.writeFieldEnd(); - } oprot.writeFieldStop(); oprot.writeStructEnd(); } } - private static class drop_table_with_environment_context_resultTupleSchemeFactory implements SchemeFactory { - public drop_table_with_environment_context_resultTupleScheme getScheme() { - return new drop_table_with_environment_context_resultTupleScheme(); + private static class truncate_table_resultTupleSchemeFactory implements SchemeFactory { + public truncate_table_resultTupleScheme getScheme() { + return new truncate_table_resultTupleScheme(); } } - private static class drop_table_with_environment_context_resultTupleScheme extends TupleScheme { + private static class truncate_table_resultTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, drop_table_with_environment_context_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, truncate_table_result struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetO1()) { optionals.set(0); } - if (struct.isSetO3()) { - optionals.set(1); - } - oprot.writeBitSet(optionals, 2); + oprot.writeBitSet(optionals, 1); if (struct.isSetO1()) { struct.o1.write(oprot); } - if (struct.isSetO3()) { - struct.o3.write(oprot); - } } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, drop_table_with_environment_context_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, truncate_table_result struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(2); + BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { - struct.o1 = new NoSuchObjectException(); + struct.o1 = new MetaException(); struct.o1.read(iprot); struct.setO1IsSet(true); } - if (incoming.get(1)) { - struct.o3 = new MetaException(); - struct.o3.read(iprot); - struct.setO3IsSet(true); - } } } @@ -49058,13 +50182,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_tables_result s case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list748 = iprot.readListBegin(); - struct.success = new ArrayList(_list748.size); - String _elem749; - for (int _i750 = 0; _i750 < _list748.size; ++_i750) + org.apache.thrift.protocol.TList _list756 = iprot.readListBegin(); + struct.success = new ArrayList(_list756.size); + String _elem757; + for (int _i758 = 0; _i758 < _list756.size; ++_i758) { - _elem749 = iprot.readString(); - struct.success.add(_elem749); + _elem757 = iprot.readString(); + struct.success.add(_elem757); } iprot.readListEnd(); } @@ -49099,9 +50223,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_tables_result oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter751 : struct.success) + for (String _iter759 : struct.success) { - oprot.writeString(_iter751); + oprot.writeString(_iter759); } oprot.writeListEnd(); } @@ -49140,9 +50264,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_tables_result s if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter752 : struct.success) + for (String _iter760 : struct.success) { - oprot.writeString(_iter752); + oprot.writeString(_iter760); } } } @@ -49157,13 +50281,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_tables_result st BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list753 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list753.size); - String _elem754; - for (int _i755 = 0; _i755 < _list753.size; ++_i755) + org.apache.thrift.protocol.TList _list761 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list761.size); + String _elem762; + for (int _i763 = 0; _i763 < _list761.size; ++_i763) { - _elem754 = iprot.readString(); - struct.success.add(_elem754); + _elem762 = iprot.readString(); + struct.success.add(_elem762); } } struct.setSuccessIsSet(true); @@ -50137,13 +51261,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_tables_by_type_ case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list756 = iprot.readListBegin(); - struct.success = new ArrayList(_list756.size); - String _elem757; - for (int _i758 = 0; _i758 < _list756.size; ++_i758) + org.apache.thrift.protocol.TList _list764 = iprot.readListBegin(); + struct.success = new ArrayList(_list764.size); + String _elem765; + for (int _i766 = 0; _i766 < _list764.size; ++_i766) { - _elem757 = iprot.readString(); - struct.success.add(_elem757); + _elem765 = iprot.readString(); + struct.success.add(_elem765); } iprot.readListEnd(); } @@ -50178,9 +51302,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_tables_by_type oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter759 : struct.success) + for (String _iter767 : struct.success) { - oprot.writeString(_iter759); + oprot.writeString(_iter767); } oprot.writeListEnd(); } @@ -50219,9 +51343,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_tables_by_type_ if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter760 : struct.success) + for (String _iter768 : struct.success) { - oprot.writeString(_iter760); + oprot.writeString(_iter768); } } } @@ -50236,13 +51360,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_tables_by_type_r BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list761 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list761.size); - String _elem762; - for (int _i763 = 0; _i763 < _list761.size; ++_i763) + org.apache.thrift.protocol.TList _list769 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list769.size); + String _elem770; + for (int _i771 = 0; _i771 < _list769.size; ++_i771) { - _elem762 = iprot.readString(); - struct.success.add(_elem762); + _elem770 = iprot.readString(); + struct.success.add(_elem770); } } struct.setSuccessIsSet(true); @@ -50747,13 +51871,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_table_meta_args case 3: // TBL_TYPES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list764 = iprot.readListBegin(); - struct.tbl_types = new ArrayList(_list764.size); - String _elem765; - for (int _i766 = 0; _i766 < _list764.size; ++_i766) + org.apache.thrift.protocol.TList _list772 = iprot.readListBegin(); + struct.tbl_types = new ArrayList(_list772.size); + String _elem773; + for (int _i774 = 0; _i774 < _list772.size; ++_i774) { - _elem765 = iprot.readString(); - struct.tbl_types.add(_elem765); + _elem773 = iprot.readString(); + struct.tbl_types.add(_elem773); } iprot.readListEnd(); } @@ -50789,9 +51913,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_table_meta_arg oprot.writeFieldBegin(TBL_TYPES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.tbl_types.size())); - for (String _iter767 : struct.tbl_types) + for (String _iter775 : struct.tbl_types) { - oprot.writeString(_iter767); + oprot.writeString(_iter775); } oprot.writeListEnd(); } @@ -50834,9 +51958,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_table_meta_args if (struct.isSetTbl_types()) { { oprot.writeI32(struct.tbl_types.size()); - for (String _iter768 : struct.tbl_types) + for (String _iter776 : struct.tbl_types) { - oprot.writeString(_iter768); + oprot.writeString(_iter776); } } } @@ -50856,13 +51980,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_table_meta_args } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list769 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.tbl_types = new ArrayList(_list769.size); - String _elem770; - for (int _i771 = 0; _i771 < _list769.size; ++_i771) + org.apache.thrift.protocol.TList _list777 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.tbl_types = new ArrayList(_list777.size); + String _elem778; + for (int _i779 = 0; _i779 < _list777.size; ++_i779) { - _elem770 = iprot.readString(); - struct.tbl_types.add(_elem770); + _elem778 = iprot.readString(); + struct.tbl_types.add(_elem778); } } struct.setTbl_typesIsSet(true); @@ -51268,14 +52392,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_table_meta_resu case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list772 = iprot.readListBegin(); - struct.success = new ArrayList(_list772.size); - TableMeta _elem773; - for (int _i774 = 0; _i774 < _list772.size; ++_i774) + org.apache.thrift.protocol.TList _list780 = iprot.readListBegin(); + struct.success = new ArrayList(_list780.size); + TableMeta _elem781; + for (int _i782 = 0; _i782 < _list780.size; ++_i782) { - _elem773 = new TableMeta(); - _elem773.read(iprot); - struct.success.add(_elem773); + _elem781 = new TableMeta(); + _elem781.read(iprot); + struct.success.add(_elem781); } iprot.readListEnd(); } @@ -51310,9 +52434,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_table_meta_res oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (TableMeta _iter775 : struct.success) + for (TableMeta _iter783 : struct.success) { - _iter775.write(oprot); + _iter783.write(oprot); } oprot.writeListEnd(); } @@ -51351,9 +52475,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_table_meta_resu if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (TableMeta _iter776 : struct.success) + for (TableMeta _iter784 : struct.success) { - _iter776.write(oprot); + _iter784.write(oprot); } } } @@ -51368,14 +52492,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_table_meta_resul BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list777 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list777.size); - TableMeta _elem778; - for (int _i779 = 0; _i779 < _list777.size; ++_i779) + org.apache.thrift.protocol.TList _list785 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list785.size); + TableMeta _elem786; + for (int _i787 = 0; _i787 < _list785.size; ++_i787) { - _elem778 = new TableMeta(); - _elem778.read(iprot); - struct.success.add(_elem778); + _elem786 = new TableMeta(); + _elem786.read(iprot); + struct.success.add(_elem786); } } struct.setSuccessIsSet(true); @@ -52141,13 +53265,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_all_tables_resu case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list780 = iprot.readListBegin(); - struct.success = new ArrayList(_list780.size); - String _elem781; - for (int _i782 = 0; _i782 < _list780.size; ++_i782) + org.apache.thrift.protocol.TList _list788 = iprot.readListBegin(); + struct.success = new ArrayList(_list788.size); + String _elem789; + for (int _i790 = 0; _i790 < _list788.size; ++_i790) { - _elem781 = iprot.readString(); - struct.success.add(_elem781); + _elem789 = iprot.readString(); + struct.success.add(_elem789); } iprot.readListEnd(); } @@ -52182,9 +53306,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_all_tables_res oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter783 : struct.success) + for (String _iter791 : struct.success) { - oprot.writeString(_iter783); + oprot.writeString(_iter791); } oprot.writeListEnd(); } @@ -52223,9 +53347,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_all_tables_resu if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter784 : struct.success) + for (String _iter792 : struct.success) { - oprot.writeString(_iter784); + oprot.writeString(_iter792); } } } @@ -52240,13 +53364,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_all_tables_resul BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list785 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list785.size); - String _elem786; - for (int _i787 = 0; _i787 < _list785.size; ++_i787) + org.apache.thrift.protocol.TList _list793 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list793.size); + String _elem794; + for (int _i795 = 0; _i795 < _list793.size; ++_i795) { - _elem786 = iprot.readString(); - struct.success.add(_elem786); + _elem794 = iprot.readString(); + struct.success.add(_elem794); } } struct.setSuccessIsSet(true); @@ -53699,13 +54823,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_table_objects_b case 2: // TBL_NAMES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list788 = iprot.readListBegin(); - struct.tbl_names = new ArrayList(_list788.size); - String _elem789; - for (int _i790 = 0; _i790 < _list788.size; ++_i790) + org.apache.thrift.protocol.TList _list796 = iprot.readListBegin(); + struct.tbl_names = new ArrayList(_list796.size); + String _elem797; + for (int _i798 = 0; _i798 < _list796.size; ++_i798) { - _elem789 = iprot.readString(); - struct.tbl_names.add(_elem789); + _elem797 = iprot.readString(); + struct.tbl_names.add(_elem797); } iprot.readListEnd(); } @@ -53736,9 +54860,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_table_objects_ oprot.writeFieldBegin(TBL_NAMES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.tbl_names.size())); - for (String _iter791 : struct.tbl_names) + for (String _iter799 : struct.tbl_names) { - oprot.writeString(_iter791); + oprot.writeString(_iter799); } oprot.writeListEnd(); } @@ -53775,9 +54899,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_table_objects_b if (struct.isSetTbl_names()) { { oprot.writeI32(struct.tbl_names.size()); - for (String _iter792 : struct.tbl_names) + for (String _iter800 : struct.tbl_names) { - oprot.writeString(_iter792); + oprot.writeString(_iter800); } } } @@ -53793,13 +54917,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_table_objects_by } if (incoming.get(1)) { { - org.apache.thrift.protocol.TList _list793 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.tbl_names = new ArrayList(_list793.size); - String _elem794; - for (int _i795 = 0; _i795 < _list793.size; ++_i795) + org.apache.thrift.protocol.TList _list801 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.tbl_names = new ArrayList(_list801.size); + String _elem802; + for (int _i803 = 0; _i803 < _list801.size; ++_i803) { - _elem794 = iprot.readString(); - struct.tbl_names.add(_elem794); + _elem802 = iprot.readString(); + struct.tbl_names.add(_elem802); } } struct.setTbl_namesIsSet(true); @@ -54124,14 +55248,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_table_objects_b case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list796 = iprot.readListBegin(); - struct.success = new ArrayList
(_list796.size); - Table _elem797; - for (int _i798 = 0; _i798 < _list796.size; ++_i798) + org.apache.thrift.protocol.TList _list804 = iprot.readListBegin(); + struct.success = new ArrayList
(_list804.size); + Table _elem805; + for (int _i806 = 0; _i806 < _list804.size; ++_i806) { - _elem797 = new Table(); - _elem797.read(iprot); - struct.success.add(_elem797); + _elem805 = new Table(); + _elem805.read(iprot); + struct.success.add(_elem805); } iprot.readListEnd(); } @@ -54157,9 +55281,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_table_objects_ oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (Table _iter799 : struct.success) + for (Table _iter807 : struct.success) { - _iter799.write(oprot); + _iter807.write(oprot); } oprot.writeListEnd(); } @@ -54190,9 +55314,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_table_objects_b if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Table _iter800 : struct.success) + for (Table _iter808 : struct.success) { - _iter800.write(oprot); + _iter808.write(oprot); } } } @@ -54204,14 +55328,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_table_objects_by BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list801 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList
(_list801.size); - Table _elem802; - for (int _i803 = 0; _i803 < _list801.size; ++_i803) + org.apache.thrift.protocol.TList _list809 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList
(_list809.size); + Table _elem810; + for (int _i811 = 0; _i811 < _list809.size; ++_i811) { - _elem802 = new Table(); - _elem802.read(iprot); - struct.success.add(_elem802); + _elem810 = new Table(); + _elem810.read(iprot); + struct.success.add(_elem810); } } struct.setSuccessIsSet(true); @@ -57324,13 +58448,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_table_names_by_ case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list804 = iprot.readListBegin(); - struct.success = new ArrayList(_list804.size); - String _elem805; - for (int _i806 = 0; _i806 < _list804.size; ++_i806) + org.apache.thrift.protocol.TList _list812 = iprot.readListBegin(); + struct.success = new ArrayList(_list812.size); + String _elem813; + for (int _i814 = 0; _i814 < _list812.size; ++_i814) { - _elem805 = iprot.readString(); - struct.success.add(_elem805); + _elem813 = iprot.readString(); + struct.success.add(_elem813); } iprot.readListEnd(); } @@ -57383,9 +58507,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_table_names_by oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter807 : struct.success) + for (String _iter815 : struct.success) { - oprot.writeString(_iter807); + oprot.writeString(_iter815); } oprot.writeListEnd(); } @@ -57440,9 +58564,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_table_names_by_ if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter808 : struct.success) + for (String _iter816 : struct.success) { - oprot.writeString(_iter808); + oprot.writeString(_iter816); } } } @@ -57463,13 +58587,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_table_names_by_f BitSet incoming = iprot.readBitSet(4); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list809 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list809.size); - String _elem810; - for (int _i811 = 0; _i811 < _list809.size; ++_i811) + org.apache.thrift.protocol.TList _list817 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list817.size); + String _elem818; + for (int _i819 = 0; _i819 < _list817.size; ++_i819) { - _elem810 = iprot.readString(); - struct.success.add(_elem810); + _elem818 = iprot.readString(); + struct.success.add(_elem818); } } struct.setSuccessIsSet(true); @@ -63328,14 +64452,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, add_partitions_args case 1: // NEW_PARTS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list812 = iprot.readListBegin(); - struct.new_parts = new ArrayList(_list812.size); - Partition _elem813; - for (int _i814 = 0; _i814 < _list812.size; ++_i814) + org.apache.thrift.protocol.TList _list820 = iprot.readListBegin(); + struct.new_parts = new ArrayList(_list820.size); + Partition _elem821; + for (int _i822 = 0; _i822 < _list820.size; ++_i822) { - _elem813 = new Partition(); - _elem813.read(iprot); - struct.new_parts.add(_elem813); + _elem821 = new Partition(); + _elem821.read(iprot); + struct.new_parts.add(_elem821); } iprot.readListEnd(); } @@ -63361,9 +64485,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, add_partitions_arg oprot.writeFieldBegin(NEW_PARTS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.new_parts.size())); - for (Partition _iter815 : struct.new_parts) + for (Partition _iter823 : struct.new_parts) { - _iter815.write(oprot); + _iter823.write(oprot); } oprot.writeListEnd(); } @@ -63394,9 +64518,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, add_partitions_args if (struct.isSetNew_parts()) { { oprot.writeI32(struct.new_parts.size()); - for (Partition _iter816 : struct.new_parts) + for (Partition _iter824 : struct.new_parts) { - _iter816.write(oprot); + _iter824.write(oprot); } } } @@ -63408,14 +64532,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, add_partitions_args BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list817 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.new_parts = new ArrayList(_list817.size); - Partition _elem818; - for (int _i819 = 0; _i819 < _list817.size; ++_i819) + org.apache.thrift.protocol.TList _list825 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.new_parts = new ArrayList(_list825.size); + Partition _elem826; + for (int _i827 = 0; _i827 < _list825.size; ++_i827) { - _elem818 = new Partition(); - _elem818.read(iprot); - struct.new_parts.add(_elem818); + _elem826 = new Partition(); + _elem826.read(iprot); + struct.new_parts.add(_elem826); } } struct.setNew_partsIsSet(true); @@ -64416,14 +65540,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, add_partitions_pspe case 1: // NEW_PARTS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list820 = iprot.readListBegin(); - struct.new_parts = new ArrayList(_list820.size); - PartitionSpec _elem821; - for (int _i822 = 0; _i822 < _list820.size; ++_i822) + org.apache.thrift.protocol.TList _list828 = iprot.readListBegin(); + struct.new_parts = new ArrayList(_list828.size); + PartitionSpec _elem829; + for (int _i830 = 0; _i830 < _list828.size; ++_i830) { - _elem821 = new PartitionSpec(); - _elem821.read(iprot); - struct.new_parts.add(_elem821); + _elem829 = new PartitionSpec(); + _elem829.read(iprot); + struct.new_parts.add(_elem829); } iprot.readListEnd(); } @@ -64449,9 +65573,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, add_partitions_psp oprot.writeFieldBegin(NEW_PARTS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.new_parts.size())); - for (PartitionSpec _iter823 : struct.new_parts) + for (PartitionSpec _iter831 : struct.new_parts) { - _iter823.write(oprot); + _iter831.write(oprot); } oprot.writeListEnd(); } @@ -64482,9 +65606,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, add_partitions_pspe if (struct.isSetNew_parts()) { { oprot.writeI32(struct.new_parts.size()); - for (PartitionSpec _iter824 : struct.new_parts) + for (PartitionSpec _iter832 : struct.new_parts) { - _iter824.write(oprot); + _iter832.write(oprot); } } } @@ -64496,14 +65620,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, add_partitions_pspec BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list825 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.new_parts = new ArrayList(_list825.size); - PartitionSpec _elem826; - for (int _i827 = 0; _i827 < _list825.size; ++_i827) + org.apache.thrift.protocol.TList _list833 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.new_parts = new ArrayList(_list833.size); + PartitionSpec _elem834; + for (int _i835 = 0; _i835 < _list833.size; ++_i835) { - _elem826 = new PartitionSpec(); - _elem826.read(iprot); - struct.new_parts.add(_elem826); + _elem834 = new PartitionSpec(); + _elem834.read(iprot); + struct.new_parts.add(_elem834); } } struct.setNew_partsIsSet(true); @@ -65679,13 +66803,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, append_partition_ar case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list828 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list828.size); - String _elem829; - for (int _i830 = 0; _i830 < _list828.size; ++_i830) + org.apache.thrift.protocol.TList _list836 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list836.size); + String _elem837; + for (int _i838 = 0; _i838 < _list836.size; ++_i838) { - _elem829 = iprot.readString(); - struct.part_vals.add(_elem829); + _elem837 = iprot.readString(); + struct.part_vals.add(_elem837); } iprot.readListEnd(); } @@ -65721,9 +66845,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, append_partition_a oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (String _iter831 : struct.part_vals) + for (String _iter839 : struct.part_vals) { - oprot.writeString(_iter831); + oprot.writeString(_iter839); } oprot.writeListEnd(); } @@ -65766,9 +66890,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, append_partition_ar if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (String _iter832 : struct.part_vals) + for (String _iter840 : struct.part_vals) { - oprot.writeString(_iter832); + oprot.writeString(_iter840); } } } @@ -65788,13 +66912,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, append_partition_arg } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list833 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list833.size); - String _elem834; - for (int _i835 = 0; _i835 < _list833.size; ++_i835) + org.apache.thrift.protocol.TList _list841 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list841.size); + String _elem842; + for (int _i843 = 0; _i843 < _list841.size; ++_i843) { - _elem834 = iprot.readString(); - struct.part_vals.add(_elem834); + _elem842 = iprot.readString(); + struct.part_vals.add(_elem842); } } struct.setPart_valsIsSet(true); @@ -68103,13 +69227,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, append_partition_wi case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list836 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list836.size); - String _elem837; - for (int _i838 = 0; _i838 < _list836.size; ++_i838) + org.apache.thrift.protocol.TList _list844 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list844.size); + String _elem845; + for (int _i846 = 0; _i846 < _list844.size; ++_i846) { - _elem837 = iprot.readString(); - struct.part_vals.add(_elem837); + _elem845 = iprot.readString(); + struct.part_vals.add(_elem845); } iprot.readListEnd(); } @@ -68154,9 +69278,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, append_partition_w oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (String _iter839 : struct.part_vals) + for (String _iter847 : struct.part_vals) { - oprot.writeString(_iter839); + oprot.writeString(_iter847); } oprot.writeListEnd(); } @@ -68207,9 +69331,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, append_partition_wi if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (String _iter840 : struct.part_vals) + for (String _iter848 : struct.part_vals) { - oprot.writeString(_iter840); + oprot.writeString(_iter848); } } } @@ -68232,13 +69356,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, append_partition_wit } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list841 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list841.size); - String _elem842; - for (int _i843 = 0; _i843 < _list841.size; ++_i843) + org.apache.thrift.protocol.TList _list849 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list849.size); + String _elem850; + for (int _i851 = 0; _i851 < _list849.size; ++_i851) { - _elem842 = iprot.readString(); - struct.part_vals.add(_elem842); + _elem850 = iprot.readString(); + struct.part_vals.add(_elem850); } } struct.setPart_valsIsSet(true); @@ -72108,13 +73232,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, drop_partition_args case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list844 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list844.size); - String _elem845; - for (int _i846 = 0; _i846 < _list844.size; ++_i846) + org.apache.thrift.protocol.TList _list852 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list852.size); + String _elem853; + for (int _i854 = 0; _i854 < _list852.size; ++_i854) { - _elem845 = iprot.readString(); - struct.part_vals.add(_elem845); + _elem853 = iprot.readString(); + struct.part_vals.add(_elem853); } iprot.readListEnd(); } @@ -72158,9 +73282,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, drop_partition_arg oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (String _iter847 : struct.part_vals) + for (String _iter855 : struct.part_vals) { - oprot.writeString(_iter847); + oprot.writeString(_iter855); } oprot.writeListEnd(); } @@ -72209,9 +73333,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, drop_partition_args if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (String _iter848 : struct.part_vals) + for (String _iter856 : struct.part_vals) { - oprot.writeString(_iter848); + oprot.writeString(_iter856); } } } @@ -72234,13 +73358,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, drop_partition_args } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list849 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list849.size); - String _elem850; - for (int _i851 = 0; _i851 < _list849.size; ++_i851) + org.apache.thrift.protocol.TList _list857 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list857.size); + String _elem858; + for (int _i859 = 0; _i859 < _list857.size; ++_i859) { - _elem850 = iprot.readString(); - struct.part_vals.add(_elem850); + _elem858 = iprot.readString(); + struct.part_vals.add(_elem858); } } struct.setPart_valsIsSet(true); @@ -73479,13 +74603,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, drop_partition_with case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list852 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list852.size); - String _elem853; - for (int _i854 = 0; _i854 < _list852.size; ++_i854) + org.apache.thrift.protocol.TList _list860 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list860.size); + String _elem861; + for (int _i862 = 0; _i862 < _list860.size; ++_i862) { - _elem853 = iprot.readString(); - struct.part_vals.add(_elem853); + _elem861 = iprot.readString(); + struct.part_vals.add(_elem861); } iprot.readListEnd(); } @@ -73538,9 +74662,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, drop_partition_wit oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (String _iter855 : struct.part_vals) + for (String _iter863 : struct.part_vals) { - oprot.writeString(_iter855); + oprot.writeString(_iter863); } oprot.writeListEnd(); } @@ -73597,9 +74721,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, drop_partition_with if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (String _iter856 : struct.part_vals) + for (String _iter864 : struct.part_vals) { - oprot.writeString(_iter856); + oprot.writeString(_iter864); } } } @@ -73625,13 +74749,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, drop_partition_with_ } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list857 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list857.size); - String _elem858; - for (int _i859 = 0; _i859 < _list857.size; ++_i859) + org.apache.thrift.protocol.TList _list865 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list865.size); + String _elem866; + for (int _i867 = 0; _i867 < _list865.size; ++_i867) { - _elem858 = iprot.readString(); - struct.part_vals.add(_elem858); + _elem866 = iprot.readString(); + struct.part_vals.add(_elem866); } } struct.setPart_valsIsSet(true); @@ -78233,13 +79357,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partition_args case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list860 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list860.size); - String _elem861; - for (int _i862 = 0; _i862 < _list860.size; ++_i862) + org.apache.thrift.protocol.TList _list868 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list868.size); + String _elem869; + for (int _i870 = 0; _i870 < _list868.size; ++_i870) { - _elem861 = iprot.readString(); - struct.part_vals.add(_elem861); + _elem869 = iprot.readString(); + struct.part_vals.add(_elem869); } iprot.readListEnd(); } @@ -78275,9 +79399,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partition_args oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (String _iter863 : struct.part_vals) + for (String _iter871 : struct.part_vals) { - oprot.writeString(_iter863); + oprot.writeString(_iter871); } oprot.writeListEnd(); } @@ -78320,9 +79444,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partition_args if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (String _iter864 : struct.part_vals) + for (String _iter872 : struct.part_vals) { - oprot.writeString(_iter864); + oprot.writeString(_iter872); } } } @@ -78342,13 +79466,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partition_args s } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list865 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list865.size); - String _elem866; - for (int _i867 = 0; _i867 < _list865.size; ++_i867) + org.apache.thrift.protocol.TList _list873 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list873.size); + String _elem874; + for (int _i875 = 0; _i875 < _list873.size; ++_i875) { - _elem866 = iprot.readString(); - struct.part_vals.add(_elem866); + _elem874 = iprot.readString(); + struct.part_vals.add(_elem874); } } struct.setPart_valsIsSet(true); @@ -79566,15 +80690,15 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, exchange_partition_ case 1: // PARTITION_SPECS if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map868 = iprot.readMapBegin(); - struct.partitionSpecs = new HashMap(2*_map868.size); - String _key869; - String _val870; - for (int _i871 = 0; _i871 < _map868.size; ++_i871) + org.apache.thrift.protocol.TMap _map876 = iprot.readMapBegin(); + struct.partitionSpecs = new HashMap(2*_map876.size); + String _key877; + String _val878; + for (int _i879 = 0; _i879 < _map876.size; ++_i879) { - _key869 = iprot.readString(); - _val870 = iprot.readString(); - struct.partitionSpecs.put(_key869, _val870); + _key877 = iprot.readString(); + _val878 = iprot.readString(); + struct.partitionSpecs.put(_key877, _val878); } iprot.readMapEnd(); } @@ -79632,10 +80756,10 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, exchange_partition oprot.writeFieldBegin(PARTITION_SPECS_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.partitionSpecs.size())); - for (Map.Entry _iter872 : struct.partitionSpecs.entrySet()) + for (Map.Entry _iter880 : struct.partitionSpecs.entrySet()) { - oprot.writeString(_iter872.getKey()); - oprot.writeString(_iter872.getValue()); + oprot.writeString(_iter880.getKey()); + oprot.writeString(_iter880.getValue()); } oprot.writeMapEnd(); } @@ -79698,10 +80822,10 @@ public void write(org.apache.thrift.protocol.TProtocol prot, exchange_partition_ if (struct.isSetPartitionSpecs()) { { oprot.writeI32(struct.partitionSpecs.size()); - for (Map.Entry _iter873 : struct.partitionSpecs.entrySet()) + for (Map.Entry _iter881 : struct.partitionSpecs.entrySet()) { - oprot.writeString(_iter873.getKey()); - oprot.writeString(_iter873.getValue()); + oprot.writeString(_iter881.getKey()); + oprot.writeString(_iter881.getValue()); } } } @@ -79725,15 +80849,15 @@ public void read(org.apache.thrift.protocol.TProtocol prot, exchange_partition_a BitSet incoming = iprot.readBitSet(5); if (incoming.get(0)) { { - org.apache.thrift.protocol.TMap _map874 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.partitionSpecs = new HashMap(2*_map874.size); - String _key875; - String _val876; - for (int _i877 = 0; _i877 < _map874.size; ++_i877) + org.apache.thrift.protocol.TMap _map882 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.partitionSpecs = new HashMap(2*_map882.size); + String _key883; + String _val884; + for (int _i885 = 0; _i885 < _map882.size; ++_i885) { - _key875 = iprot.readString(); - _val876 = iprot.readString(); - struct.partitionSpecs.put(_key875, _val876); + _key883 = iprot.readString(); + _val884 = iprot.readString(); + struct.partitionSpecs.put(_key883, _val884); } } struct.setPartitionSpecsIsSet(true); @@ -81179,15 +82303,15 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, exchange_partitions case 1: // PARTITION_SPECS if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map878 = iprot.readMapBegin(); - struct.partitionSpecs = new HashMap(2*_map878.size); - String _key879; - String _val880; - for (int _i881 = 0; _i881 < _map878.size; ++_i881) + org.apache.thrift.protocol.TMap _map886 = iprot.readMapBegin(); + struct.partitionSpecs = new HashMap(2*_map886.size); + String _key887; + String _val888; + for (int _i889 = 0; _i889 < _map886.size; ++_i889) { - _key879 = iprot.readString(); - _val880 = iprot.readString(); - struct.partitionSpecs.put(_key879, _val880); + _key887 = iprot.readString(); + _val888 = iprot.readString(); + struct.partitionSpecs.put(_key887, _val888); } iprot.readMapEnd(); } @@ -81245,10 +82369,10 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, exchange_partition oprot.writeFieldBegin(PARTITION_SPECS_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.partitionSpecs.size())); - for (Map.Entry _iter882 : struct.partitionSpecs.entrySet()) + for (Map.Entry _iter890 : struct.partitionSpecs.entrySet()) { - oprot.writeString(_iter882.getKey()); - oprot.writeString(_iter882.getValue()); + oprot.writeString(_iter890.getKey()); + oprot.writeString(_iter890.getValue()); } oprot.writeMapEnd(); } @@ -81311,10 +82435,10 @@ public void write(org.apache.thrift.protocol.TProtocol prot, exchange_partitions if (struct.isSetPartitionSpecs()) { { oprot.writeI32(struct.partitionSpecs.size()); - for (Map.Entry _iter883 : struct.partitionSpecs.entrySet()) + for (Map.Entry _iter891 : struct.partitionSpecs.entrySet()) { - oprot.writeString(_iter883.getKey()); - oprot.writeString(_iter883.getValue()); + oprot.writeString(_iter891.getKey()); + oprot.writeString(_iter891.getValue()); } } } @@ -81338,15 +82462,15 @@ public void read(org.apache.thrift.protocol.TProtocol prot, exchange_partitions_ BitSet incoming = iprot.readBitSet(5); if (incoming.get(0)) { { - org.apache.thrift.protocol.TMap _map884 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.partitionSpecs = new HashMap(2*_map884.size); - String _key885; - String _val886; - for (int _i887 = 0; _i887 < _map884.size; ++_i887) + org.apache.thrift.protocol.TMap _map892 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.partitionSpecs = new HashMap(2*_map892.size); + String _key893; + String _val894; + for (int _i895 = 0; _i895 < _map892.size; ++_i895) { - _key885 = iprot.readString(); - _val886 = iprot.readString(); - struct.partitionSpecs.put(_key885, _val886); + _key893 = iprot.readString(); + _val894 = iprot.readString(); + struct.partitionSpecs.put(_key893, _val894); } } struct.setPartitionSpecsIsSet(true); @@ -82011,14 +83135,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, exchange_partitions case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list888 = iprot.readListBegin(); - struct.success = new ArrayList(_list888.size); - Partition _elem889; - for (int _i890 = 0; _i890 < _list888.size; ++_i890) + org.apache.thrift.protocol.TList _list896 = iprot.readListBegin(); + struct.success = new ArrayList(_list896.size); + Partition _elem897; + for (int _i898 = 0; _i898 < _list896.size; ++_i898) { - _elem889 = new Partition(); - _elem889.read(iprot); - struct.success.add(_elem889); + _elem897 = new Partition(); + _elem897.read(iprot); + struct.success.add(_elem897); } iprot.readListEnd(); } @@ -82080,9 +83204,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, exchange_partition oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (Partition _iter891 : struct.success) + for (Partition _iter899 : struct.success) { - _iter891.write(oprot); + _iter899.write(oprot); } oprot.writeListEnd(); } @@ -82145,9 +83269,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, exchange_partitions if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Partition _iter892 : struct.success) + for (Partition _iter900 : struct.success) { - _iter892.write(oprot); + _iter900.write(oprot); } } } @@ -82171,14 +83295,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, exchange_partitions_ BitSet incoming = iprot.readBitSet(5); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list893 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list893.size); - Partition _elem894; - for (int _i895 = 0; _i895 < _list893.size; ++_i895) + org.apache.thrift.protocol.TList _list901 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list901.size); + Partition _elem902; + for (int _i903 = 0; _i903 < _list901.size; ++_i903) { - _elem894 = new Partition(); - _elem894.read(iprot); - struct.success.add(_elem894); + _elem902 = new Partition(); + _elem902.read(iprot); + struct.success.add(_elem902); } } struct.setSuccessIsSet(true); @@ -82877,13 +84001,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partition_with_ case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list896 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list896.size); - String _elem897; - for (int _i898 = 0; _i898 < _list896.size; ++_i898) + org.apache.thrift.protocol.TList _list904 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list904.size); + String _elem905; + for (int _i906 = 0; _i906 < _list904.size; ++_i906) { - _elem897 = iprot.readString(); - struct.part_vals.add(_elem897); + _elem905 = iprot.readString(); + struct.part_vals.add(_elem905); } iprot.readListEnd(); } @@ -82903,13 +84027,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partition_with_ case 5: // GROUP_NAMES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list899 = iprot.readListBegin(); - struct.group_names = new ArrayList(_list899.size); - String _elem900; - for (int _i901 = 0; _i901 < _list899.size; ++_i901) + org.apache.thrift.protocol.TList _list907 = iprot.readListBegin(); + struct.group_names = new ArrayList(_list907.size); + String _elem908; + for (int _i909 = 0; _i909 < _list907.size; ++_i909) { - _elem900 = iprot.readString(); - struct.group_names.add(_elem900); + _elem908 = iprot.readString(); + struct.group_names.add(_elem908); } iprot.readListEnd(); } @@ -82945,9 +84069,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partition_with oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (String _iter902 : struct.part_vals) + for (String _iter910 : struct.part_vals) { - oprot.writeString(_iter902); + oprot.writeString(_iter910); } oprot.writeListEnd(); } @@ -82962,9 +84086,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partition_with oprot.writeFieldBegin(GROUP_NAMES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.group_names.size())); - for (String _iter903 : struct.group_names) + for (String _iter911 : struct.group_names) { - oprot.writeString(_iter903); + oprot.writeString(_iter911); } oprot.writeListEnd(); } @@ -83013,9 +84137,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partition_with_ if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (String _iter904 : struct.part_vals) + for (String _iter912 : struct.part_vals) { - oprot.writeString(_iter904); + oprot.writeString(_iter912); } } } @@ -83025,9 +84149,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partition_with_ if (struct.isSetGroup_names()) { { oprot.writeI32(struct.group_names.size()); - for (String _iter905 : struct.group_names) + for (String _iter913 : struct.group_names) { - oprot.writeString(_iter905); + oprot.writeString(_iter913); } } } @@ -83047,13 +84171,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partition_with_a } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list906 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list906.size); - String _elem907; - for (int _i908 = 0; _i908 < _list906.size; ++_i908) + org.apache.thrift.protocol.TList _list914 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list914.size); + String _elem915; + for (int _i916 = 0; _i916 < _list914.size; ++_i916) { - _elem907 = iprot.readString(); - struct.part_vals.add(_elem907); + _elem915 = iprot.readString(); + struct.part_vals.add(_elem915); } } struct.setPart_valsIsSet(true); @@ -83064,13 +84188,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partition_with_a } if (incoming.get(4)) { { - org.apache.thrift.protocol.TList _list909 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.group_names = new ArrayList(_list909.size); - String _elem910; - for (int _i911 = 0; _i911 < _list909.size; ++_i911) + org.apache.thrift.protocol.TList _list917 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.group_names = new ArrayList(_list917.size); + String _elem918; + for (int _i919 = 0; _i919 < _list917.size; ++_i919) { - _elem910 = iprot.readString(); - struct.group_names.add(_elem910); + _elem918 = iprot.readString(); + struct.group_names.add(_elem918); } } struct.setGroup_namesIsSet(true); @@ -85839,14 +86963,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_resu case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list912 = iprot.readListBegin(); - struct.success = new ArrayList(_list912.size); - Partition _elem913; - for (int _i914 = 0; _i914 < _list912.size; ++_i914) + org.apache.thrift.protocol.TList _list920 = iprot.readListBegin(); + struct.success = new ArrayList(_list920.size); + Partition _elem921; + for (int _i922 = 0; _i922 < _list920.size; ++_i922) { - _elem913 = new Partition(); - _elem913.read(iprot); - struct.success.add(_elem913); + _elem921 = new Partition(); + _elem921.read(iprot); + struct.success.add(_elem921); } iprot.readListEnd(); } @@ -85890,9 +87014,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_res oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (Partition _iter915 : struct.success) + for (Partition _iter923 : struct.success) { - _iter915.write(oprot); + _iter923.write(oprot); } oprot.writeListEnd(); } @@ -85939,9 +87063,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_resu if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Partition _iter916 : struct.success) + for (Partition _iter924 : struct.success) { - _iter916.write(oprot); + _iter924.write(oprot); } } } @@ -85959,14 +87083,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_resul BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list917 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list917.size); - Partition _elem918; - for (int _i919 = 0; _i919 < _list917.size; ++_i919) + org.apache.thrift.protocol.TList _list925 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list925.size); + Partition _elem926; + for (int _i927 = 0; _i927 < _list925.size; ++_i927) { - _elem918 = new Partition(); - _elem918.read(iprot); - struct.success.add(_elem918); + _elem926 = new Partition(); + _elem926.read(iprot); + struct.success.add(_elem926); } } struct.setSuccessIsSet(true); @@ -86656,13 +87780,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_with case 5: // GROUP_NAMES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list920 = iprot.readListBegin(); - struct.group_names = new ArrayList(_list920.size); - String _elem921; - for (int _i922 = 0; _i922 < _list920.size; ++_i922) + org.apache.thrift.protocol.TList _list928 = iprot.readListBegin(); + struct.group_names = new ArrayList(_list928.size); + String _elem929; + for (int _i930 = 0; _i930 < _list928.size; ++_i930) { - _elem921 = iprot.readString(); - struct.group_names.add(_elem921); + _elem929 = iprot.readString(); + struct.group_names.add(_elem929); } iprot.readListEnd(); } @@ -86706,9 +87830,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_wit oprot.writeFieldBegin(GROUP_NAMES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.group_names.size())); - for (String _iter923 : struct.group_names) + for (String _iter931 : struct.group_names) { - oprot.writeString(_iter923); + oprot.writeString(_iter931); } oprot.writeListEnd(); } @@ -86763,9 +87887,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_with if (struct.isSetGroup_names()) { { oprot.writeI32(struct.group_names.size()); - for (String _iter924 : struct.group_names) + for (String _iter932 : struct.group_names) { - oprot.writeString(_iter924); + oprot.writeString(_iter932); } } } @@ -86793,13 +87917,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_with_ } if (incoming.get(4)) { { - org.apache.thrift.protocol.TList _list925 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.group_names = new ArrayList(_list925.size); - String _elem926; - for (int _i927 = 0; _i927 < _list925.size; ++_i927) + org.apache.thrift.protocol.TList _list933 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.group_names = new ArrayList(_list933.size); + String _elem934; + for (int _i935 = 0; _i935 < _list933.size; ++_i935) { - _elem926 = iprot.readString(); - struct.group_names.add(_elem926); + _elem934 = iprot.readString(); + struct.group_names.add(_elem934); } } struct.setGroup_namesIsSet(true); @@ -87286,14 +88410,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_with case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list928 = iprot.readListBegin(); - struct.success = new ArrayList(_list928.size); - Partition _elem929; - for (int _i930 = 0; _i930 < _list928.size; ++_i930) + org.apache.thrift.protocol.TList _list936 = iprot.readListBegin(); + struct.success = new ArrayList(_list936.size); + Partition _elem937; + for (int _i938 = 0; _i938 < _list936.size; ++_i938) { - _elem929 = new Partition(); - _elem929.read(iprot); - struct.success.add(_elem929); + _elem937 = new Partition(); + _elem937.read(iprot); + struct.success.add(_elem937); } iprot.readListEnd(); } @@ -87337,9 +88461,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_wit oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (Partition _iter931 : struct.success) + for (Partition _iter939 : struct.success) { - _iter931.write(oprot); + _iter939.write(oprot); } oprot.writeListEnd(); } @@ -87386,9 +88510,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_with if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Partition _iter932 : struct.success) + for (Partition _iter940 : struct.success) { - _iter932.write(oprot); + _iter940.write(oprot); } } } @@ -87406,14 +88530,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_with_ BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list933 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list933.size); - Partition _elem934; - for (int _i935 = 0; _i935 < _list933.size; ++_i935) + org.apache.thrift.protocol.TList _list941 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list941.size); + Partition _elem942; + for (int _i943 = 0; _i943 < _list941.size; ++_i943) { - _elem934 = new Partition(); - _elem934.read(iprot); - struct.success.add(_elem934); + _elem942 = new Partition(); + _elem942.read(iprot); + struct.success.add(_elem942); } } struct.setSuccessIsSet(true); @@ -88476,14 +89600,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_pspe case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list936 = iprot.readListBegin(); - struct.success = new ArrayList(_list936.size); - PartitionSpec _elem937; - for (int _i938 = 0; _i938 < _list936.size; ++_i938) + org.apache.thrift.protocol.TList _list944 = iprot.readListBegin(); + struct.success = new ArrayList(_list944.size); + PartitionSpec _elem945; + for (int _i946 = 0; _i946 < _list944.size; ++_i946) { - _elem937 = new PartitionSpec(); - _elem937.read(iprot); - struct.success.add(_elem937); + _elem945 = new PartitionSpec(); + _elem945.read(iprot); + struct.success.add(_elem945); } iprot.readListEnd(); } @@ -88527,9 +89651,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_psp oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (PartitionSpec _iter939 : struct.success) + for (PartitionSpec _iter947 : struct.success) { - _iter939.write(oprot); + _iter947.write(oprot); } oprot.writeListEnd(); } @@ -88576,9 +89700,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_pspe if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (PartitionSpec _iter940 : struct.success) + for (PartitionSpec _iter948 : struct.success) { - _iter940.write(oprot); + _iter948.write(oprot); } } } @@ -88596,14 +89720,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_pspec BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list941 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list941.size); - PartitionSpec _elem942; - for (int _i943 = 0; _i943 < _list941.size; ++_i943) + org.apache.thrift.protocol.TList _list949 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list949.size); + PartitionSpec _elem950; + for (int _i951 = 0; _i951 < _list949.size; ++_i951) { - _elem942 = new PartitionSpec(); - _elem942.read(iprot); - struct.success.add(_elem942); + _elem950 = new PartitionSpec(); + _elem950.read(iprot); + struct.success.add(_elem950); } } struct.setSuccessIsSet(true); @@ -89582,13 +90706,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partition_names case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list944 = iprot.readListBegin(); - struct.success = new ArrayList(_list944.size); - String _elem945; - for (int _i946 = 0; _i946 < _list944.size; ++_i946) + org.apache.thrift.protocol.TList _list952 = iprot.readListBegin(); + struct.success = new ArrayList(_list952.size); + String _elem953; + for (int _i954 = 0; _i954 < _list952.size; ++_i954) { - _elem945 = iprot.readString(); - struct.success.add(_elem945); + _elem953 = iprot.readString(); + struct.success.add(_elem953); } iprot.readListEnd(); } @@ -89623,9 +90747,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partition_name oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter947 : struct.success) + for (String _iter955 : struct.success) { - oprot.writeString(_iter947); + oprot.writeString(_iter955); } oprot.writeListEnd(); } @@ -89664,9 +90788,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partition_names if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter948 : struct.success) + for (String _iter956 : struct.success) { - oprot.writeString(_iter948); + oprot.writeString(_iter956); } } } @@ -89681,13 +90805,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partition_names_ BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list949 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list949.size); - String _elem950; - for (int _i951 = 0; _i951 < _list949.size; ++_i951) + org.apache.thrift.protocol.TList _list957 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list957.size); + String _elem958; + for (int _i959 = 0; _i959 < _list957.size; ++_i959) { - _elem950 = iprot.readString(); - struct.success.add(_elem950); + _elem958 = iprot.readString(); + struct.success.add(_elem958); } } struct.setSuccessIsSet(true); @@ -90275,13 +91399,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_ps_a case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list952 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list952.size); - String _elem953; - for (int _i954 = 0; _i954 < _list952.size; ++_i954) + org.apache.thrift.protocol.TList _list960 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list960.size); + String _elem961; + for (int _i962 = 0; _i962 < _list960.size; ++_i962) { - _elem953 = iprot.readString(); - struct.part_vals.add(_elem953); + _elem961 = iprot.readString(); + struct.part_vals.add(_elem961); } iprot.readListEnd(); } @@ -90325,9 +91449,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_ps_ oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (String _iter955 : struct.part_vals) + for (String _iter963 : struct.part_vals) { - oprot.writeString(_iter955); + oprot.writeString(_iter963); } oprot.writeListEnd(); } @@ -90376,9 +91500,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_a if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (String _iter956 : struct.part_vals) + for (String _iter964 : struct.part_vals) { - oprot.writeString(_iter956); + oprot.writeString(_iter964); } } } @@ -90401,13 +91525,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_ar } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list957 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list957.size); - String _elem958; - for (int _i959 = 0; _i959 < _list957.size; ++_i959) + org.apache.thrift.protocol.TList _list965 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list965.size); + String _elem966; + for (int _i967 = 0; _i967 < _list965.size; ++_i967) { - _elem958 = iprot.readString(); - struct.part_vals.add(_elem958); + _elem966 = iprot.readString(); + struct.part_vals.add(_elem966); } } struct.setPart_valsIsSet(true); @@ -90898,14 +92022,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_ps_r case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list960 = iprot.readListBegin(); - struct.success = new ArrayList(_list960.size); - Partition _elem961; - for (int _i962 = 0; _i962 < _list960.size; ++_i962) + org.apache.thrift.protocol.TList _list968 = iprot.readListBegin(); + struct.success = new ArrayList(_list968.size); + Partition _elem969; + for (int _i970 = 0; _i970 < _list968.size; ++_i970) { - _elem961 = new Partition(); - _elem961.read(iprot); - struct.success.add(_elem961); + _elem969 = new Partition(); + _elem969.read(iprot); + struct.success.add(_elem969); } iprot.readListEnd(); } @@ -90949,9 +92073,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_ps_ oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (Partition _iter963 : struct.success) + for (Partition _iter971 : struct.success) { - _iter963.write(oprot); + _iter971.write(oprot); } oprot.writeListEnd(); } @@ -90998,9 +92122,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_r if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Partition _iter964 : struct.success) + for (Partition _iter972 : struct.success) { - _iter964.write(oprot); + _iter972.write(oprot); } } } @@ -91018,14 +92142,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_re BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list965 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list965.size); - Partition _elem966; - for (int _i967 = 0; _i967 < _list965.size; ++_i967) + org.apache.thrift.protocol.TList _list973 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list973.size); + Partition _elem974; + for (int _i975 = 0; _i975 < _list973.size; ++_i975) { - _elem966 = new Partition(); - _elem966.read(iprot); - struct.success.add(_elem966); + _elem974 = new Partition(); + _elem974.read(iprot); + struct.success.add(_elem974); } } struct.setSuccessIsSet(true); @@ -91797,13 +92921,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_ps_w case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list968 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list968.size); - String _elem969; - for (int _i970 = 0; _i970 < _list968.size; ++_i970) + org.apache.thrift.protocol.TList _list976 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list976.size); + String _elem977; + for (int _i978 = 0; _i978 < _list976.size; ++_i978) { - _elem969 = iprot.readString(); - struct.part_vals.add(_elem969); + _elem977 = iprot.readString(); + struct.part_vals.add(_elem977); } iprot.readListEnd(); } @@ -91831,13 +92955,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_ps_w case 6: // GROUP_NAMES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list971 = iprot.readListBegin(); - struct.group_names = new ArrayList(_list971.size); - String _elem972; - for (int _i973 = 0; _i973 < _list971.size; ++_i973) + org.apache.thrift.protocol.TList _list979 = iprot.readListBegin(); + struct.group_names = new ArrayList(_list979.size); + String _elem980; + for (int _i981 = 0; _i981 < _list979.size; ++_i981) { - _elem972 = iprot.readString(); - struct.group_names.add(_elem972); + _elem980 = iprot.readString(); + struct.group_names.add(_elem980); } iprot.readListEnd(); } @@ -91873,9 +92997,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_ps_ oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (String _iter974 : struct.part_vals) + for (String _iter982 : struct.part_vals) { - oprot.writeString(_iter974); + oprot.writeString(_iter982); } oprot.writeListEnd(); } @@ -91893,9 +93017,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_ps_ oprot.writeFieldBegin(GROUP_NAMES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.group_names.size())); - for (String _iter975 : struct.group_names) + for (String _iter983 : struct.group_names) { - oprot.writeString(_iter975); + oprot.writeString(_iter983); } oprot.writeListEnd(); } @@ -91947,9 +93071,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_w if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (String _iter976 : struct.part_vals) + for (String _iter984 : struct.part_vals) { - oprot.writeString(_iter976); + oprot.writeString(_iter984); } } } @@ -91962,9 +93086,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_w if (struct.isSetGroup_names()) { { oprot.writeI32(struct.group_names.size()); - for (String _iter977 : struct.group_names) + for (String _iter985 : struct.group_names) { - oprot.writeString(_iter977); + oprot.writeString(_iter985); } } } @@ -91984,13 +93108,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_wi } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list978 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list978.size); - String _elem979; - for (int _i980 = 0; _i980 < _list978.size; ++_i980) + org.apache.thrift.protocol.TList _list986 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list986.size); + String _elem987; + for (int _i988 = 0; _i988 < _list986.size; ++_i988) { - _elem979 = iprot.readString(); - struct.part_vals.add(_elem979); + _elem987 = iprot.readString(); + struct.part_vals.add(_elem987); } } struct.setPart_valsIsSet(true); @@ -92005,13 +93129,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_wi } if (incoming.get(5)) { { - org.apache.thrift.protocol.TList _list981 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.group_names = new ArrayList(_list981.size); - String _elem982; - for (int _i983 = 0; _i983 < _list981.size; ++_i983) + org.apache.thrift.protocol.TList _list989 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.group_names = new ArrayList(_list989.size); + String _elem990; + for (int _i991 = 0; _i991 < _list989.size; ++_i991) { - _elem982 = iprot.readString(); - struct.group_names.add(_elem982); + _elem990 = iprot.readString(); + struct.group_names.add(_elem990); } } struct.setGroup_namesIsSet(true); @@ -92498,14 +93622,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_ps_w case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list984 = iprot.readListBegin(); - struct.success = new ArrayList(_list984.size); - Partition _elem985; - for (int _i986 = 0; _i986 < _list984.size; ++_i986) + org.apache.thrift.protocol.TList _list992 = iprot.readListBegin(); + struct.success = new ArrayList(_list992.size); + Partition _elem993; + for (int _i994 = 0; _i994 < _list992.size; ++_i994) { - _elem985 = new Partition(); - _elem985.read(iprot); - struct.success.add(_elem985); + _elem993 = new Partition(); + _elem993.read(iprot); + struct.success.add(_elem993); } iprot.readListEnd(); } @@ -92549,9 +93673,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_ps_ oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (Partition _iter987 : struct.success) + for (Partition _iter995 : struct.success) { - _iter987.write(oprot); + _iter995.write(oprot); } oprot.writeListEnd(); } @@ -92598,9 +93722,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_w if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Partition _iter988 : struct.success) + for (Partition _iter996 : struct.success) { - _iter988.write(oprot); + _iter996.write(oprot); } } } @@ -92618,14 +93742,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_wi BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list989 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list989.size); - Partition _elem990; - for (int _i991 = 0; _i991 < _list989.size; ++_i991) + org.apache.thrift.protocol.TList _list997 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list997.size); + Partition _elem998; + for (int _i999 = 0; _i999 < _list997.size; ++_i999) { - _elem990 = new Partition(); - _elem990.read(iprot); - struct.success.add(_elem990); + _elem998 = new Partition(); + _elem998.read(iprot); + struct.success.add(_elem998); } } struct.setSuccessIsSet(true); @@ -93218,13 +94342,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partition_names case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list992 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list992.size); - String _elem993; - for (int _i994 = 0; _i994 < _list992.size; ++_i994) + org.apache.thrift.protocol.TList _list1000 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list1000.size); + String _elem1001; + for (int _i1002 = 0; _i1002 < _list1000.size; ++_i1002) { - _elem993 = iprot.readString(); - struct.part_vals.add(_elem993); + _elem1001 = iprot.readString(); + struct.part_vals.add(_elem1001); } iprot.readListEnd(); } @@ -93268,9 +94392,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partition_name oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (String _iter995 : struct.part_vals) + for (String _iter1003 : struct.part_vals) { - oprot.writeString(_iter995); + oprot.writeString(_iter1003); } oprot.writeListEnd(); } @@ -93319,9 +94443,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partition_names if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (String _iter996 : struct.part_vals) + for (String _iter1004 : struct.part_vals) { - oprot.writeString(_iter996); + oprot.writeString(_iter1004); } } } @@ -93344,13 +94468,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partition_names_ } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list997 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list997.size); - String _elem998; - for (int _i999 = 0; _i999 < _list997.size; ++_i999) + org.apache.thrift.protocol.TList _list1005 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list1005.size); + String _elem1006; + for (int _i1007 = 0; _i1007 < _list1005.size; ++_i1007) { - _elem998 = iprot.readString(); - struct.part_vals.add(_elem998); + _elem1006 = iprot.readString(); + struct.part_vals.add(_elem1006); } } struct.setPart_valsIsSet(true); @@ -93838,13 +94962,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partition_names case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1000 = iprot.readListBegin(); - struct.success = new ArrayList(_list1000.size); - String _elem1001; - for (int _i1002 = 0; _i1002 < _list1000.size; ++_i1002) + org.apache.thrift.protocol.TList _list1008 = iprot.readListBegin(); + struct.success = new ArrayList(_list1008.size); + String _elem1009; + for (int _i1010 = 0; _i1010 < _list1008.size; ++_i1010) { - _elem1001 = iprot.readString(); - struct.success.add(_elem1001); + _elem1009 = iprot.readString(); + struct.success.add(_elem1009); } iprot.readListEnd(); } @@ -93888,9 +95012,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partition_name oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter1003 : struct.success) + for (String _iter1011 : struct.success) { - oprot.writeString(_iter1003); + oprot.writeString(_iter1011); } oprot.writeListEnd(); } @@ -93937,9 +95061,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partition_names if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter1004 : struct.success) + for (String _iter1012 : struct.success) { - oprot.writeString(_iter1004); + oprot.writeString(_iter1012); } } } @@ -93957,13 +95081,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partition_names_ BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1005 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list1005.size); - String _elem1006; - for (int _i1007 = 0; _i1007 < _list1005.size; ++_i1007) + org.apache.thrift.protocol.TList _list1013 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list1013.size); + String _elem1014; + for (int _i1015 = 0; _i1015 < _list1013.size; ++_i1015) { - _elem1006 = iprot.readString(); - struct.success.add(_elem1006); + _elem1014 = iprot.readString(); + struct.success.add(_elem1014); } } struct.setSuccessIsSet(true); @@ -95130,14 +96254,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_by_f case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1008 = iprot.readListBegin(); - struct.success = new ArrayList(_list1008.size); - Partition _elem1009; - for (int _i1010 = 0; _i1010 < _list1008.size; ++_i1010) + org.apache.thrift.protocol.TList _list1016 = iprot.readListBegin(); + struct.success = new ArrayList(_list1016.size); + Partition _elem1017; + for (int _i1018 = 0; _i1018 < _list1016.size; ++_i1018) { - _elem1009 = new Partition(); - _elem1009.read(iprot); - struct.success.add(_elem1009); + _elem1017 = new Partition(); + _elem1017.read(iprot); + struct.success.add(_elem1017); } iprot.readListEnd(); } @@ -95181,9 +96305,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_by_ oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (Partition _iter1011 : struct.success) + for (Partition _iter1019 : struct.success) { - _iter1011.write(oprot); + _iter1019.write(oprot); } oprot.writeListEnd(); } @@ -95230,9 +96354,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_by_f if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Partition _iter1012 : struct.success) + for (Partition _iter1020 : struct.success) { - _iter1012.write(oprot); + _iter1020.write(oprot); } } } @@ -95250,14 +96374,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_by_fi BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1013 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list1013.size); - Partition _elem1014; - for (int _i1015 = 0; _i1015 < _list1013.size; ++_i1015) + org.apache.thrift.protocol.TList _list1021 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list1021.size); + Partition _elem1022; + for (int _i1023 = 0; _i1023 < _list1021.size; ++_i1023) { - _elem1014 = new Partition(); - _elem1014.read(iprot); - struct.success.add(_elem1014); + _elem1022 = new Partition(); + _elem1022.read(iprot); + struct.success.add(_elem1022); } } struct.setSuccessIsSet(true); @@ -96424,14 +97548,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_part_specs_by_f case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1016 = iprot.readListBegin(); - struct.success = new ArrayList(_list1016.size); - PartitionSpec _elem1017; - for (int _i1018 = 0; _i1018 < _list1016.size; ++_i1018) + org.apache.thrift.protocol.TList _list1024 = iprot.readListBegin(); + struct.success = new ArrayList(_list1024.size); + PartitionSpec _elem1025; + for (int _i1026 = 0; _i1026 < _list1024.size; ++_i1026) { - _elem1017 = new PartitionSpec(); - _elem1017.read(iprot); - struct.success.add(_elem1017); + _elem1025 = new PartitionSpec(); + _elem1025.read(iprot); + struct.success.add(_elem1025); } iprot.readListEnd(); } @@ -96475,9 +97599,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_part_specs_by_ oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (PartitionSpec _iter1019 : struct.success) + for (PartitionSpec _iter1027 : struct.success) { - _iter1019.write(oprot); + _iter1027.write(oprot); } oprot.writeListEnd(); } @@ -96524,9 +97648,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_part_specs_by_f if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (PartitionSpec _iter1020 : struct.success) + for (PartitionSpec _iter1028 : struct.success) { - _iter1020.write(oprot); + _iter1028.write(oprot); } } } @@ -96544,14 +97668,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_part_specs_by_fi BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1021 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list1021.size); - PartitionSpec _elem1022; - for (int _i1023 = 0; _i1023 < _list1021.size; ++_i1023) + org.apache.thrift.protocol.TList _list1029 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list1029.size); + PartitionSpec _elem1030; + for (int _i1031 = 0; _i1031 < _list1029.size; ++_i1031) { - _elem1022 = new PartitionSpec(); - _elem1022.read(iprot); - struct.success.add(_elem1022); + _elem1030 = new PartitionSpec(); + _elem1030.read(iprot); + struct.success.add(_elem1030); } } struct.setSuccessIsSet(true); @@ -99135,13 +100259,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_by_n case 3: // NAMES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1024 = iprot.readListBegin(); - struct.names = new ArrayList(_list1024.size); - String _elem1025; - for (int _i1026 = 0; _i1026 < _list1024.size; ++_i1026) + org.apache.thrift.protocol.TList _list1032 = iprot.readListBegin(); + struct.names = new ArrayList(_list1032.size); + String _elem1033; + for (int _i1034 = 0; _i1034 < _list1032.size; ++_i1034) { - _elem1025 = iprot.readString(); - struct.names.add(_elem1025); + _elem1033 = iprot.readString(); + struct.names.add(_elem1033); } iprot.readListEnd(); } @@ -99177,9 +100301,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_by_ oprot.writeFieldBegin(NAMES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.names.size())); - for (String _iter1027 : struct.names) + for (String _iter1035 : struct.names) { - oprot.writeString(_iter1027); + oprot.writeString(_iter1035); } oprot.writeListEnd(); } @@ -99222,9 +100346,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_by_n if (struct.isSetNames()) { { oprot.writeI32(struct.names.size()); - for (String _iter1028 : struct.names) + for (String _iter1036 : struct.names) { - oprot.writeString(_iter1028); + oprot.writeString(_iter1036); } } } @@ -99244,13 +100368,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_by_na } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list1029 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.names = new ArrayList(_list1029.size); - String _elem1030; - for (int _i1031 = 0; _i1031 < _list1029.size; ++_i1031) + org.apache.thrift.protocol.TList _list1037 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.names = new ArrayList(_list1037.size); + String _elem1038; + for (int _i1039 = 0; _i1039 < _list1037.size; ++_i1039) { - _elem1030 = iprot.readString(); - struct.names.add(_elem1030); + _elem1038 = iprot.readString(); + struct.names.add(_elem1038); } } struct.setNamesIsSet(true); @@ -99737,14 +100861,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_by_n case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1032 = iprot.readListBegin(); - struct.success = new ArrayList(_list1032.size); - Partition _elem1033; - for (int _i1034 = 0; _i1034 < _list1032.size; ++_i1034) + org.apache.thrift.protocol.TList _list1040 = iprot.readListBegin(); + struct.success = new ArrayList(_list1040.size); + Partition _elem1041; + for (int _i1042 = 0; _i1042 < _list1040.size; ++_i1042) { - _elem1033 = new Partition(); - _elem1033.read(iprot); - struct.success.add(_elem1033); + _elem1041 = new Partition(); + _elem1041.read(iprot); + struct.success.add(_elem1041); } iprot.readListEnd(); } @@ -99788,9 +100912,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_by_ oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (Partition _iter1035 : struct.success) + for (Partition _iter1043 : struct.success) { - _iter1035.write(oprot); + _iter1043.write(oprot); } oprot.writeListEnd(); } @@ -99837,9 +100961,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_by_n if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Partition _iter1036 : struct.success) + for (Partition _iter1044 : struct.success) { - _iter1036.write(oprot); + _iter1044.write(oprot); } } } @@ -99857,14 +100981,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_by_na BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1037 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list1037.size); - Partition _elem1038; - for (int _i1039 = 0; _i1039 < _list1037.size; ++_i1039) + org.apache.thrift.protocol.TList _list1045 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list1045.size); + Partition _elem1046; + for (int _i1047 = 0; _i1047 < _list1045.size; ++_i1047) { - _elem1038 = new Partition(); - _elem1038.read(iprot); - struct.success.add(_elem1038); + _elem1046 = new Partition(); + _elem1046.read(iprot); + struct.success.add(_elem1046); } } struct.setSuccessIsSet(true); @@ -101414,14 +102538,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, alter_partitions_ar case 3: // NEW_PARTS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1040 = iprot.readListBegin(); - struct.new_parts = new ArrayList(_list1040.size); - Partition _elem1041; - for (int _i1042 = 0; _i1042 < _list1040.size; ++_i1042) + org.apache.thrift.protocol.TList _list1048 = iprot.readListBegin(); + struct.new_parts = new ArrayList(_list1048.size); + Partition _elem1049; + for (int _i1050 = 0; _i1050 < _list1048.size; ++_i1050) { - _elem1041 = new Partition(); - _elem1041.read(iprot); - struct.new_parts.add(_elem1041); + _elem1049 = new Partition(); + _elem1049.read(iprot); + struct.new_parts.add(_elem1049); } iprot.readListEnd(); } @@ -101457,9 +102581,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, alter_partitions_a oprot.writeFieldBegin(NEW_PARTS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.new_parts.size())); - for (Partition _iter1043 : struct.new_parts) + for (Partition _iter1051 : struct.new_parts) { - _iter1043.write(oprot); + _iter1051.write(oprot); } oprot.writeListEnd(); } @@ -101502,9 +102626,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, alter_partitions_ar if (struct.isSetNew_parts()) { { oprot.writeI32(struct.new_parts.size()); - for (Partition _iter1044 : struct.new_parts) + for (Partition _iter1052 : struct.new_parts) { - _iter1044.write(oprot); + _iter1052.write(oprot); } } } @@ -101524,14 +102648,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, alter_partitions_arg } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list1045 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.new_parts = new ArrayList(_list1045.size); - Partition _elem1046; - for (int _i1047 = 0; _i1047 < _list1045.size; ++_i1047) + org.apache.thrift.protocol.TList _list1053 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.new_parts = new ArrayList(_list1053.size); + Partition _elem1054; + for (int _i1055 = 0; _i1055 < _list1053.size; ++_i1055) { - _elem1046 = new Partition(); - _elem1046.read(iprot); - struct.new_parts.add(_elem1046); + _elem1054 = new Partition(); + _elem1054.read(iprot); + struct.new_parts.add(_elem1054); } } struct.setNew_partsIsSet(true); @@ -102584,14 +103708,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, alter_partitions_wi case 3: // NEW_PARTS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1048 = iprot.readListBegin(); - struct.new_parts = new ArrayList(_list1048.size); - Partition _elem1049; - for (int _i1050 = 0; _i1050 < _list1048.size; ++_i1050) + org.apache.thrift.protocol.TList _list1056 = iprot.readListBegin(); + struct.new_parts = new ArrayList(_list1056.size); + Partition _elem1057; + for (int _i1058 = 0; _i1058 < _list1056.size; ++_i1058) { - _elem1049 = new Partition(); - _elem1049.read(iprot); - struct.new_parts.add(_elem1049); + _elem1057 = new Partition(); + _elem1057.read(iprot); + struct.new_parts.add(_elem1057); } iprot.readListEnd(); } @@ -102636,9 +103760,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, alter_partitions_w oprot.writeFieldBegin(NEW_PARTS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.new_parts.size())); - for (Partition _iter1051 : struct.new_parts) + for (Partition _iter1059 : struct.new_parts) { - _iter1051.write(oprot); + _iter1059.write(oprot); } oprot.writeListEnd(); } @@ -102689,9 +103813,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, alter_partitions_wi if (struct.isSetNew_parts()) { { oprot.writeI32(struct.new_parts.size()); - for (Partition _iter1052 : struct.new_parts) + for (Partition _iter1060 : struct.new_parts) { - _iter1052.write(oprot); + _iter1060.write(oprot); } } } @@ -102714,14 +103838,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, alter_partitions_wit } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list1053 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.new_parts = new ArrayList(_list1053.size); - Partition _elem1054; - for (int _i1055 = 0; _i1055 < _list1053.size; ++_i1055) + org.apache.thrift.protocol.TList _list1061 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.new_parts = new ArrayList(_list1061.size); + Partition _elem1062; + for (int _i1063 = 0; _i1063 < _list1061.size; ++_i1063) { - _elem1054 = new Partition(); - _elem1054.read(iprot); - struct.new_parts.add(_elem1054); + _elem1062 = new Partition(); + _elem1062.read(iprot); + struct.new_parts.add(_elem1062); } } struct.setNew_partsIsSet(true); @@ -104922,13 +106046,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, rename_partition_ar case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1056 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list1056.size); - String _elem1057; - for (int _i1058 = 0; _i1058 < _list1056.size; ++_i1058) + org.apache.thrift.protocol.TList _list1064 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list1064.size); + String _elem1065; + for (int _i1066 = 0; _i1066 < _list1064.size; ++_i1066) { - _elem1057 = iprot.readString(); - struct.part_vals.add(_elem1057); + _elem1065 = iprot.readString(); + struct.part_vals.add(_elem1065); } iprot.readListEnd(); } @@ -104973,9 +106097,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, rename_partition_a oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (String _iter1059 : struct.part_vals) + for (String _iter1067 : struct.part_vals) { - oprot.writeString(_iter1059); + oprot.writeString(_iter1067); } oprot.writeListEnd(); } @@ -105026,9 +106150,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, rename_partition_ar if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (String _iter1060 : struct.part_vals) + for (String _iter1068 : struct.part_vals) { - oprot.writeString(_iter1060); + oprot.writeString(_iter1068); } } } @@ -105051,13 +106175,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, rename_partition_arg } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list1061 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list1061.size); - String _elem1062; - for (int _i1063 = 0; _i1063 < _list1061.size; ++_i1063) + org.apache.thrift.protocol.TList _list1069 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list1069.size); + String _elem1070; + for (int _i1071 = 0; _i1071 < _list1069.size; ++_i1071) { - _elem1062 = iprot.readString(); - struct.part_vals.add(_elem1062); + _elem1070 = iprot.readString(); + struct.part_vals.add(_elem1070); } } struct.setPart_valsIsSet(true); @@ -105931,13 +107055,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, partition_name_has_ case 1: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1064 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list1064.size); - String _elem1065; - for (int _i1066 = 0; _i1066 < _list1064.size; ++_i1066) + org.apache.thrift.protocol.TList _list1072 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list1072.size); + String _elem1073; + for (int _i1074 = 0; _i1074 < _list1072.size; ++_i1074) { - _elem1065 = iprot.readString(); - struct.part_vals.add(_elem1065); + _elem1073 = iprot.readString(); + struct.part_vals.add(_elem1073); } iprot.readListEnd(); } @@ -105971,9 +107095,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, partition_name_has oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (String _iter1067 : struct.part_vals) + for (String _iter1075 : struct.part_vals) { - oprot.writeString(_iter1067); + oprot.writeString(_iter1075); } oprot.writeListEnd(); } @@ -106010,9 +107134,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, partition_name_has_ if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (String _iter1068 : struct.part_vals) + for (String _iter1076 : struct.part_vals) { - oprot.writeString(_iter1068); + oprot.writeString(_iter1076); } } } @@ -106027,13 +107151,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, partition_name_has_v BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1069 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list1069.size); - String _elem1070; - for (int _i1071 = 0; _i1071 < _list1069.size; ++_i1071) + org.apache.thrift.protocol.TList _list1077 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list1077.size); + String _elem1078; + for (int _i1079 = 0; _i1079 < _list1077.size; ++_i1079) { - _elem1070 = iprot.readString(); - struct.part_vals.add(_elem1070); + _elem1078 = iprot.readString(); + struct.part_vals.add(_elem1078); } } struct.setPart_valsIsSet(true); @@ -108188,13 +109312,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, partition_name_to_v case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1072 = iprot.readListBegin(); - struct.success = new ArrayList(_list1072.size); - String _elem1073; - for (int _i1074 = 0; _i1074 < _list1072.size; ++_i1074) + org.apache.thrift.protocol.TList _list1080 = iprot.readListBegin(); + struct.success = new ArrayList(_list1080.size); + String _elem1081; + for (int _i1082 = 0; _i1082 < _list1080.size; ++_i1082) { - _elem1073 = iprot.readString(); - struct.success.add(_elem1073); + _elem1081 = iprot.readString(); + struct.success.add(_elem1081); } iprot.readListEnd(); } @@ -108229,9 +109353,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, partition_name_to_ oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter1075 : struct.success) + for (String _iter1083 : struct.success) { - oprot.writeString(_iter1075); + oprot.writeString(_iter1083); } oprot.writeListEnd(); } @@ -108270,9 +109394,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, partition_name_to_v if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter1076 : struct.success) + for (String _iter1084 : struct.success) { - oprot.writeString(_iter1076); + oprot.writeString(_iter1084); } } } @@ -108287,13 +109411,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, partition_name_to_va BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1077 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list1077.size); - String _elem1078; - for (int _i1079 = 0; _i1079 < _list1077.size; ++_i1079) + org.apache.thrift.protocol.TList _list1085 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list1085.size); + String _elem1086; + for (int _i1087 = 0; _i1087 < _list1085.size; ++_i1087) { - _elem1078 = iprot.readString(); - struct.success.add(_elem1078); + _elem1086 = iprot.readString(); + struct.success.add(_elem1086); } } struct.setSuccessIsSet(true); @@ -109056,15 +110180,15 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, partition_name_to_s case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map1080 = iprot.readMapBegin(); - struct.success = new HashMap(2*_map1080.size); - String _key1081; - String _val1082; - for (int _i1083 = 0; _i1083 < _map1080.size; ++_i1083) + org.apache.thrift.protocol.TMap _map1088 = iprot.readMapBegin(); + struct.success = new HashMap(2*_map1088.size); + String _key1089; + String _val1090; + for (int _i1091 = 0; _i1091 < _map1088.size; ++_i1091) { - _key1081 = iprot.readString(); - _val1082 = iprot.readString(); - struct.success.put(_key1081, _val1082); + _key1089 = iprot.readString(); + _val1090 = iprot.readString(); + struct.success.put(_key1089, _val1090); } iprot.readMapEnd(); } @@ -109099,10 +110223,10 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, partition_name_to_ oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (Map.Entry _iter1084 : struct.success.entrySet()) + for (Map.Entry _iter1092 : struct.success.entrySet()) { - oprot.writeString(_iter1084.getKey()); - oprot.writeString(_iter1084.getValue()); + oprot.writeString(_iter1092.getKey()); + oprot.writeString(_iter1092.getValue()); } oprot.writeMapEnd(); } @@ -109141,10 +110265,10 @@ public void write(org.apache.thrift.protocol.TProtocol prot, partition_name_to_s if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Map.Entry _iter1085 : struct.success.entrySet()) + for (Map.Entry _iter1093 : struct.success.entrySet()) { - oprot.writeString(_iter1085.getKey()); - oprot.writeString(_iter1085.getValue()); + oprot.writeString(_iter1093.getKey()); + oprot.writeString(_iter1093.getValue()); } } } @@ -109159,15 +110283,15 @@ public void read(org.apache.thrift.protocol.TProtocol prot, partition_name_to_sp BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TMap _map1086 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new HashMap(2*_map1086.size); - String _key1087; - String _val1088; - for (int _i1089 = 0; _i1089 < _map1086.size; ++_i1089) + org.apache.thrift.protocol.TMap _map1094 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new HashMap(2*_map1094.size); + String _key1095; + String _val1096; + for (int _i1097 = 0; _i1097 < _map1094.size; ++_i1097) { - _key1087 = iprot.readString(); - _val1088 = iprot.readString(); - struct.success.put(_key1087, _val1088); + _key1095 = iprot.readString(); + _val1096 = iprot.readString(); + struct.success.put(_key1095, _val1096); } } struct.setSuccessIsSet(true); @@ -109762,15 +110886,15 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, markPartitionForEve case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map1090 = iprot.readMapBegin(); - struct.part_vals = new HashMap(2*_map1090.size); - String _key1091; - String _val1092; - for (int _i1093 = 0; _i1093 < _map1090.size; ++_i1093) + org.apache.thrift.protocol.TMap _map1098 = iprot.readMapBegin(); + struct.part_vals = new HashMap(2*_map1098.size); + String _key1099; + String _val1100; + for (int _i1101 = 0; _i1101 < _map1098.size; ++_i1101) { - _key1091 = iprot.readString(); - _val1092 = iprot.readString(); - struct.part_vals.put(_key1091, _val1092); + _key1099 = iprot.readString(); + _val1100 = iprot.readString(); + struct.part_vals.put(_key1099, _val1100); } iprot.readMapEnd(); } @@ -109814,10 +110938,10 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, markPartitionForEv oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (Map.Entry _iter1094 : struct.part_vals.entrySet()) + for (Map.Entry _iter1102 : struct.part_vals.entrySet()) { - oprot.writeString(_iter1094.getKey()); - oprot.writeString(_iter1094.getValue()); + oprot.writeString(_iter1102.getKey()); + oprot.writeString(_iter1102.getValue()); } oprot.writeMapEnd(); } @@ -109868,10 +110992,10 @@ public void write(org.apache.thrift.protocol.TProtocol prot, markPartitionForEve if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (Map.Entry _iter1095 : struct.part_vals.entrySet()) + for (Map.Entry _iter1103 : struct.part_vals.entrySet()) { - oprot.writeString(_iter1095.getKey()); - oprot.writeString(_iter1095.getValue()); + oprot.writeString(_iter1103.getKey()); + oprot.writeString(_iter1103.getValue()); } } } @@ -109894,15 +111018,15 @@ public void read(org.apache.thrift.protocol.TProtocol prot, markPartitionForEven } if (incoming.get(2)) { { - org.apache.thrift.protocol.TMap _map1096 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new HashMap(2*_map1096.size); - String _key1097; - String _val1098; - for (int _i1099 = 0; _i1099 < _map1096.size; ++_i1099) + org.apache.thrift.protocol.TMap _map1104 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new HashMap(2*_map1104.size); + String _key1105; + String _val1106; + for (int _i1107 = 0; _i1107 < _map1104.size; ++_i1107) { - _key1097 = iprot.readString(); - _val1098 = iprot.readString(); - struct.part_vals.put(_key1097, _val1098); + _key1105 = iprot.readString(); + _val1106 = iprot.readString(); + struct.part_vals.put(_key1105, _val1106); } } struct.setPart_valsIsSet(true); @@ -111386,15 +112510,15 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, isPartitionMarkedFo case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map1100 = iprot.readMapBegin(); - struct.part_vals = new HashMap(2*_map1100.size); - String _key1101; - String _val1102; - for (int _i1103 = 0; _i1103 < _map1100.size; ++_i1103) + org.apache.thrift.protocol.TMap _map1108 = iprot.readMapBegin(); + struct.part_vals = new HashMap(2*_map1108.size); + String _key1109; + String _val1110; + for (int _i1111 = 0; _i1111 < _map1108.size; ++_i1111) { - _key1101 = iprot.readString(); - _val1102 = iprot.readString(); - struct.part_vals.put(_key1101, _val1102); + _key1109 = iprot.readString(); + _val1110 = iprot.readString(); + struct.part_vals.put(_key1109, _val1110); } iprot.readMapEnd(); } @@ -111438,10 +112562,10 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, isPartitionMarkedF oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (Map.Entry _iter1104 : struct.part_vals.entrySet()) + for (Map.Entry _iter1112 : struct.part_vals.entrySet()) { - oprot.writeString(_iter1104.getKey()); - oprot.writeString(_iter1104.getValue()); + oprot.writeString(_iter1112.getKey()); + oprot.writeString(_iter1112.getValue()); } oprot.writeMapEnd(); } @@ -111492,10 +112616,10 @@ public void write(org.apache.thrift.protocol.TProtocol prot, isPartitionMarkedFo if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (Map.Entry _iter1105 : struct.part_vals.entrySet()) + for (Map.Entry _iter1113 : struct.part_vals.entrySet()) { - oprot.writeString(_iter1105.getKey()); - oprot.writeString(_iter1105.getValue()); + oprot.writeString(_iter1113.getKey()); + oprot.writeString(_iter1113.getValue()); } } } @@ -111518,15 +112642,15 @@ public void read(org.apache.thrift.protocol.TProtocol prot, isPartitionMarkedFor } if (incoming.get(2)) { { - org.apache.thrift.protocol.TMap _map1106 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new HashMap(2*_map1106.size); - String _key1107; - String _val1108; - for (int _i1109 = 0; _i1109 < _map1106.size; ++_i1109) + org.apache.thrift.protocol.TMap _map1114 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new HashMap(2*_map1114.size); + String _key1115; + String _val1116; + for (int _i1117 = 0; _i1117 < _map1114.size; ++_i1117) { - _key1107 = iprot.readString(); - _val1108 = iprot.readString(); - struct.part_vals.put(_key1107, _val1108); + _key1115 = iprot.readString(); + _val1116 = iprot.readString(); + struct.part_vals.put(_key1115, _val1116); } } struct.setPart_valsIsSet(true); @@ -118250,14 +119374,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_indexes_result case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1110 = iprot.readListBegin(); - struct.success = new ArrayList(_list1110.size); - Index _elem1111; - for (int _i1112 = 0; _i1112 < _list1110.size; ++_i1112) + org.apache.thrift.protocol.TList _list1118 = iprot.readListBegin(); + struct.success = new ArrayList(_list1118.size); + Index _elem1119; + for (int _i1120 = 0; _i1120 < _list1118.size; ++_i1120) { - _elem1111 = new Index(); - _elem1111.read(iprot); - struct.success.add(_elem1111); + _elem1119 = new Index(); + _elem1119.read(iprot); + struct.success.add(_elem1119); } iprot.readListEnd(); } @@ -118301,9 +119425,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_indexes_result oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (Index _iter1113 : struct.success) + for (Index _iter1121 : struct.success) { - _iter1113.write(oprot); + _iter1121.write(oprot); } oprot.writeListEnd(); } @@ -118350,9 +119474,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_indexes_result if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Index _iter1114 : struct.success) + for (Index _iter1122 : struct.success) { - _iter1114.write(oprot); + _iter1122.write(oprot); } } } @@ -118370,14 +119494,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_indexes_result s BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1115 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list1115.size); - Index _elem1116; - for (int _i1117 = 0; _i1117 < _list1115.size; ++_i1117) + org.apache.thrift.protocol.TList _list1123 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list1123.size); + Index _elem1124; + for (int _i1125 = 0; _i1125 < _list1123.size; ++_i1125) { - _elem1116 = new Index(); - _elem1116.read(iprot); - struct.success.add(_elem1116); + _elem1124 = new Index(); + _elem1124.read(iprot); + struct.success.add(_elem1124); } } struct.setSuccessIsSet(true); @@ -119356,13 +120480,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_index_names_res case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1118 = iprot.readListBegin(); - struct.success = new ArrayList(_list1118.size); - String _elem1119; - for (int _i1120 = 0; _i1120 < _list1118.size; ++_i1120) + org.apache.thrift.protocol.TList _list1126 = iprot.readListBegin(); + struct.success = new ArrayList(_list1126.size); + String _elem1127; + for (int _i1128 = 0; _i1128 < _list1126.size; ++_i1128) { - _elem1119 = iprot.readString(); - struct.success.add(_elem1119); + _elem1127 = iprot.readString(); + struct.success.add(_elem1127); } iprot.readListEnd(); } @@ -119397,9 +120521,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_index_names_re oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter1121 : struct.success) + for (String _iter1129 : struct.success) { - oprot.writeString(_iter1121); + oprot.writeString(_iter1129); } oprot.writeListEnd(); } @@ -119438,9 +120562,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_index_names_res if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter1122 : struct.success) + for (String _iter1130 : struct.success) { - oprot.writeString(_iter1122); + oprot.writeString(_iter1130); } } } @@ -119455,13 +120579,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_index_names_resu BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1123 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list1123.size); - String _elem1124; - for (int _i1125 = 0; _i1125 < _list1123.size; ++_i1125) + org.apache.thrift.protocol.TList _list1131 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list1131.size); + String _elem1132; + for (int _i1133 = 0; _i1133 < _list1131.size; ++_i1133) { - _elem1124 = iprot.readString(); - struct.success.add(_elem1124); + _elem1132 = iprot.readString(); + struct.success.add(_elem1132); } } struct.setSuccessIsSet(true); @@ -137072,13 +138196,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_functions_resul case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1126 = iprot.readListBegin(); - struct.success = new ArrayList(_list1126.size); - String _elem1127; - for (int _i1128 = 0; _i1128 < _list1126.size; ++_i1128) + org.apache.thrift.protocol.TList _list1134 = iprot.readListBegin(); + struct.success = new ArrayList(_list1134.size); + String _elem1135; + for (int _i1136 = 0; _i1136 < _list1134.size; ++_i1136) { - _elem1127 = iprot.readString(); - struct.success.add(_elem1127); + _elem1135 = iprot.readString(); + struct.success.add(_elem1135); } iprot.readListEnd(); } @@ -137113,9 +138237,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_functions_resu oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter1129 : struct.success) + for (String _iter1137 : struct.success) { - oprot.writeString(_iter1129); + oprot.writeString(_iter1137); } oprot.writeListEnd(); } @@ -137154,9 +138278,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_functions_resul if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter1130 : struct.success) + for (String _iter1138 : struct.success) { - oprot.writeString(_iter1130); + oprot.writeString(_iter1138); } } } @@ -137171,13 +138295,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_functions_result BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1131 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list1131.size); - String _elem1132; - for (int _i1133 = 0; _i1133 < _list1131.size; ++_i1133) + org.apache.thrift.protocol.TList _list1139 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list1139.size); + String _elem1140; + for (int _i1141 = 0; _i1141 < _list1139.size; ++_i1141) { - _elem1132 = iprot.readString(); - struct.success.add(_elem1132); + _elem1140 = iprot.readString(); + struct.success.add(_elem1140); } } struct.setSuccessIsSet(true); @@ -141232,13 +142356,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_role_names_resu case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1134 = iprot.readListBegin(); - struct.success = new ArrayList(_list1134.size); - String _elem1135; - for (int _i1136 = 0; _i1136 < _list1134.size; ++_i1136) + org.apache.thrift.protocol.TList _list1142 = iprot.readListBegin(); + struct.success = new ArrayList(_list1142.size); + String _elem1143; + for (int _i1144 = 0; _i1144 < _list1142.size; ++_i1144) { - _elem1135 = iprot.readString(); - struct.success.add(_elem1135); + _elem1143 = iprot.readString(); + struct.success.add(_elem1143); } iprot.readListEnd(); } @@ -141273,9 +142397,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_role_names_res oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter1137 : struct.success) + for (String _iter1145 : struct.success) { - oprot.writeString(_iter1137); + oprot.writeString(_iter1145); } oprot.writeListEnd(); } @@ -141314,9 +142438,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_role_names_resu if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter1138 : struct.success) + for (String _iter1146 : struct.success) { - oprot.writeString(_iter1138); + oprot.writeString(_iter1146); } } } @@ -141331,13 +142455,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_role_names_resul BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1139 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list1139.size); - String _elem1140; - for (int _i1141 = 0; _i1141 < _list1139.size; ++_i1141) + org.apache.thrift.protocol.TList _list1147 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list1147.size); + String _elem1148; + for (int _i1149 = 0; _i1149 < _list1147.size; ++_i1149) { - _elem1140 = iprot.readString(); - struct.success.add(_elem1140); + _elem1148 = iprot.readString(); + struct.success.add(_elem1148); } } struct.setSuccessIsSet(true); @@ -144628,14 +145752,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, list_roles_result s case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1142 = iprot.readListBegin(); - struct.success = new ArrayList(_list1142.size); - Role _elem1143; - for (int _i1144 = 0; _i1144 < _list1142.size; ++_i1144) + org.apache.thrift.protocol.TList _list1150 = iprot.readListBegin(); + struct.success = new ArrayList(_list1150.size); + Role _elem1151; + for (int _i1152 = 0; _i1152 < _list1150.size; ++_i1152) { - _elem1143 = new Role(); - _elem1143.read(iprot); - struct.success.add(_elem1143); + _elem1151 = new Role(); + _elem1151.read(iprot); + struct.success.add(_elem1151); } iprot.readListEnd(); } @@ -144670,9 +145794,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, list_roles_result oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (Role _iter1145 : struct.success) + for (Role _iter1153 : struct.success) { - _iter1145.write(oprot); + _iter1153.write(oprot); } oprot.writeListEnd(); } @@ -144711,9 +145835,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, list_roles_result s if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Role _iter1146 : struct.success) + for (Role _iter1154 : struct.success) { - _iter1146.write(oprot); + _iter1154.write(oprot); } } } @@ -144728,14 +145852,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, list_roles_result st BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1147 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list1147.size); - Role _elem1148; - for (int _i1149 = 0; _i1149 < _list1147.size; ++_i1149) + org.apache.thrift.protocol.TList _list1155 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list1155.size); + Role _elem1156; + for (int _i1157 = 0; _i1157 < _list1155.size; ++_i1157) { - _elem1148 = new Role(); - _elem1148.read(iprot); - struct.success.add(_elem1148); + _elem1156 = new Role(); + _elem1156.read(iprot); + struct.success.add(_elem1156); } } struct.setSuccessIsSet(true); @@ -147740,13 +148864,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_privilege_set_a case 3: // GROUP_NAMES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1150 = iprot.readListBegin(); - struct.group_names = new ArrayList(_list1150.size); - String _elem1151; - for (int _i1152 = 0; _i1152 < _list1150.size; ++_i1152) + org.apache.thrift.protocol.TList _list1158 = iprot.readListBegin(); + struct.group_names = new ArrayList(_list1158.size); + String _elem1159; + for (int _i1160 = 0; _i1160 < _list1158.size; ++_i1160) { - _elem1151 = iprot.readString(); - struct.group_names.add(_elem1151); + _elem1159 = iprot.readString(); + struct.group_names.add(_elem1159); } iprot.readListEnd(); } @@ -147782,9 +148906,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_privilege_set_ oprot.writeFieldBegin(GROUP_NAMES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.group_names.size())); - for (String _iter1153 : struct.group_names) + for (String _iter1161 : struct.group_names) { - oprot.writeString(_iter1153); + oprot.writeString(_iter1161); } oprot.writeListEnd(); } @@ -147827,9 +148951,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_privilege_set_a if (struct.isSetGroup_names()) { { oprot.writeI32(struct.group_names.size()); - for (String _iter1154 : struct.group_names) + for (String _iter1162 : struct.group_names) { - oprot.writeString(_iter1154); + oprot.writeString(_iter1162); } } } @@ -147850,13 +148974,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_privilege_set_ar } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list1155 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.group_names = new ArrayList(_list1155.size); - String _elem1156; - for (int _i1157 = 0; _i1157 < _list1155.size; ++_i1157) + org.apache.thrift.protocol.TList _list1163 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.group_names = new ArrayList(_list1163.size); + String _elem1164; + for (int _i1165 = 0; _i1165 < _list1163.size; ++_i1165) { - _elem1156 = iprot.readString(); - struct.group_names.add(_elem1156); + _elem1164 = iprot.readString(); + struct.group_names.add(_elem1164); } } struct.setGroup_namesIsSet(true); @@ -149314,14 +150438,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, list_privileges_res case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1158 = iprot.readListBegin(); - struct.success = new ArrayList(_list1158.size); - HiveObjectPrivilege _elem1159; - for (int _i1160 = 0; _i1160 < _list1158.size; ++_i1160) + org.apache.thrift.protocol.TList _list1166 = iprot.readListBegin(); + struct.success = new ArrayList(_list1166.size); + HiveObjectPrivilege _elem1167; + for (int _i1168 = 0; _i1168 < _list1166.size; ++_i1168) { - _elem1159 = new HiveObjectPrivilege(); - _elem1159.read(iprot); - struct.success.add(_elem1159); + _elem1167 = new HiveObjectPrivilege(); + _elem1167.read(iprot); + struct.success.add(_elem1167); } iprot.readListEnd(); } @@ -149356,9 +150480,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, list_privileges_re oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (HiveObjectPrivilege _iter1161 : struct.success) + for (HiveObjectPrivilege _iter1169 : struct.success) { - _iter1161.write(oprot); + _iter1169.write(oprot); } oprot.writeListEnd(); } @@ -149397,9 +150521,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, list_privileges_res if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (HiveObjectPrivilege _iter1162 : struct.success) + for (HiveObjectPrivilege _iter1170 : struct.success) { - _iter1162.write(oprot); + _iter1170.write(oprot); } } } @@ -149414,14 +150538,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, list_privileges_resu BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1163 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list1163.size); - HiveObjectPrivilege _elem1164; - for (int _i1165 = 0; _i1165 < _list1163.size; ++_i1165) + org.apache.thrift.protocol.TList _list1171 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list1171.size); + HiveObjectPrivilege _elem1172; + for (int _i1173 = 0; _i1173 < _list1171.size; ++_i1173) { - _elem1164 = new HiveObjectPrivilege(); - _elem1164.read(iprot); - struct.success.add(_elem1164); + _elem1172 = new HiveObjectPrivilege(); + _elem1172.read(iprot); + struct.success.add(_elem1172); } } struct.setSuccessIsSet(true); @@ -152323,13 +153447,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, set_ugi_args struct case 2: // GROUP_NAMES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1166 = iprot.readListBegin(); - struct.group_names = new ArrayList(_list1166.size); - String _elem1167; - for (int _i1168 = 0; _i1168 < _list1166.size; ++_i1168) + org.apache.thrift.protocol.TList _list1174 = iprot.readListBegin(); + struct.group_names = new ArrayList(_list1174.size); + String _elem1175; + for (int _i1176 = 0; _i1176 < _list1174.size; ++_i1176) { - _elem1167 = iprot.readString(); - struct.group_names.add(_elem1167); + _elem1175 = iprot.readString(); + struct.group_names.add(_elem1175); } iprot.readListEnd(); } @@ -152360,9 +153484,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, set_ugi_args struc oprot.writeFieldBegin(GROUP_NAMES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.group_names.size())); - for (String _iter1169 : struct.group_names) + for (String _iter1177 : struct.group_names) { - oprot.writeString(_iter1169); + oprot.writeString(_iter1177); } oprot.writeListEnd(); } @@ -152399,9 +153523,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, set_ugi_args struct if (struct.isSetGroup_names()) { { oprot.writeI32(struct.group_names.size()); - for (String _iter1170 : struct.group_names) + for (String _iter1178 : struct.group_names) { - oprot.writeString(_iter1170); + oprot.writeString(_iter1178); } } } @@ -152417,13 +153541,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, set_ugi_args struct) } if (incoming.get(1)) { { - org.apache.thrift.protocol.TList _list1171 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.group_names = new ArrayList(_list1171.size); - String _elem1172; - for (int _i1173 = 0; _i1173 < _list1171.size; ++_i1173) + org.apache.thrift.protocol.TList _list1179 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.group_names = new ArrayList(_list1179.size); + String _elem1180; + for (int _i1181 = 0; _i1181 < _list1179.size; ++_i1181) { - _elem1172 = iprot.readString(); - struct.group_names.add(_elem1172); + _elem1180 = iprot.readString(); + struct.group_names.add(_elem1180); } } struct.setGroup_namesIsSet(true); @@ -152826,13 +153950,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, set_ugi_result stru case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1174 = iprot.readListBegin(); - struct.success = new ArrayList(_list1174.size); - String _elem1175; - for (int _i1176 = 0; _i1176 < _list1174.size; ++_i1176) + org.apache.thrift.protocol.TList _list1182 = iprot.readListBegin(); + struct.success = new ArrayList(_list1182.size); + String _elem1183; + for (int _i1184 = 0; _i1184 < _list1182.size; ++_i1184) { - _elem1175 = iprot.readString(); - struct.success.add(_elem1175); + _elem1183 = iprot.readString(); + struct.success.add(_elem1183); } iprot.readListEnd(); } @@ -152867,9 +153991,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, set_ugi_result str oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter1177 : struct.success) + for (String _iter1185 : struct.success) { - oprot.writeString(_iter1177); + oprot.writeString(_iter1185); } oprot.writeListEnd(); } @@ -152908,9 +154032,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, set_ugi_result stru if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter1178 : struct.success) + for (String _iter1186 : struct.success) { - oprot.writeString(_iter1178); + oprot.writeString(_iter1186); } } } @@ -152925,13 +154049,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, set_ugi_result struc BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1179 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list1179.size); - String _elem1180; - for (int _i1181 = 0; _i1181 < _list1179.size; ++_i1181) + org.apache.thrift.protocol.TList _list1187 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list1187.size); + String _elem1188; + for (int _i1189 = 0; _i1189 < _list1187.size; ++_i1189) { - _elem1180 = iprot.readString(); - struct.success.add(_elem1180); + _elem1188 = iprot.readString(); + struct.success.add(_elem1188); } } struct.setSuccessIsSet(true); @@ -158222,13 +159346,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_all_token_ident case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1182 = iprot.readListBegin(); - struct.success = new ArrayList(_list1182.size); - String _elem1183; - for (int _i1184 = 0; _i1184 < _list1182.size; ++_i1184) + org.apache.thrift.protocol.TList _list1190 = iprot.readListBegin(); + struct.success = new ArrayList(_list1190.size); + String _elem1191; + for (int _i1192 = 0; _i1192 < _list1190.size; ++_i1192) { - _elem1183 = iprot.readString(); - struct.success.add(_elem1183); + _elem1191 = iprot.readString(); + struct.success.add(_elem1191); } iprot.readListEnd(); } @@ -158254,9 +159378,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_all_token_iden oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter1185 : struct.success) + for (String _iter1193 : struct.success) { - oprot.writeString(_iter1185); + oprot.writeString(_iter1193); } oprot.writeListEnd(); } @@ -158287,9 +159411,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_all_token_ident if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter1186 : struct.success) + for (String _iter1194 : struct.success) { - oprot.writeString(_iter1186); + oprot.writeString(_iter1194); } } } @@ -158301,13 +159425,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_all_token_identi BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1187 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list1187.size); - String _elem1188; - for (int _i1189 = 0; _i1189 < _list1187.size; ++_i1189) + org.apache.thrift.protocol.TList _list1195 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list1195.size); + String _elem1196; + for (int _i1197 = 0; _i1197 < _list1195.size; ++_i1197) { - _elem1188 = iprot.readString(); - struct.success.add(_elem1188); + _elem1196 = iprot.readString(); + struct.success.add(_elem1196); } } struct.setSuccessIsSet(true); @@ -161337,13 +162461,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_master_keys_res case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1190 = iprot.readListBegin(); - struct.success = new ArrayList(_list1190.size); - String _elem1191; - for (int _i1192 = 0; _i1192 < _list1190.size; ++_i1192) + org.apache.thrift.protocol.TList _list1198 = iprot.readListBegin(); + struct.success = new ArrayList(_list1198.size); + String _elem1199; + for (int _i1200 = 0; _i1200 < _list1198.size; ++_i1200) { - _elem1191 = iprot.readString(); - struct.success.add(_elem1191); + _elem1199 = iprot.readString(); + struct.success.add(_elem1199); } iprot.readListEnd(); } @@ -161369,9 +162493,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_master_keys_re oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter1193 : struct.success) + for (String _iter1201 : struct.success) { - oprot.writeString(_iter1193); + oprot.writeString(_iter1201); } oprot.writeListEnd(); } @@ -161402,9 +162526,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_master_keys_res if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter1194 : struct.success) + for (String _iter1202 : struct.success) { - oprot.writeString(_iter1194); + oprot.writeString(_iter1202); } } } @@ -161416,13 +162540,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_master_keys_resu BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1195 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list1195.size); - String _elem1196; - for (int _i1197 = 0; _i1197 < _list1195.size; ++_i1197) + org.apache.thrift.protocol.TList _list1203 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list1203.size); + String _elem1204; + for (int _i1205 = 0; _i1205 < _list1203.size; ++_i1205) { - _elem1196 = iprot.readString(); - struct.success.add(_elem1196); + _elem1204 = iprot.readString(); + struct.success.add(_elem1204); } } struct.setSuccessIsSet(true); diff --git a/metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php b/metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php index 9bfc2b25232c..7eaf39589aca 100644 --- a/metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php +++ b/metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php @@ -201,6 +201,13 @@ public function drop_table($dbname, $name, $deleteData); * @throws \metastore\MetaException */ public function drop_table_with_environment_context($dbname, $name, $deleteData, \metastore\EnvironmentContext $environment_context); + /** + * @param string $dbName + * @param string $tableName + * @param string[] $partNames + * @throws \metastore\MetaException + */ + public function truncate_table($dbName, $tableName, array $partNames); /** * @param string $db_name * @param string $pattern @@ -2568,6 +2575,59 @@ public function recv_drop_table_with_environment_context() return; } + public function truncate_table($dbName, $tableName, array $partNames) + { + $this->send_truncate_table($dbName, $tableName, $partNames); + $this->recv_truncate_table(); + } + + public function send_truncate_table($dbName, $tableName, array $partNames) + { + $args = new \metastore\ThriftHiveMetastore_truncate_table_args(); + $args->dbName = $dbName; + $args->tableName = $tableName; + $args->partNames = $partNames; + $bin_accel = ($this->output_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_write_binary'); + if ($bin_accel) + { + thrift_protocol_write_binary($this->output_, 'truncate_table', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite()); + } + else + { + $this->output_->writeMessageBegin('truncate_table', TMessageType::CALL, $this->seqid_); + $args->write($this->output_); + $this->output_->writeMessageEnd(); + $this->output_->getTransport()->flush(); + } + } + + public function recv_truncate_table() + { + $bin_accel = ($this->input_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_read_binary'); + if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\metastore\ThriftHiveMetastore_truncate_table_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_truncate_table_result(); + $result->read($this->input_); + $this->input_->readMessageEnd(); + } + if ($result->o1 !== null) { + throw $result->o1; + } + return; + } + public function get_tables($db_name, $pattern) { $this->send_get_tables($db_name, $pattern); @@ -15329,6 +15389,230 @@ public function write($output) { } +class ThriftHiveMetastore_truncate_table_args { + static $_TSPEC; + + /** + * @var string + */ + public $dbName = null; + /** + * @var string + */ + public $tableName = null; + /** + * @var string[] + */ + public $partNames = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'dbName', + 'type' => TType::STRING, + ), + 2 => array( + 'var' => 'tableName', + 'type' => TType::STRING, + ), + 3 => array( + 'var' => 'partNames', + 'type' => TType::LST, + 'etype' => TType::STRING, + 'elem' => array( + 'type' => TType::STRING, + ), + ), + ); + } + if (is_array($vals)) { + if (isset($vals['dbName'])) { + $this->dbName = $vals['dbName']; + } + if (isset($vals['tableName'])) { + $this->tableName = $vals['tableName']; + } + if (isset($vals['partNames'])) { + $this->partNames = $vals['partNames']; + } + } + } + + public function getName() { + return 'ThriftHiveMetastore_truncate_table_args'; + } + + public function read($input) + { + $xfer = 0; + $fname = null; + $ftype = 0; + $fid = 0; + $xfer += $input->readStructBegin($fname); + while (true) + { + $xfer += $input->readFieldBegin($fname, $ftype, $fid); + if ($ftype == TType::STOP) { + break; + } + switch ($fid) + { + case 1: + if ($ftype == TType::STRING) { + $xfer += $input->readString($this->dbName); + } else { + $xfer += $input->skip($ftype); + } + break; + case 2: + if ($ftype == TType::STRING) { + $xfer += $input->readString($this->tableName); + } else { + $xfer += $input->skip($ftype); + } + break; + case 3: + if ($ftype == TType::LST) { + $this->partNames = array(); + $_size662 = 0; + $_etype665 = 0; + $xfer += $input->readListBegin($_etype665, $_size662); + for ($_i666 = 0; $_i666 < $_size662; ++$_i666) + { + $elem667 = null; + $xfer += $input->readString($elem667); + $this->partNames []= $elem667; + } + $xfer += $input->readListEnd(); + } 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_truncate_table_args'); + if ($this->dbName !== null) { + $xfer += $output->writeFieldBegin('dbName', TType::STRING, 1); + $xfer += $output->writeString($this->dbName); + $xfer += $output->writeFieldEnd(); + } + if ($this->tableName !== null) { + $xfer += $output->writeFieldBegin('tableName', TType::STRING, 2); + $xfer += $output->writeString($this->tableName); + $xfer += $output->writeFieldEnd(); + } + if ($this->partNames !== null) { + if (!is_array($this->partNames)) { + throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); + } + $xfer += $output->writeFieldBegin('partNames', TType::LST, 3); + { + $output->writeListBegin(TType::STRING, count($this->partNames)); + { + foreach ($this->partNames as $iter668) + { + $xfer += $output->writeString($iter668); + } + } + $output->writeListEnd(); + } + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class ThriftHiveMetastore_truncate_table_result { + static $_TSPEC; + + /** + * @var \metastore\MetaException + */ + public $o1 = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'o1', + 'type' => TType::STRUCT, + 'class' => '\metastore\MetaException', + ), + ); + } + if (is_array($vals)) { + if (isset($vals['o1'])) { + $this->o1 = $vals['o1']; + } + } + } + + public function getName() { + return 'ThriftHiveMetastore_truncate_table_result'; + } + + public function read($input) + { + $xfer = 0; + $fname = null; + $ftype = 0; + $fid = 0; + $xfer += $input->readStructBegin($fname); + while (true) + { + $xfer += $input->readFieldBegin($fname, $ftype, $fid); + if ($ftype == TType::STOP) { + break; + } + switch ($fid) + { + case 1: + if ($ftype == TType::STRUCT) { + $this->o1 = new \metastore\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_truncate_table_result'); + 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_tables_args { static $_TSPEC; @@ -15489,14 +15773,14 @@ public function read($input) case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size662 = 0; - $_etype665 = 0; - $xfer += $input->readListBegin($_etype665, $_size662); - for ($_i666 = 0; $_i666 < $_size662; ++$_i666) + $_size669 = 0; + $_etype672 = 0; + $xfer += $input->readListBegin($_etype672, $_size669); + for ($_i673 = 0; $_i673 < $_size669; ++$_i673) { - $elem667 = null; - $xfer += $input->readString($elem667); - $this->success []= $elem667; + $elem674 = null; + $xfer += $input->readString($elem674); + $this->success []= $elem674; } $xfer += $input->readListEnd(); } else { @@ -15532,9 +15816,9 @@ public function write($output) { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter668) + foreach ($this->success as $iter675) { - $xfer += $output->writeString($iter668); + $xfer += $output->writeString($iter675); } } $output->writeListEnd(); @@ -15736,14 +16020,14 @@ public function read($input) case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size669 = 0; - $_etype672 = 0; - $xfer += $input->readListBegin($_etype672, $_size669); - for ($_i673 = 0; $_i673 < $_size669; ++$_i673) + $_size676 = 0; + $_etype679 = 0; + $xfer += $input->readListBegin($_etype679, $_size676); + for ($_i680 = 0; $_i680 < $_size676; ++$_i680) { - $elem674 = null; - $xfer += $input->readString($elem674); - $this->success []= $elem674; + $elem681 = null; + $xfer += $input->readString($elem681); + $this->success []= $elem681; } $xfer += $input->readListEnd(); } else { @@ -15779,9 +16063,9 @@ public function write($output) { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter675) + foreach ($this->success as $iter682) { - $xfer += $output->writeString($iter675); + $xfer += $output->writeString($iter682); } } $output->writeListEnd(); @@ -15886,14 +16170,14 @@ public function read($input) case 3: if ($ftype == TType::LST) { $this->tbl_types = array(); - $_size676 = 0; - $_etype679 = 0; - $xfer += $input->readListBegin($_etype679, $_size676); - for ($_i680 = 0; $_i680 < $_size676; ++$_i680) + $_size683 = 0; + $_etype686 = 0; + $xfer += $input->readListBegin($_etype686, $_size683); + for ($_i687 = 0; $_i687 < $_size683; ++$_i687) { - $elem681 = null; - $xfer += $input->readString($elem681); - $this->tbl_types []= $elem681; + $elem688 = null; + $xfer += $input->readString($elem688); + $this->tbl_types []= $elem688; } $xfer += $input->readListEnd(); } else { @@ -15931,9 +16215,9 @@ public function write($output) { { $output->writeListBegin(TType::STRING, count($this->tbl_types)); { - foreach ($this->tbl_types as $iter682) + foreach ($this->tbl_types as $iter689) { - $xfer += $output->writeString($iter682); + $xfer += $output->writeString($iter689); } } $output->writeListEnd(); @@ -16010,15 +16294,15 @@ public function read($input) case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size683 = 0; - $_etype686 = 0; - $xfer += $input->readListBegin($_etype686, $_size683); - for ($_i687 = 0; $_i687 < $_size683; ++$_i687) + $_size690 = 0; + $_etype693 = 0; + $xfer += $input->readListBegin($_etype693, $_size690); + for ($_i694 = 0; $_i694 < $_size690; ++$_i694) { - $elem688 = null; - $elem688 = new \metastore\TableMeta(); - $xfer += $elem688->read($input); - $this->success []= $elem688; + $elem695 = null; + $elem695 = new \metastore\TableMeta(); + $xfer += $elem695->read($input); + $this->success []= $elem695; } $xfer += $input->readListEnd(); } else { @@ -16054,9 +16338,9 @@ public function write($output) { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter689) + foreach ($this->success as $iter696) { - $xfer += $iter689->write($output); + $xfer += $iter696->write($output); } } $output->writeListEnd(); @@ -16212,14 +16496,14 @@ public function read($input) case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size690 = 0; - $_etype693 = 0; - $xfer += $input->readListBegin($_etype693, $_size690); - for ($_i694 = 0; $_i694 < $_size690; ++$_i694) + $_size697 = 0; + $_etype700 = 0; + $xfer += $input->readListBegin($_etype700, $_size697); + for ($_i701 = 0; $_i701 < $_size697; ++$_i701) { - $elem695 = null; - $xfer += $input->readString($elem695); - $this->success []= $elem695; + $elem702 = null; + $xfer += $input->readString($elem702); + $this->success []= $elem702; } $xfer += $input->readListEnd(); } else { @@ -16255,9 +16539,9 @@ public function write($output) { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter696) + foreach ($this->success as $iter703) { - $xfer += $output->writeString($iter696); + $xfer += $output->writeString($iter703); } } $output->writeListEnd(); @@ -16572,14 +16856,14 @@ public function read($input) case 2: if ($ftype == TType::LST) { $this->tbl_names = array(); - $_size697 = 0; - $_etype700 = 0; - $xfer += $input->readListBegin($_etype700, $_size697); - for ($_i701 = 0; $_i701 < $_size697; ++$_i701) + $_size704 = 0; + $_etype707 = 0; + $xfer += $input->readListBegin($_etype707, $_size704); + for ($_i708 = 0; $_i708 < $_size704; ++$_i708) { - $elem702 = null; - $xfer += $input->readString($elem702); - $this->tbl_names []= $elem702; + $elem709 = null; + $xfer += $input->readString($elem709); + $this->tbl_names []= $elem709; } $xfer += $input->readListEnd(); } else { @@ -16612,9 +16896,9 @@ public function write($output) { { $output->writeListBegin(TType::STRING, count($this->tbl_names)); { - foreach ($this->tbl_names as $iter703) + foreach ($this->tbl_names as $iter710) { - $xfer += $output->writeString($iter703); + $xfer += $output->writeString($iter710); } } $output->writeListEnd(); @@ -16679,15 +16963,15 @@ public function read($input) case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size704 = 0; - $_etype707 = 0; - $xfer += $input->readListBegin($_etype707, $_size704); - for ($_i708 = 0; $_i708 < $_size704; ++$_i708) + $_size711 = 0; + $_etype714 = 0; + $xfer += $input->readListBegin($_etype714, $_size711); + for ($_i715 = 0; $_i715 < $_size711; ++$_i715) { - $elem709 = null; - $elem709 = new \metastore\Table(); - $xfer += $elem709->read($input); - $this->success []= $elem709; + $elem716 = null; + $elem716 = new \metastore\Table(); + $xfer += $elem716->read($input); + $this->success []= $elem716; } $xfer += $input->readListEnd(); } else { @@ -16715,9 +16999,9 @@ public function write($output) { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter710) + foreach ($this->success as $iter717) { - $xfer += $iter710->write($output); + $xfer += $iter717->write($output); } } $output->writeListEnd(); @@ -17383,14 +17667,14 @@ public function read($input) case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size711 = 0; - $_etype714 = 0; - $xfer += $input->readListBegin($_etype714, $_size711); - for ($_i715 = 0; $_i715 < $_size711; ++$_i715) + $_size718 = 0; + $_etype721 = 0; + $xfer += $input->readListBegin($_etype721, $_size718); + for ($_i722 = 0; $_i722 < $_size718; ++$_i722) { - $elem716 = null; - $xfer += $input->readString($elem716); - $this->success []= $elem716; + $elem723 = null; + $xfer += $input->readString($elem723); + $this->success []= $elem723; } $xfer += $input->readListEnd(); } else { @@ -17442,9 +17726,9 @@ public function write($output) { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter717) + foreach ($this->success as $iter724) { - $xfer += $output->writeString($iter717); + $xfer += $output->writeString($iter724); } } $output->writeListEnd(); @@ -18757,15 +19041,15 @@ public function read($input) case 1: if ($ftype == TType::LST) { $this->new_parts = array(); - $_size718 = 0; - $_etype721 = 0; - $xfer += $input->readListBegin($_etype721, $_size718); - for ($_i722 = 0; $_i722 < $_size718; ++$_i722) + $_size725 = 0; + $_etype728 = 0; + $xfer += $input->readListBegin($_etype728, $_size725); + for ($_i729 = 0; $_i729 < $_size725; ++$_i729) { - $elem723 = null; - $elem723 = new \metastore\Partition(); - $xfer += $elem723->read($input); - $this->new_parts []= $elem723; + $elem730 = null; + $elem730 = new \metastore\Partition(); + $xfer += $elem730->read($input); + $this->new_parts []= $elem730; } $xfer += $input->readListEnd(); } else { @@ -18793,9 +19077,9 @@ public function write($output) { { $output->writeListBegin(TType::STRUCT, count($this->new_parts)); { - foreach ($this->new_parts as $iter724) + foreach ($this->new_parts as $iter731) { - $xfer += $iter724->write($output); + $xfer += $iter731->write($output); } } $output->writeListEnd(); @@ -19010,15 +19294,15 @@ public function read($input) case 1: if ($ftype == TType::LST) { $this->new_parts = array(); - $_size725 = 0; - $_etype728 = 0; - $xfer += $input->readListBegin($_etype728, $_size725); - for ($_i729 = 0; $_i729 < $_size725; ++$_i729) + $_size732 = 0; + $_etype735 = 0; + $xfer += $input->readListBegin($_etype735, $_size732); + for ($_i736 = 0; $_i736 < $_size732; ++$_i736) { - $elem730 = null; - $elem730 = new \metastore\PartitionSpec(); - $xfer += $elem730->read($input); - $this->new_parts []= $elem730; + $elem737 = null; + $elem737 = new \metastore\PartitionSpec(); + $xfer += $elem737->read($input); + $this->new_parts []= $elem737; } $xfer += $input->readListEnd(); } else { @@ -19046,9 +19330,9 @@ public function write($output) { { $output->writeListBegin(TType::STRUCT, count($this->new_parts)); { - foreach ($this->new_parts as $iter731) + foreach ($this->new_parts as $iter738) { - $xfer += $iter731->write($output); + $xfer += $iter738->write($output); } } $output->writeListEnd(); @@ -19298,14 +19582,14 @@ public function read($input) case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size732 = 0; - $_etype735 = 0; - $xfer += $input->readListBegin($_etype735, $_size732); - for ($_i736 = 0; $_i736 < $_size732; ++$_i736) + $_size739 = 0; + $_etype742 = 0; + $xfer += $input->readListBegin($_etype742, $_size739); + for ($_i743 = 0; $_i743 < $_size739; ++$_i743) { - $elem737 = null; - $xfer += $input->readString($elem737); - $this->part_vals []= $elem737; + $elem744 = null; + $xfer += $input->readString($elem744); + $this->part_vals []= $elem744; } $xfer += $input->readListEnd(); } else { @@ -19343,9 +19627,9 @@ public function write($output) { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter738) + foreach ($this->part_vals as $iter745) { - $xfer += $output->writeString($iter738); + $xfer += $output->writeString($iter745); } } $output->writeListEnd(); @@ -19847,14 +20131,14 @@ public function read($input) case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size739 = 0; - $_etype742 = 0; - $xfer += $input->readListBegin($_etype742, $_size739); - for ($_i743 = 0; $_i743 < $_size739; ++$_i743) + $_size746 = 0; + $_etype749 = 0; + $xfer += $input->readListBegin($_etype749, $_size746); + for ($_i750 = 0; $_i750 < $_size746; ++$_i750) { - $elem744 = null; - $xfer += $input->readString($elem744); - $this->part_vals []= $elem744; + $elem751 = null; + $xfer += $input->readString($elem751); + $this->part_vals []= $elem751; } $xfer += $input->readListEnd(); } else { @@ -19900,9 +20184,9 @@ public function write($output) { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter745) + foreach ($this->part_vals as $iter752) { - $xfer += $output->writeString($iter745); + $xfer += $output->writeString($iter752); } } $output->writeListEnd(); @@ -20756,14 +21040,14 @@ public function read($input) case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size746 = 0; - $_etype749 = 0; - $xfer += $input->readListBegin($_etype749, $_size746); - for ($_i750 = 0; $_i750 < $_size746; ++$_i750) + $_size753 = 0; + $_etype756 = 0; + $xfer += $input->readListBegin($_etype756, $_size753); + for ($_i757 = 0; $_i757 < $_size753; ++$_i757) { - $elem751 = null; - $xfer += $input->readString($elem751); - $this->part_vals []= $elem751; + $elem758 = null; + $xfer += $input->readString($elem758); + $this->part_vals []= $elem758; } $xfer += $input->readListEnd(); } else { @@ -20808,9 +21092,9 @@ public function write($output) { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter752) + foreach ($this->part_vals as $iter759) { - $xfer += $output->writeString($iter752); + $xfer += $output->writeString($iter759); } } $output->writeListEnd(); @@ -21063,14 +21347,14 @@ public function read($input) case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size753 = 0; - $_etype756 = 0; - $xfer += $input->readListBegin($_etype756, $_size753); - for ($_i757 = 0; $_i757 < $_size753; ++$_i757) + $_size760 = 0; + $_etype763 = 0; + $xfer += $input->readListBegin($_etype763, $_size760); + for ($_i764 = 0; $_i764 < $_size760; ++$_i764) { - $elem758 = null; - $xfer += $input->readString($elem758); - $this->part_vals []= $elem758; + $elem765 = null; + $xfer += $input->readString($elem765); + $this->part_vals []= $elem765; } $xfer += $input->readListEnd(); } else { @@ -21123,9 +21407,9 @@ public function write($output) { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter759) + foreach ($this->part_vals as $iter766) { - $xfer += $output->writeString($iter759); + $xfer += $output->writeString($iter766); } } $output->writeListEnd(); @@ -22139,14 +22423,14 @@ public function read($input) case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size760 = 0; - $_etype763 = 0; - $xfer += $input->readListBegin($_etype763, $_size760); - for ($_i764 = 0; $_i764 < $_size760; ++$_i764) + $_size767 = 0; + $_etype770 = 0; + $xfer += $input->readListBegin($_etype770, $_size767); + for ($_i771 = 0; $_i771 < $_size767; ++$_i771) { - $elem765 = null; - $xfer += $input->readString($elem765); - $this->part_vals []= $elem765; + $elem772 = null; + $xfer += $input->readString($elem772); + $this->part_vals []= $elem772; } $xfer += $input->readListEnd(); } else { @@ -22184,9 +22468,9 @@ public function write($output) { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter766) + foreach ($this->part_vals as $iter773) { - $xfer += $output->writeString($iter766); + $xfer += $output->writeString($iter773); } } $output->writeListEnd(); @@ -22428,17 +22712,17 @@ public function read($input) case 1: if ($ftype == TType::MAP) { $this->partitionSpecs = array(); - $_size767 = 0; - $_ktype768 = 0; - $_vtype769 = 0; - $xfer += $input->readMapBegin($_ktype768, $_vtype769, $_size767); - for ($_i771 = 0; $_i771 < $_size767; ++$_i771) + $_size774 = 0; + $_ktype775 = 0; + $_vtype776 = 0; + $xfer += $input->readMapBegin($_ktype775, $_vtype776, $_size774); + for ($_i778 = 0; $_i778 < $_size774; ++$_i778) { - $key772 = ''; - $val773 = ''; - $xfer += $input->readString($key772); - $xfer += $input->readString($val773); - $this->partitionSpecs[$key772] = $val773; + $key779 = ''; + $val780 = ''; + $xfer += $input->readString($key779); + $xfer += $input->readString($val780); + $this->partitionSpecs[$key779] = $val780; } $xfer += $input->readMapEnd(); } else { @@ -22494,10 +22778,10 @@ public function write($output) { { $output->writeMapBegin(TType::STRING, TType::STRING, count($this->partitionSpecs)); { - foreach ($this->partitionSpecs as $kiter774 => $viter775) + foreach ($this->partitionSpecs as $kiter781 => $viter782) { - $xfer += $output->writeString($kiter774); - $xfer += $output->writeString($viter775); + $xfer += $output->writeString($kiter781); + $xfer += $output->writeString($viter782); } } $output->writeMapEnd(); @@ -22809,17 +23093,17 @@ public function read($input) case 1: if ($ftype == TType::MAP) { $this->partitionSpecs = array(); - $_size776 = 0; - $_ktype777 = 0; - $_vtype778 = 0; - $xfer += $input->readMapBegin($_ktype777, $_vtype778, $_size776); - for ($_i780 = 0; $_i780 < $_size776; ++$_i780) + $_size783 = 0; + $_ktype784 = 0; + $_vtype785 = 0; + $xfer += $input->readMapBegin($_ktype784, $_vtype785, $_size783); + for ($_i787 = 0; $_i787 < $_size783; ++$_i787) { - $key781 = ''; - $val782 = ''; - $xfer += $input->readString($key781); - $xfer += $input->readString($val782); - $this->partitionSpecs[$key781] = $val782; + $key788 = ''; + $val789 = ''; + $xfer += $input->readString($key788); + $xfer += $input->readString($val789); + $this->partitionSpecs[$key788] = $val789; } $xfer += $input->readMapEnd(); } else { @@ -22875,10 +23159,10 @@ public function write($output) { { $output->writeMapBegin(TType::STRING, TType::STRING, count($this->partitionSpecs)); { - foreach ($this->partitionSpecs as $kiter783 => $viter784) + foreach ($this->partitionSpecs as $kiter790 => $viter791) { - $xfer += $output->writeString($kiter783); - $xfer += $output->writeString($viter784); + $xfer += $output->writeString($kiter790); + $xfer += $output->writeString($viter791); } } $output->writeMapEnd(); @@ -23011,15 +23295,15 @@ public function read($input) case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size785 = 0; - $_etype788 = 0; - $xfer += $input->readListBegin($_etype788, $_size785); - for ($_i789 = 0; $_i789 < $_size785; ++$_i789) + $_size792 = 0; + $_etype795 = 0; + $xfer += $input->readListBegin($_etype795, $_size792); + for ($_i796 = 0; $_i796 < $_size792; ++$_i796) { - $elem790 = null; - $elem790 = new \metastore\Partition(); - $xfer += $elem790->read($input); - $this->success []= $elem790; + $elem797 = null; + $elem797 = new \metastore\Partition(); + $xfer += $elem797->read($input); + $this->success []= $elem797; } $xfer += $input->readListEnd(); } else { @@ -23079,9 +23363,9 @@ public function write($output) { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter791) + foreach ($this->success as $iter798) { - $xfer += $iter791->write($output); + $xfer += $iter798->write($output); } } $output->writeListEnd(); @@ -23227,14 +23511,14 @@ public function read($input) case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size792 = 0; - $_etype795 = 0; - $xfer += $input->readListBegin($_etype795, $_size792); - for ($_i796 = 0; $_i796 < $_size792; ++$_i796) + $_size799 = 0; + $_etype802 = 0; + $xfer += $input->readListBegin($_etype802, $_size799); + for ($_i803 = 0; $_i803 < $_size799; ++$_i803) { - $elem797 = null; - $xfer += $input->readString($elem797); - $this->part_vals []= $elem797; + $elem804 = null; + $xfer += $input->readString($elem804); + $this->part_vals []= $elem804; } $xfer += $input->readListEnd(); } else { @@ -23251,14 +23535,14 @@ public function read($input) case 5: if ($ftype == TType::LST) { $this->group_names = array(); - $_size798 = 0; - $_etype801 = 0; - $xfer += $input->readListBegin($_etype801, $_size798); - for ($_i802 = 0; $_i802 < $_size798; ++$_i802) + $_size805 = 0; + $_etype808 = 0; + $xfer += $input->readListBegin($_etype808, $_size805); + for ($_i809 = 0; $_i809 < $_size805; ++$_i809) { - $elem803 = null; - $xfer += $input->readString($elem803); - $this->group_names []= $elem803; + $elem810 = null; + $xfer += $input->readString($elem810); + $this->group_names []= $elem810; } $xfer += $input->readListEnd(); } else { @@ -23296,9 +23580,9 @@ public function write($output) { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter804) + foreach ($this->part_vals as $iter811) { - $xfer += $output->writeString($iter804); + $xfer += $output->writeString($iter811); } } $output->writeListEnd(); @@ -23318,9 +23602,9 @@ public function write($output) { { $output->writeListBegin(TType::STRING, count($this->group_names)); { - foreach ($this->group_names as $iter805) + foreach ($this->group_names as $iter812) { - $xfer += $output->writeString($iter805); + $xfer += $output->writeString($iter812); } } $output->writeListEnd(); @@ -23911,15 +24195,15 @@ public function read($input) case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size806 = 0; - $_etype809 = 0; - $xfer += $input->readListBegin($_etype809, $_size806); - for ($_i810 = 0; $_i810 < $_size806; ++$_i810) + $_size813 = 0; + $_etype816 = 0; + $xfer += $input->readListBegin($_etype816, $_size813); + for ($_i817 = 0; $_i817 < $_size813; ++$_i817) { - $elem811 = null; - $elem811 = new \metastore\Partition(); - $xfer += $elem811->read($input); - $this->success []= $elem811; + $elem818 = null; + $elem818 = new \metastore\Partition(); + $xfer += $elem818->read($input); + $this->success []= $elem818; } $xfer += $input->readListEnd(); } else { @@ -23963,9 +24247,9 @@ public function write($output) { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter812) + foreach ($this->success as $iter819) { - $xfer += $iter812->write($output); + $xfer += $iter819->write($output); } } $output->writeListEnd(); @@ -24111,14 +24395,14 @@ public function read($input) case 5: if ($ftype == TType::LST) { $this->group_names = array(); - $_size813 = 0; - $_etype816 = 0; - $xfer += $input->readListBegin($_etype816, $_size813); - for ($_i817 = 0; $_i817 < $_size813; ++$_i817) + $_size820 = 0; + $_etype823 = 0; + $xfer += $input->readListBegin($_etype823, $_size820); + for ($_i824 = 0; $_i824 < $_size820; ++$_i824) { - $elem818 = null; - $xfer += $input->readString($elem818); - $this->group_names []= $elem818; + $elem825 = null; + $xfer += $input->readString($elem825); + $this->group_names []= $elem825; } $xfer += $input->readListEnd(); } else { @@ -24166,9 +24450,9 @@ public function write($output) { { $output->writeListBegin(TType::STRING, count($this->group_names)); { - foreach ($this->group_names as $iter819) + foreach ($this->group_names as $iter826) { - $xfer += $output->writeString($iter819); + $xfer += $output->writeString($iter826); } } $output->writeListEnd(); @@ -24257,15 +24541,15 @@ public function read($input) case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size820 = 0; - $_etype823 = 0; - $xfer += $input->readListBegin($_etype823, $_size820); - for ($_i824 = 0; $_i824 < $_size820; ++$_i824) + $_size827 = 0; + $_etype830 = 0; + $xfer += $input->readListBegin($_etype830, $_size827); + for ($_i831 = 0; $_i831 < $_size827; ++$_i831) { - $elem825 = null; - $elem825 = new \metastore\Partition(); - $xfer += $elem825->read($input); - $this->success []= $elem825; + $elem832 = null; + $elem832 = new \metastore\Partition(); + $xfer += $elem832->read($input); + $this->success []= $elem832; } $xfer += $input->readListEnd(); } else { @@ -24309,9 +24593,9 @@ public function write($output) { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter826) + foreach ($this->success as $iter833) { - $xfer += $iter826->write($output); + $xfer += $iter833->write($output); } } $output->writeListEnd(); @@ -24531,15 +24815,15 @@ public function read($input) case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size827 = 0; - $_etype830 = 0; - $xfer += $input->readListBegin($_etype830, $_size827); - for ($_i831 = 0; $_i831 < $_size827; ++$_i831) + $_size834 = 0; + $_etype837 = 0; + $xfer += $input->readListBegin($_etype837, $_size834); + for ($_i838 = 0; $_i838 < $_size834; ++$_i838) { - $elem832 = null; - $elem832 = new \metastore\PartitionSpec(); - $xfer += $elem832->read($input); - $this->success []= $elem832; + $elem839 = null; + $elem839 = new \metastore\PartitionSpec(); + $xfer += $elem839->read($input); + $this->success []= $elem839; } $xfer += $input->readListEnd(); } else { @@ -24583,9 +24867,9 @@ public function write($output) { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter833) + foreach ($this->success as $iter840) { - $xfer += $iter833->write($output); + $xfer += $iter840->write($output); } } $output->writeListEnd(); @@ -24792,14 +25076,14 @@ public function read($input) case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size834 = 0; - $_etype837 = 0; - $xfer += $input->readListBegin($_etype837, $_size834); - for ($_i838 = 0; $_i838 < $_size834; ++$_i838) + $_size841 = 0; + $_etype844 = 0; + $xfer += $input->readListBegin($_etype844, $_size841); + for ($_i845 = 0; $_i845 < $_size841; ++$_i845) { - $elem839 = null; - $xfer += $input->readString($elem839); - $this->success []= $elem839; + $elem846 = null; + $xfer += $input->readString($elem846); + $this->success []= $elem846; } $xfer += $input->readListEnd(); } else { @@ -24835,9 +25119,9 @@ public function write($output) { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter840) + foreach ($this->success as $iter847) { - $xfer += $output->writeString($iter840); + $xfer += $output->writeString($iter847); } } $output->writeListEnd(); @@ -24953,14 +25237,14 @@ public function read($input) case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size841 = 0; - $_etype844 = 0; - $xfer += $input->readListBegin($_etype844, $_size841); - for ($_i845 = 0; $_i845 < $_size841; ++$_i845) + $_size848 = 0; + $_etype851 = 0; + $xfer += $input->readListBegin($_etype851, $_size848); + for ($_i852 = 0; $_i852 < $_size848; ++$_i852) { - $elem846 = null; - $xfer += $input->readString($elem846); - $this->part_vals []= $elem846; + $elem853 = null; + $xfer += $input->readString($elem853); + $this->part_vals []= $elem853; } $xfer += $input->readListEnd(); } else { @@ -25005,9 +25289,9 @@ public function write($output) { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter847) + foreach ($this->part_vals as $iter854) { - $xfer += $output->writeString($iter847); + $xfer += $output->writeString($iter854); } } $output->writeListEnd(); @@ -25101,15 +25385,15 @@ public function read($input) case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size848 = 0; - $_etype851 = 0; - $xfer += $input->readListBegin($_etype851, $_size848); - for ($_i852 = 0; $_i852 < $_size848; ++$_i852) + $_size855 = 0; + $_etype858 = 0; + $xfer += $input->readListBegin($_etype858, $_size855); + for ($_i859 = 0; $_i859 < $_size855; ++$_i859) { - $elem853 = null; - $elem853 = new \metastore\Partition(); - $xfer += $elem853->read($input); - $this->success []= $elem853; + $elem860 = null; + $elem860 = new \metastore\Partition(); + $xfer += $elem860->read($input); + $this->success []= $elem860; } $xfer += $input->readListEnd(); } else { @@ -25153,9 +25437,9 @@ public function write($output) { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter854) + foreach ($this->success as $iter861) { - $xfer += $iter854->write($output); + $xfer += $iter861->write($output); } } $output->writeListEnd(); @@ -25302,14 +25586,14 @@ public function read($input) case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size855 = 0; - $_etype858 = 0; - $xfer += $input->readListBegin($_etype858, $_size855); - for ($_i859 = 0; $_i859 < $_size855; ++$_i859) + $_size862 = 0; + $_etype865 = 0; + $xfer += $input->readListBegin($_etype865, $_size862); + for ($_i866 = 0; $_i866 < $_size862; ++$_i866) { - $elem860 = null; - $xfer += $input->readString($elem860); - $this->part_vals []= $elem860; + $elem867 = null; + $xfer += $input->readString($elem867); + $this->part_vals []= $elem867; } $xfer += $input->readListEnd(); } else { @@ -25333,14 +25617,14 @@ public function read($input) case 6: if ($ftype == TType::LST) { $this->group_names = array(); - $_size861 = 0; - $_etype864 = 0; - $xfer += $input->readListBegin($_etype864, $_size861); - for ($_i865 = 0; $_i865 < $_size861; ++$_i865) + $_size868 = 0; + $_etype871 = 0; + $xfer += $input->readListBegin($_etype871, $_size868); + for ($_i872 = 0; $_i872 < $_size868; ++$_i872) { - $elem866 = null; - $xfer += $input->readString($elem866); - $this->group_names []= $elem866; + $elem873 = null; + $xfer += $input->readString($elem873); + $this->group_names []= $elem873; } $xfer += $input->readListEnd(); } else { @@ -25378,9 +25662,9 @@ public function write($output) { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter867) + foreach ($this->part_vals as $iter874) { - $xfer += $output->writeString($iter867); + $xfer += $output->writeString($iter874); } } $output->writeListEnd(); @@ -25405,9 +25689,9 @@ public function write($output) { { $output->writeListBegin(TType::STRING, count($this->group_names)); { - foreach ($this->group_names as $iter868) + foreach ($this->group_names as $iter875) { - $xfer += $output->writeString($iter868); + $xfer += $output->writeString($iter875); } } $output->writeListEnd(); @@ -25496,15 +25780,15 @@ public function read($input) case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size869 = 0; - $_etype872 = 0; - $xfer += $input->readListBegin($_etype872, $_size869); - for ($_i873 = 0; $_i873 < $_size869; ++$_i873) + $_size876 = 0; + $_etype879 = 0; + $xfer += $input->readListBegin($_etype879, $_size876); + for ($_i880 = 0; $_i880 < $_size876; ++$_i880) { - $elem874 = null; - $elem874 = new \metastore\Partition(); - $xfer += $elem874->read($input); - $this->success []= $elem874; + $elem881 = null; + $elem881 = new \metastore\Partition(); + $xfer += $elem881->read($input); + $this->success []= $elem881; } $xfer += $input->readListEnd(); } else { @@ -25548,9 +25832,9 @@ public function write($output) { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter875) + foreach ($this->success as $iter882) { - $xfer += $iter875->write($output); + $xfer += $iter882->write($output); } } $output->writeListEnd(); @@ -25671,14 +25955,14 @@ public function read($input) case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size876 = 0; - $_etype879 = 0; - $xfer += $input->readListBegin($_etype879, $_size876); - for ($_i880 = 0; $_i880 < $_size876; ++$_i880) + $_size883 = 0; + $_etype886 = 0; + $xfer += $input->readListBegin($_etype886, $_size883); + for ($_i887 = 0; $_i887 < $_size883; ++$_i887) { - $elem881 = null; - $xfer += $input->readString($elem881); - $this->part_vals []= $elem881; + $elem888 = null; + $xfer += $input->readString($elem888); + $this->part_vals []= $elem888; } $xfer += $input->readListEnd(); } else { @@ -25723,9 +26007,9 @@ public function write($output) { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter882) + foreach ($this->part_vals as $iter889) { - $xfer += $output->writeString($iter882); + $xfer += $output->writeString($iter889); } } $output->writeListEnd(); @@ -25818,14 +26102,14 @@ public function read($input) case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size883 = 0; - $_etype886 = 0; - $xfer += $input->readListBegin($_etype886, $_size883); - for ($_i887 = 0; $_i887 < $_size883; ++$_i887) + $_size890 = 0; + $_etype893 = 0; + $xfer += $input->readListBegin($_etype893, $_size890); + for ($_i894 = 0; $_i894 < $_size890; ++$_i894) { - $elem888 = null; - $xfer += $input->readString($elem888); - $this->success []= $elem888; + $elem895 = null; + $xfer += $input->readString($elem895); + $this->success []= $elem895; } $xfer += $input->readListEnd(); } else { @@ -25869,9 +26153,9 @@ public function write($output) { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter889) + foreach ($this->success as $iter896) { - $xfer += $output->writeString($iter889); + $xfer += $output->writeString($iter896); } } $output->writeListEnd(); @@ -26114,15 +26398,15 @@ public function read($input) case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size890 = 0; - $_etype893 = 0; - $xfer += $input->readListBegin($_etype893, $_size890); - for ($_i894 = 0; $_i894 < $_size890; ++$_i894) + $_size897 = 0; + $_etype900 = 0; + $xfer += $input->readListBegin($_etype900, $_size897); + for ($_i901 = 0; $_i901 < $_size897; ++$_i901) { - $elem895 = null; - $elem895 = new \metastore\Partition(); - $xfer += $elem895->read($input); - $this->success []= $elem895; + $elem902 = null; + $elem902 = new \metastore\Partition(); + $xfer += $elem902->read($input); + $this->success []= $elem902; } $xfer += $input->readListEnd(); } else { @@ -26166,9 +26450,9 @@ public function write($output) { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter896) + foreach ($this->success as $iter903) { - $xfer += $iter896->write($output); + $xfer += $iter903->write($output); } } $output->writeListEnd(); @@ -26411,15 +26695,15 @@ public function read($input) case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size897 = 0; - $_etype900 = 0; - $xfer += $input->readListBegin($_etype900, $_size897); - for ($_i901 = 0; $_i901 < $_size897; ++$_i901) + $_size904 = 0; + $_etype907 = 0; + $xfer += $input->readListBegin($_etype907, $_size904); + for ($_i908 = 0; $_i908 < $_size904; ++$_i908) { - $elem902 = null; - $elem902 = new \metastore\PartitionSpec(); - $xfer += $elem902->read($input); - $this->success []= $elem902; + $elem909 = null; + $elem909 = new \metastore\PartitionSpec(); + $xfer += $elem909->read($input); + $this->success []= $elem909; } $xfer += $input->readListEnd(); } else { @@ -26463,9 +26747,9 @@ public function write($output) { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter903) + foreach ($this->success as $iter910) { - $xfer += $iter903->write($output); + $xfer += $iter910->write($output); } } $output->writeListEnd(); @@ -27031,14 +27315,14 @@ public function read($input) case 3: if ($ftype == TType::LST) { $this->names = array(); - $_size904 = 0; - $_etype907 = 0; - $xfer += $input->readListBegin($_etype907, $_size904); - for ($_i908 = 0; $_i908 < $_size904; ++$_i908) + $_size911 = 0; + $_etype914 = 0; + $xfer += $input->readListBegin($_etype914, $_size911); + for ($_i915 = 0; $_i915 < $_size911; ++$_i915) { - $elem909 = null; - $xfer += $input->readString($elem909); - $this->names []= $elem909; + $elem916 = null; + $xfer += $input->readString($elem916); + $this->names []= $elem916; } $xfer += $input->readListEnd(); } else { @@ -27076,9 +27360,9 @@ public function write($output) { { $output->writeListBegin(TType::STRING, count($this->names)); { - foreach ($this->names as $iter910) + foreach ($this->names as $iter917) { - $xfer += $output->writeString($iter910); + $xfer += $output->writeString($iter917); } } $output->writeListEnd(); @@ -27167,15 +27451,15 @@ public function read($input) case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size911 = 0; - $_etype914 = 0; - $xfer += $input->readListBegin($_etype914, $_size911); - for ($_i915 = 0; $_i915 < $_size911; ++$_i915) + $_size918 = 0; + $_etype921 = 0; + $xfer += $input->readListBegin($_etype921, $_size918); + for ($_i922 = 0; $_i922 < $_size918; ++$_i922) { - $elem916 = null; - $elem916 = new \metastore\Partition(); - $xfer += $elem916->read($input); - $this->success []= $elem916; + $elem923 = null; + $elem923 = new \metastore\Partition(); + $xfer += $elem923->read($input); + $this->success []= $elem923; } $xfer += $input->readListEnd(); } else { @@ -27219,9 +27503,9 @@ public function write($output) { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter917) + foreach ($this->success as $iter924) { - $xfer += $iter917->write($output); + $xfer += $iter924->write($output); } } $output->writeListEnd(); @@ -27560,15 +27844,15 @@ public function read($input) case 3: if ($ftype == TType::LST) { $this->new_parts = array(); - $_size918 = 0; - $_etype921 = 0; - $xfer += $input->readListBegin($_etype921, $_size918); - for ($_i922 = 0; $_i922 < $_size918; ++$_i922) + $_size925 = 0; + $_etype928 = 0; + $xfer += $input->readListBegin($_etype928, $_size925); + for ($_i929 = 0; $_i929 < $_size925; ++$_i929) { - $elem923 = null; - $elem923 = new \metastore\Partition(); - $xfer += $elem923->read($input); - $this->new_parts []= $elem923; + $elem930 = null; + $elem930 = new \metastore\Partition(); + $xfer += $elem930->read($input); + $this->new_parts []= $elem930; } $xfer += $input->readListEnd(); } else { @@ -27606,9 +27890,9 @@ public function write($output) { { $output->writeListBegin(TType::STRUCT, count($this->new_parts)); { - foreach ($this->new_parts as $iter924) + foreach ($this->new_parts as $iter931) { - $xfer += $iter924->write($output); + $xfer += $iter931->write($output); } } $output->writeListEnd(); @@ -27823,15 +28107,15 @@ public function read($input) case 3: if ($ftype == TType::LST) { $this->new_parts = array(); - $_size925 = 0; - $_etype928 = 0; - $xfer += $input->readListBegin($_etype928, $_size925); - for ($_i929 = 0; $_i929 < $_size925; ++$_i929) + $_size932 = 0; + $_etype935 = 0; + $xfer += $input->readListBegin($_etype935, $_size932); + for ($_i936 = 0; $_i936 < $_size932; ++$_i936) { - $elem930 = null; - $elem930 = new \metastore\Partition(); - $xfer += $elem930->read($input); - $this->new_parts []= $elem930; + $elem937 = null; + $elem937 = new \metastore\Partition(); + $xfer += $elem937->read($input); + $this->new_parts []= $elem937; } $xfer += $input->readListEnd(); } else { @@ -27877,9 +28161,9 @@ public function write($output) { { $output->writeListBegin(TType::STRUCT, count($this->new_parts)); { - foreach ($this->new_parts as $iter931) + foreach ($this->new_parts as $iter938) { - $xfer += $iter931->write($output); + $xfer += $iter938->write($output); } } $output->writeListEnd(); @@ -28357,14 +28641,14 @@ public function read($input) case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size932 = 0; - $_etype935 = 0; - $xfer += $input->readListBegin($_etype935, $_size932); - for ($_i936 = 0; $_i936 < $_size932; ++$_i936) + $_size939 = 0; + $_etype942 = 0; + $xfer += $input->readListBegin($_etype942, $_size939); + for ($_i943 = 0; $_i943 < $_size939; ++$_i943) { - $elem937 = null; - $xfer += $input->readString($elem937); - $this->part_vals []= $elem937; + $elem944 = null; + $xfer += $input->readString($elem944); + $this->part_vals []= $elem944; } $xfer += $input->readListEnd(); } else { @@ -28410,9 +28694,9 @@ public function write($output) { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter938) + foreach ($this->part_vals as $iter945) { - $xfer += $output->writeString($iter938); + $xfer += $output->writeString($iter945); } } $output->writeListEnd(); @@ -28597,14 +28881,14 @@ public function read($input) case 1: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size939 = 0; - $_etype942 = 0; - $xfer += $input->readListBegin($_etype942, $_size939); - for ($_i943 = 0; $_i943 < $_size939; ++$_i943) + $_size946 = 0; + $_etype949 = 0; + $xfer += $input->readListBegin($_etype949, $_size946); + for ($_i950 = 0; $_i950 < $_size946; ++$_i950) { - $elem944 = null; - $xfer += $input->readString($elem944); - $this->part_vals []= $elem944; + $elem951 = null; + $xfer += $input->readString($elem951); + $this->part_vals []= $elem951; } $xfer += $input->readListEnd(); } else { @@ -28639,9 +28923,9 @@ public function write($output) { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter945) + foreach ($this->part_vals as $iter952) { - $xfer += $output->writeString($iter945); + $xfer += $output->writeString($iter952); } } $output->writeListEnd(); @@ -29095,14 +29379,14 @@ public function read($input) case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size946 = 0; - $_etype949 = 0; - $xfer += $input->readListBegin($_etype949, $_size946); - for ($_i950 = 0; $_i950 < $_size946; ++$_i950) + $_size953 = 0; + $_etype956 = 0; + $xfer += $input->readListBegin($_etype956, $_size953); + for ($_i957 = 0; $_i957 < $_size953; ++$_i957) { - $elem951 = null; - $xfer += $input->readString($elem951); - $this->success []= $elem951; + $elem958 = null; + $xfer += $input->readString($elem958); + $this->success []= $elem958; } $xfer += $input->readListEnd(); } else { @@ -29138,9 +29422,9 @@ public function write($output) { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter952) + foreach ($this->success as $iter959) { - $xfer += $output->writeString($iter952); + $xfer += $output->writeString($iter959); } } $output->writeListEnd(); @@ -29300,17 +29584,17 @@ public function read($input) case 0: if ($ftype == TType::MAP) { $this->success = array(); - $_size953 = 0; - $_ktype954 = 0; - $_vtype955 = 0; - $xfer += $input->readMapBegin($_ktype954, $_vtype955, $_size953); - for ($_i957 = 0; $_i957 < $_size953; ++$_i957) + $_size960 = 0; + $_ktype961 = 0; + $_vtype962 = 0; + $xfer += $input->readMapBegin($_ktype961, $_vtype962, $_size960); + for ($_i964 = 0; $_i964 < $_size960; ++$_i964) { - $key958 = ''; - $val959 = ''; - $xfer += $input->readString($key958); - $xfer += $input->readString($val959); - $this->success[$key958] = $val959; + $key965 = ''; + $val966 = ''; + $xfer += $input->readString($key965); + $xfer += $input->readString($val966); + $this->success[$key965] = $val966; } $xfer += $input->readMapEnd(); } else { @@ -29346,10 +29630,10 @@ public function write($output) { { $output->writeMapBegin(TType::STRING, TType::STRING, count($this->success)); { - foreach ($this->success as $kiter960 => $viter961) + foreach ($this->success as $kiter967 => $viter968) { - $xfer += $output->writeString($kiter960); - $xfer += $output->writeString($viter961); + $xfer += $output->writeString($kiter967); + $xfer += $output->writeString($viter968); } } $output->writeMapEnd(); @@ -29469,17 +29753,17 @@ public function read($input) case 3: if ($ftype == TType::MAP) { $this->part_vals = array(); - $_size962 = 0; - $_ktype963 = 0; - $_vtype964 = 0; - $xfer += $input->readMapBegin($_ktype963, $_vtype964, $_size962); - for ($_i966 = 0; $_i966 < $_size962; ++$_i966) + $_size969 = 0; + $_ktype970 = 0; + $_vtype971 = 0; + $xfer += $input->readMapBegin($_ktype970, $_vtype971, $_size969); + for ($_i973 = 0; $_i973 < $_size969; ++$_i973) { - $key967 = ''; - $val968 = ''; - $xfer += $input->readString($key967); - $xfer += $input->readString($val968); - $this->part_vals[$key967] = $val968; + $key974 = ''; + $val975 = ''; + $xfer += $input->readString($key974); + $xfer += $input->readString($val975); + $this->part_vals[$key974] = $val975; } $xfer += $input->readMapEnd(); } else { @@ -29524,10 +29808,10 @@ public function write($output) { { $output->writeMapBegin(TType::STRING, TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $kiter969 => $viter970) + foreach ($this->part_vals as $kiter976 => $viter977) { - $xfer += $output->writeString($kiter969); - $xfer += $output->writeString($viter970); + $xfer += $output->writeString($kiter976); + $xfer += $output->writeString($viter977); } } $output->writeMapEnd(); @@ -29849,17 +30133,17 @@ public function read($input) case 3: if ($ftype == TType::MAP) { $this->part_vals = array(); - $_size971 = 0; - $_ktype972 = 0; - $_vtype973 = 0; - $xfer += $input->readMapBegin($_ktype972, $_vtype973, $_size971); - for ($_i975 = 0; $_i975 < $_size971; ++$_i975) + $_size978 = 0; + $_ktype979 = 0; + $_vtype980 = 0; + $xfer += $input->readMapBegin($_ktype979, $_vtype980, $_size978); + for ($_i982 = 0; $_i982 < $_size978; ++$_i982) { - $key976 = ''; - $val977 = ''; - $xfer += $input->readString($key976); - $xfer += $input->readString($val977); - $this->part_vals[$key976] = $val977; + $key983 = ''; + $val984 = ''; + $xfer += $input->readString($key983); + $xfer += $input->readString($val984); + $this->part_vals[$key983] = $val984; } $xfer += $input->readMapEnd(); } else { @@ -29904,10 +30188,10 @@ public function write($output) { { $output->writeMapBegin(TType::STRING, TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $kiter978 => $viter979) + foreach ($this->part_vals as $kiter985 => $viter986) { - $xfer += $output->writeString($kiter978); - $xfer += $output->writeString($viter979); + $xfer += $output->writeString($kiter985); + $xfer += $output->writeString($viter986); } } $output->writeMapEnd(); @@ -31381,15 +31665,15 @@ public function read($input) case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size980 = 0; - $_etype983 = 0; - $xfer += $input->readListBegin($_etype983, $_size980); - for ($_i984 = 0; $_i984 < $_size980; ++$_i984) + $_size987 = 0; + $_etype990 = 0; + $xfer += $input->readListBegin($_etype990, $_size987); + for ($_i991 = 0; $_i991 < $_size987; ++$_i991) { - $elem985 = null; - $elem985 = new \metastore\Index(); - $xfer += $elem985->read($input); - $this->success []= $elem985; + $elem992 = null; + $elem992 = new \metastore\Index(); + $xfer += $elem992->read($input); + $this->success []= $elem992; } $xfer += $input->readListEnd(); } else { @@ -31433,9 +31717,9 @@ public function write($output) { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter986) + foreach ($this->success as $iter993) { - $xfer += $iter986->write($output); + $xfer += $iter993->write($output); } } $output->writeListEnd(); @@ -31642,14 +31926,14 @@ public function read($input) case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size987 = 0; - $_etype990 = 0; - $xfer += $input->readListBegin($_etype990, $_size987); - for ($_i991 = 0; $_i991 < $_size987; ++$_i991) + $_size994 = 0; + $_etype997 = 0; + $xfer += $input->readListBegin($_etype997, $_size994); + for ($_i998 = 0; $_i998 < $_size994; ++$_i998) { - $elem992 = null; - $xfer += $input->readString($elem992); - $this->success []= $elem992; + $elem999 = null; + $xfer += $input->readString($elem999); + $this->success []= $elem999; } $xfer += $input->readListEnd(); } else { @@ -31685,9 +31969,9 @@ public function write($output) { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter993) + foreach ($this->success as $iter1000) { - $xfer += $output->writeString($iter993); + $xfer += $output->writeString($iter1000); } } $output->writeListEnd(); @@ -35581,14 +35865,14 @@ public function read($input) case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size994 = 0; - $_etype997 = 0; - $xfer += $input->readListBegin($_etype997, $_size994); - for ($_i998 = 0; $_i998 < $_size994; ++$_i998) + $_size1001 = 0; + $_etype1004 = 0; + $xfer += $input->readListBegin($_etype1004, $_size1001); + for ($_i1005 = 0; $_i1005 < $_size1001; ++$_i1005) { - $elem999 = null; - $xfer += $input->readString($elem999); - $this->success []= $elem999; + $elem1006 = null; + $xfer += $input->readString($elem1006); + $this->success []= $elem1006; } $xfer += $input->readListEnd(); } else { @@ -35624,9 +35908,9 @@ public function write($output) { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter1000) + foreach ($this->success as $iter1007) { - $xfer += $output->writeString($iter1000); + $xfer += $output->writeString($iter1007); } } $output->writeListEnd(); @@ -36495,14 +36779,14 @@ public function read($input) case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size1001 = 0; - $_etype1004 = 0; - $xfer += $input->readListBegin($_etype1004, $_size1001); - for ($_i1005 = 0; $_i1005 < $_size1001; ++$_i1005) + $_size1008 = 0; + $_etype1011 = 0; + $xfer += $input->readListBegin($_etype1011, $_size1008); + for ($_i1012 = 0; $_i1012 < $_size1008; ++$_i1012) { - $elem1006 = null; - $xfer += $input->readString($elem1006); - $this->success []= $elem1006; + $elem1013 = null; + $xfer += $input->readString($elem1013); + $this->success []= $elem1013; } $xfer += $input->readListEnd(); } else { @@ -36538,9 +36822,9 @@ public function write($output) { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter1007) + foreach ($this->success as $iter1014) { - $xfer += $output->writeString($iter1007); + $xfer += $output->writeString($iter1014); } } $output->writeListEnd(); @@ -37231,15 +37515,15 @@ public function read($input) case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size1008 = 0; - $_etype1011 = 0; - $xfer += $input->readListBegin($_etype1011, $_size1008); - for ($_i1012 = 0; $_i1012 < $_size1008; ++$_i1012) + $_size1015 = 0; + $_etype1018 = 0; + $xfer += $input->readListBegin($_etype1018, $_size1015); + for ($_i1019 = 0; $_i1019 < $_size1015; ++$_i1019) { - $elem1013 = null; - $elem1013 = new \metastore\Role(); - $xfer += $elem1013->read($input); - $this->success []= $elem1013; + $elem1020 = null; + $elem1020 = new \metastore\Role(); + $xfer += $elem1020->read($input); + $this->success []= $elem1020; } $xfer += $input->readListEnd(); } else { @@ -37275,9 +37559,9 @@ public function write($output) { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter1014) + foreach ($this->success as $iter1021) { - $xfer += $iter1014->write($output); + $xfer += $iter1021->write($output); } } $output->writeListEnd(); @@ -37939,14 +38223,14 @@ public function read($input) case 3: if ($ftype == TType::LST) { $this->group_names = array(); - $_size1015 = 0; - $_etype1018 = 0; - $xfer += $input->readListBegin($_etype1018, $_size1015); - for ($_i1019 = 0; $_i1019 < $_size1015; ++$_i1019) + $_size1022 = 0; + $_etype1025 = 0; + $xfer += $input->readListBegin($_etype1025, $_size1022); + for ($_i1026 = 0; $_i1026 < $_size1022; ++$_i1026) { - $elem1020 = null; - $xfer += $input->readString($elem1020); - $this->group_names []= $elem1020; + $elem1027 = null; + $xfer += $input->readString($elem1027); + $this->group_names []= $elem1027; } $xfer += $input->readListEnd(); } else { @@ -37987,9 +38271,9 @@ public function write($output) { { $output->writeListBegin(TType::STRING, count($this->group_names)); { - foreach ($this->group_names as $iter1021) + foreach ($this->group_names as $iter1028) { - $xfer += $output->writeString($iter1021); + $xfer += $output->writeString($iter1028); } } $output->writeListEnd(); @@ -38297,15 +38581,15 @@ public function read($input) case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size1022 = 0; - $_etype1025 = 0; - $xfer += $input->readListBegin($_etype1025, $_size1022); - for ($_i1026 = 0; $_i1026 < $_size1022; ++$_i1026) + $_size1029 = 0; + $_etype1032 = 0; + $xfer += $input->readListBegin($_etype1032, $_size1029); + for ($_i1033 = 0; $_i1033 < $_size1029; ++$_i1033) { - $elem1027 = null; - $elem1027 = new \metastore\HiveObjectPrivilege(); - $xfer += $elem1027->read($input); - $this->success []= $elem1027; + $elem1034 = null; + $elem1034 = new \metastore\HiveObjectPrivilege(); + $xfer += $elem1034->read($input); + $this->success []= $elem1034; } $xfer += $input->readListEnd(); } else { @@ -38341,9 +38625,9 @@ public function write($output) { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter1028) + foreach ($this->success as $iter1035) { - $xfer += $iter1028->write($output); + $xfer += $iter1035->write($output); } } $output->writeListEnd(); @@ -38975,14 +39259,14 @@ public function read($input) case 2: if ($ftype == TType::LST) { $this->group_names = array(); - $_size1029 = 0; - $_etype1032 = 0; - $xfer += $input->readListBegin($_etype1032, $_size1029); - for ($_i1033 = 0; $_i1033 < $_size1029; ++$_i1033) + $_size1036 = 0; + $_etype1039 = 0; + $xfer += $input->readListBegin($_etype1039, $_size1036); + for ($_i1040 = 0; $_i1040 < $_size1036; ++$_i1040) { - $elem1034 = null; - $xfer += $input->readString($elem1034); - $this->group_names []= $elem1034; + $elem1041 = null; + $xfer += $input->readString($elem1041); + $this->group_names []= $elem1041; } $xfer += $input->readListEnd(); } else { @@ -39015,9 +39299,9 @@ public function write($output) { { $output->writeListBegin(TType::STRING, count($this->group_names)); { - foreach ($this->group_names as $iter1035) + foreach ($this->group_names as $iter1042) { - $xfer += $output->writeString($iter1035); + $xfer += $output->writeString($iter1042); } } $output->writeListEnd(); @@ -39093,14 +39377,14 @@ public function read($input) case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size1036 = 0; - $_etype1039 = 0; - $xfer += $input->readListBegin($_etype1039, $_size1036); - for ($_i1040 = 0; $_i1040 < $_size1036; ++$_i1040) + $_size1043 = 0; + $_etype1046 = 0; + $xfer += $input->readListBegin($_etype1046, $_size1043); + for ($_i1047 = 0; $_i1047 < $_size1043; ++$_i1047) { - $elem1041 = null; - $xfer += $input->readString($elem1041); - $this->success []= $elem1041; + $elem1048 = null; + $xfer += $input->readString($elem1048); + $this->success []= $elem1048; } $xfer += $input->readListEnd(); } else { @@ -39136,9 +39420,9 @@ public function write($output) { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter1042) + foreach ($this->success as $iter1049) { - $xfer += $output->writeString($iter1042); + $xfer += $output->writeString($iter1049); } } $output->writeListEnd(); @@ -40255,14 +40539,14 @@ public function read($input) case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size1043 = 0; - $_etype1046 = 0; - $xfer += $input->readListBegin($_etype1046, $_size1043); - for ($_i1047 = 0; $_i1047 < $_size1043; ++$_i1047) + $_size1050 = 0; + $_etype1053 = 0; + $xfer += $input->readListBegin($_etype1053, $_size1050); + for ($_i1054 = 0; $_i1054 < $_size1050; ++$_i1054) { - $elem1048 = null; - $xfer += $input->readString($elem1048); - $this->success []= $elem1048; + $elem1055 = null; + $xfer += $input->readString($elem1055); + $this->success []= $elem1055; } $xfer += $input->readListEnd(); } else { @@ -40290,9 +40574,9 @@ public function write($output) { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter1049) + foreach ($this->success as $iter1056) { - $xfer += $output->writeString($iter1049); + $xfer += $output->writeString($iter1056); } } $output->writeListEnd(); @@ -40931,14 +41215,14 @@ public function read($input) case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size1050 = 0; - $_etype1053 = 0; - $xfer += $input->readListBegin($_etype1053, $_size1050); - for ($_i1054 = 0; $_i1054 < $_size1050; ++$_i1054) + $_size1057 = 0; + $_etype1060 = 0; + $xfer += $input->readListBegin($_etype1060, $_size1057); + for ($_i1061 = 0; $_i1061 < $_size1057; ++$_i1061) { - $elem1055 = null; - $xfer += $input->readString($elem1055); - $this->success []= $elem1055; + $elem1062 = null; + $xfer += $input->readString($elem1062); + $this->success []= $elem1062; } $xfer += $input->readListEnd(); } else { @@ -40966,9 +41250,9 @@ public function write($output) { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter1056) + foreach ($this->success as $iter1063) { - $xfer += $output->writeString($iter1056); + $xfer += $output->writeString($iter1063); } } $output->writeListEnd(); 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 5c247075ef89..f2a97997a4aa 100755 --- a/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote +++ b/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote @@ -48,6 +48,7 @@ if len(sys.argv) <= 1 or sys.argv[1] == '--help': print(' void add_foreign_key(AddForeignKeyRequest req)') print(' void drop_table(string dbname, string name, bool deleteData)') print(' void drop_table_with_environment_context(string dbname, string name, bool deleteData, EnvironmentContext environment_context)') + print(' void truncate_table(string dbName, string tableName, partNames)') print(' get_tables(string db_name, string pattern)') print(' get_tables_by_type(string db_name, string pattern, string tableType)') print(' get_table_meta(string db_patterns, string tbl_patterns, tbl_types)') @@ -390,6 +391,12 @@ elif cmd == 'drop_table_with_environment_context': sys.exit(1) pp.pprint(client.drop_table_with_environment_context(args[0],args[1],eval(args[2]),eval(args[3]),)) +elif cmd == 'truncate_table': + if len(args) != 3: + print('truncate_table requires 3 args') + sys.exit(1) + pp.pprint(client.truncate_table(args[0],args[1],eval(args[2]),)) + elif cmd == 'get_tables': if len(args) != 2: print('get_tables requires 2 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 86bbef38f4ad..8ee84af14f87 100644 --- a/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py +++ b/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py @@ -205,6 +205,15 @@ def drop_table_with_environment_context(self, dbname, name, deleteData, environm """ pass + def truncate_table(self, dbName, tableName, partNames): + """ + Parameters: + - dbName + - tableName + - partNames + """ + pass + def get_tables(self, db_name, pattern): """ Parameters: @@ -2101,6 +2110,41 @@ def recv_drop_table_with_environment_context(self): raise result.o3 return + def truncate_table(self, dbName, tableName, partNames): + """ + Parameters: + - dbName + - tableName + - partNames + """ + self.send_truncate_table(dbName, tableName, partNames) + self.recv_truncate_table() + + def send_truncate_table(self, dbName, tableName, partNames): + self._oprot.writeMessageBegin('truncate_table', TMessageType.CALL, self._seqid) + args = truncate_table_args() + args.dbName = dbName + args.tableName = tableName + args.partNames = partNames + args.write(self._oprot) + self._oprot.writeMessageEnd() + self._oprot.trans.flush() + + def recv_truncate_table(self): + iprot = self._iprot + (fname, mtype, rseqid) = iprot.readMessageBegin() + if mtype == TMessageType.EXCEPTION: + x = TApplicationException() + x.read(iprot) + iprot.readMessageEnd() + raise x + result = truncate_table_result() + result.read(iprot) + iprot.readMessageEnd() + if result.o1 is not None: + raise result.o1 + return + def get_tables(self, db_name, pattern): """ Parameters: @@ -6788,6 +6832,7 @@ def __init__(self, handler): self._processMap["add_foreign_key"] = Processor.process_add_foreign_key self._processMap["drop_table"] = Processor.process_drop_table self._processMap["drop_table_with_environment_context"] = Processor.process_drop_table_with_environment_context + self._processMap["truncate_table"] = Processor.process_truncate_table self._processMap["get_tables"] = Processor.process_get_tables self._processMap["get_tables_by_type"] = Processor.process_get_tables_by_type self._processMap["get_table_meta"] = Processor.process_get_table_meta @@ -7557,6 +7602,28 @@ def process_drop_table_with_environment_context(self, seqid, iprot, oprot): oprot.writeMessageEnd() oprot.trans.flush() + def process_truncate_table(self, seqid, iprot, oprot): + args = truncate_table_args() + args.read(iprot) + iprot.readMessageEnd() + result = truncate_table_result() + try: + self._handler.truncate_table(args.dbName, args.tableName, args.partNames) + 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("truncate_table", msg_type, seqid) + result.write(oprot) + oprot.writeMessageEnd() + oprot.trans.flush() + def process_get_tables(self, seqid, iprot, oprot): args = get_tables_args() args.read(iprot) @@ -14715,6 +14782,171 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) +class truncate_table_args: + """ + Attributes: + - dbName + - tableName + - partNames + """ + + thrift_spec = ( + None, # 0 + (1, TType.STRING, 'dbName', None, None, ), # 1 + (2, TType.STRING, 'tableName', None, None, ), # 2 + (3, TType.LIST, 'partNames', (TType.STRING,None), None, ), # 3 + ) + + def __init__(self, dbName=None, tableName=None, partNames=None,): + self.dbName = dbName + self.tableName = tableName + self.partNames = partNames + + def read(self, iprot): + if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: + fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) + return + iprot.readStructBegin() + while True: + (fname, ftype, fid) = iprot.readFieldBegin() + if ftype == TType.STOP: + break + if fid == 1: + if ftype == TType.STRING: + self.dbName = iprot.readString() + else: + iprot.skip(ftype) + elif fid == 2: + if ftype == TType.STRING: + self.tableName = iprot.readString() + else: + iprot.skip(ftype) + elif fid == 3: + if ftype == TType.LIST: + self.partNames = [] + (_etype662, _size659) = iprot.readListBegin() + for _i663 in xrange(_size659): + _elem664 = iprot.readString() + self.partNames.append(_elem664) + iprot.readListEnd() + else: + iprot.skip(ftype) + else: + iprot.skip(ftype) + iprot.readFieldEnd() + iprot.readStructEnd() + + def write(self, oprot): + if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: + oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) + return + oprot.writeStructBegin('truncate_table_args') + if self.dbName is not None: + oprot.writeFieldBegin('dbName', TType.STRING, 1) + oprot.writeString(self.dbName) + oprot.writeFieldEnd() + if self.tableName is not None: + oprot.writeFieldBegin('tableName', TType.STRING, 2) + oprot.writeString(self.tableName) + oprot.writeFieldEnd() + if self.partNames is not None: + oprot.writeFieldBegin('partNames', TType.LIST, 3) + oprot.writeListBegin(TType.STRING, len(self.partNames)) + for iter665 in self.partNames: + oprot.writeString(iter665) + oprot.writeListEnd() + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.dbName) + value = (value * 31) ^ hash(self.tableName) + value = (value * 31) ^ hash(self.partNames) + 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 truncate_table_result: + """ + Attributes: + - o1 + """ + + thrift_spec = ( + None, # 0 + (1, TType.STRUCT, 'o1', (MetaException, MetaException.thrift_spec), None, ), # 1 + ) + + def __init__(self, o1=None,): + self.o1 = o1 + + def read(self, iprot): + if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: + fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) + return + iprot.readStructBegin() + while True: + (fname, ftype, fid) = iprot.readFieldBegin() + if ftype == TType.STOP: + break + if fid == 1: + if ftype == TType.STRUCT: + self.o1 = 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('truncate_table_result') + 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.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_tables_args: """ Attributes: @@ -14821,10 +15053,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype662, _size659) = iprot.readListBegin() - for _i663 in xrange(_size659): - _elem664 = iprot.readString() - self.success.append(_elem664) + (_etype669, _size666) = iprot.readListBegin() + for _i670 in xrange(_size666): + _elem671 = iprot.readString() + self.success.append(_elem671) iprot.readListEnd() else: iprot.skip(ftype) @@ -14847,8 +15079,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter665 in self.success: - oprot.writeString(iter665) + for iter672 in self.success: + oprot.writeString(iter672) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -14998,10 +15230,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype669, _size666) = iprot.readListBegin() - for _i670 in xrange(_size666): - _elem671 = iprot.readString() - self.success.append(_elem671) + (_etype676, _size673) = iprot.readListBegin() + for _i677 in xrange(_size673): + _elem678 = iprot.readString() + self.success.append(_elem678) iprot.readListEnd() else: iprot.skip(ftype) @@ -15024,8 +15256,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter672 in self.success: - oprot.writeString(iter672) + for iter679 in self.success: + oprot.writeString(iter679) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -15098,10 +15330,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.tbl_types = [] - (_etype676, _size673) = iprot.readListBegin() - for _i677 in xrange(_size673): - _elem678 = iprot.readString() - self.tbl_types.append(_elem678) + (_etype683, _size680) = iprot.readListBegin() + for _i684 in xrange(_size680): + _elem685 = iprot.readString() + self.tbl_types.append(_elem685) iprot.readListEnd() else: iprot.skip(ftype) @@ -15126,8 +15358,8 @@ def write(self, oprot): if self.tbl_types is not None: oprot.writeFieldBegin('tbl_types', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.tbl_types)) - for iter679 in self.tbl_types: - oprot.writeString(iter679) + for iter686 in self.tbl_types: + oprot.writeString(iter686) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -15183,11 +15415,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype683, _size680) = iprot.readListBegin() - for _i684 in xrange(_size680): - _elem685 = TableMeta() - _elem685.read(iprot) - self.success.append(_elem685) + (_etype690, _size687) = iprot.readListBegin() + for _i691 in xrange(_size687): + _elem692 = TableMeta() + _elem692.read(iprot) + self.success.append(_elem692) iprot.readListEnd() else: iprot.skip(ftype) @@ -15210,8 +15442,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter686 in self.success: - iter686.write(oprot) + for iter693 in self.success: + iter693.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -15335,10 +15567,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype690, _size687) = iprot.readListBegin() - for _i691 in xrange(_size687): - _elem692 = iprot.readString() - self.success.append(_elem692) + (_etype697, _size694) = iprot.readListBegin() + for _i698 in xrange(_size694): + _elem699 = iprot.readString() + self.success.append(_elem699) iprot.readListEnd() else: iprot.skip(ftype) @@ -15361,8 +15593,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter693 in self.success: - oprot.writeString(iter693) + for iter700 in self.success: + oprot.writeString(iter700) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -15598,10 +15830,10 @@ def read(self, iprot): elif fid == 2: if ftype == TType.LIST: self.tbl_names = [] - (_etype697, _size694) = iprot.readListBegin() - for _i698 in xrange(_size694): - _elem699 = iprot.readString() - self.tbl_names.append(_elem699) + (_etype704, _size701) = iprot.readListBegin() + for _i705 in xrange(_size701): + _elem706 = iprot.readString() + self.tbl_names.append(_elem706) iprot.readListEnd() else: iprot.skip(ftype) @@ -15622,8 +15854,8 @@ def write(self, oprot): if self.tbl_names is not None: oprot.writeFieldBegin('tbl_names', TType.LIST, 2) oprot.writeListBegin(TType.STRING, len(self.tbl_names)) - for iter700 in self.tbl_names: - oprot.writeString(iter700) + for iter707 in self.tbl_names: + oprot.writeString(iter707) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -15675,11 +15907,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype704, _size701) = iprot.readListBegin() - for _i705 in xrange(_size701): - _elem706 = Table() - _elem706.read(iprot) - self.success.append(_elem706) + (_etype711, _size708) = iprot.readListBegin() + for _i712 in xrange(_size708): + _elem713 = Table() + _elem713.read(iprot) + self.success.append(_elem713) iprot.readListEnd() else: iprot.skip(ftype) @@ -15696,8 +15928,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter707 in self.success: - iter707.write(oprot) + for iter714 in self.success: + iter714.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -16180,10 +16412,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype711, _size708) = iprot.readListBegin() - for _i712 in xrange(_size708): - _elem713 = iprot.readString() - self.success.append(_elem713) + (_etype718, _size715) = iprot.readListBegin() + for _i719 in xrange(_size715): + _elem720 = iprot.readString() + self.success.append(_elem720) iprot.readListEnd() else: iprot.skip(ftype) @@ -16218,8 +16450,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter714 in self.success: - oprot.writeString(iter714) + for iter721 in self.success: + oprot.writeString(iter721) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -17189,11 +17421,11 @@ def read(self, iprot): if fid == 1: if ftype == TType.LIST: self.new_parts = [] - (_etype718, _size715) = iprot.readListBegin() - for _i719 in xrange(_size715): - _elem720 = Partition() - _elem720.read(iprot) - self.new_parts.append(_elem720) + (_etype725, _size722) = iprot.readListBegin() + for _i726 in xrange(_size722): + _elem727 = Partition() + _elem727.read(iprot) + self.new_parts.append(_elem727) iprot.readListEnd() else: iprot.skip(ftype) @@ -17210,8 +17442,8 @@ def write(self, oprot): if self.new_parts is not None: oprot.writeFieldBegin('new_parts', TType.LIST, 1) oprot.writeListBegin(TType.STRUCT, len(self.new_parts)) - for iter721 in self.new_parts: - iter721.write(oprot) + for iter728 in self.new_parts: + iter728.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -17369,11 +17601,11 @@ def read(self, iprot): if fid == 1: if ftype == TType.LIST: self.new_parts = [] - (_etype725, _size722) = iprot.readListBegin() - for _i726 in xrange(_size722): - _elem727 = PartitionSpec() - _elem727.read(iprot) - self.new_parts.append(_elem727) + (_etype732, _size729) = iprot.readListBegin() + for _i733 in xrange(_size729): + _elem734 = PartitionSpec() + _elem734.read(iprot) + self.new_parts.append(_elem734) iprot.readListEnd() else: iprot.skip(ftype) @@ -17390,8 +17622,8 @@ def write(self, oprot): if self.new_parts is not None: oprot.writeFieldBegin('new_parts', TType.LIST, 1) oprot.writeListBegin(TType.STRUCT, len(self.new_parts)) - for iter728 in self.new_parts: - iter728.write(oprot) + for iter735 in self.new_parts: + iter735.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -17565,10 +17797,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype732, _size729) = iprot.readListBegin() - for _i733 in xrange(_size729): - _elem734 = iprot.readString() - self.part_vals.append(_elem734) + (_etype739, _size736) = iprot.readListBegin() + for _i740 in xrange(_size736): + _elem741 = iprot.readString() + self.part_vals.append(_elem741) iprot.readListEnd() else: iprot.skip(ftype) @@ -17593,8 +17825,8 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter735 in self.part_vals: - oprot.writeString(iter735) + for iter742 in self.part_vals: + oprot.writeString(iter742) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -17947,10 +18179,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype739, _size736) = iprot.readListBegin() - for _i740 in xrange(_size736): - _elem741 = iprot.readString() - self.part_vals.append(_elem741) + (_etype746, _size743) = iprot.readListBegin() + for _i747 in xrange(_size743): + _elem748 = iprot.readString() + self.part_vals.append(_elem748) iprot.readListEnd() else: iprot.skip(ftype) @@ -17981,8 +18213,8 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter742 in self.part_vals: - oprot.writeString(iter742) + for iter749 in self.part_vals: + oprot.writeString(iter749) oprot.writeListEnd() oprot.writeFieldEnd() if self.environment_context is not None: @@ -18577,10 +18809,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype746, _size743) = iprot.readListBegin() - for _i747 in xrange(_size743): - _elem748 = iprot.readString() - self.part_vals.append(_elem748) + (_etype753, _size750) = iprot.readListBegin() + for _i754 in xrange(_size750): + _elem755 = iprot.readString() + self.part_vals.append(_elem755) iprot.readListEnd() else: iprot.skip(ftype) @@ -18610,8 +18842,8 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter749 in self.part_vals: - oprot.writeString(iter749) + for iter756 in self.part_vals: + oprot.writeString(iter756) oprot.writeListEnd() oprot.writeFieldEnd() if self.deleteData is not None: @@ -18784,10 +19016,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype753, _size750) = iprot.readListBegin() - for _i754 in xrange(_size750): - _elem755 = iprot.readString() - self.part_vals.append(_elem755) + (_etype760, _size757) = iprot.readListBegin() + for _i761 in xrange(_size757): + _elem762 = iprot.readString() + self.part_vals.append(_elem762) iprot.readListEnd() else: iprot.skip(ftype) @@ -18823,8 +19055,8 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter756 in self.part_vals: - oprot.writeString(iter756) + for iter763 in self.part_vals: + oprot.writeString(iter763) oprot.writeListEnd() oprot.writeFieldEnd() if self.deleteData is not None: @@ -19561,10 +19793,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype760, _size757) = iprot.readListBegin() - for _i761 in xrange(_size757): - _elem762 = iprot.readString() - self.part_vals.append(_elem762) + (_etype767, _size764) = iprot.readListBegin() + for _i768 in xrange(_size764): + _elem769 = iprot.readString() + self.part_vals.append(_elem769) iprot.readListEnd() else: iprot.skip(ftype) @@ -19589,8 +19821,8 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter763 in self.part_vals: - oprot.writeString(iter763) + for iter770 in self.part_vals: + oprot.writeString(iter770) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -19749,11 +19981,11 @@ def read(self, iprot): if fid == 1: if ftype == TType.MAP: self.partitionSpecs = {} - (_ktype765, _vtype766, _size764 ) = iprot.readMapBegin() - for _i768 in xrange(_size764): - _key769 = iprot.readString() - _val770 = iprot.readString() - self.partitionSpecs[_key769] = _val770 + (_ktype772, _vtype773, _size771 ) = iprot.readMapBegin() + for _i775 in xrange(_size771): + _key776 = iprot.readString() + _val777 = iprot.readString() + self.partitionSpecs[_key776] = _val777 iprot.readMapEnd() else: iprot.skip(ftype) @@ -19790,9 +20022,9 @@ def write(self, oprot): if self.partitionSpecs is not None: oprot.writeFieldBegin('partitionSpecs', TType.MAP, 1) oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.partitionSpecs)) - for kiter771,viter772 in self.partitionSpecs.items(): - oprot.writeString(kiter771) - oprot.writeString(viter772) + for kiter778,viter779 in self.partitionSpecs.items(): + oprot.writeString(kiter778) + oprot.writeString(viter779) oprot.writeMapEnd() oprot.writeFieldEnd() if self.source_db is not None: @@ -19997,11 +20229,11 @@ def read(self, iprot): if fid == 1: if ftype == TType.MAP: self.partitionSpecs = {} - (_ktype774, _vtype775, _size773 ) = iprot.readMapBegin() - for _i777 in xrange(_size773): - _key778 = iprot.readString() - _val779 = iprot.readString() - self.partitionSpecs[_key778] = _val779 + (_ktype781, _vtype782, _size780 ) = iprot.readMapBegin() + for _i784 in xrange(_size780): + _key785 = iprot.readString() + _val786 = iprot.readString() + self.partitionSpecs[_key785] = _val786 iprot.readMapEnd() else: iprot.skip(ftype) @@ -20038,9 +20270,9 @@ def write(self, oprot): if self.partitionSpecs is not None: oprot.writeFieldBegin('partitionSpecs', TType.MAP, 1) oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.partitionSpecs)) - for kiter780,viter781 in self.partitionSpecs.items(): - oprot.writeString(kiter780) - oprot.writeString(viter781) + for kiter787,viter788 in self.partitionSpecs.items(): + oprot.writeString(kiter787) + oprot.writeString(viter788) oprot.writeMapEnd() oprot.writeFieldEnd() if self.source_db is not None: @@ -20123,11 +20355,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype785, _size782) = iprot.readListBegin() - for _i786 in xrange(_size782): - _elem787 = Partition() - _elem787.read(iprot) - self.success.append(_elem787) + (_etype792, _size789) = iprot.readListBegin() + for _i793 in xrange(_size789): + _elem794 = Partition() + _elem794.read(iprot) + self.success.append(_elem794) iprot.readListEnd() else: iprot.skip(ftype) @@ -20168,8 +20400,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter788 in self.success: - iter788.write(oprot) + for iter795 in self.success: + iter795.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -20263,10 +20495,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype792, _size789) = iprot.readListBegin() - for _i793 in xrange(_size789): - _elem794 = iprot.readString() - self.part_vals.append(_elem794) + (_etype799, _size796) = iprot.readListBegin() + for _i800 in xrange(_size796): + _elem801 = iprot.readString() + self.part_vals.append(_elem801) iprot.readListEnd() else: iprot.skip(ftype) @@ -20278,10 +20510,10 @@ def read(self, iprot): elif fid == 5: if ftype == TType.LIST: self.group_names = [] - (_etype798, _size795) = iprot.readListBegin() - for _i799 in xrange(_size795): - _elem800 = iprot.readString() - self.group_names.append(_elem800) + (_etype805, _size802) = iprot.readListBegin() + for _i806 in xrange(_size802): + _elem807 = iprot.readString() + self.group_names.append(_elem807) iprot.readListEnd() else: iprot.skip(ftype) @@ -20306,8 +20538,8 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter801 in self.part_vals: - oprot.writeString(iter801) + for iter808 in self.part_vals: + oprot.writeString(iter808) oprot.writeListEnd() oprot.writeFieldEnd() if self.user_name is not None: @@ -20317,8 +20549,8 @@ def write(self, oprot): if self.group_names is not None: oprot.writeFieldBegin('group_names', TType.LIST, 5) oprot.writeListBegin(TType.STRING, len(self.group_names)) - for iter802 in self.group_names: - oprot.writeString(iter802) + for iter809 in self.group_names: + oprot.writeString(iter809) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -20747,11 +20979,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype806, _size803) = iprot.readListBegin() - for _i807 in xrange(_size803): - _elem808 = Partition() - _elem808.read(iprot) - self.success.append(_elem808) + (_etype813, _size810) = iprot.readListBegin() + for _i814 in xrange(_size810): + _elem815 = Partition() + _elem815.read(iprot) + self.success.append(_elem815) iprot.readListEnd() else: iprot.skip(ftype) @@ -20780,8 +21012,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter809 in self.success: - iter809.write(oprot) + for iter816 in self.success: + iter816.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -20875,10 +21107,10 @@ def read(self, iprot): elif fid == 5: if ftype == TType.LIST: self.group_names = [] - (_etype813, _size810) = iprot.readListBegin() - for _i814 in xrange(_size810): - _elem815 = iprot.readString() - self.group_names.append(_elem815) + (_etype820, _size817) = iprot.readListBegin() + for _i821 in xrange(_size817): + _elem822 = iprot.readString() + self.group_names.append(_elem822) iprot.readListEnd() else: iprot.skip(ftype) @@ -20911,8 +21143,8 @@ def write(self, oprot): if self.group_names is not None: oprot.writeFieldBegin('group_names', TType.LIST, 5) oprot.writeListBegin(TType.STRING, len(self.group_names)) - for iter816 in self.group_names: - oprot.writeString(iter816) + for iter823 in self.group_names: + oprot.writeString(iter823) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -20973,11 +21205,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype820, _size817) = iprot.readListBegin() - for _i821 in xrange(_size817): - _elem822 = Partition() - _elem822.read(iprot) - self.success.append(_elem822) + (_etype827, _size824) = iprot.readListBegin() + for _i828 in xrange(_size824): + _elem829 = Partition() + _elem829.read(iprot) + self.success.append(_elem829) iprot.readListEnd() else: iprot.skip(ftype) @@ -21006,8 +21238,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter823 in self.success: - iter823.write(oprot) + for iter830 in self.success: + iter830.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -21165,11 +21397,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype827, _size824) = iprot.readListBegin() - for _i828 in xrange(_size824): - _elem829 = PartitionSpec() - _elem829.read(iprot) - self.success.append(_elem829) + (_etype834, _size831) = iprot.readListBegin() + for _i835 in xrange(_size831): + _elem836 = PartitionSpec() + _elem836.read(iprot) + self.success.append(_elem836) iprot.readListEnd() else: iprot.skip(ftype) @@ -21198,8 +21430,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter830 in self.success: - iter830.write(oprot) + for iter837 in self.success: + iter837.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -21354,10 +21586,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype834, _size831) = iprot.readListBegin() - for _i835 in xrange(_size831): - _elem836 = iprot.readString() - self.success.append(_elem836) + (_etype841, _size838) = iprot.readListBegin() + for _i842 in xrange(_size838): + _elem843 = iprot.readString() + self.success.append(_elem843) iprot.readListEnd() else: iprot.skip(ftype) @@ -21380,8 +21612,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter837 in self.success: - oprot.writeString(iter837) + for iter844 in self.success: + oprot.writeString(iter844) oprot.writeListEnd() oprot.writeFieldEnd() if self.o2 is not None: @@ -21457,10 +21689,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype841, _size838) = iprot.readListBegin() - for _i842 in xrange(_size838): - _elem843 = iprot.readString() - self.part_vals.append(_elem843) + (_etype848, _size845) = iprot.readListBegin() + for _i849 in xrange(_size845): + _elem850 = iprot.readString() + self.part_vals.append(_elem850) iprot.readListEnd() else: iprot.skip(ftype) @@ -21490,8 +21722,8 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter844 in self.part_vals: - oprot.writeString(iter844) + for iter851 in self.part_vals: + oprot.writeString(iter851) oprot.writeListEnd() oprot.writeFieldEnd() if self.max_parts is not None: @@ -21555,11 +21787,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype848, _size845) = iprot.readListBegin() - for _i849 in xrange(_size845): - _elem850 = Partition() - _elem850.read(iprot) - self.success.append(_elem850) + (_etype855, _size852) = iprot.readListBegin() + for _i856 in xrange(_size852): + _elem857 = Partition() + _elem857.read(iprot) + self.success.append(_elem857) iprot.readListEnd() else: iprot.skip(ftype) @@ -21588,8 +21820,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter851 in self.success: - iter851.write(oprot) + for iter858 in self.success: + iter858.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -21676,10 +21908,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype855, _size852) = iprot.readListBegin() - for _i856 in xrange(_size852): - _elem857 = iprot.readString() - self.part_vals.append(_elem857) + (_etype862, _size859) = iprot.readListBegin() + for _i863 in xrange(_size859): + _elem864 = iprot.readString() + self.part_vals.append(_elem864) iprot.readListEnd() else: iprot.skip(ftype) @@ -21696,10 +21928,10 @@ def read(self, iprot): elif fid == 6: if ftype == TType.LIST: self.group_names = [] - (_etype861, _size858) = iprot.readListBegin() - for _i862 in xrange(_size858): - _elem863 = iprot.readString() - self.group_names.append(_elem863) + (_etype868, _size865) = iprot.readListBegin() + for _i869 in xrange(_size865): + _elem870 = iprot.readString() + self.group_names.append(_elem870) iprot.readListEnd() else: iprot.skip(ftype) @@ -21724,8 +21956,8 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter864 in self.part_vals: - oprot.writeString(iter864) + for iter871 in self.part_vals: + oprot.writeString(iter871) oprot.writeListEnd() oprot.writeFieldEnd() if self.max_parts is not None: @@ -21739,8 +21971,8 @@ def write(self, oprot): if self.group_names is not None: oprot.writeFieldBegin('group_names', TType.LIST, 6) oprot.writeListBegin(TType.STRING, len(self.group_names)) - for iter865 in self.group_names: - oprot.writeString(iter865) + for iter872 in self.group_names: + oprot.writeString(iter872) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -21802,11 +22034,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype869, _size866) = iprot.readListBegin() - for _i870 in xrange(_size866): - _elem871 = Partition() - _elem871.read(iprot) - self.success.append(_elem871) + (_etype876, _size873) = iprot.readListBegin() + for _i877 in xrange(_size873): + _elem878 = Partition() + _elem878.read(iprot) + self.success.append(_elem878) iprot.readListEnd() else: iprot.skip(ftype) @@ -21835,8 +22067,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter872 in self.success: - iter872.write(oprot) + for iter879 in self.success: + iter879.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -21917,10 +22149,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype876, _size873) = iprot.readListBegin() - for _i877 in xrange(_size873): - _elem878 = iprot.readString() - self.part_vals.append(_elem878) + (_etype883, _size880) = iprot.readListBegin() + for _i884 in xrange(_size880): + _elem885 = iprot.readString() + self.part_vals.append(_elem885) iprot.readListEnd() else: iprot.skip(ftype) @@ -21950,8 +22182,8 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter879 in self.part_vals: - oprot.writeString(iter879) + for iter886 in self.part_vals: + oprot.writeString(iter886) oprot.writeListEnd() oprot.writeFieldEnd() if self.max_parts is not None: @@ -22015,10 +22247,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype883, _size880) = iprot.readListBegin() - for _i884 in xrange(_size880): - _elem885 = iprot.readString() - self.success.append(_elem885) + (_etype890, _size887) = iprot.readListBegin() + for _i891 in xrange(_size887): + _elem892 = iprot.readString() + self.success.append(_elem892) iprot.readListEnd() else: iprot.skip(ftype) @@ -22047,8 +22279,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter886 in self.success: - oprot.writeString(iter886) + for iter893 in self.success: + oprot.writeString(iter893) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -22219,11 +22451,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype890, _size887) = iprot.readListBegin() - for _i891 in xrange(_size887): - _elem892 = Partition() - _elem892.read(iprot) - self.success.append(_elem892) + (_etype897, _size894) = iprot.readListBegin() + for _i898 in xrange(_size894): + _elem899 = Partition() + _elem899.read(iprot) + self.success.append(_elem899) iprot.readListEnd() else: iprot.skip(ftype) @@ -22252,8 +22484,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter893 in self.success: - iter893.write(oprot) + for iter900 in self.success: + iter900.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -22424,11 +22656,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype897, _size894) = iprot.readListBegin() - for _i898 in xrange(_size894): - _elem899 = PartitionSpec() - _elem899.read(iprot) - self.success.append(_elem899) + (_etype904, _size901) = iprot.readListBegin() + for _i905 in xrange(_size901): + _elem906 = PartitionSpec() + _elem906.read(iprot) + self.success.append(_elem906) iprot.readListEnd() else: iprot.skip(ftype) @@ -22457,8 +22689,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter900 in self.success: - iter900.write(oprot) + for iter907 in self.success: + iter907.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -22878,10 +23110,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.names = [] - (_etype904, _size901) = iprot.readListBegin() - for _i905 in xrange(_size901): - _elem906 = iprot.readString() - self.names.append(_elem906) + (_etype911, _size908) = iprot.readListBegin() + for _i912 in xrange(_size908): + _elem913 = iprot.readString() + self.names.append(_elem913) iprot.readListEnd() else: iprot.skip(ftype) @@ -22906,8 +23138,8 @@ def write(self, oprot): if self.names is not None: oprot.writeFieldBegin('names', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.names)) - for iter907 in self.names: - oprot.writeString(iter907) + for iter914 in self.names: + oprot.writeString(iter914) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -22966,11 +23198,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype911, _size908) = iprot.readListBegin() - for _i912 in xrange(_size908): - _elem913 = Partition() - _elem913.read(iprot) - self.success.append(_elem913) + (_etype918, _size915) = iprot.readListBegin() + for _i919 in xrange(_size915): + _elem920 = Partition() + _elem920.read(iprot) + self.success.append(_elem920) iprot.readListEnd() else: iprot.skip(ftype) @@ -22999,8 +23231,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter914 in self.success: - iter914.write(oprot) + for iter921 in self.success: + iter921.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -23250,11 +23482,11 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.new_parts = [] - (_etype918, _size915) = iprot.readListBegin() - for _i919 in xrange(_size915): - _elem920 = Partition() - _elem920.read(iprot) - self.new_parts.append(_elem920) + (_etype925, _size922) = iprot.readListBegin() + for _i926 in xrange(_size922): + _elem927 = Partition() + _elem927.read(iprot) + self.new_parts.append(_elem927) iprot.readListEnd() else: iprot.skip(ftype) @@ -23279,8 +23511,8 @@ def write(self, oprot): if self.new_parts is not None: oprot.writeFieldBegin('new_parts', TType.LIST, 3) oprot.writeListBegin(TType.STRUCT, len(self.new_parts)) - for iter921 in self.new_parts: - iter921.write(oprot) + for iter928 in self.new_parts: + iter928.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -23433,11 +23665,11 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.new_parts = [] - (_etype925, _size922) = iprot.readListBegin() - for _i926 in xrange(_size922): - _elem927 = Partition() - _elem927.read(iprot) - self.new_parts.append(_elem927) + (_etype932, _size929) = iprot.readListBegin() + for _i933 in xrange(_size929): + _elem934 = Partition() + _elem934.read(iprot) + self.new_parts.append(_elem934) iprot.readListEnd() else: iprot.skip(ftype) @@ -23468,8 +23700,8 @@ def write(self, oprot): if self.new_parts is not None: oprot.writeFieldBegin('new_parts', TType.LIST, 3) oprot.writeListBegin(TType.STRUCT, len(self.new_parts)) - for iter928 in self.new_parts: - iter928.write(oprot) + for iter935 in self.new_parts: + iter935.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.environment_context is not None: @@ -23813,10 +24045,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype932, _size929) = iprot.readListBegin() - for _i933 in xrange(_size929): - _elem934 = iprot.readString() - self.part_vals.append(_elem934) + (_etype939, _size936) = iprot.readListBegin() + for _i940 in xrange(_size936): + _elem941 = iprot.readString() + self.part_vals.append(_elem941) iprot.readListEnd() else: iprot.skip(ftype) @@ -23847,8 +24079,8 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter935 in self.part_vals: - oprot.writeString(iter935) + for iter942 in self.part_vals: + oprot.writeString(iter942) oprot.writeListEnd() oprot.writeFieldEnd() if self.new_part is not None: @@ -23990,10 +24222,10 @@ def read(self, iprot): if fid == 1: if ftype == TType.LIST: self.part_vals = [] - (_etype939, _size936) = iprot.readListBegin() - for _i940 in xrange(_size936): - _elem941 = iprot.readString() - self.part_vals.append(_elem941) + (_etype946, _size943) = iprot.readListBegin() + for _i947 in xrange(_size943): + _elem948 = iprot.readString() + self.part_vals.append(_elem948) iprot.readListEnd() else: iprot.skip(ftype) @@ -24015,8 +24247,8 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 1) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter942 in self.part_vals: - oprot.writeString(iter942) + for iter949 in self.part_vals: + oprot.writeString(iter949) oprot.writeListEnd() oprot.writeFieldEnd() if self.throw_exception is not None: @@ -24374,10 +24606,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype946, _size943) = iprot.readListBegin() - for _i947 in xrange(_size943): - _elem948 = iprot.readString() - self.success.append(_elem948) + (_etype953, _size950) = iprot.readListBegin() + for _i954 in xrange(_size950): + _elem955 = iprot.readString() + self.success.append(_elem955) iprot.readListEnd() else: iprot.skip(ftype) @@ -24400,8 +24632,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter949 in self.success: - oprot.writeString(iter949) + for iter956 in self.success: + oprot.writeString(iter956) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -24525,11 +24757,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.MAP: self.success = {} - (_ktype951, _vtype952, _size950 ) = iprot.readMapBegin() - for _i954 in xrange(_size950): - _key955 = iprot.readString() - _val956 = iprot.readString() - self.success[_key955] = _val956 + (_ktype958, _vtype959, _size957 ) = iprot.readMapBegin() + for _i961 in xrange(_size957): + _key962 = iprot.readString() + _val963 = iprot.readString() + self.success[_key962] = _val963 iprot.readMapEnd() else: iprot.skip(ftype) @@ -24552,9 +24784,9 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.MAP, 0) oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success)) - for kiter957,viter958 in self.success.items(): - oprot.writeString(kiter957) - oprot.writeString(viter958) + for kiter964,viter965 in self.success.items(): + oprot.writeString(kiter964) + oprot.writeString(viter965) oprot.writeMapEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -24630,11 +24862,11 @@ def read(self, iprot): elif fid == 3: if ftype == TType.MAP: self.part_vals = {} - (_ktype960, _vtype961, _size959 ) = iprot.readMapBegin() - for _i963 in xrange(_size959): - _key964 = iprot.readString() - _val965 = iprot.readString() - self.part_vals[_key964] = _val965 + (_ktype967, _vtype968, _size966 ) = iprot.readMapBegin() + for _i970 in xrange(_size966): + _key971 = iprot.readString() + _val972 = iprot.readString() + self.part_vals[_key971] = _val972 iprot.readMapEnd() else: iprot.skip(ftype) @@ -24664,9 +24896,9 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.MAP, 3) oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.part_vals)) - for kiter966,viter967 in self.part_vals.items(): - oprot.writeString(kiter966) - oprot.writeString(viter967) + for kiter973,viter974 in self.part_vals.items(): + oprot.writeString(kiter973) + oprot.writeString(viter974) oprot.writeMapEnd() oprot.writeFieldEnd() if self.eventType is not None: @@ -24880,11 +25112,11 @@ def read(self, iprot): elif fid == 3: if ftype == TType.MAP: self.part_vals = {} - (_ktype969, _vtype970, _size968 ) = iprot.readMapBegin() - for _i972 in xrange(_size968): - _key973 = iprot.readString() - _val974 = iprot.readString() - self.part_vals[_key973] = _val974 + (_ktype976, _vtype977, _size975 ) = iprot.readMapBegin() + for _i979 in xrange(_size975): + _key980 = iprot.readString() + _val981 = iprot.readString() + self.part_vals[_key980] = _val981 iprot.readMapEnd() else: iprot.skip(ftype) @@ -24914,9 +25146,9 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.MAP, 3) oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.part_vals)) - for kiter975,viter976 in self.part_vals.items(): - oprot.writeString(kiter975) - oprot.writeString(viter976) + for kiter982,viter983 in self.part_vals.items(): + oprot.writeString(kiter982) + oprot.writeString(viter983) oprot.writeMapEnd() oprot.writeFieldEnd() if self.eventType is not None: @@ -25971,11 +26203,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype980, _size977) = iprot.readListBegin() - for _i981 in xrange(_size977): - _elem982 = Index() - _elem982.read(iprot) - self.success.append(_elem982) + (_etype987, _size984) = iprot.readListBegin() + for _i988 in xrange(_size984): + _elem989 = Index() + _elem989.read(iprot) + self.success.append(_elem989) iprot.readListEnd() else: iprot.skip(ftype) @@ -26004,8 +26236,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter983 in self.success: - iter983.write(oprot) + for iter990 in self.success: + iter990.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -26160,10 +26392,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype987, _size984) = iprot.readListBegin() - for _i988 in xrange(_size984): - _elem989 = iprot.readString() - self.success.append(_elem989) + (_etype994, _size991) = iprot.readListBegin() + for _i995 in xrange(_size991): + _elem996 = iprot.readString() + self.success.append(_elem996) iprot.readListEnd() else: iprot.skip(ftype) @@ -26186,8 +26418,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter990 in self.success: - oprot.writeString(iter990) + for iter997 in self.success: + oprot.writeString(iter997) oprot.writeListEnd() oprot.writeFieldEnd() if self.o2 is not None: @@ -29053,10 +29285,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype994, _size991) = iprot.readListBegin() - for _i995 in xrange(_size991): - _elem996 = iprot.readString() - self.success.append(_elem996) + (_etype1001, _size998) = iprot.readListBegin() + for _i1002 in xrange(_size998): + _elem1003 = iprot.readString() + self.success.append(_elem1003) iprot.readListEnd() else: iprot.skip(ftype) @@ -29079,8 +29311,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter997 in self.success: - oprot.writeString(iter997) + for iter1004 in self.success: + oprot.writeString(iter1004) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -29768,10 +30000,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1001, _size998) = iprot.readListBegin() - for _i1002 in xrange(_size998): - _elem1003 = iprot.readString() - self.success.append(_elem1003) + (_etype1008, _size1005) = iprot.readListBegin() + for _i1009 in xrange(_size1005): + _elem1010 = iprot.readString() + self.success.append(_elem1010) iprot.readListEnd() else: iprot.skip(ftype) @@ -29794,8 +30026,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter1004 in self.success: - oprot.writeString(iter1004) + for iter1011 in self.success: + oprot.writeString(iter1011) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -30309,11 +30541,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1008, _size1005) = iprot.readListBegin() - for _i1009 in xrange(_size1005): - _elem1010 = Role() - _elem1010.read(iprot) - self.success.append(_elem1010) + (_etype1015, _size1012) = iprot.readListBegin() + for _i1016 in xrange(_size1012): + _elem1017 = Role() + _elem1017.read(iprot) + self.success.append(_elem1017) iprot.readListEnd() else: iprot.skip(ftype) @@ -30336,8 +30568,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter1011 in self.success: - iter1011.write(oprot) + for iter1018 in self.success: + iter1018.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -30846,10 +31078,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.group_names = [] - (_etype1015, _size1012) = iprot.readListBegin() - for _i1016 in xrange(_size1012): - _elem1017 = iprot.readString() - self.group_names.append(_elem1017) + (_etype1022, _size1019) = iprot.readListBegin() + for _i1023 in xrange(_size1019): + _elem1024 = iprot.readString() + self.group_names.append(_elem1024) iprot.readListEnd() else: iprot.skip(ftype) @@ -30874,8 +31106,8 @@ def write(self, oprot): if self.group_names is not None: oprot.writeFieldBegin('group_names', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.group_names)) - for iter1018 in self.group_names: - oprot.writeString(iter1018) + for iter1025 in self.group_names: + oprot.writeString(iter1025) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -31102,11 +31334,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1022, _size1019) = iprot.readListBegin() - for _i1023 in xrange(_size1019): - _elem1024 = HiveObjectPrivilege() - _elem1024.read(iprot) - self.success.append(_elem1024) + (_etype1029, _size1026) = iprot.readListBegin() + for _i1030 in xrange(_size1026): + _elem1031 = HiveObjectPrivilege() + _elem1031.read(iprot) + self.success.append(_elem1031) iprot.readListEnd() else: iprot.skip(ftype) @@ -31129,8 +31361,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter1025 in self.success: - iter1025.write(oprot) + for iter1032 in self.success: + iter1032.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -31628,10 +31860,10 @@ def read(self, iprot): elif fid == 2: if ftype == TType.LIST: self.group_names = [] - (_etype1029, _size1026) = iprot.readListBegin() - for _i1030 in xrange(_size1026): - _elem1031 = iprot.readString() - self.group_names.append(_elem1031) + (_etype1036, _size1033) = iprot.readListBegin() + for _i1037 in xrange(_size1033): + _elem1038 = iprot.readString() + self.group_names.append(_elem1038) iprot.readListEnd() else: iprot.skip(ftype) @@ -31652,8 +31884,8 @@ def write(self, oprot): if self.group_names is not None: oprot.writeFieldBegin('group_names', TType.LIST, 2) oprot.writeListBegin(TType.STRING, len(self.group_names)) - for iter1032 in self.group_names: - oprot.writeString(iter1032) + for iter1039 in self.group_names: + oprot.writeString(iter1039) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -31708,10 +31940,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1036, _size1033) = iprot.readListBegin() - for _i1037 in xrange(_size1033): - _elem1038 = iprot.readString() - self.success.append(_elem1038) + (_etype1043, _size1040) = iprot.readListBegin() + for _i1044 in xrange(_size1040): + _elem1045 = iprot.readString() + self.success.append(_elem1045) iprot.readListEnd() else: iprot.skip(ftype) @@ -31734,8 +31966,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter1039 in self.success: - oprot.writeString(iter1039) + for iter1046 in self.success: + oprot.writeString(iter1046) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -32667,10 +32899,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1043, _size1040) = iprot.readListBegin() - for _i1044 in xrange(_size1040): - _elem1045 = iprot.readString() - self.success.append(_elem1045) + (_etype1050, _size1047) = iprot.readListBegin() + for _i1051 in xrange(_size1047): + _elem1052 = iprot.readString() + self.success.append(_elem1052) iprot.readListEnd() else: iprot.skip(ftype) @@ -32687,8 +32919,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter1046 in self.success: - oprot.writeString(iter1046) + for iter1053 in self.success: + oprot.writeString(iter1053) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -33215,10 +33447,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1050, _size1047) = iprot.readListBegin() - for _i1051 in xrange(_size1047): - _elem1052 = iprot.readString() - self.success.append(_elem1052) + (_etype1057, _size1054) = iprot.readListBegin() + for _i1058 in xrange(_size1054): + _elem1059 = iprot.readString() + self.success.append(_elem1059) iprot.readListEnd() else: iprot.skip(ftype) @@ -33235,8 +33467,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter1053 in self.success: - oprot.writeString(iter1053) + for iter1060 in self.success: + oprot.writeString(iter1060) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() 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 7cdfc8665770..04e63f3a9b85 100644 --- a/metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb +++ b/metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb @@ -416,6 +416,21 @@ def recv_drop_table_with_environment_context() return end + def truncate_table(dbName, tableName, partNames) + send_truncate_table(dbName, tableName, partNames) + recv_truncate_table() + end + + def send_truncate_table(dbName, tableName, partNames) + send_message('truncate_table', Truncate_table_args, :dbName => dbName, :tableName => tableName, :partNames => partNames) + end + + def recv_truncate_table() + result = receive_message(Truncate_table_result) + raise result.o1 unless result.o1.nil? + return + end + def get_tables(db_name, pattern) send_get_tables(db_name, pattern) return recv_get_tables() @@ -2880,6 +2895,17 @@ def process_drop_table_with_environment_context(seqid, iprot, oprot) write_result(result, oprot, 'drop_table_with_environment_context', seqid) end + def process_truncate_table(seqid, iprot, oprot) + args = read_args(iprot, Truncate_table_args) + result = Truncate_table_result.new() + begin + @handler.truncate_table(args.dbName, args.tableName, args.partNames) + rescue ::MetaException => o1 + result.o1 = o1 + end + write_result(result, oprot, 'truncate_table', seqid) + end + def process_get_tables(seqid, iprot, oprot) args = read_args(iprot, Get_tables_args) result = Get_tables_result.new() @@ -5326,6 +5352,42 @@ def validate ::Thrift::Struct.generate_accessors self end + class Truncate_table_args + include ::Thrift::Struct, ::Thrift::Struct_Union + DBNAME = 1 + TABLENAME = 2 + PARTNAMES = 3 + + FIELDS = { + DBNAME => {:type => ::Thrift::Types::STRING, :name => 'dbName'}, + TABLENAME => {:type => ::Thrift::Types::STRING, :name => 'tableName'}, + PARTNAMES => {:type => ::Thrift::Types::LIST, :name => 'partNames', :element => {:type => ::Thrift::Types::STRING}} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Truncate_table_result + include ::Thrift::Struct, ::Thrift::Struct_Union + O1 = 1 + + FIELDS = { + 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_tables_args include ::Thrift::Struct, ::Thrift::Struct_Union DB_NAME = 1 diff --git a/metastore/src/java/org/apache/hadoop/hive/metastore/HiveAlterHandler.java b/metastore/src/java/org/apache/hadoop/hive/metastore/HiveAlterHandler.java index 77b354151795..d2abdffb1408 100644 --- a/metastore/src/java/org/apache/hadoop/hive/metastore/HiveAlterHandler.java +++ b/metastore/src/java/org/apache/hadoop/hive/metastore/HiveAlterHandler.java @@ -272,7 +272,7 @@ public void alterTable(RawStore msdb, Warehouse wh, String dbname, if (transactionalListeners != null && !transactionalListeners.isEmpty()) { MetaStoreListenerNotifier.notifyEvent(transactionalListeners, EventMessage.EventType.ALTER_TABLE, - new AlterTableEvent(oldt, newt, true, handler), + new AlterTableEvent(oldt, newt, false, true, handler), environmentContext); } // commit the changes @@ -384,7 +384,7 @@ public Partition alterPartition(final RawStore msdb, Warehouse wh, final String if (transactionalListeners != null && !transactionalListeners.isEmpty()) { MetaStoreListenerNotifier.notifyEvent(transactionalListeners, EventMessage.EventType.ALTER_PARTITION, - new AlterPartitionEvent(oldPart, new_part, tbl, true, handler), + new AlterPartitionEvent(oldPart, new_part, tbl, false, true, handler), environmentContext); @@ -503,7 +503,7 @@ public Partition alterPartition(final RawStore msdb, Warehouse wh, final String if (transactionalListeners != null && !transactionalListeners.isEmpty()) { MetaStoreListenerNotifier.notifyEvent(transactionalListeners, EventMessage.EventType.ALTER_PARTITION, - new AlterPartitionEvent(oldPart, new_part, tbl, true, handler), + new AlterPartitionEvent(oldPart, new_part, tbl, false, true, handler), environmentContext); } @@ -536,7 +536,7 @@ public Partition alterPartition(final RawStore msdb, Warehouse wh, final String if (transactionalListeners != null && !transactionalListeners.isEmpty()) { MetaStoreListenerNotifier.notifyEvent(transactionalListeners, EventMessage.EventType.ALTER_PARTITION, - new AlterPartitionEvent(new_part, oldPart, tbl, success, handler), + new AlterPartitionEvent(new_part, oldPart, tbl, false, success, handler), environmentContext); } @@ -625,7 +625,7 @@ public List alterPartitions(final RawStore msdb, Warehouse wh, final if (transactionalListeners != null && !transactionalListeners.isEmpty()) { MetaStoreListenerNotifier.notifyEvent(transactionalListeners, EventMessage.EventType.ALTER_PARTITION, - new AlterPartitionEvent(oldPart, newPart, tbl, true, handler)); + new AlterPartitionEvent(oldPart, newPart, tbl, false, true, handler)); } } 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 557ae5aca87c..cbcfc72ac73c 100644 --- a/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java +++ b/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java @@ -63,6 +63,7 @@ import com.google.common.collect.Multimaps; import org.apache.commons.cli.OptionBuilder; import org.apache.hadoop.conf.Configuration; +import org.apache.hadoop.fs.FileStatus; import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.fs.Path; import org.apache.hadoop.hive.common.FileUtils; @@ -80,6 +81,7 @@ import org.apache.hadoop.hive.common.metrics.common.MetricsVariable; import org.apache.hadoop.hive.conf.HiveConf; import org.apache.hadoop.hive.conf.HiveConf.ConfVars; +import org.apache.hadoop.hive.io.HdfsUtils; import org.apache.hadoop.hive.metastore.api.*; import org.apache.hadoop.hive.metastore.events.AddIndexEvent; import org.apache.hadoop.hive.metastore.events.AddPartitionEvent; @@ -1898,6 +1900,151 @@ public void drop_table_with_environment_context(final String dbname, final Strin } + private void updateStatsForTruncate(Map props, EnvironmentContext environmentContext) { + if (null == props) { + return; + } + for (String stat : StatsSetupConst.supportedStats) { + String statVal = props.get(stat); + if (statVal != null) { + //In the case of truncate table, we set the stats to be 0. + props.put(stat, "0"); + } + } + //first set basic stats to true + StatsSetupConst.setBasicStatsState(props, StatsSetupConst.TRUE); + environmentContext.putToProperties(StatsSetupConst.STATS_GENERATED, StatsSetupConst.TASK); + //then invalidate column stats + StatsSetupConst.clearColumnStatsState(props); + return; + } + + private void alterPartitionForTruncate(final RawStore ms, + final String dbName, + final String tableName, + final Table table, + final Partition partition) throws Exception { + EnvironmentContext environmentContext = new EnvironmentContext(); + updateStatsForTruncate(partition.getParameters(), environmentContext); + + if (!transactionalListeners.isEmpty()) { + MetaStoreListenerNotifier.notifyEvent(transactionalListeners, + EventType.ALTER_PARTITION, + new AlterPartitionEvent(partition, partition, table, true, true, this)); + } + + if (!listeners.isEmpty()) { + MetaStoreListenerNotifier.notifyEvent(listeners, + EventType.ALTER_PARTITION, + new AlterPartitionEvent(partition, partition, table, true, true, this)); + } + + alterHandler.alterPartition(ms, wh, dbName, tableName, null, partition, environmentContext, this); + } + + private void alterTableStatsForTruncate(final RawStore ms, + final String dbName, + final String tableName, + final Table table, + final List partNames) throws Exception { + if (partNames == null) { + if (0 != table.getPartitionKeysSize()) { + for (Partition partition : ms.getPartitions(dbName, tableName, Integer.MAX_VALUE)) { + alterPartitionForTruncate(ms, dbName, tableName, table, partition); + } + } else { + EnvironmentContext environmentContext = new EnvironmentContext(); + updateStatsForTruncate(table.getParameters(), environmentContext); + + if (!transactionalListeners.isEmpty()) { + MetaStoreListenerNotifier.notifyEvent(transactionalListeners, + EventType.ALTER_TABLE, + new AlterTableEvent(table, table, true, true, this)); + } + + if (!listeners.isEmpty()) { + MetaStoreListenerNotifier.notifyEvent(listeners, + EventType.ALTER_TABLE, + new AlterTableEvent(table, table, true, true, this)); + } + + alterHandler.alterTable(ms, wh, dbName, tableName, table, environmentContext, this); + } + } else { + for (Partition partition : ms.getPartitionsByNames(dbName, tableName, partNames)) { + alterPartitionForTruncate(ms, dbName, tableName, table, partition); + } + } + return; + } + + private List getLocationsForTruncate(final RawStore ms, + final String dbName, + final String tableName, + final Table table, + final List partNames) throws Exception { + List locations = new ArrayList(); + if (partNames == null) { + if (0 != table.getPartitionKeysSize()) { + for (Partition partition : ms.getPartitions(dbName, tableName, Integer.MAX_VALUE)) { + locations.add(new Path(partition.getSd().getLocation())); + } + } else { + locations.add(new Path(table.getSd().getLocation())); + } + } else { + for (Partition partition : ms.getPartitionsByNames(dbName, tableName, partNames)) { + locations.add(new Path(partition.getSd().getLocation())); + } + } + return locations; + } + + @Override + public void truncate_table(final String dbName, final String tableName, List partNames) + throws NoSuchObjectException, MetaException { + try { + Table tbl = get_table_core(dbName, tableName); + boolean isAutopurge = (tbl.isSetParameters() && "true".equalsIgnoreCase(tbl.getParameters().get("auto.purge"))); + + // This is not transactional + for (Path location : getLocationsForTruncate(getMS(), dbName, tableName, tbl, partNames)) { + FileSystem fs = location.getFileSystem(getHiveConf()); + HadoopShims.HdfsEncryptionShim shim + = ShimLoader.getHadoopShims().createHdfsEncryptionShim(fs, getHiveConf()); + if (!shim.isPathEncrypted(location)) { + HdfsUtils.HadoopFileStatus status = new HdfsUtils.HadoopFileStatus(getHiveConf(), fs, location); + FileStatus targetStatus = fs.getFileStatus(location); + String targetGroup = targetStatus == null ? null : targetStatus.getGroup(); + wh.deleteDir(location, true, isAutopurge); + fs.mkdirs(location); + HdfsUtils.setFullFileStatus(getHiveConf(), status, targetGroup, fs, location, false); + } else { + FileStatus[] statuses = fs.listStatus(location, FileUtils.HIDDEN_FILES_PATH_FILTER); + if (statuses == null || statuses.length == 0) { + continue; + } + for (final FileStatus status : statuses) { + wh.deleteDir(status.getPath(), true, isAutopurge); + } + } + } + + // Alter the table/partition stats and also notify truncate table event + alterTableStatsForTruncate(getMS(), dbName, tableName, tbl, partNames); + } catch (IOException e) { + throw new MetaException(e.getMessage()); + } catch (Exception e) { + if (e instanceof MetaException) { + throw (MetaException) e; + } else if (e instanceof NoSuchObjectException) { + throw (NoSuchObjectException) e; + } else { + throw newMetaException(e); + } + } + } + /** * Is this an external table? * @@ -3731,7 +3878,7 @@ private void rename_partition(final String db_name, final String tbl_name, MetaStoreListenerNotifier.notifyEvent(listeners, EventType.ALTER_PARTITION, - new AlterPartitionEvent(oldPart, new_part, table, true, this), + new AlterPartitionEvent(oldPart, new_part, table, false, true, this), envContext); } } catch (InvalidObjectException e) { @@ -3804,7 +3951,7 @@ public void alter_partitions_with_environment_context(final String db_name, fina if (!listeners.isEmpty()) { MetaStoreListenerNotifier.notifyEvent(listeners, EventType.ALTER_PARTITION, - new AlterPartitionEvent(oldTmpPart, tmpPart, table, true, this)); + new AlterPartitionEvent(oldTmpPart, tmpPart, table, false, true, this)); } } } catch (InvalidObjectException e) { @@ -3950,7 +4097,7 @@ private void alter_table_core(final String dbname, final String name, final Tabl if (!listeners.isEmpty()) { MetaStoreListenerNotifier.notifyEvent(listeners, EventType.ALTER_TABLE, - new AlterTableEvent(oldt, newTable, true, this), + new AlterTableEvent(oldt, newTable, false, true, this), envContext); } } catch (NoSuchObjectException e) { diff --git a/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java b/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java index dcb14e8084af..53f81188c1cd 100644 --- a/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java +++ b/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java @@ -1092,6 +1092,23 @@ public void dropTable(String dbname, String name, boolean deleteData, } } + /** + * Truncate the table/partitions in the DEFAULT database. + * @param dbName + * The db to which the table to be truncate belongs to + * @param tableName + * The table to truncate + * @param partNames + * List of partitions to truncate. NULL will truncate the whole table/all partitions + * @throws MetaException + * @throws TException + * Could not truncate table properly. + */ + @Override + public void truncateTable(String dbName, String tableName, List partNames) throws MetaException, TException { + client.truncate_table(dbName, tableName, partNames); + } + /** * @param type * @return true if the type is dropped 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 e9df1e149ac0..023a2893c3b0 100644 --- a/metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java +++ b/metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java @@ -304,6 +304,20 @@ void dropTable(String tableName, boolean deleteData) void dropTable(String dbname, String tableName) throws MetaException, TException, NoSuchObjectException; + /** + * Truncate the table/partitions in the DEFAULT database. + * @param dbName + * The db to which the table to be truncate belongs to + * @param tableName + * The table to truncate + * @param partNames + * List of partitions to truncate. NULL will truncate the whole table/all partitions + * @throws MetaException + * @throws TException + * Could not truncate table properly. + */ + void truncateTable(String dbName, String tableName, List partNames) throws MetaException, TException; + boolean tableExists(String databaseName, String tableName) throws MetaException, TException, UnknownDBException; diff --git a/metastore/src/java/org/apache/hadoop/hive/metastore/MetaStoreEventListener.java b/metastore/src/java/org/apache/hadoop/hive/metastore/MetaStoreEventListener.java index b0defb52c509..868e5a57eeaa 100644 --- a/metastore/src/java/org/apache/hadoop/hive/metastore/MetaStoreEventListener.java +++ b/metastore/src/java/org/apache/hadoop/hive/metastore/MetaStoreEventListener.java @@ -74,11 +74,6 @@ public void onCreateTable (CreateTableEvent tableEvent) throws MetaException { public void onDropTable (DropTableEvent tableEvent) throws MetaException { } - /** - * @param add partition event - * @throws MetaException - */ - /** * @param tableEvent alter table event * @throws MetaException @@ -86,8 +81,11 @@ public void onDropTable (DropTableEvent tableEvent) throws MetaException { public void onAlterTable (AlterTableEvent tableEvent) throws MetaException { } - public void onAddPartition (AddPartitionEvent partitionEvent) - throws MetaException { + /** + * @param partitionEvent add partition event + * @throws MetaException + */ + public void onAddPartition (AddPartitionEvent partitionEvent) throws MetaException { } /** diff --git a/metastore/src/java/org/apache/hadoop/hive/metastore/events/AlterPartitionEvent.java b/metastore/src/java/org/apache/hadoop/hive/metastore/events/AlterPartitionEvent.java index 8edb50bc40fc..e5b8495e2de5 100644 --- a/metastore/src/java/org/apache/hadoop/hive/metastore/events/AlterPartitionEvent.java +++ b/metastore/src/java/org/apache/hadoop/hive/metastore/events/AlterPartitionEvent.java @@ -27,13 +27,15 @@ public class AlterPartitionEvent extends ListenerEvent { private final Partition oldPart; private final Partition newPart; private final Table table; + private final boolean isTruncateOp; - public AlterPartitionEvent(Partition oldPart, Partition newPart, Table table, - boolean status, HMSHandler handler) { + public AlterPartitionEvent(Partition oldPart, Partition newPart, Table table, boolean isTruncateOp, + boolean status, HMSHandler handler) { super(status, handler); this.oldPart = oldPart; this.newPart = newPart; this.table = table; + this.isTruncateOp = isTruncateOp; } /** @@ -58,4 +60,12 @@ public Partition getNewPartition() { public Table getTable() { return table; } + + /** + * Get the truncate table flag + * @return + */ + public boolean getIsTruncateOp() { + return isTruncateOp; + } } diff --git a/metastore/src/java/org/apache/hadoop/hive/metastore/events/AlterTableEvent.java b/metastore/src/java/org/apache/hadoop/hive/metastore/events/AlterTableEvent.java index 4d6dce2d0c28..22ea5138fc78 100644 --- a/metastore/src/java/org/apache/hadoop/hive/metastore/events/AlterTableEvent.java +++ b/metastore/src/java/org/apache/hadoop/hive/metastore/events/AlterTableEvent.java @@ -26,10 +26,13 @@ public class AlterTableEvent extends ListenerEvent { private final Table newTable; private final Table oldTable; - public AlterTableEvent (Table oldTable, Table newTable, boolean status, HMSHandler handler) { + private final boolean isTruncateOp; + + public AlterTableEvent (Table oldTable, Table newTable, boolean isTruncateOp, boolean status, HMSHandler handler) { super (status, handler); this.oldTable = oldTable; this.newTable = newTable; + this.isTruncateOp = isTruncateOp; } /** @@ -45,4 +48,11 @@ public Table getOldTable() { public Table getNewTable() { return newTable; } + + /** + * @return the flag for truncate + */ + public boolean getIsTruncateOp() { + return isTruncateOp; + } } \ No newline at end of file diff --git a/metastore/src/java/org/apache/hadoop/hive/metastore/messaging/AlterPartitionMessage.java b/metastore/src/java/org/apache/hadoop/hive/metastore/messaging/AlterPartitionMessage.java index ed6080bef023..e9ed7e5b3b43 100644 --- a/metastore/src/java/org/apache/hadoop/hive/metastore/messaging/AlterPartitionMessage.java +++ b/metastore/src/java/org/apache/hadoop/hive/metastore/messaging/AlterPartitionMessage.java @@ -31,6 +31,8 @@ protected AlterPartitionMessage() { public abstract String getTable(); + public abstract boolean getIsTruncateOp(); + public abstract Map getKeyValues(); public abstract Table getTableObj() throws Exception; diff --git a/metastore/src/java/org/apache/hadoop/hive/metastore/messaging/AlterTableMessage.java b/metastore/src/java/org/apache/hadoop/hive/metastore/messaging/AlterTableMessage.java index 5487123953cd..39a87bcfd105 100644 --- a/metastore/src/java/org/apache/hadoop/hive/metastore/messaging/AlterTableMessage.java +++ b/metastore/src/java/org/apache/hadoop/hive/metastore/messaging/AlterTableMessage.java @@ -28,6 +28,8 @@ protected AlterTableMessage() { public abstract String getTable(); + public abstract boolean getIsTruncateOp(); + public abstract Table getTableObjBefore() throws Exception; public abstract Table getTableObjAfter() throws Exception; diff --git a/metastore/src/java/org/apache/hadoop/hive/metastore/messaging/MessageFactory.java b/metastore/src/java/org/apache/hadoop/hive/metastore/messaging/MessageFactory.java index 1ed7cc50ef37..1bd52a8ce4ee 100644 --- a/metastore/src/java/org/apache/hadoop/hive/metastore/messaging/MessageFactory.java +++ b/metastore/src/java/org/apache/hadoop/hive/metastore/messaging/MessageFactory.java @@ -149,9 +149,10 @@ public static MessageDeserializer getDeserializer(String format, * and some are not yet supported. * @param before The table before the alter * @param after The table after the alter + * @param isTruncateOp Flag to denote truncate table * @return */ - public abstract AlterTableMessage buildAlterTableMessage(Table before, Table after); + public abstract AlterTableMessage buildAlterTableMessage(Table before, Table after, boolean isTruncateOp); /** * Factory method for DropTableMessage. @@ -175,10 +176,11 @@ public abstract AddPartitionMessage buildAddPartitionMessage(Table table, Iterat * @param table The table in which the partition is being altered * @param before The partition before it was altered * @param after The partition after it was altered + * @param isTruncateOp Flag to denote truncate partition * @return a new AlterPartitionMessage */ public abstract AlterPartitionMessage buildAlterPartitionMessage(Table table, Partition before, - Partition after); + Partition after, boolean isTruncateOp); /** * Factory method for DropPartitionMessage. diff --git a/metastore/src/java/org/apache/hadoop/hive/metastore/messaging/json/JSONAlterPartitionMessage.java b/metastore/src/java/org/apache/hadoop/hive/metastore/messaging/json/JSONAlterPartitionMessage.java index dd1bf3c5c31e..bd7776c5d3d5 100644 --- a/metastore/src/java/org/apache/hadoop/hive/metastore/messaging/json/JSONAlterPartitionMessage.java +++ b/metastore/src/java/org/apache/hadoop/hive/metastore/messaging/json/JSONAlterPartitionMessage.java @@ -36,6 +36,9 @@ public class JSONAlterPartitionMessage extends AlterPartitionMessage { @JsonProperty String server, servicePrincipal, db, table, tableObjJson; + @JsonProperty + String isTruncateOp; + @JsonProperty Long timestamp; @@ -52,11 +55,12 @@ public JSONAlterPartitionMessage() { } public JSONAlterPartitionMessage(String server, String servicePrincipal, Table tableObj, - Partition partitionObjBefore, Partition partitionObjAfter, Long timestamp) { + Partition partitionObjBefore, Partition partitionObjAfter, boolean isTruncateOp, Long timestamp) { this.server = server; this.servicePrincipal = servicePrincipal; this.db = tableObj.getDbName(); this.table = tableObj.getTableName(); + this.isTruncateOp = Boolean.toString(isTruncateOp); this.timestamp = timestamp; this.keyValues = JSONMessageFactory.getPartitionKeyValues(tableObj, partitionObjBefore); try { @@ -94,6 +98,9 @@ public String getTable() { return table; } + @Override + public boolean getIsTruncateOp() { return Boolean.parseBoolean(isTruncateOp); } + @Override public Map getKeyValues() { return keyValues; diff --git a/metastore/src/java/org/apache/hadoop/hive/metastore/messaging/json/JSONAlterTableMessage.java b/metastore/src/java/org/apache/hadoop/hive/metastore/messaging/json/JSONAlterTableMessage.java index 792015ef68f3..58eb1a72f076 100644 --- a/metastore/src/java/org/apache/hadoop/hive/metastore/messaging/json/JSONAlterTableMessage.java +++ b/metastore/src/java/org/apache/hadoop/hive/metastore/messaging/json/JSONAlterTableMessage.java @@ -31,6 +31,9 @@ public class JSONAlterTableMessage extends AlterTableMessage { @JsonProperty String server, servicePrincipal, db, table, tableObjBeforeJson, tableObjAfterJson; + @JsonProperty + String isTruncateOp; + @JsonProperty Long timestamp; @@ -41,11 +44,12 @@ public JSONAlterTableMessage() { } public JSONAlterTableMessage(String server, String servicePrincipal, Table tableObjBefore, Table tableObjAfter, - Long timestamp) { + boolean isTruncateOp, Long timestamp) { this.server = server; this.servicePrincipal = servicePrincipal; this.db = tableObjBefore.getDbName(); this.table = tableObjBefore.getTableName(); + this.isTruncateOp = Boolean.toString(isTruncateOp); this.timestamp = timestamp; try { this.tableObjBeforeJson = JSONMessageFactory.createTableObjJson(tableObjBefore); @@ -81,6 +85,9 @@ public String getTable() { return table; } + @Override + public boolean getIsTruncateOp() { return Boolean.parseBoolean(isTruncateOp); } + @Override public Table getTableObjBefore() throws Exception { return (Table) JSONMessageFactory.getTObj(tableObjBeforeJson,Table.class); diff --git a/metastore/src/java/org/apache/hadoop/hive/metastore/messaging/json/JSONMessageFactory.java b/metastore/src/java/org/apache/hadoop/hive/metastore/messaging/json/JSONMessageFactory.java index bb81949cd629..04a4041dd4e2 100644 --- a/metastore/src/java/org/apache/hadoop/hive/metastore/messaging/json/JSONMessageFactory.java +++ b/metastore/src/java/org/apache/hadoop/hive/metastore/messaging/json/JSONMessageFactory.java @@ -28,6 +28,10 @@ import com.google.common.collect.Iterables; +import org.apache.hadoop.fs.FileStatus; +import org.apache.hadoop.fs.FileSystem; +import org.apache.hadoop.fs.Path; +import org.apache.hadoop.hive.common.FileUtils; import org.apache.hadoop.hive.metastore.api.Database; import org.apache.hadoop.hive.metastore.api.Function; import org.apache.hadoop.hive.metastore.api.Index; @@ -104,8 +108,8 @@ public CreateTableMessage buildCreateTableMessage(Table table, Iterator } @Override - public AlterTableMessage buildAlterTableMessage(Table before, Table after) { - return new JSONAlterTableMessage(MS_SERVER_URL, MS_SERVICE_PRINCIPAL, before, after, now()); + public AlterTableMessage buildAlterTableMessage(Table before, Table after, boolean isTruncateOp) { + return new JSONAlterTableMessage(MS_SERVER_URL, MS_SERVICE_PRINCIPAL, before, after, isTruncateOp, now()); } @Override @@ -123,8 +127,8 @@ public AddPartitionMessage buildAddPartitionMessage(Table table, @Override public AlterPartitionMessage buildAlterPartitionMessage(Table table, Partition before, - Partition after) { - return new JSONAlterPartitionMessage(MS_SERVER_URL, MS_SERVICE_PRINCIPAL, table, before, after, + Partition after, boolean isTruncateOp) { + return new JSONAlterPartitionMessage(MS_SERVER_URL, MS_SERVICE_PRINCIPAL, table, before, after, isTruncateOp, now()); } @@ -297,5 +301,4 @@ public String apply(@Nullable JsonNode input) { }; return getTObjs(Iterables.transform(jsonArrayIterator, textExtractor), objClass); } - } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/exec/DDLTask.java b/ql/src/java/org/apache/hadoop/hive/ql/exec/DDLTask.java index 917e565f28b2..757b7fc0eaa3 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/exec/DDLTask.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/exec/DDLTask.java @@ -4661,32 +4661,8 @@ private int truncateTable(Hive db, TruncateTableDesc truncateTableDesc) throws H String tableName = truncateTableDesc.getTableName(); Map partSpec = truncateTableDesc.getPartSpec(); - Table table = db.getTable(tableName, true); - boolean isAutopurge = "true".equalsIgnoreCase(table.getProperty("auto.purge")); try { - // this is not transactional - for (Path location : getLocations(db, table, partSpec)) { - FileSystem fs = location.getFileSystem(conf); - HadoopShims.HdfsEncryptionShim shim - = ShimLoader.getHadoopShims().createHdfsEncryptionShim(fs, conf); - if (!shim.isPathEncrypted(location)) { - HdfsUtils.HadoopFileStatus status = new HdfsUtils.HadoopFileStatus(conf, fs, location); - FileStatus targetStatus = fs.getFileStatus(location); - String targetGroup = targetStatus == null ? null : targetStatus.getGroup(); - FileUtils.moveToTrash(fs, location, conf, isAutopurge); - fs.mkdirs(location); - HdfsUtils.setFullFileStatus(conf, status, targetGroup, fs, location, false); - } else { - FileStatus[] statuses = fs.listStatus(location, FileUtils.HIDDEN_FILES_PATH_FILTER); - if (statuses == null || statuses.length == 0) { - continue; - } - boolean success = Hive.trashFiles(fs, statuses, conf, isAutopurge); - if (!success) { - throw new HiveException("Error in deleting the contents of " + location.toString()); - } - } - } + db.truncateTable(tableName, partSpec); } catch (Exception e) { throw new HiveException(e, ErrorMsg.GENERIC_ERROR); } @@ -4717,58 +4693,6 @@ private int exchangeTablePartition(Hive db, return 0; } - private List getLocations(Hive db, Table table, Map partSpec) - throws HiveException, InvalidOperationException { - List locations = new ArrayList(); - if (partSpec == null) { - if (table.isPartitioned()) { - for (Partition partition : db.getPartitions(table)) { - locations.add(partition.getDataLocation()); - EnvironmentContext environmentContext = new EnvironmentContext(); - if (needToUpdateStats(partition.getParameters(), environmentContext)) { - db.alterPartition(table.getDbName(), table.getTableName(), partition, environmentContext); - } - } - } else { - locations.add(table.getPath()); - EnvironmentContext environmentContext = new EnvironmentContext(); - if (needToUpdateStats(table.getParameters(), environmentContext)) { - db.alterTable(table.getDbName()+"."+table.getTableName(), table, environmentContext); - } - } - } else { - for (Partition partition : db.getPartitionsByNames(table, partSpec)) { - locations.add(partition.getDataLocation()); - EnvironmentContext environmentContext = new EnvironmentContext(); - if (needToUpdateStats(partition.getParameters(), environmentContext)) { - db.alterPartition(table.getDbName(), table.getTableName(), partition, environmentContext); - } - } - } - return locations; - } - - private boolean needToUpdateStats(Map props, EnvironmentContext environmentContext) { - if (null == props) { - return false; - } - boolean statsPresent = false; - for (String stat : StatsSetupConst.supportedStats) { - String statVal = props.get(stat); - if (statVal != null && Long.parseLong(statVal) > 0) { - statsPresent = true; - //In the case of truncate table, we set the stats to be 0. - props.put(stat, "0"); - } - } - //first set basic stats to true - StatsSetupConst.setBasicStatsState(props, StatsSetupConst.TRUE); - environmentContext.putToProperties(StatsSetupConst.STATS_GENERATED, StatsSetupConst.TASK); - //then invalidate column stats - StatsSetupConst.clearColumnStatsState(props); - return statsPresent; - } - @Override public StageType getType() { return StageType.DDL; 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 ec364875e81d..45c77a2f2d88 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 @@ -1201,6 +1201,27 @@ public void dropTable(String dbName, String tableName, boolean deleteData, } } + + + /** + * Truncates the table/partition as per specifications. Just trash the data files + * + * @param dbDotTableName + * name of the table + * @throws HiveException + */ + public void truncateTable(String dbDotTableName, Map partSpec) throws HiveException { + try { + Table table = getTable(dbDotTableName, true); + + List partNames = ((null == partSpec) + ? null : getPartitionNames(table.getDbName(), table.getTableName(), partSpec, (short) -1)); + getMSC().truncateTable(table.getDbName(), table.getTableName(), partNames); + } catch (Exception e) { + throw new HiveException(e); + } + } + public HiveConf getConf() { return (conf); } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/parse/ImportSemanticAnalyzer.java b/ql/src/java/org/apache/hadoop/hive/ql/parse/ImportSemanticAnalyzer.java index 8752e519740b..71d6074cbebc 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/parse/ImportSemanticAnalyzer.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/parse/ImportSemanticAnalyzer.java @@ -505,7 +505,7 @@ private static void checkTable(Table table, ImportTableDesc tableDesc, Replicati } } - // Next, we verify that the destination table is not offline, a view, or a non-native table + // Next, we verify that the destination table is not offline, or a non-native table EximUtil.validateTable(table); // If the import statement specified that we're importing to an external diff --git a/ql/src/java/org/apache/hadoop/hive/ql/parse/ReplicationSemanticAnalyzer.java b/ql/src/java/org/apache/hadoop/hive/ql/parse/ReplicationSemanticAnalyzer.java index a85ba420e262..c4cc9bcdd367 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/parse/ReplicationSemanticAnalyzer.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/parse/ReplicationSemanticAnalyzer.java @@ -71,6 +71,7 @@ import org.apache.hadoop.hive.ql.plan.ExprNodeGenericFuncDesc; import org.apache.hadoop.hive.ql.plan.PlanUtils; import org.apache.hadoop.hive.ql.plan.RenamePartitionDesc; +import org.apache.hadoop.hive.ql.plan.TruncateTableDesc; import org.apache.hadoop.hive.serde2.typeinfo.PrimitiveTypeInfo; import org.apache.hadoop.hive.serde2.typeinfo.TypeInfoFactory; import org.apache.hadoop.io.IOUtils; @@ -128,8 +129,10 @@ public enum DUMPTYPE { EVENT_DROP_PARTITION("EVENT_DROP_PARTITION"), EVENT_ALTER_TABLE("EVENT_ALTER_TABLE"), EVENT_RENAME_TABLE("EVENT_RENAME_TABLE"), + EVENT_TRUNCATE_TABLE("EVENT_TRUNCATE_TABLE"), EVENT_ALTER_PARTITION("EVENT_ALTER_PARTITION"), EVENT_RENAME_PARTITION("EVENT_RENAME_PARTITION"), + EVENT_TRUNCATE_PARTITION("EVENT_TRUNCATE_PARTITION"), EVENT_INSERT("EVENT_INSERT"), EVENT_UNKNOWN("EVENT_UNKNOWN"); @@ -937,6 +940,24 @@ private List> analyzeEventLoad( } } } + case EVENT_TRUNCATE_TABLE: { + AlterTableMessage truncateTableMessage = md.getAlterTableMessage(dmd.getPayload()); + String actualDbName = ((dbName == null) || dbName.isEmpty() ? truncateTableMessage.getDB() : dbName); + String actualTblName = ((tblName == null) || tblName.isEmpty() ? truncateTableMessage.getTable() : tblName); + + TruncateTableDesc truncateTableDesc = new TruncateTableDesc( + actualDbName + "." + actualTblName, null); + Task truncateTableTask = TaskFactory.get(new DDLWork(inputs, outputs, truncateTableDesc), conf); + if (precursor != null) { + precursor.addDependentTask(truncateTableTask); + } + + List> tasks = new ArrayList>(); + tasks.add(truncateTableTask); + LOG.debug("Added truncate tbl task : {}:{}", truncateTableTask.getId(), truncateTableDesc.getTableName()); + dbsUpdated.put(actualDbName,dmd.getEventTo()); + return tasks; + } case EVENT_ALTER_PARTITION: { return analyzeTableLoad(dbName, tblName, locn, precursor, dbsUpdated, tablesUpdated); } @@ -978,6 +999,40 @@ private List> analyzeEventLoad( tablesUpdated.put(tableName, dmd.getEventTo()); return tasks; } + case EVENT_TRUNCATE_PARTITION: { + AlterPartitionMessage truncatePtnMessage = md.getAlterPartitionMessage(dmd.getPayload()); + String actualDbName = ((dbName == null) || dbName.isEmpty() ? truncatePtnMessage.getDB() : dbName); + String actualTblName = ((tblName == null) || tblName.isEmpty() ? truncatePtnMessage.getTable() : tblName); + + Map partSpec = new LinkedHashMap(); + try { + org.apache.hadoop.hive.metastore.api.Table tblObj = truncatePtnMessage.getTableObj(); + org.apache.hadoop.hive.metastore.api.Partition pobjAfter = truncatePtnMessage.getPtnObjAfter(); + Iterator afterValIter = pobjAfter.getValuesIterator(); + for (FieldSchema fs : tblObj.getPartitionKeys()){ + partSpec.put(fs.getName(), afterValIter.next()); + } + } catch (Exception e) { + if (!(e instanceof SemanticException)){ + throw new SemanticException("Error reading message members", e); + } else { + throw (SemanticException)e; + } + } + + TruncateTableDesc truncateTableDesc = new TruncateTableDesc( + actualDbName + "." + actualTblName, partSpec); + Task truncatePtnTask = TaskFactory.get(new DDLWork(inputs, outputs, truncateTableDesc), conf); + if (precursor != null) { + precursor.addDependentTask(truncatePtnTask); + } + + List> tasks = new ArrayList>(); + tasks.add(truncatePtnTask); + LOG.debug("Added truncate ptn task : {}:{}", truncatePtnTask.getId(), truncateTableDesc.getTableName()); + dbsUpdated.put(actualDbName,dmd.getEventTo()); + return tasks; + } case EVENT_INSERT: { md = MessageFactory.getInstance().getDeserializer(); InsertMessage insertMessage = md.getInsertMessage(dmd.getPayload()); diff --git a/ql/src/java/org/apache/hadoop/hive/ql/parse/repl/events/AlterPartitionHandler.java b/ql/src/java/org/apache/hadoop/hive/ql/parse/repl/events/AlterPartitionHandler.java index 1073cd093c6d..20d04dcb7f96 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/parse/repl/events/AlterPartitionHandler.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/parse/repl/events/AlterPartitionHandler.java @@ -23,6 +23,7 @@ import org.apache.hadoop.hive.ql.metadata.Partition; import org.apache.hadoop.hive.ql.metadata.Table; import org.apache.hadoop.hive.ql.parse.EximUtil; +import org.apache.hadoop.hive.ql.parse.SemanticException; import java.util.ArrayList; import java.util.Iterator; @@ -34,6 +35,7 @@ public class AlterPartitionHandler extends AbstractHandler { private final org.apache.hadoop.hive.metastore.api.Partition after; private final org.apache.hadoop.hive.metastore.api.Table tableObject; + private final boolean isTruncateOp; private final Scenario scenario; AlterPartitionHandler(NotificationEvent event) throws Exception { @@ -42,6 +44,7 @@ public class AlterPartitionHandler extends AbstractHandler { tableObject = apm.getTableObj(); org.apache.hadoop.hive.metastore.api.Partition before = apm.getPtnObjBefore(); after = apm.getPtnObjAfter(); + isTruncateOp = apm.getIsTruncateOp(); scenario = scenarioType(before, after); } @@ -57,12 +60,18 @@ DUMPTYPE dumpType() { DUMPTYPE dumpType() { return DUMPTYPE.EVENT_RENAME_PARTITION; } + }, + TRUNCATE { + @Override + DUMPTYPE dumpType() { + return DUMPTYPE.EVENT_TRUNCATE_PARTITION; + } }; abstract DUMPTYPE dumpType(); } - private static Scenario scenarioType(org.apache.hadoop.hive.metastore.api.Partition before, + private Scenario scenarioType(org.apache.hadoop.hive.metastore.api.Partition before, org.apache.hadoop.hive.metastore.api.Partition after) { Iterator beforeValIter = before.getValuesIterator(); Iterator afterValIter = after.getValuesIterator(); @@ -71,7 +80,7 @@ private static Scenario scenarioType(org.apache.hadoop.hive.metastore.api.Partit return Scenario.RENAME; } } - return Scenario.ALTER; + return isTruncateOp ? Scenario.TRUNCATE : Scenario.ALTER; } @Override diff --git a/ql/src/java/org/apache/hadoop/hive/ql/parse/repl/events/AlterTableHandler.java b/ql/src/java/org/apache/hadoop/hive/ql/parse/repl/events/AlterTableHandler.java index 04d9d79d8799..bfe018163d0e 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/parse/repl/events/AlterTableHandler.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/parse/repl/events/AlterTableHandler.java @@ -22,6 +22,7 @@ import org.apache.hadoop.hive.metastore.messaging.AlterTableMessage; import org.apache.hadoop.hive.ql.metadata.Table; import org.apache.hadoop.hive.ql.parse.EximUtil; +import org.apache.hadoop.hive.ql.parse.SemanticException; import static org.apache.hadoop.hive.ql.parse.ReplicationSemanticAnalyzer.DUMPTYPE; import static org.apache.hadoop.hive.ql.parse.ReplicationSemanticAnalyzer.DumpMetaData; @@ -29,6 +30,7 @@ public class AlterTableHandler extends AbstractHandler { private final org.apache.hadoop.hive.metastore.api.Table before; private final org.apache.hadoop.hive.metastore.api.Table after; + private final boolean isTruncateOp; private final Scenario scenario; private enum Scenario { @@ -43,6 +45,12 @@ DUMPTYPE dumpType() { DUMPTYPE dumpType() { return DUMPTYPE.EVENT_RENAME_TABLE; } + }, + TRUNCATE { + @Override + DUMPTYPE dumpType() { + return DUMPTYPE.EVENT_TRUNCATE_TABLE; + } }; abstract DUMPTYPE dumpType(); @@ -53,15 +61,18 @@ DUMPTYPE dumpType() { AlterTableMessage atm = deserializer.getAlterTableMessage(event.getMessage()); before = atm.getTableObjBefore(); after = atm.getTableObjAfter(); + isTruncateOp = atm.getIsTruncateOp(); scenario = scenarioType(before, after); } - private static Scenario scenarioType(org.apache.hadoop.hive.metastore.api.Table before, + private Scenario scenarioType(org.apache.hadoop.hive.metastore.api.Table before, org.apache.hadoop.hive.metastore.api.Table after) { - return before.getDbName().equals(after.getDbName()) - && before.getTableName().equals(after.getTableName()) - ? Scenario.ALTER - : Scenario.RENAME; + if (before.getDbName().equals(after.getDbName()) + && before.getTableName().equals(after.getTableName())) { + return isTruncateOp ? Scenario.TRUNCATE : Scenario.ALTER; + } else { + return Scenario.RENAME; + } } @Override diff --git a/ql/src/test/results/clientpositive/columnStatsUpdateForStatsOptimizer_2.q.out b/ql/src/test/results/clientpositive/columnStatsUpdateForStatsOptimizer_2.q.out index af21343ae0d0..a7c9b3fc414d 100644 --- a/ql/src/test/results/clientpositive/columnStatsUpdateForStatsOptimizer_2.q.out +++ b/ql/src/test/results/clientpositive/columnStatsUpdateForStatsOptimizer_2.q.out @@ -292,10 +292,10 @@ Table Type: MANAGED_TABLE Table Parameters: COLUMN_STATS_ACCURATE {\"BASIC_STATS\":\"true\"} #### A masked pattern was here #### - numFiles 2 + numFiles 0 numRows 0 rawDataSize 0 - totalSize 547 + totalSize 0 #### A masked pattern was here #### # Storage Information @@ -322,11 +322,11 @@ STAGE PLANS: Map Operator Tree: TableScan alias: calendar - Statistics: Num rows: 136 Data size: 547 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Select Operator expressions: month (type: int) outputColumnNames: month - Statistics: Num rows: 136 Data size: 547 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Group By Operator aggregations: max(month) mode: hash