commit 9aa5b2203673ea75e725b166bb8f2eab9df97ac8 Author: Alan Gates Date: Thu May 24 12:04:13 2018 -0700 HIVE-19688 Make catalogs updatable diff --git beeline/src/java/org/apache/hive/beeline/HiveSchemaTool.java beeline/src/java/org/apache/hive/beeline/HiveSchemaTool.java index 7aad265b0a..7bf12dcabc 100644 --- beeline/src/java/org/apache/hive/beeline/HiveSchemaTool.java +++ beeline/src/java/org/apache/hive/beeline/HiveSchemaTool.java @@ -928,6 +928,12 @@ void createCatalog(String catName, String location, String description, boolean throw new HiveMetaException("No catalogs found, have you upgraded the database?"); } int catNum = rs.getInt(1) + 1; + // We need to stay out of the way of any sequences used by the underlying database. + // Otherwise the next time the client tries to add a catalog we'll get an error. + // There should never be billions of catalogs, so we'll shift our sequence number up + // there to avoid clashes. + int floor = 1 << 30; + if (catNum < floor) catNum = floor; String update = "insert into " + quoteIf("CTLGS") + "(" + quoteIf("CTLG_ID") + ", " + quoteIf("NAME") + ", " + quoteAlways("DESC") + ", " + quoteIf( "LOCATION_URI") + ") " + @@ -950,6 +956,61 @@ void createCatalog(String catName, String location, String description, boolean } @VisibleForTesting + void alterCatalog(String catName, String location, String description) throws HiveMetaException { + if (location == null && description == null) { + throw new HiveMetaException("Asked to update catalog " + catName + + " but not given any changes to update"); + } + catName = normalizeIdentifier(catName); + System.out.println("Updating catalog " + catName); + + Connection conn = getConnectionToMetastore(true); + boolean success = false; + try { + conn.setAutoCommit(false); + try (Statement stmt = conn.createStatement()) { + StringBuilder update = new StringBuilder("update ") + .append(quoteIf("CTLGS")) + .append(" set "); + if (location != null) { + update.append(quoteIf("LOCATION_URI")) + .append(" = '") + .append(location) + .append("' "); + } + if (description != null) { + if (location != null) update.append(", "); + update.append(quoteAlways("DESC")) + .append(" = '") + .append(description) + .append("'"); + } + update.append(" where ") + .append(quoteIf("NAME")) + .append(" = '") + .append(catName) + .append("'"); + LOG.debug("Going to run " + update.toString()); + int count = stmt.executeUpdate(update.toString()); + if (count != 1) { + throw new HiveMetaException("Failed to find catalog " + catName + " to update"); + } + conn.commit(); + success = true; + } + } catch (SQLException e) { + throw new HiveMetaException("Failed to update catalog", e); + } finally { + try { + if (!success) conn.rollback(); + } catch (SQLException e) { + // Not really much we can do here. + LOG.error("Failed to rollback, everything will probably go bad from here.", e); + } + } + } + + @VisibleForTesting void moveDatabase(String fromCatName, String toCatName, String dbName) throws HiveMetaException { fromCatName = normalizeIdentifier(fromCatName); toCatName = normalizeIdentifier(toCatName); @@ -1243,6 +1304,10 @@ private static void initOptions(Options cmdLineOptions) { .hasArg() .withDescription("Create a catalog, requires --catalogLocation parameter as well") .create("createCatalog"); + Option alterCatalog = OptionBuilder + .hasArg() + .withDescription("Alter a catalog, requires --catalogLocation and/or --catalogDescription parameter as well") + .create("alterCatalog"); Option moveDatabase = OptionBuilder .hasArg() .withDescription("Move a database between catalogs. Argument is the database name. " + @@ -1256,10 +1321,17 @@ private static void initOptions(Options cmdLineOptions) { .create("moveTable"); OptionGroup optGroup = new OptionGroup(); - optGroup.addOption(upgradeOpt).addOption(initOpt). - addOption(help).addOption(upgradeFromOpt). - addOption(initToOpt).addOption(infoOpt).addOption(validateOpt) - .addOption(createCatalog).addOption(moveDatabase).addOption(moveTable); + optGroup.addOption(upgradeOpt) + .addOption(initOpt) + .addOption(help) + .addOption(upgradeFromOpt) + .addOption(initToOpt) + .addOption(infoOpt) + .addOption(validateOpt) + .addOption(createCatalog) + .addOption(alterCatalog) + .addOption(moveDatabase) + .addOption(moveTable); optGroup.setRequired(true); Option userNameOpt = OptionBuilder.withArgName("user") @@ -1459,6 +1531,9 @@ public static void main(String[] args) { schemaTool.createCatalog(line.getOptionValue("createCatalog"), line.getOptionValue("catalogLocation"), line.getOptionValue("catalogDescription"), line.hasOption("ifNotExists")); + } else if (line.hasOption("alterCatalog")) { + schemaTool.alterCatalog(line.getOptionValue("alterCatalog"), + line.getOptionValue("catalogLocation"), line.getOptionValue("catalogDescription")); } else if (line.hasOption("moveDatabase")) { schemaTool.moveDatabase(line.getOptionValue("fromCatalog"), line.getOptionValue("toCatalog"), line.getOptionValue("moveDatabase")); diff --git itests/hive-unit/src/test/java/org/apache/hive/beeline/TestSchemaToolCatalogOps.java itests/hive-unit/src/test/java/org/apache/hive/beeline/TestSchemaToolCatalogOps.java index db10ae64f7..f5bc570bdf 100644 --- itests/hive-unit/src/test/java/org/apache/hive/beeline/TestSchemaToolCatalogOps.java +++ itests/hive-unit/src/test/java/org/apache/hive/beeline/TestSchemaToolCatalogOps.java @@ -108,7 +108,7 @@ public void createExistingCatalog() throws HiveMetaException { } @Test - public void createExistingCatalogWithIfNotExists() throws HiveMetaException, TException { + public void createExistingCatalogWithIfNotExists() throws HiveMetaException { String catName = "my_existing_test_catalog"; String location = "file:///tmp/my_test_catalog"; String description = "very descriptive"; @@ -118,6 +118,48 @@ public void createExistingCatalogWithIfNotExists() throws HiveMetaException, TEx } @Test + public void alterCatalog() throws HiveMetaException, TException { + String catName = "an_alterable_catalog"; + String location = "file:///tmp/an_alterable_catalog"; + String description = "description"; + schemaTool.createCatalog(catName, location, description, false); + + location = "file:///tmp/somewhere_else"; + schemaTool.alterCatalog(catName, location, null); + Catalog cat = client.getCatalog(catName); + Assert.assertEquals(location, cat.getLocationUri()); + Assert.assertEquals(description, cat.getDescription()); + + description = "a better description"; + schemaTool.alterCatalog(catName, null, description); + cat = client.getCatalog(catName); + Assert.assertEquals(location, cat.getLocationUri()); + Assert.assertEquals(description, cat.getDescription()); + + location = "file:///tmp/a_third_location"; + description = "best description yet"; + schemaTool.alterCatalog(catName, location, description); + cat = client.getCatalog(catName); + Assert.assertEquals(location, cat.getLocationUri()); + Assert.assertEquals(description, cat.getDescription()); + } + + @Test(expected = HiveMetaException.class) + public void alterBogusCatalog() throws HiveMetaException { + schemaTool.alterCatalog("nosuch", "file:///tmp/somewhere", "whatever"); + } + + @Test(expected = HiveMetaException.class) + public void alterCatalogNoChange() throws HiveMetaException { + String catName = "alter_cat_no_change"; + String location = "file:///tmp/alter_cat_no_change"; + String description = "description"; + schemaTool.createCatalog(catName, location, description, false); + + schemaTool.alterCatalog(catName, null, null); + } + + @Test public void moveDatabase() throws HiveMetaException, TException { String toCatName = "moveDbCat"; String dbName = "moveDbDb"; diff --git standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp index a25ebe5c1d..ae287f9a9f 100644 --- standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp +++ standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp @@ -646,6 +646,233 @@ uint32_t ThriftHiveMetastore_create_catalog_presult::read(::apache::thrift::prot } +ThriftHiveMetastore_alter_catalog_args::~ThriftHiveMetastore_alter_catalog_args() throw() { +} + + +uint32_t ThriftHiveMetastore_alter_catalog_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->rqst.read(iprot); + this->__isset.rqst = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_alter_catalog_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_catalog_args"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->rqst.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_catalog_pargs::~ThriftHiveMetastore_alter_catalog_pargs() throw() { +} + + +uint32_t ThriftHiveMetastore_alter_catalog_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_catalog_pargs"); + + xfer += oprot->writeFieldBegin("rqst", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->rqst)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_catalog_result::~ThriftHiveMetastore_alter_catalog_result() throw() { +} + + +uint32_t ThriftHiveMetastore_alter_catalog_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_alter_catalog_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_alter_catalog_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_alter_catalog_presult::~ThriftHiveMetastore_alter_catalog_presult() throw() { +} + + +uint32_t ThriftHiveMetastore_alter_catalog_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + ThriftHiveMetastore_get_catalog_args::~ThriftHiveMetastore_get_catalog_args() throw() { } @@ -2107,14 +2334,14 @@ uint32_t ThriftHiveMetastore_get_databases_result::read(::apache::thrift::protoc if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1200; - ::apache::thrift::protocol::TType _etype1203; - xfer += iprot->readListBegin(_etype1203, _size1200); - this->success.resize(_size1200); - uint32_t _i1204; - for (_i1204 = 0; _i1204 < _size1200; ++_i1204) + uint32_t _size1202; + ::apache::thrift::protocol::TType _etype1205; + xfer += iprot->readListBegin(_etype1205, _size1202); + this->success.resize(_size1202); + uint32_t _i1206; + for (_i1206 = 0; _i1206 < _size1202; ++_i1206) { - xfer += iprot->readString(this->success[_i1204]); + xfer += iprot->readString(this->success[_i1206]); } xfer += iprot->readListEnd(); } @@ -2153,10 +2380,10 @@ uint32_t ThriftHiveMetastore_get_databases_result::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1205; - for (_iter1205 = this->success.begin(); _iter1205 != this->success.end(); ++_iter1205) + std::vector ::const_iterator _iter1207; + for (_iter1207 = this->success.begin(); _iter1207 != this->success.end(); ++_iter1207) { - xfer += oprot->writeString((*_iter1205)); + xfer += oprot->writeString((*_iter1207)); } xfer += oprot->writeListEnd(); } @@ -2201,14 +2428,14 @@ uint32_t ThriftHiveMetastore_get_databases_presult::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1206; - ::apache::thrift::protocol::TType _etype1209; - xfer += iprot->readListBegin(_etype1209, _size1206); - (*(this->success)).resize(_size1206); - uint32_t _i1210; - for (_i1210 = 0; _i1210 < _size1206; ++_i1210) + 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) { - xfer += iprot->readString((*(this->success))[_i1210]); + xfer += iprot->readString((*(this->success))[_i1212]); } xfer += iprot->readListEnd(); } @@ -2325,14 +2552,14 @@ uint32_t ThriftHiveMetastore_get_all_databases_result::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1211; - ::apache::thrift::protocol::TType _etype1214; - xfer += iprot->readListBegin(_etype1214, _size1211); - this->success.resize(_size1211); - uint32_t _i1215; - for (_i1215 = 0; _i1215 < _size1211; ++_i1215) + uint32_t _size1213; + ::apache::thrift::protocol::TType _etype1216; + xfer += iprot->readListBegin(_etype1216, _size1213); + this->success.resize(_size1213); + uint32_t _i1217; + for (_i1217 = 0; _i1217 < _size1213; ++_i1217) { - xfer += iprot->readString(this->success[_i1215]); + xfer += iprot->readString(this->success[_i1217]); } xfer += iprot->readListEnd(); } @@ -2371,10 +2598,10 @@ uint32_t ThriftHiveMetastore_get_all_databases_result::write(::apache::thrift::p xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1216; - for (_iter1216 = this->success.begin(); _iter1216 != this->success.end(); ++_iter1216) + std::vector ::const_iterator _iter1218; + for (_iter1218 = this->success.begin(); _iter1218 != this->success.end(); ++_iter1218) { - xfer += oprot->writeString((*_iter1216)); + xfer += oprot->writeString((*_iter1218)); } xfer += oprot->writeListEnd(); } @@ -2419,14 +2646,14 @@ uint32_t ThriftHiveMetastore_get_all_databases_presult::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1217; - ::apache::thrift::protocol::TType _etype1220; - xfer += iprot->readListBegin(_etype1220, _size1217); - (*(this->success)).resize(_size1217); - uint32_t _i1221; - for (_i1221 = 0; _i1221 < _size1217; ++_i1221) + uint32_t _size1219; + ::apache::thrift::protocol::TType _etype1222; + xfer += iprot->readListBegin(_etype1222, _size1219); + (*(this->success)).resize(_size1219); + uint32_t _i1223; + for (_i1223 = 0; _i1223 < _size1219; ++_i1223) { - xfer += iprot->readString((*(this->success))[_i1221]); + xfer += iprot->readString((*(this->success))[_i1223]); } xfer += iprot->readListEnd(); } @@ -3488,17 +3715,17 @@ uint32_t ThriftHiveMetastore_get_type_all_result::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_MAP) { { this->success.clear(); - uint32_t _size1222; - ::apache::thrift::protocol::TType _ktype1223; - ::apache::thrift::protocol::TType _vtype1224; - xfer += iprot->readMapBegin(_ktype1223, _vtype1224, _size1222); - uint32_t _i1226; - for (_i1226 = 0; _i1226 < _size1222; ++_i1226) + uint32_t _size1224; + ::apache::thrift::protocol::TType _ktype1225; + ::apache::thrift::protocol::TType _vtype1226; + xfer += iprot->readMapBegin(_ktype1225, _vtype1226, _size1224); + uint32_t _i1228; + for (_i1228 = 0; _i1228 < _size1224; ++_i1228) { - std::string _key1227; - xfer += iprot->readString(_key1227); - Type& _val1228 = this->success[_key1227]; - xfer += _val1228.read(iprot); + std::string _key1229; + xfer += iprot->readString(_key1229); + Type& _val1230 = this->success[_key1229]; + xfer += _val1230.read(iprot); } xfer += iprot->readMapEnd(); } @@ -3537,11 +3764,11 @@ uint32_t ThriftHiveMetastore_get_type_all_result::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_MAP, 0); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::map ::const_iterator _iter1229; - for (_iter1229 = this->success.begin(); _iter1229 != this->success.end(); ++_iter1229) + std::map ::const_iterator _iter1231; + for (_iter1231 = this->success.begin(); _iter1231 != this->success.end(); ++_iter1231) { - xfer += oprot->writeString(_iter1229->first); - xfer += _iter1229->second.write(oprot); + xfer += oprot->writeString(_iter1231->first); + xfer += _iter1231->second.write(oprot); } xfer += oprot->writeMapEnd(); } @@ -3586,17 +3813,17 @@ uint32_t ThriftHiveMetastore_get_type_all_presult::read(::apache::thrift::protoc if (ftype == ::apache::thrift::protocol::T_MAP) { { (*(this->success)).clear(); - uint32_t _size1230; - ::apache::thrift::protocol::TType _ktype1231; - ::apache::thrift::protocol::TType _vtype1232; - xfer += iprot->readMapBegin(_ktype1231, _vtype1232, _size1230); - uint32_t _i1234; - for (_i1234 = 0; _i1234 < _size1230; ++_i1234) + uint32_t _size1232; + ::apache::thrift::protocol::TType _ktype1233; + ::apache::thrift::protocol::TType _vtype1234; + xfer += iprot->readMapBegin(_ktype1233, _vtype1234, _size1232); + uint32_t _i1236; + for (_i1236 = 0; _i1236 < _size1232; ++_i1236) { - std::string _key1235; - xfer += iprot->readString(_key1235); - Type& _val1236 = (*(this->success))[_key1235]; - xfer += _val1236.read(iprot); + std::string _key1237; + xfer += iprot->readString(_key1237); + Type& _val1238 = (*(this->success))[_key1237]; + xfer += _val1238.read(iprot); } xfer += iprot->readMapEnd(); } @@ -3750,14 +3977,14 @@ uint32_t ThriftHiveMetastore_get_fields_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1237; - ::apache::thrift::protocol::TType _etype1240; - xfer += iprot->readListBegin(_etype1240, _size1237); - this->success.resize(_size1237); - uint32_t _i1241; - for (_i1241 = 0; _i1241 < _size1237; ++_i1241) + uint32_t _size1239; + ::apache::thrift::protocol::TType _etype1242; + xfer += iprot->readListBegin(_etype1242, _size1239); + this->success.resize(_size1239); + uint32_t _i1243; + for (_i1243 = 0; _i1243 < _size1239; ++_i1243) { - xfer += this->success[_i1241].read(iprot); + xfer += this->success[_i1243].read(iprot); } xfer += iprot->readListEnd(); } @@ -3812,10 +4039,10 @@ uint32_t ThriftHiveMetastore_get_fields_result::write(::apache::thrift::protocol xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1242; - for (_iter1242 = this->success.begin(); _iter1242 != this->success.end(); ++_iter1242) + std::vector ::const_iterator _iter1244; + for (_iter1244 = this->success.begin(); _iter1244 != this->success.end(); ++_iter1244) { - xfer += (*_iter1242).write(oprot); + xfer += (*_iter1244).write(oprot); } xfer += oprot->writeListEnd(); } @@ -3868,14 +4095,14 @@ uint32_t ThriftHiveMetastore_get_fields_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1243; - ::apache::thrift::protocol::TType _etype1246; - xfer += iprot->readListBegin(_etype1246, _size1243); - (*(this->success)).resize(_size1243); - uint32_t _i1247; - for (_i1247 = 0; _i1247 < _size1243; ++_i1247) + uint32_t _size1245; + ::apache::thrift::protocol::TType _etype1248; + xfer += iprot->readListBegin(_etype1248, _size1245); + (*(this->success)).resize(_size1245); + uint32_t _i1249; + for (_i1249 = 0; _i1249 < _size1245; ++_i1249) { - xfer += (*(this->success))[_i1247].read(iprot); + xfer += (*(this->success))[_i1249].read(iprot); } xfer += iprot->readListEnd(); } @@ -4061,14 +4288,14 @@ uint32_t ThriftHiveMetastore_get_fields_with_environment_context_result::read(:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1248; - ::apache::thrift::protocol::TType _etype1251; - xfer += iprot->readListBegin(_etype1251, _size1248); - this->success.resize(_size1248); - uint32_t _i1252; - for (_i1252 = 0; _i1252 < _size1248; ++_i1252) + uint32_t _size1250; + ::apache::thrift::protocol::TType _etype1253; + xfer += iprot->readListBegin(_etype1253, _size1250); + this->success.resize(_size1250); + uint32_t _i1254; + for (_i1254 = 0; _i1254 < _size1250; ++_i1254) { - xfer += this->success[_i1252].read(iprot); + xfer += this->success[_i1254].read(iprot); } xfer += iprot->readListEnd(); } @@ -4123,10 +4350,10 @@ uint32_t ThriftHiveMetastore_get_fields_with_environment_context_result::write(: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1253; - for (_iter1253 = this->success.begin(); _iter1253 != this->success.end(); ++_iter1253) + std::vector ::const_iterator _iter1255; + for (_iter1255 = this->success.begin(); _iter1255 != this->success.end(); ++_iter1255) { - xfer += (*_iter1253).write(oprot); + xfer += (*_iter1255).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4179,14 +4406,14 @@ uint32_t ThriftHiveMetastore_get_fields_with_environment_context_presult::read(: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1254; - ::apache::thrift::protocol::TType _etype1257; - xfer += iprot->readListBegin(_etype1257, _size1254); - (*(this->success)).resize(_size1254); - uint32_t _i1258; - for (_i1258 = 0; _i1258 < _size1254; ++_i1258) + uint32_t _size1256; + ::apache::thrift::protocol::TType _etype1259; + xfer += iprot->readListBegin(_etype1259, _size1256); + (*(this->success)).resize(_size1256); + uint32_t _i1260; + for (_i1260 = 0; _i1260 < _size1256; ++_i1260) { - xfer += (*(this->success))[_i1258].read(iprot); + xfer += (*(this->success))[_i1260].read(iprot); } xfer += iprot->readListEnd(); } @@ -4356,14 +4583,14 @@ uint32_t ThriftHiveMetastore_get_schema_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1259; - ::apache::thrift::protocol::TType _etype1262; - xfer += iprot->readListBegin(_etype1262, _size1259); - this->success.resize(_size1259); - uint32_t _i1263; - for (_i1263 = 0; _i1263 < _size1259; ++_i1263) + uint32_t _size1261; + ::apache::thrift::protocol::TType _etype1264; + xfer += iprot->readListBegin(_etype1264, _size1261); + this->success.resize(_size1261); + uint32_t _i1265; + for (_i1265 = 0; _i1265 < _size1261; ++_i1265) { - xfer += this->success[_i1263].read(iprot); + xfer += this->success[_i1265].read(iprot); } xfer += iprot->readListEnd(); } @@ -4418,10 +4645,10 @@ uint32_t ThriftHiveMetastore_get_schema_result::write(::apache::thrift::protocol xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1264; - for (_iter1264 = this->success.begin(); _iter1264 != this->success.end(); ++_iter1264) + std::vector ::const_iterator _iter1266; + for (_iter1266 = this->success.begin(); _iter1266 != this->success.end(); ++_iter1266) { - xfer += (*_iter1264).write(oprot); + xfer += (*_iter1266).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4474,14 +4701,14 @@ uint32_t ThriftHiveMetastore_get_schema_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1265; - ::apache::thrift::protocol::TType _etype1268; - xfer += iprot->readListBegin(_etype1268, _size1265); - (*(this->success)).resize(_size1265); - uint32_t _i1269; - for (_i1269 = 0; _i1269 < _size1265; ++_i1269) + uint32_t _size1267; + ::apache::thrift::protocol::TType _etype1270; + xfer += iprot->readListBegin(_etype1270, _size1267); + (*(this->success)).resize(_size1267); + uint32_t _i1271; + for (_i1271 = 0; _i1271 < _size1267; ++_i1271) { - xfer += (*(this->success))[_i1269].read(iprot); + xfer += (*(this->success))[_i1271].read(iprot); } xfer += iprot->readListEnd(); } @@ -4667,14 +4894,14 @@ uint32_t ThriftHiveMetastore_get_schema_with_environment_context_result::read(:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1270; - ::apache::thrift::protocol::TType _etype1273; - xfer += iprot->readListBegin(_etype1273, _size1270); - this->success.resize(_size1270); - uint32_t _i1274; - for (_i1274 = 0; _i1274 < _size1270; ++_i1274) + uint32_t _size1272; + ::apache::thrift::protocol::TType _etype1275; + xfer += iprot->readListBegin(_etype1275, _size1272); + this->success.resize(_size1272); + uint32_t _i1276; + for (_i1276 = 0; _i1276 < _size1272; ++_i1276) { - xfer += this->success[_i1274].read(iprot); + xfer += this->success[_i1276].read(iprot); } xfer += iprot->readListEnd(); } @@ -4729,10 +4956,10 @@ uint32_t ThriftHiveMetastore_get_schema_with_environment_context_result::write(: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1275; - for (_iter1275 = this->success.begin(); _iter1275 != this->success.end(); ++_iter1275) + std::vector ::const_iterator _iter1277; + for (_iter1277 = this->success.begin(); _iter1277 != this->success.end(); ++_iter1277) { - xfer += (*_iter1275).write(oprot); + xfer += (*_iter1277).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4785,14 +5012,14 @@ uint32_t ThriftHiveMetastore_get_schema_with_environment_context_presult::read(: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1276; - ::apache::thrift::protocol::TType _etype1279; - xfer += iprot->readListBegin(_etype1279, _size1276); - (*(this->success)).resize(_size1276); - uint32_t _i1280; - for (_i1280 = 0; _i1280 < _size1276; ++_i1280) + uint32_t _size1278; + ::apache::thrift::protocol::TType _etype1281; + xfer += iprot->readListBegin(_etype1281, _size1278); + (*(this->success)).resize(_size1278); + uint32_t _i1282; + for (_i1282 = 0; _i1282 < _size1278; ++_i1282) { - xfer += (*(this->success))[_i1280].read(iprot); + xfer += (*(this->success))[_i1282].read(iprot); } xfer += iprot->readListEnd(); } @@ -5385,14 +5612,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->primaryKeys.clear(); - uint32_t _size1281; - ::apache::thrift::protocol::TType _etype1284; - xfer += iprot->readListBegin(_etype1284, _size1281); - this->primaryKeys.resize(_size1281); - uint32_t _i1285; - for (_i1285 = 0; _i1285 < _size1281; ++_i1285) + uint32_t _size1283; + ::apache::thrift::protocol::TType _etype1286; + xfer += iprot->readListBegin(_etype1286, _size1283); + this->primaryKeys.resize(_size1283); + uint32_t _i1287; + for (_i1287 = 0; _i1287 < _size1283; ++_i1287) { - xfer += this->primaryKeys[_i1285].read(iprot); + xfer += this->primaryKeys[_i1287].read(iprot); } xfer += iprot->readListEnd(); } @@ -5405,14 +5632,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->foreignKeys.clear(); - uint32_t _size1286; - ::apache::thrift::protocol::TType _etype1289; - xfer += iprot->readListBegin(_etype1289, _size1286); - this->foreignKeys.resize(_size1286); - uint32_t _i1290; - for (_i1290 = 0; _i1290 < _size1286; ++_i1290) + uint32_t _size1288; + ::apache::thrift::protocol::TType _etype1291; + xfer += iprot->readListBegin(_etype1291, _size1288); + this->foreignKeys.resize(_size1288); + uint32_t _i1292; + for (_i1292 = 0; _i1292 < _size1288; ++_i1292) { - xfer += this->foreignKeys[_i1290].read(iprot); + xfer += this->foreignKeys[_i1292].read(iprot); } xfer += iprot->readListEnd(); } @@ -5425,14 +5652,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->uniqueConstraints.clear(); - uint32_t _size1291; - ::apache::thrift::protocol::TType _etype1294; - xfer += iprot->readListBegin(_etype1294, _size1291); - this->uniqueConstraints.resize(_size1291); - uint32_t _i1295; - for (_i1295 = 0; _i1295 < _size1291; ++_i1295) + uint32_t _size1293; + ::apache::thrift::protocol::TType _etype1296; + xfer += iprot->readListBegin(_etype1296, _size1293); + this->uniqueConstraints.resize(_size1293); + uint32_t _i1297; + for (_i1297 = 0; _i1297 < _size1293; ++_i1297) { - xfer += this->uniqueConstraints[_i1295].read(iprot); + xfer += this->uniqueConstraints[_i1297].read(iprot); } xfer += iprot->readListEnd(); } @@ -5445,14 +5672,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->notNullConstraints.clear(); - uint32_t _size1296; - ::apache::thrift::protocol::TType _etype1299; - xfer += iprot->readListBegin(_etype1299, _size1296); - this->notNullConstraints.resize(_size1296); - uint32_t _i1300; - for (_i1300 = 0; _i1300 < _size1296; ++_i1300) + uint32_t _size1298; + ::apache::thrift::protocol::TType _etype1301; + xfer += iprot->readListBegin(_etype1301, _size1298); + this->notNullConstraints.resize(_size1298); + uint32_t _i1302; + for (_i1302 = 0; _i1302 < _size1298; ++_i1302) { - xfer += this->notNullConstraints[_i1300].read(iprot); + xfer += this->notNullConstraints[_i1302].read(iprot); } xfer += iprot->readListEnd(); } @@ -5465,14 +5692,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->defaultConstraints.clear(); - uint32_t _size1301; - ::apache::thrift::protocol::TType _etype1304; - xfer += iprot->readListBegin(_etype1304, _size1301); - this->defaultConstraints.resize(_size1301); - uint32_t _i1305; - for (_i1305 = 0; _i1305 < _size1301; ++_i1305) + uint32_t _size1303; + ::apache::thrift::protocol::TType _etype1306; + xfer += iprot->readListBegin(_etype1306, _size1303); + this->defaultConstraints.resize(_size1303); + uint32_t _i1307; + for (_i1307 = 0; _i1307 < _size1303; ++_i1307) { - xfer += this->defaultConstraints[_i1305].read(iprot); + xfer += this->defaultConstraints[_i1307].read(iprot); } xfer += iprot->readListEnd(); } @@ -5485,14 +5712,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->checkConstraints.clear(); - uint32_t _size1306; - ::apache::thrift::protocol::TType _etype1309; - xfer += iprot->readListBegin(_etype1309, _size1306); - this->checkConstraints.resize(_size1306); - uint32_t _i1310; - for (_i1310 = 0; _i1310 < _size1306; ++_i1310) + uint32_t _size1308; + ::apache::thrift::protocol::TType _etype1311; + xfer += iprot->readListBegin(_etype1311, _size1308); + this->checkConstraints.resize(_size1308); + uint32_t _i1312; + for (_i1312 = 0; _i1312 < _size1308; ++_i1312) { - xfer += this->checkConstraints[_i1310].read(iprot); + xfer += this->checkConstraints[_i1312].read(iprot); } xfer += iprot->readListEnd(); } @@ -5525,10 +5752,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache: xfer += oprot->writeFieldBegin("primaryKeys", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->primaryKeys.size())); - std::vector ::const_iterator _iter1311; - for (_iter1311 = this->primaryKeys.begin(); _iter1311 != this->primaryKeys.end(); ++_iter1311) + std::vector ::const_iterator _iter1313; + for (_iter1313 = this->primaryKeys.begin(); _iter1313 != this->primaryKeys.end(); ++_iter1313) { - xfer += (*_iter1311).write(oprot); + xfer += (*_iter1313).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5537,10 +5764,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache: xfer += oprot->writeFieldBegin("foreignKeys", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->foreignKeys.size())); - std::vector ::const_iterator _iter1312; - for (_iter1312 = this->foreignKeys.begin(); _iter1312 != this->foreignKeys.end(); ++_iter1312) + std::vector ::const_iterator _iter1314; + for (_iter1314 = this->foreignKeys.begin(); _iter1314 != this->foreignKeys.end(); ++_iter1314) { - xfer += (*_iter1312).write(oprot); + xfer += (*_iter1314).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5549,10 +5776,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache: xfer += oprot->writeFieldBegin("uniqueConstraints", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->uniqueConstraints.size())); - std::vector ::const_iterator _iter1313; - for (_iter1313 = this->uniqueConstraints.begin(); _iter1313 != this->uniqueConstraints.end(); ++_iter1313) + std::vector ::const_iterator _iter1315; + for (_iter1315 = this->uniqueConstraints.begin(); _iter1315 != this->uniqueConstraints.end(); ++_iter1315) { - xfer += (*_iter1313).write(oprot); + xfer += (*_iter1315).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5561,10 +5788,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache: xfer += oprot->writeFieldBegin("notNullConstraints", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->notNullConstraints.size())); - std::vector ::const_iterator _iter1314; - for (_iter1314 = this->notNullConstraints.begin(); _iter1314 != this->notNullConstraints.end(); ++_iter1314) + std::vector ::const_iterator _iter1316; + for (_iter1316 = this->notNullConstraints.begin(); _iter1316 != this->notNullConstraints.end(); ++_iter1316) { - xfer += (*_iter1314).write(oprot); + xfer += (*_iter1316).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5573,10 +5800,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache: xfer += oprot->writeFieldBegin("defaultConstraints", ::apache::thrift::protocol::T_LIST, 6); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->defaultConstraints.size())); - std::vector ::const_iterator _iter1315; - for (_iter1315 = this->defaultConstraints.begin(); _iter1315 != this->defaultConstraints.end(); ++_iter1315) + std::vector ::const_iterator _iter1317; + for (_iter1317 = this->defaultConstraints.begin(); _iter1317 != this->defaultConstraints.end(); ++_iter1317) { - xfer += (*_iter1315).write(oprot); + xfer += (*_iter1317).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5585,10 +5812,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache: xfer += oprot->writeFieldBegin("checkConstraints", ::apache::thrift::protocol::T_LIST, 7); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->checkConstraints.size())); - std::vector ::const_iterator _iter1316; - for (_iter1316 = this->checkConstraints.begin(); _iter1316 != this->checkConstraints.end(); ++_iter1316) + std::vector ::const_iterator _iter1318; + for (_iter1318 = this->checkConstraints.begin(); _iter1318 != this->checkConstraints.end(); ++_iter1318) { - xfer += (*_iter1316).write(oprot); + xfer += (*_iter1318).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5616,10 +5843,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache xfer += oprot->writeFieldBegin("primaryKeys", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->primaryKeys)).size())); - std::vector ::const_iterator _iter1317; - for (_iter1317 = (*(this->primaryKeys)).begin(); _iter1317 != (*(this->primaryKeys)).end(); ++_iter1317) + std::vector ::const_iterator _iter1319; + for (_iter1319 = (*(this->primaryKeys)).begin(); _iter1319 != (*(this->primaryKeys)).end(); ++_iter1319) { - xfer += (*_iter1317).write(oprot); + xfer += (*_iter1319).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5628,10 +5855,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache xfer += oprot->writeFieldBegin("foreignKeys", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->foreignKeys)).size())); - std::vector ::const_iterator _iter1318; - for (_iter1318 = (*(this->foreignKeys)).begin(); _iter1318 != (*(this->foreignKeys)).end(); ++_iter1318) + std::vector ::const_iterator _iter1320; + for (_iter1320 = (*(this->foreignKeys)).begin(); _iter1320 != (*(this->foreignKeys)).end(); ++_iter1320) { - xfer += (*_iter1318).write(oprot); + xfer += (*_iter1320).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5640,10 +5867,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache xfer += oprot->writeFieldBegin("uniqueConstraints", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->uniqueConstraints)).size())); - std::vector ::const_iterator _iter1319; - for (_iter1319 = (*(this->uniqueConstraints)).begin(); _iter1319 != (*(this->uniqueConstraints)).end(); ++_iter1319) + std::vector ::const_iterator _iter1321; + for (_iter1321 = (*(this->uniqueConstraints)).begin(); _iter1321 != (*(this->uniqueConstraints)).end(); ++_iter1321) { - xfer += (*_iter1319).write(oprot); + xfer += (*_iter1321).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5652,10 +5879,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache xfer += oprot->writeFieldBegin("notNullConstraints", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->notNullConstraints)).size())); - std::vector ::const_iterator _iter1320; - for (_iter1320 = (*(this->notNullConstraints)).begin(); _iter1320 != (*(this->notNullConstraints)).end(); ++_iter1320) + std::vector ::const_iterator _iter1322; + for (_iter1322 = (*(this->notNullConstraints)).begin(); _iter1322 != (*(this->notNullConstraints)).end(); ++_iter1322) { - xfer += (*_iter1320).write(oprot); + xfer += (*_iter1322).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5664,10 +5891,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache xfer += oprot->writeFieldBegin("defaultConstraints", ::apache::thrift::protocol::T_LIST, 6); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->defaultConstraints)).size())); - std::vector ::const_iterator _iter1321; - for (_iter1321 = (*(this->defaultConstraints)).begin(); _iter1321 != (*(this->defaultConstraints)).end(); ++_iter1321) + std::vector ::const_iterator _iter1323; + for (_iter1323 = (*(this->defaultConstraints)).begin(); _iter1323 != (*(this->defaultConstraints)).end(); ++_iter1323) { - xfer += (*_iter1321).write(oprot); + xfer += (*_iter1323).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5676,10 +5903,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache xfer += oprot->writeFieldBegin("checkConstraints", ::apache::thrift::protocol::T_LIST, 7); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->checkConstraints)).size())); - std::vector ::const_iterator _iter1322; - for (_iter1322 = (*(this->checkConstraints)).begin(); _iter1322 != (*(this->checkConstraints)).end(); ++_iter1322) + std::vector ::const_iterator _iter1324; + for (_iter1324 = (*(this->checkConstraints)).begin(); _iter1324 != (*(this->checkConstraints)).end(); ++_iter1324) { - xfer += (*_iter1322).write(oprot); + xfer += (*_iter1324).write(oprot); } xfer += oprot->writeListEnd(); } @@ -7847,14 +8074,14 @@ uint32_t ThriftHiveMetastore_truncate_table_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partNames.clear(); - uint32_t _size1323; - ::apache::thrift::protocol::TType _etype1326; - xfer += iprot->readListBegin(_etype1326, _size1323); - this->partNames.resize(_size1323); - uint32_t _i1327; - for (_i1327 = 0; _i1327 < _size1323; ++_i1327) + uint32_t _size1325; + ::apache::thrift::protocol::TType _etype1328; + xfer += iprot->readListBegin(_etype1328, _size1325); + this->partNames.resize(_size1325); + uint32_t _i1329; + for (_i1329 = 0; _i1329 < _size1325; ++_i1329) { - xfer += iprot->readString(this->partNames[_i1327]); + xfer += iprot->readString(this->partNames[_i1329]); } xfer += iprot->readListEnd(); } @@ -7891,10 +8118,10 @@ uint32_t ThriftHiveMetastore_truncate_table_args::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("partNames", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partNames.size())); - std::vector ::const_iterator _iter1328; - for (_iter1328 = this->partNames.begin(); _iter1328 != this->partNames.end(); ++_iter1328) + std::vector ::const_iterator _iter1330; + for (_iter1330 = this->partNames.begin(); _iter1330 != this->partNames.end(); ++_iter1330) { - xfer += oprot->writeString((*_iter1328)); + xfer += oprot->writeString((*_iter1330)); } xfer += oprot->writeListEnd(); } @@ -7926,10 +8153,10 @@ uint32_t ThriftHiveMetastore_truncate_table_pargs::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("partNames", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->partNames)).size())); - std::vector ::const_iterator _iter1329; - for (_iter1329 = (*(this->partNames)).begin(); _iter1329 != (*(this->partNames)).end(); ++_iter1329) + std::vector ::const_iterator _iter1331; + for (_iter1331 = (*(this->partNames)).begin(); _iter1331 != (*(this->partNames)).end(); ++_iter1331) { - xfer += oprot->writeString((*_iter1329)); + xfer += oprot->writeString((*_iter1331)); } xfer += oprot->writeListEnd(); } @@ -8173,14 +8400,14 @@ uint32_t ThriftHiveMetastore_get_tables_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1330; - ::apache::thrift::protocol::TType _etype1333; - xfer += iprot->readListBegin(_etype1333, _size1330); - this->success.resize(_size1330); - uint32_t _i1334; - for (_i1334 = 0; _i1334 < _size1330; ++_i1334) + uint32_t _size1332; + ::apache::thrift::protocol::TType _etype1335; + xfer += iprot->readListBegin(_etype1335, _size1332); + this->success.resize(_size1332); + uint32_t _i1336; + for (_i1336 = 0; _i1336 < _size1332; ++_i1336) { - xfer += iprot->readString(this->success[_i1334]); + xfer += iprot->readString(this->success[_i1336]); } xfer += iprot->readListEnd(); } @@ -8219,10 +8446,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 _iter1335; - for (_iter1335 = this->success.begin(); _iter1335 != this->success.end(); ++_iter1335) + std::vector ::const_iterator _iter1337; + for (_iter1337 = this->success.begin(); _iter1337 != this->success.end(); ++_iter1337) { - xfer += oprot->writeString((*_iter1335)); + xfer += oprot->writeString((*_iter1337)); } xfer += oprot->writeListEnd(); } @@ -8267,14 +8494,14 @@ uint32_t ThriftHiveMetastore_get_tables_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1336; - ::apache::thrift::protocol::TType _etype1339; - xfer += iprot->readListBegin(_etype1339, _size1336); - (*(this->success)).resize(_size1336); - uint32_t _i1340; - for (_i1340 = 0; _i1340 < _size1336; ++_i1340) + uint32_t _size1338; + ::apache::thrift::protocol::TType _etype1341; + xfer += iprot->readListBegin(_etype1341, _size1338); + (*(this->success)).resize(_size1338); + uint32_t _i1342; + for (_i1342 = 0; _i1342 < _size1338; ++_i1342) { - xfer += iprot->readString((*(this->success))[_i1340]); + xfer += iprot->readString((*(this->success))[_i1342]); } xfer += iprot->readListEnd(); } @@ -8444,14 +8671,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 _size1341; - ::apache::thrift::protocol::TType _etype1344; - xfer += iprot->readListBegin(_etype1344, _size1341); - this->success.resize(_size1341); - uint32_t _i1345; - for (_i1345 = 0; _i1345 < _size1341; ++_i1345) + uint32_t _size1343; + ::apache::thrift::protocol::TType _etype1346; + xfer += iprot->readListBegin(_etype1346, _size1343); + this->success.resize(_size1343); + uint32_t _i1347; + for (_i1347 = 0; _i1347 < _size1343; ++_i1347) { - xfer += iprot->readString(this->success[_i1345]); + xfer += iprot->readString(this->success[_i1347]); } xfer += iprot->readListEnd(); } @@ -8490,10 +8717,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 _iter1346; - for (_iter1346 = this->success.begin(); _iter1346 != this->success.end(); ++_iter1346) + std::vector ::const_iterator _iter1348; + for (_iter1348 = this->success.begin(); _iter1348 != this->success.end(); ++_iter1348) { - xfer += oprot->writeString((*_iter1346)); + xfer += oprot->writeString((*_iter1348)); } xfer += oprot->writeListEnd(); } @@ -8538,14 +8765,14 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_presult::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1347; - ::apache::thrift::protocol::TType _etype1350; - xfer += iprot->readListBegin(_etype1350, _size1347); - (*(this->success)).resize(_size1347); - uint32_t _i1351; - for (_i1351 = 0; _i1351 < _size1347; ++_i1351) + uint32_t _size1349; + ::apache::thrift::protocol::TType _etype1352; + xfer += iprot->readListBegin(_etype1352, _size1349); + (*(this->success)).resize(_size1349); + uint32_t _i1353; + for (_i1353 = 0; _i1353 < _size1349; ++_i1353) { - xfer += iprot->readString((*(this->success))[_i1351]); + xfer += iprot->readString((*(this->success))[_i1353]); } xfer += iprot->readListEnd(); } @@ -8683,14 +8910,14 @@ uint32_t ThriftHiveMetastore_get_materialized_views_for_rewriting_result::read(: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1352; - ::apache::thrift::protocol::TType _etype1355; - xfer += iprot->readListBegin(_etype1355, _size1352); - this->success.resize(_size1352); - uint32_t _i1356; - for (_i1356 = 0; _i1356 < _size1352; ++_i1356) + uint32_t _size1354; + ::apache::thrift::protocol::TType _etype1357; + xfer += iprot->readListBegin(_etype1357, _size1354); + this->success.resize(_size1354); + uint32_t _i1358; + for (_i1358 = 0; _i1358 < _size1354; ++_i1358) { - xfer += iprot->readString(this->success[_i1356]); + xfer += iprot->readString(this->success[_i1358]); } xfer += iprot->readListEnd(); } @@ -8729,10 +8956,10 @@ uint32_t ThriftHiveMetastore_get_materialized_views_for_rewriting_result::write( 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 _iter1357; - for (_iter1357 = this->success.begin(); _iter1357 != this->success.end(); ++_iter1357) + std::vector ::const_iterator _iter1359; + for (_iter1359 = this->success.begin(); _iter1359 != this->success.end(); ++_iter1359) { - xfer += oprot->writeString((*_iter1357)); + xfer += oprot->writeString((*_iter1359)); } xfer += oprot->writeListEnd(); } @@ -8777,14 +9004,14 @@ uint32_t ThriftHiveMetastore_get_materialized_views_for_rewriting_presult::read( if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1358; - ::apache::thrift::protocol::TType _etype1361; - xfer += iprot->readListBegin(_etype1361, _size1358); - (*(this->success)).resize(_size1358); - uint32_t _i1362; - for (_i1362 = 0; _i1362 < _size1358; ++_i1362) + uint32_t _size1360; + ::apache::thrift::protocol::TType _etype1363; + xfer += iprot->readListBegin(_etype1363, _size1360); + (*(this->success)).resize(_size1360); + uint32_t _i1364; + for (_i1364 = 0; _i1364 < _size1360; ++_i1364) { - xfer += iprot->readString((*(this->success))[_i1362]); + xfer += iprot->readString((*(this->success))[_i1364]); } xfer += iprot->readListEnd(); } @@ -8859,14 +9086,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 _size1363; - ::apache::thrift::protocol::TType _etype1366; - xfer += iprot->readListBegin(_etype1366, _size1363); - this->tbl_types.resize(_size1363); - uint32_t _i1367; - for (_i1367 = 0; _i1367 < _size1363; ++_i1367) + uint32_t _size1365; + ::apache::thrift::protocol::TType _etype1368; + xfer += iprot->readListBegin(_etype1368, _size1365); + this->tbl_types.resize(_size1365); + uint32_t _i1369; + for (_i1369 = 0; _i1369 < _size1365; ++_i1369) { - xfer += iprot->readString(this->tbl_types[_i1367]); + xfer += iprot->readString(this->tbl_types[_i1369]); } xfer += iprot->readListEnd(); } @@ -8903,10 +9130,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 _iter1368; - for (_iter1368 = this->tbl_types.begin(); _iter1368 != this->tbl_types.end(); ++_iter1368) + std::vector ::const_iterator _iter1370; + for (_iter1370 = this->tbl_types.begin(); _iter1370 != this->tbl_types.end(); ++_iter1370) { - xfer += oprot->writeString((*_iter1368)); + xfer += oprot->writeString((*_iter1370)); } xfer += oprot->writeListEnd(); } @@ -8938,10 +9165,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 _iter1369; - for (_iter1369 = (*(this->tbl_types)).begin(); _iter1369 != (*(this->tbl_types)).end(); ++_iter1369) + std::vector ::const_iterator _iter1371; + for (_iter1371 = (*(this->tbl_types)).begin(); _iter1371 != (*(this->tbl_types)).end(); ++_iter1371) { - xfer += oprot->writeString((*_iter1369)); + xfer += oprot->writeString((*_iter1371)); } xfer += oprot->writeListEnd(); } @@ -8982,14 +9209,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1370; - ::apache::thrift::protocol::TType _etype1373; - xfer += iprot->readListBegin(_etype1373, _size1370); - this->success.resize(_size1370); - uint32_t _i1374; - for (_i1374 = 0; _i1374 < _size1370; ++_i1374) + uint32_t _size1372; + ::apache::thrift::protocol::TType _etype1375; + xfer += iprot->readListBegin(_etype1375, _size1372); + this->success.resize(_size1372); + uint32_t _i1376; + for (_i1376 = 0; _i1376 < _size1372; ++_i1376) { - xfer += this->success[_i1374].read(iprot); + xfer += this->success[_i1376].read(iprot); } xfer += iprot->readListEnd(); } @@ -9028,10 +9255,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 _iter1375; - for (_iter1375 = this->success.begin(); _iter1375 != this->success.end(); ++_iter1375) + std::vector ::const_iterator _iter1377; + for (_iter1377 = this->success.begin(); _iter1377 != this->success.end(); ++_iter1377) { - xfer += (*_iter1375).write(oprot); + xfer += (*_iter1377).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9076,14 +9303,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1376; - ::apache::thrift::protocol::TType _etype1379; - xfer += iprot->readListBegin(_etype1379, _size1376); - (*(this->success)).resize(_size1376); - uint32_t _i1380; - for (_i1380 = 0; _i1380 < _size1376; ++_i1380) + uint32_t _size1378; + ::apache::thrift::protocol::TType _etype1381; + xfer += iprot->readListBegin(_etype1381, _size1378); + (*(this->success)).resize(_size1378); + uint32_t _i1382; + for (_i1382 = 0; _i1382 < _size1378; ++_i1382) { - xfer += (*(this->success))[_i1380].read(iprot); + xfer += (*(this->success))[_i1382].read(iprot); } xfer += iprot->readListEnd(); } @@ -9221,14 +9448,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1381; - ::apache::thrift::protocol::TType _etype1384; - xfer += iprot->readListBegin(_etype1384, _size1381); - this->success.resize(_size1381); - uint32_t _i1385; - for (_i1385 = 0; _i1385 < _size1381; ++_i1385) + uint32_t _size1383; + ::apache::thrift::protocol::TType _etype1386; + xfer += iprot->readListBegin(_etype1386, _size1383); + this->success.resize(_size1383); + uint32_t _i1387; + for (_i1387 = 0; _i1387 < _size1383; ++_i1387) { - xfer += iprot->readString(this->success[_i1385]); + xfer += iprot->readString(this->success[_i1387]); } xfer += iprot->readListEnd(); } @@ -9267,10 +9494,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 _iter1386; - for (_iter1386 = this->success.begin(); _iter1386 != this->success.end(); ++_iter1386) + std::vector ::const_iterator _iter1388; + for (_iter1388 = this->success.begin(); _iter1388 != this->success.end(); ++_iter1388) { - xfer += oprot->writeString((*_iter1386)); + xfer += oprot->writeString((*_iter1388)); } xfer += oprot->writeListEnd(); } @@ -9315,14 +9542,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1387; - ::apache::thrift::protocol::TType _etype1390; - xfer += iprot->readListBegin(_etype1390, _size1387); - (*(this->success)).resize(_size1387); - uint32_t _i1391; - for (_i1391 = 0; _i1391 < _size1387; ++_i1391) + uint32_t _size1389; + ::apache::thrift::protocol::TType _etype1392; + xfer += iprot->readListBegin(_etype1392, _size1389); + (*(this->success)).resize(_size1389); + uint32_t _i1393; + for (_i1393 = 0; _i1393 < _size1389; ++_i1393) { - xfer += iprot->readString((*(this->success))[_i1391]); + xfer += iprot->readString((*(this->success))[_i1393]); } xfer += iprot->readListEnd(); } @@ -9632,14 +9859,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 _size1392; - ::apache::thrift::protocol::TType _etype1395; - xfer += iprot->readListBegin(_etype1395, _size1392); - this->tbl_names.resize(_size1392); - uint32_t _i1396; - for (_i1396 = 0; _i1396 < _size1392; ++_i1396) + uint32_t _size1394; + ::apache::thrift::protocol::TType _etype1397; + xfer += iprot->readListBegin(_etype1397, _size1394); + this->tbl_names.resize(_size1394); + uint32_t _i1398; + for (_i1398 = 0; _i1398 < _size1394; ++_i1398) { - xfer += iprot->readString(this->tbl_names[_i1396]); + xfer += iprot->readString(this->tbl_names[_i1398]); } xfer += iprot->readListEnd(); } @@ -9672,10 +9899,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 _iter1397; - for (_iter1397 = this->tbl_names.begin(); _iter1397 != this->tbl_names.end(); ++_iter1397) + std::vector ::const_iterator _iter1399; + for (_iter1399 = this->tbl_names.begin(); _iter1399 != this->tbl_names.end(); ++_iter1399) { - xfer += oprot->writeString((*_iter1397)); + xfer += oprot->writeString((*_iter1399)); } xfer += oprot->writeListEnd(); } @@ -9703,10 +9930,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 _iter1398; - for (_iter1398 = (*(this->tbl_names)).begin(); _iter1398 != (*(this->tbl_names)).end(); ++_iter1398) + std::vector ::const_iterator _iter1400; + for (_iter1400 = (*(this->tbl_names)).begin(); _iter1400 != (*(this->tbl_names)).end(); ++_iter1400) { - xfer += oprot->writeString((*_iter1398)); + xfer += oprot->writeString((*_iter1400)); } xfer += oprot->writeListEnd(); } @@ -9747,14 +9974,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 _size1399; - ::apache::thrift::protocol::TType _etype1402; - xfer += iprot->readListBegin(_etype1402, _size1399); - this->success.resize(_size1399); - uint32_t _i1403; - for (_i1403 = 0; _i1403 < _size1399; ++_i1403) + uint32_t _size1401; + ::apache::thrift::protocol::TType _etype1404; + xfer += iprot->readListBegin(_etype1404, _size1401); + this->success.resize(_size1401); + uint32_t _i1405; + for (_i1405 = 0; _i1405 < _size1401; ++_i1405) { - xfer += this->success[_i1403].read(iprot); + xfer += this->success[_i1405].read(iprot); } xfer += iprot->readListEnd(); } @@ -9785,10 +10012,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 _iter1404; - for (_iter1404 = this->success.begin(); _iter1404 != this->success.end(); ++_iter1404) + std::vector
::const_iterator _iter1406; + for (_iter1406 = this->success.begin(); _iter1406 != this->success.end(); ++_iter1406) { - xfer += (*_iter1404).write(oprot); + xfer += (*_iter1406).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9829,14 +10056,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 _size1405; - ::apache::thrift::protocol::TType _etype1408; - xfer += iprot->readListBegin(_etype1408, _size1405); - (*(this->success)).resize(_size1405); - uint32_t _i1409; - for (_i1409 = 0; _i1409 < _size1405; ++_i1409) + 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) { - xfer += (*(this->success))[_i1409].read(iprot); + xfer += (*(this->success))[_i1411].read(iprot); } xfer += iprot->readListEnd(); } @@ -10369,14 +10596,14 @@ uint32_t ThriftHiveMetastore_get_materialization_invalidation_info_args::read(:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tbl_names.clear(); - uint32_t _size1410; - ::apache::thrift::protocol::TType _etype1413; - xfer += iprot->readListBegin(_etype1413, _size1410); - this->tbl_names.resize(_size1410); - uint32_t _i1414; - for (_i1414 = 0; _i1414 < _size1410; ++_i1414) + uint32_t _size1412; + ::apache::thrift::protocol::TType _etype1415; + xfer += iprot->readListBegin(_etype1415, _size1412); + this->tbl_names.resize(_size1412); + uint32_t _i1416; + for (_i1416 = 0; _i1416 < _size1412; ++_i1416) { - xfer += iprot->readString(this->tbl_names[_i1414]); + xfer += iprot->readString(this->tbl_names[_i1416]); } xfer += iprot->readListEnd(); } @@ -10409,10 +10636,10 @@ uint32_t ThriftHiveMetastore_get_materialization_invalidation_info_args::write(: 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 _iter1415; - for (_iter1415 = this->tbl_names.begin(); _iter1415 != this->tbl_names.end(); ++_iter1415) + std::vector ::const_iterator _iter1417; + for (_iter1417 = this->tbl_names.begin(); _iter1417 != this->tbl_names.end(); ++_iter1417) { - xfer += oprot->writeString((*_iter1415)); + xfer += oprot->writeString((*_iter1417)); } xfer += oprot->writeListEnd(); } @@ -10440,10 +10667,10 @@ uint32_t ThriftHiveMetastore_get_materialization_invalidation_info_pargs::write( 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 _iter1416; - for (_iter1416 = (*(this->tbl_names)).begin(); _iter1416 != (*(this->tbl_names)).end(); ++_iter1416) + std::vector ::const_iterator _iter1418; + for (_iter1418 = (*(this->tbl_names)).begin(); _iter1418 != (*(this->tbl_names)).end(); ++_iter1418) { - xfer += oprot->writeString((*_iter1416)); + xfer += oprot->writeString((*_iter1418)); } xfer += oprot->writeListEnd(); } @@ -10484,17 +10711,17 @@ uint32_t ThriftHiveMetastore_get_materialization_invalidation_info_result::read( if (ftype == ::apache::thrift::protocol::T_MAP) { { this->success.clear(); - uint32_t _size1417; - ::apache::thrift::protocol::TType _ktype1418; - ::apache::thrift::protocol::TType _vtype1419; - xfer += iprot->readMapBegin(_ktype1418, _vtype1419, _size1417); - uint32_t _i1421; - for (_i1421 = 0; _i1421 < _size1417; ++_i1421) + uint32_t _size1419; + ::apache::thrift::protocol::TType _ktype1420; + ::apache::thrift::protocol::TType _vtype1421; + xfer += iprot->readMapBegin(_ktype1420, _vtype1421, _size1419); + uint32_t _i1423; + for (_i1423 = 0; _i1423 < _size1419; ++_i1423) { - std::string _key1422; - xfer += iprot->readString(_key1422); - Materialization& _val1423 = this->success[_key1422]; - xfer += _val1423.read(iprot); + std::string _key1424; + xfer += iprot->readString(_key1424); + Materialization& _val1425 = this->success[_key1424]; + xfer += _val1425.read(iprot); } xfer += iprot->readMapEnd(); } @@ -10549,11 +10776,11 @@ uint32_t ThriftHiveMetastore_get_materialization_invalidation_info_result::write xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_MAP, 0); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::map ::const_iterator _iter1424; - for (_iter1424 = this->success.begin(); _iter1424 != this->success.end(); ++_iter1424) + std::map ::const_iterator _iter1426; + for (_iter1426 = this->success.begin(); _iter1426 != this->success.end(); ++_iter1426) { - xfer += oprot->writeString(_iter1424->first); - xfer += _iter1424->second.write(oprot); + xfer += oprot->writeString(_iter1426->first); + xfer += _iter1426->second.write(oprot); } xfer += oprot->writeMapEnd(); } @@ -10606,17 +10833,17 @@ uint32_t ThriftHiveMetastore_get_materialization_invalidation_info_presult::read if (ftype == ::apache::thrift::protocol::T_MAP) { { (*(this->success)).clear(); - uint32_t _size1425; - ::apache::thrift::protocol::TType _ktype1426; - ::apache::thrift::protocol::TType _vtype1427; - xfer += iprot->readMapBegin(_ktype1426, _vtype1427, _size1425); - uint32_t _i1429; - for (_i1429 = 0; _i1429 < _size1425; ++_i1429) + uint32_t _size1427; + ::apache::thrift::protocol::TType _ktype1428; + ::apache::thrift::protocol::TType _vtype1429; + xfer += iprot->readMapBegin(_ktype1428, _vtype1429, _size1427); + uint32_t _i1431; + for (_i1431 = 0; _i1431 < _size1427; ++_i1431) { - std::string _key1430; - xfer += iprot->readString(_key1430); - Materialization& _val1431 = (*(this->success))[_key1430]; - xfer += _val1431.read(iprot); + std::string _key1432; + xfer += iprot->readString(_key1432); + Materialization& _val1433 = (*(this->success))[_key1432]; + xfer += _val1433.read(iprot); } xfer += iprot->readMapEnd(); } @@ -11077,14 +11304,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 _size1432; - ::apache::thrift::protocol::TType _etype1435; - xfer += iprot->readListBegin(_etype1435, _size1432); - this->success.resize(_size1432); - uint32_t _i1436; - for (_i1436 = 0; _i1436 < _size1432; ++_i1436) + uint32_t _size1434; + ::apache::thrift::protocol::TType _etype1437; + xfer += iprot->readListBegin(_etype1437, _size1434); + this->success.resize(_size1434); + uint32_t _i1438; + for (_i1438 = 0; _i1438 < _size1434; ++_i1438) { - xfer += iprot->readString(this->success[_i1436]); + xfer += iprot->readString(this->success[_i1438]); } xfer += iprot->readListEnd(); } @@ -11139,10 +11366,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 _iter1437; - for (_iter1437 = this->success.begin(); _iter1437 != this->success.end(); ++_iter1437) + std::vector ::const_iterator _iter1439; + for (_iter1439 = this->success.begin(); _iter1439 != this->success.end(); ++_iter1439) { - xfer += oprot->writeString((*_iter1437)); + xfer += oprot->writeString((*_iter1439)); } xfer += oprot->writeListEnd(); } @@ -11195,14 +11422,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 _size1438; - ::apache::thrift::protocol::TType _etype1441; - xfer += iprot->readListBegin(_etype1441, _size1438); - (*(this->success)).resize(_size1438); - uint32_t _i1442; - for (_i1442 = 0; _i1442 < _size1438; ++_i1442) + uint32_t _size1440; + ::apache::thrift::protocol::TType _etype1443; + xfer += iprot->readListBegin(_etype1443, _size1440); + (*(this->success)).resize(_size1440); + uint32_t _i1444; + for (_i1444 = 0; _i1444 < _size1440; ++_i1444) { - xfer += iprot->readString((*(this->success))[_i1442]); + xfer += iprot->readString((*(this->success))[_i1444]); } xfer += iprot->readListEnd(); } @@ -12536,14 +12763,14 @@ uint32_t ThriftHiveMetastore_add_partitions_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size1443; - ::apache::thrift::protocol::TType _etype1446; - xfer += iprot->readListBegin(_etype1446, _size1443); - this->new_parts.resize(_size1443); - uint32_t _i1447; - for (_i1447 = 0; _i1447 < _size1443; ++_i1447) + uint32_t _size1445; + ::apache::thrift::protocol::TType _etype1448; + xfer += iprot->readListBegin(_etype1448, _size1445); + this->new_parts.resize(_size1445); + uint32_t _i1449; + for (_i1449 = 0; _i1449 < _size1445; ++_i1449) { - xfer += this->new_parts[_i1447].read(iprot); + xfer += this->new_parts[_i1449].read(iprot); } xfer += iprot->readListEnd(); } @@ -12572,10 +12799,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 _iter1448; - for (_iter1448 = this->new_parts.begin(); _iter1448 != this->new_parts.end(); ++_iter1448) + std::vector ::const_iterator _iter1450; + for (_iter1450 = this->new_parts.begin(); _iter1450 != this->new_parts.end(); ++_iter1450) { - xfer += (*_iter1448).write(oprot); + xfer += (*_iter1450).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12599,10 +12826,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 _iter1449; - for (_iter1449 = (*(this->new_parts)).begin(); _iter1449 != (*(this->new_parts)).end(); ++_iter1449) + std::vector ::const_iterator _iter1451; + for (_iter1451 = (*(this->new_parts)).begin(); _iter1451 != (*(this->new_parts)).end(); ++_iter1451) { - xfer += (*_iter1449).write(oprot); + xfer += (*_iter1451).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12811,14 +13038,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 _size1450; - ::apache::thrift::protocol::TType _etype1453; - xfer += iprot->readListBegin(_etype1453, _size1450); - this->new_parts.resize(_size1450); - uint32_t _i1454; - for (_i1454 = 0; _i1454 < _size1450; ++_i1454) + uint32_t _size1452; + ::apache::thrift::protocol::TType _etype1455; + xfer += iprot->readListBegin(_etype1455, _size1452); + this->new_parts.resize(_size1452); + uint32_t _i1456; + for (_i1456 = 0; _i1456 < _size1452; ++_i1456) { - xfer += this->new_parts[_i1454].read(iprot); + xfer += this->new_parts[_i1456].read(iprot); } xfer += iprot->readListEnd(); } @@ -12847,10 +13074,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 _iter1455; - for (_iter1455 = this->new_parts.begin(); _iter1455 != this->new_parts.end(); ++_iter1455) + std::vector ::const_iterator _iter1457; + for (_iter1457 = this->new_parts.begin(); _iter1457 != this->new_parts.end(); ++_iter1457) { - xfer += (*_iter1455).write(oprot); + xfer += (*_iter1457).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12874,10 +13101,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 _iter1456; - for (_iter1456 = (*(this->new_parts)).begin(); _iter1456 != (*(this->new_parts)).end(); ++_iter1456) + std::vector ::const_iterator _iter1458; + for (_iter1458 = (*(this->new_parts)).begin(); _iter1458 != (*(this->new_parts)).end(); ++_iter1458) { - xfer += (*_iter1456).write(oprot); + xfer += (*_iter1458).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13102,14 +13329,14 @@ uint32_t ThriftHiveMetastore_append_partition_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1457; - ::apache::thrift::protocol::TType _etype1460; - xfer += iprot->readListBegin(_etype1460, _size1457); - this->part_vals.resize(_size1457); - uint32_t _i1461; - for (_i1461 = 0; _i1461 < _size1457; ++_i1461) + uint32_t _size1459; + ::apache::thrift::protocol::TType _etype1462; + xfer += iprot->readListBegin(_etype1462, _size1459); + this->part_vals.resize(_size1459); + uint32_t _i1463; + for (_i1463 = 0; _i1463 < _size1459; ++_i1463) { - xfer += iprot->readString(this->part_vals[_i1461]); + xfer += iprot->readString(this->part_vals[_i1463]); } xfer += iprot->readListEnd(); } @@ -13146,10 +13373,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 _iter1462; - for (_iter1462 = this->part_vals.begin(); _iter1462 != this->part_vals.end(); ++_iter1462) + std::vector ::const_iterator _iter1464; + for (_iter1464 = this->part_vals.begin(); _iter1464 != this->part_vals.end(); ++_iter1464) { - xfer += oprot->writeString((*_iter1462)); + xfer += oprot->writeString((*_iter1464)); } xfer += oprot->writeListEnd(); } @@ -13181,10 +13408,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 _iter1463; - for (_iter1463 = (*(this->part_vals)).begin(); _iter1463 != (*(this->part_vals)).end(); ++_iter1463) + std::vector ::const_iterator _iter1465; + for (_iter1465 = (*(this->part_vals)).begin(); _iter1465 != (*(this->part_vals)).end(); ++_iter1465) { - xfer += oprot->writeString((*_iter1463)); + xfer += oprot->writeString((*_iter1465)); } xfer += oprot->writeListEnd(); } @@ -13656,14 +13883,14 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::rea if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1464; - ::apache::thrift::protocol::TType _etype1467; - xfer += iprot->readListBegin(_etype1467, _size1464); - this->part_vals.resize(_size1464); - uint32_t _i1468; - for (_i1468 = 0; _i1468 < _size1464; ++_i1468) + uint32_t _size1466; + ::apache::thrift::protocol::TType _etype1469; + xfer += iprot->readListBegin(_etype1469, _size1466); + this->part_vals.resize(_size1466); + uint32_t _i1470; + for (_i1470 = 0; _i1470 < _size1466; ++_i1470) { - xfer += iprot->readString(this->part_vals[_i1468]); + xfer += iprot->readString(this->part_vals[_i1470]); } xfer += iprot->readListEnd(); } @@ -13708,10 +13935,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 _iter1469; - for (_iter1469 = this->part_vals.begin(); _iter1469 != this->part_vals.end(); ++_iter1469) + std::vector ::const_iterator _iter1471; + for (_iter1471 = this->part_vals.begin(); _iter1471 != this->part_vals.end(); ++_iter1471) { - xfer += oprot->writeString((*_iter1469)); + xfer += oprot->writeString((*_iter1471)); } xfer += oprot->writeListEnd(); } @@ -13747,10 +13974,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 _iter1470; - for (_iter1470 = (*(this->part_vals)).begin(); _iter1470 != (*(this->part_vals)).end(); ++_iter1470) + std::vector ::const_iterator _iter1472; + for (_iter1472 = (*(this->part_vals)).begin(); _iter1472 != (*(this->part_vals)).end(); ++_iter1472) { - xfer += oprot->writeString((*_iter1470)); + xfer += oprot->writeString((*_iter1472)); } xfer += oprot->writeListEnd(); } @@ -14553,14 +14780,14 @@ uint32_t ThriftHiveMetastore_drop_partition_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1471; - ::apache::thrift::protocol::TType _etype1474; - xfer += iprot->readListBegin(_etype1474, _size1471); - this->part_vals.resize(_size1471); - uint32_t _i1475; - for (_i1475 = 0; _i1475 < _size1471; ++_i1475) + uint32_t _size1473; + ::apache::thrift::protocol::TType _etype1476; + xfer += iprot->readListBegin(_etype1476, _size1473); + this->part_vals.resize(_size1473); + uint32_t _i1477; + for (_i1477 = 0; _i1477 < _size1473; ++_i1477) { - xfer += iprot->readString(this->part_vals[_i1475]); + xfer += iprot->readString(this->part_vals[_i1477]); } xfer += iprot->readListEnd(); } @@ -14605,10 +14832,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 _iter1476; - for (_iter1476 = this->part_vals.begin(); _iter1476 != this->part_vals.end(); ++_iter1476) + std::vector ::const_iterator _iter1478; + for (_iter1478 = this->part_vals.begin(); _iter1478 != this->part_vals.end(); ++_iter1478) { - xfer += oprot->writeString((*_iter1476)); + xfer += oprot->writeString((*_iter1478)); } xfer += oprot->writeListEnd(); } @@ -14644,10 +14871,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 _iter1477; - for (_iter1477 = (*(this->part_vals)).begin(); _iter1477 != (*(this->part_vals)).end(); ++_iter1477) + std::vector ::const_iterator _iter1479; + for (_iter1479 = (*(this->part_vals)).begin(); _iter1479 != (*(this->part_vals)).end(); ++_iter1479) { - xfer += oprot->writeString((*_iter1477)); + xfer += oprot->writeString((*_iter1479)); } xfer += oprot->writeListEnd(); } @@ -14856,14 +15083,14 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::read( if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1478; - ::apache::thrift::protocol::TType _etype1481; - xfer += iprot->readListBegin(_etype1481, _size1478); - this->part_vals.resize(_size1478); - uint32_t _i1482; - for (_i1482 = 0; _i1482 < _size1478; ++_i1482) + uint32_t _size1480; + ::apache::thrift::protocol::TType _etype1483; + xfer += iprot->readListBegin(_etype1483, _size1480); + this->part_vals.resize(_size1480); + uint32_t _i1484; + for (_i1484 = 0; _i1484 < _size1480; ++_i1484) { - xfer += iprot->readString(this->part_vals[_i1482]); + xfer += iprot->readString(this->part_vals[_i1484]); } xfer += iprot->readListEnd(); } @@ -14916,10 +15143,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 _iter1483; - for (_iter1483 = this->part_vals.begin(); _iter1483 != this->part_vals.end(); ++_iter1483) + std::vector ::const_iterator _iter1485; + for (_iter1485 = this->part_vals.begin(); _iter1485 != this->part_vals.end(); ++_iter1485) { - xfer += oprot->writeString((*_iter1483)); + xfer += oprot->writeString((*_iter1485)); } xfer += oprot->writeListEnd(); } @@ -14959,10 +15186,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 _iter1484; - for (_iter1484 = (*(this->part_vals)).begin(); _iter1484 != (*(this->part_vals)).end(); ++_iter1484) + std::vector ::const_iterator _iter1486; + for (_iter1486 = (*(this->part_vals)).begin(); _iter1486 != (*(this->part_vals)).end(); ++_iter1486) { - xfer += oprot->writeString((*_iter1484)); + xfer += oprot->writeString((*_iter1486)); } xfer += oprot->writeListEnd(); } @@ -15968,14 +16195,14 @@ uint32_t ThriftHiveMetastore_get_partition_args::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1485; - ::apache::thrift::protocol::TType _etype1488; - xfer += iprot->readListBegin(_etype1488, _size1485); - this->part_vals.resize(_size1485); - uint32_t _i1489; - for (_i1489 = 0; _i1489 < _size1485; ++_i1489) + uint32_t _size1487; + ::apache::thrift::protocol::TType _etype1490; + xfer += iprot->readListBegin(_etype1490, _size1487); + this->part_vals.resize(_size1487); + uint32_t _i1491; + for (_i1491 = 0; _i1491 < _size1487; ++_i1491) { - xfer += iprot->readString(this->part_vals[_i1489]); + xfer += iprot->readString(this->part_vals[_i1491]); } xfer += iprot->readListEnd(); } @@ -16012,10 +16239,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 _iter1490; - for (_iter1490 = this->part_vals.begin(); _iter1490 != this->part_vals.end(); ++_iter1490) + std::vector ::const_iterator _iter1492; + for (_iter1492 = this->part_vals.begin(); _iter1492 != this->part_vals.end(); ++_iter1492) { - xfer += oprot->writeString((*_iter1490)); + xfer += oprot->writeString((*_iter1492)); } xfer += oprot->writeListEnd(); } @@ -16047,10 +16274,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 _iter1491; - for (_iter1491 = (*(this->part_vals)).begin(); _iter1491 != (*(this->part_vals)).end(); ++_iter1491) + std::vector ::const_iterator _iter1493; + for (_iter1493 = (*(this->part_vals)).begin(); _iter1493 != (*(this->part_vals)).end(); ++_iter1493) { - xfer += oprot->writeString((*_iter1491)); + xfer += oprot->writeString((*_iter1493)); } xfer += oprot->writeListEnd(); } @@ -16239,17 +16466,17 @@ uint32_t ThriftHiveMetastore_exchange_partition_args::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size1492; - ::apache::thrift::protocol::TType _ktype1493; - ::apache::thrift::protocol::TType _vtype1494; - xfer += iprot->readMapBegin(_ktype1493, _vtype1494, _size1492); - uint32_t _i1496; - for (_i1496 = 0; _i1496 < _size1492; ++_i1496) + uint32_t _size1494; + ::apache::thrift::protocol::TType _ktype1495; + ::apache::thrift::protocol::TType _vtype1496; + xfer += iprot->readMapBegin(_ktype1495, _vtype1496, _size1494); + uint32_t _i1498; + for (_i1498 = 0; _i1498 < _size1494; ++_i1498) { - std::string _key1497; - xfer += iprot->readString(_key1497); - std::string& _val1498 = this->partitionSpecs[_key1497]; - xfer += iprot->readString(_val1498); + std::string _key1499; + xfer += iprot->readString(_key1499); + std::string& _val1500 = this->partitionSpecs[_key1499]; + xfer += iprot->readString(_val1500); } xfer += iprot->readMapEnd(); } @@ -16310,11 +16537,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 _iter1499; - for (_iter1499 = this->partitionSpecs.begin(); _iter1499 != this->partitionSpecs.end(); ++_iter1499) + std::map ::const_iterator _iter1501; + for (_iter1501 = this->partitionSpecs.begin(); _iter1501 != this->partitionSpecs.end(); ++_iter1501) { - xfer += oprot->writeString(_iter1499->first); - xfer += oprot->writeString(_iter1499->second); + xfer += oprot->writeString(_iter1501->first); + xfer += oprot->writeString(_iter1501->second); } xfer += oprot->writeMapEnd(); } @@ -16354,11 +16581,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 _iter1500; - for (_iter1500 = (*(this->partitionSpecs)).begin(); _iter1500 != (*(this->partitionSpecs)).end(); ++_iter1500) + std::map ::const_iterator _iter1502; + for (_iter1502 = (*(this->partitionSpecs)).begin(); _iter1502 != (*(this->partitionSpecs)).end(); ++_iter1502) { - xfer += oprot->writeString(_iter1500->first); - xfer += oprot->writeString(_iter1500->second); + xfer += oprot->writeString(_iter1502->first); + xfer += oprot->writeString(_iter1502->second); } xfer += oprot->writeMapEnd(); } @@ -16603,17 +16830,17 @@ uint32_t ThriftHiveMetastore_exchange_partitions_args::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size1501; - ::apache::thrift::protocol::TType _ktype1502; - ::apache::thrift::protocol::TType _vtype1503; - xfer += iprot->readMapBegin(_ktype1502, _vtype1503, _size1501); - uint32_t _i1505; - for (_i1505 = 0; _i1505 < _size1501; ++_i1505) + uint32_t _size1503; + ::apache::thrift::protocol::TType _ktype1504; + ::apache::thrift::protocol::TType _vtype1505; + xfer += iprot->readMapBegin(_ktype1504, _vtype1505, _size1503); + uint32_t _i1507; + for (_i1507 = 0; _i1507 < _size1503; ++_i1507) { - std::string _key1506; - xfer += iprot->readString(_key1506); - std::string& _val1507 = this->partitionSpecs[_key1506]; - xfer += iprot->readString(_val1507); + std::string _key1508; + xfer += iprot->readString(_key1508); + std::string& _val1509 = this->partitionSpecs[_key1508]; + xfer += iprot->readString(_val1509); } xfer += iprot->readMapEnd(); } @@ -16674,11 +16901,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 _iter1508; - for (_iter1508 = this->partitionSpecs.begin(); _iter1508 != this->partitionSpecs.end(); ++_iter1508) + std::map ::const_iterator _iter1510; + for (_iter1510 = this->partitionSpecs.begin(); _iter1510 != this->partitionSpecs.end(); ++_iter1510) { - xfer += oprot->writeString(_iter1508->first); - xfer += oprot->writeString(_iter1508->second); + xfer += oprot->writeString(_iter1510->first); + xfer += oprot->writeString(_iter1510->second); } xfer += oprot->writeMapEnd(); } @@ -16718,11 +16945,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 _iter1509; - for (_iter1509 = (*(this->partitionSpecs)).begin(); _iter1509 != (*(this->partitionSpecs)).end(); ++_iter1509) + std::map ::const_iterator _iter1511; + for (_iter1511 = (*(this->partitionSpecs)).begin(); _iter1511 != (*(this->partitionSpecs)).end(); ++_iter1511) { - xfer += oprot->writeString(_iter1509->first); - xfer += oprot->writeString(_iter1509->second); + xfer += oprot->writeString(_iter1511->first); + xfer += oprot->writeString(_iter1511->second); } xfer += oprot->writeMapEnd(); } @@ -16779,14 +17006,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1510; - ::apache::thrift::protocol::TType _etype1513; - xfer += iprot->readListBegin(_etype1513, _size1510); - this->success.resize(_size1510); - uint32_t _i1514; - for (_i1514 = 0; _i1514 < _size1510; ++_i1514) + uint32_t _size1512; + ::apache::thrift::protocol::TType _etype1515; + xfer += iprot->readListBegin(_etype1515, _size1512); + this->success.resize(_size1512); + uint32_t _i1516; + for (_i1516 = 0; _i1516 < _size1512; ++_i1516) { - xfer += this->success[_i1514].read(iprot); + xfer += this->success[_i1516].read(iprot); } xfer += iprot->readListEnd(); } @@ -16849,10 +17076,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 _iter1515; - for (_iter1515 = this->success.begin(); _iter1515 != this->success.end(); ++_iter1515) + std::vector ::const_iterator _iter1517; + for (_iter1517 = this->success.begin(); _iter1517 != this->success.end(); ++_iter1517) { - xfer += (*_iter1515).write(oprot); + xfer += (*_iter1517).write(oprot); } xfer += oprot->writeListEnd(); } @@ -16909,14 +17136,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1516; - ::apache::thrift::protocol::TType _etype1519; - xfer += iprot->readListBegin(_etype1519, _size1516); - (*(this->success)).resize(_size1516); - uint32_t _i1520; - for (_i1520 = 0; _i1520 < _size1516; ++_i1520) + uint32_t _size1518; + ::apache::thrift::protocol::TType _etype1521; + xfer += iprot->readListBegin(_etype1521, _size1518); + (*(this->success)).resize(_size1518); + uint32_t _i1522; + for (_i1522 = 0; _i1522 < _size1518; ++_i1522) { - xfer += (*(this->success))[_i1520].read(iprot); + xfer += (*(this->success))[_i1522].read(iprot); } xfer += iprot->readListEnd(); } @@ -17015,14 +17242,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 _size1521; - ::apache::thrift::protocol::TType _etype1524; - xfer += iprot->readListBegin(_etype1524, _size1521); - this->part_vals.resize(_size1521); - uint32_t _i1525; - for (_i1525 = 0; _i1525 < _size1521; ++_i1525) + uint32_t _size1523; + ::apache::thrift::protocol::TType _etype1526; + xfer += iprot->readListBegin(_etype1526, _size1523); + this->part_vals.resize(_size1523); + uint32_t _i1527; + for (_i1527 = 0; _i1527 < _size1523; ++_i1527) { - xfer += iprot->readString(this->part_vals[_i1525]); + xfer += iprot->readString(this->part_vals[_i1527]); } xfer += iprot->readListEnd(); } @@ -17043,14 +17270,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 _size1526; - ::apache::thrift::protocol::TType _etype1529; - xfer += iprot->readListBegin(_etype1529, _size1526); - this->group_names.resize(_size1526); - uint32_t _i1530; - for (_i1530 = 0; _i1530 < _size1526; ++_i1530) + uint32_t _size1528; + ::apache::thrift::protocol::TType _etype1531; + xfer += iprot->readListBegin(_etype1531, _size1528); + this->group_names.resize(_size1528); + uint32_t _i1532; + for (_i1532 = 0; _i1532 < _size1528; ++_i1532) { - xfer += iprot->readString(this->group_names[_i1530]); + xfer += iprot->readString(this->group_names[_i1532]); } xfer += iprot->readListEnd(); } @@ -17087,10 +17314,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 _iter1531; - for (_iter1531 = this->part_vals.begin(); _iter1531 != this->part_vals.end(); ++_iter1531) + std::vector ::const_iterator _iter1533; + for (_iter1533 = this->part_vals.begin(); _iter1533 != this->part_vals.end(); ++_iter1533) { - xfer += oprot->writeString((*_iter1531)); + xfer += oprot->writeString((*_iter1533)); } xfer += oprot->writeListEnd(); } @@ -17103,10 +17330,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 _iter1532; - for (_iter1532 = this->group_names.begin(); _iter1532 != this->group_names.end(); ++_iter1532) + std::vector ::const_iterator _iter1534; + for (_iter1534 = this->group_names.begin(); _iter1534 != this->group_names.end(); ++_iter1534) { - xfer += oprot->writeString((*_iter1532)); + xfer += oprot->writeString((*_iter1534)); } xfer += oprot->writeListEnd(); } @@ -17138,10 +17365,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 _iter1533; - for (_iter1533 = (*(this->part_vals)).begin(); _iter1533 != (*(this->part_vals)).end(); ++_iter1533) + std::vector ::const_iterator _iter1535; + for (_iter1535 = (*(this->part_vals)).begin(); _iter1535 != (*(this->part_vals)).end(); ++_iter1535) { - xfer += oprot->writeString((*_iter1533)); + xfer += oprot->writeString((*_iter1535)); } xfer += oprot->writeListEnd(); } @@ -17154,10 +17381,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 _iter1534; - for (_iter1534 = (*(this->group_names)).begin(); _iter1534 != (*(this->group_names)).end(); ++_iter1534) + std::vector ::const_iterator _iter1536; + for (_iter1536 = (*(this->group_names)).begin(); _iter1536 != (*(this->group_names)).end(); ++_iter1536) { - xfer += oprot->writeString((*_iter1534)); + xfer += oprot->writeString((*_iter1536)); } xfer += oprot->writeListEnd(); } @@ -17716,14 +17943,14 @@ uint32_t ThriftHiveMetastore_get_partitions_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1535; - ::apache::thrift::protocol::TType _etype1538; - xfer += iprot->readListBegin(_etype1538, _size1535); - this->success.resize(_size1535); - uint32_t _i1539; - for (_i1539 = 0; _i1539 < _size1535; ++_i1539) + uint32_t _size1537; + ::apache::thrift::protocol::TType _etype1540; + xfer += iprot->readListBegin(_etype1540, _size1537); + this->success.resize(_size1537); + uint32_t _i1541; + for (_i1541 = 0; _i1541 < _size1537; ++_i1541) { - xfer += this->success[_i1539].read(iprot); + xfer += this->success[_i1541].read(iprot); } xfer += iprot->readListEnd(); } @@ -17770,10 +17997,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 _iter1540; - for (_iter1540 = this->success.begin(); _iter1540 != this->success.end(); ++_iter1540) + std::vector ::const_iterator _iter1542; + for (_iter1542 = this->success.begin(); _iter1542 != this->success.end(); ++_iter1542) { - xfer += (*_iter1540).write(oprot); + xfer += (*_iter1542).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17822,14 +18049,14 @@ uint32_t ThriftHiveMetastore_get_partitions_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1541; - ::apache::thrift::protocol::TType _etype1544; - xfer += iprot->readListBegin(_etype1544, _size1541); - (*(this->success)).resize(_size1541); - uint32_t _i1545; - for (_i1545 = 0; _i1545 < _size1541; ++_i1545) + uint32_t _size1543; + ::apache::thrift::protocol::TType _etype1546; + xfer += iprot->readListBegin(_etype1546, _size1543); + (*(this->success)).resize(_size1543); + uint32_t _i1547; + for (_i1547 = 0; _i1547 < _size1543; ++_i1547) { - xfer += (*(this->success))[_i1545].read(iprot); + xfer += (*(this->success))[_i1547].read(iprot); } xfer += iprot->readListEnd(); } @@ -17928,14 +18155,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 _size1546; - ::apache::thrift::protocol::TType _etype1549; - xfer += iprot->readListBegin(_etype1549, _size1546); - this->group_names.resize(_size1546); - uint32_t _i1550; - for (_i1550 = 0; _i1550 < _size1546; ++_i1550) + uint32_t _size1548; + ::apache::thrift::protocol::TType _etype1551; + xfer += iprot->readListBegin(_etype1551, _size1548); + this->group_names.resize(_size1548); + uint32_t _i1552; + for (_i1552 = 0; _i1552 < _size1548; ++_i1552) { - xfer += iprot->readString(this->group_names[_i1550]); + xfer += iprot->readString(this->group_names[_i1552]); } xfer += iprot->readListEnd(); } @@ -17980,10 +18207,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 _iter1551; - for (_iter1551 = this->group_names.begin(); _iter1551 != this->group_names.end(); ++_iter1551) + std::vector ::const_iterator _iter1553; + for (_iter1553 = this->group_names.begin(); _iter1553 != this->group_names.end(); ++_iter1553) { - xfer += oprot->writeString((*_iter1551)); + xfer += oprot->writeString((*_iter1553)); } xfer += oprot->writeListEnd(); } @@ -18023,10 +18250,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 _iter1552; - for (_iter1552 = (*(this->group_names)).begin(); _iter1552 != (*(this->group_names)).end(); ++_iter1552) + std::vector ::const_iterator _iter1554; + for (_iter1554 = (*(this->group_names)).begin(); _iter1554 != (*(this->group_names)).end(); ++_iter1554) { - xfer += oprot->writeString((*_iter1552)); + xfer += oprot->writeString((*_iter1554)); } xfer += oprot->writeListEnd(); } @@ -18067,14 +18294,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1553; - ::apache::thrift::protocol::TType _etype1556; - xfer += iprot->readListBegin(_etype1556, _size1553); - this->success.resize(_size1553); - uint32_t _i1557; - for (_i1557 = 0; _i1557 < _size1553; ++_i1557) + uint32_t _size1555; + ::apache::thrift::protocol::TType _etype1558; + xfer += iprot->readListBegin(_etype1558, _size1555); + this->success.resize(_size1555); + uint32_t _i1559; + for (_i1559 = 0; _i1559 < _size1555; ++_i1559) { - xfer += this->success[_i1557].read(iprot); + xfer += this->success[_i1559].read(iprot); } xfer += iprot->readListEnd(); } @@ -18121,10 +18348,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 _iter1558; - for (_iter1558 = this->success.begin(); _iter1558 != this->success.end(); ++_iter1558) + std::vector ::const_iterator _iter1560; + for (_iter1560 = this->success.begin(); _iter1560 != this->success.end(); ++_iter1560) { - xfer += (*_iter1558).write(oprot); + xfer += (*_iter1560).write(oprot); } xfer += oprot->writeListEnd(); } @@ -18173,14 +18400,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1559; - ::apache::thrift::protocol::TType _etype1562; - xfer += iprot->readListBegin(_etype1562, _size1559); - (*(this->success)).resize(_size1559); - uint32_t _i1563; - for (_i1563 = 0; _i1563 < _size1559; ++_i1563) + uint32_t _size1561; + ::apache::thrift::protocol::TType _etype1564; + xfer += iprot->readListBegin(_etype1564, _size1561); + (*(this->success)).resize(_size1561); + uint32_t _i1565; + for (_i1565 = 0; _i1565 < _size1561; ++_i1565) { - xfer += (*(this->success))[_i1563].read(iprot); + xfer += (*(this->success))[_i1565].read(iprot); } xfer += iprot->readListEnd(); } @@ -18358,14 +18585,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_result::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1564; - ::apache::thrift::protocol::TType _etype1567; - xfer += iprot->readListBegin(_etype1567, _size1564); - this->success.resize(_size1564); - uint32_t _i1568; - for (_i1568 = 0; _i1568 < _size1564; ++_i1568) + uint32_t _size1566; + ::apache::thrift::protocol::TType _etype1569; + xfer += iprot->readListBegin(_etype1569, _size1566); + this->success.resize(_size1566); + uint32_t _i1570; + for (_i1570 = 0; _i1570 < _size1566; ++_i1570) { - xfer += this->success[_i1568].read(iprot); + xfer += this->success[_i1570].read(iprot); } xfer += iprot->readListEnd(); } @@ -18412,10 +18639,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 _iter1569; - for (_iter1569 = this->success.begin(); _iter1569 != this->success.end(); ++_iter1569) + std::vector ::const_iterator _iter1571; + for (_iter1571 = this->success.begin(); _iter1571 != this->success.end(); ++_iter1571) { - xfer += (*_iter1569).write(oprot); + xfer += (*_iter1571).write(oprot); } xfer += oprot->writeListEnd(); } @@ -18464,14 +18691,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_presult::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1570; - ::apache::thrift::protocol::TType _etype1573; - xfer += iprot->readListBegin(_etype1573, _size1570); - (*(this->success)).resize(_size1570); - uint32_t _i1574; - for (_i1574 = 0; _i1574 < _size1570; ++_i1574) + uint32_t _size1572; + ::apache::thrift::protocol::TType _etype1575; + xfer += iprot->readListBegin(_etype1575, _size1572); + (*(this->success)).resize(_size1572); + uint32_t _i1576; + for (_i1576 = 0; _i1576 < _size1572; ++_i1576) { - xfer += (*(this->success))[_i1574].read(iprot); + xfer += (*(this->success))[_i1576].read(iprot); } xfer += iprot->readListEnd(); } @@ -18649,14 +18876,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1575; - ::apache::thrift::protocol::TType _etype1578; - xfer += iprot->readListBegin(_etype1578, _size1575); - this->success.resize(_size1575); - uint32_t _i1579; - for (_i1579 = 0; _i1579 < _size1575; ++_i1579) + uint32_t _size1577; + ::apache::thrift::protocol::TType _etype1580; + xfer += iprot->readListBegin(_etype1580, _size1577); + this->success.resize(_size1577); + uint32_t _i1581; + for (_i1581 = 0; _i1581 < _size1577; ++_i1581) { - xfer += iprot->readString(this->success[_i1579]); + xfer += iprot->readString(this->success[_i1581]); } xfer += iprot->readListEnd(); } @@ -18703,10 +18930,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 _iter1580; - for (_iter1580 = this->success.begin(); _iter1580 != this->success.end(); ++_iter1580) + std::vector ::const_iterator _iter1582; + for (_iter1582 = this->success.begin(); _iter1582 != this->success.end(); ++_iter1582) { - xfer += oprot->writeString((*_iter1580)); + xfer += oprot->writeString((*_iter1582)); } xfer += oprot->writeListEnd(); } @@ -18755,14 +18982,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1581; - ::apache::thrift::protocol::TType _etype1584; - xfer += iprot->readListBegin(_etype1584, _size1581); - (*(this->success)).resize(_size1581); - uint32_t _i1585; - for (_i1585 = 0; _i1585 < _size1581; ++_i1585) + uint32_t _size1583; + ::apache::thrift::protocol::TType _etype1586; + xfer += iprot->readListBegin(_etype1586, _size1583); + (*(this->success)).resize(_size1583); + uint32_t _i1587; + for (_i1587 = 0; _i1587 < _size1583; ++_i1587) { - xfer += iprot->readString((*(this->success))[_i1585]); + xfer += iprot->readString((*(this->success))[_i1587]); } xfer += iprot->readListEnd(); } @@ -19072,14 +19299,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 _size1586; - ::apache::thrift::protocol::TType _etype1589; - xfer += iprot->readListBegin(_etype1589, _size1586); - this->part_vals.resize(_size1586); - uint32_t _i1590; - for (_i1590 = 0; _i1590 < _size1586; ++_i1590) + uint32_t _size1588; + ::apache::thrift::protocol::TType _etype1591; + xfer += iprot->readListBegin(_etype1591, _size1588); + this->part_vals.resize(_size1588); + uint32_t _i1592; + for (_i1592 = 0; _i1592 < _size1588; ++_i1592) { - xfer += iprot->readString(this->part_vals[_i1590]); + xfer += iprot->readString(this->part_vals[_i1592]); } xfer += iprot->readListEnd(); } @@ -19124,10 +19351,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 _iter1591; - for (_iter1591 = this->part_vals.begin(); _iter1591 != this->part_vals.end(); ++_iter1591) + std::vector ::const_iterator _iter1593; + for (_iter1593 = this->part_vals.begin(); _iter1593 != this->part_vals.end(); ++_iter1593) { - xfer += oprot->writeString((*_iter1591)); + xfer += oprot->writeString((*_iter1593)); } xfer += oprot->writeListEnd(); } @@ -19163,10 +19390,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 _iter1592; - for (_iter1592 = (*(this->part_vals)).begin(); _iter1592 != (*(this->part_vals)).end(); ++_iter1592) + std::vector ::const_iterator _iter1594; + for (_iter1594 = (*(this->part_vals)).begin(); _iter1594 != (*(this->part_vals)).end(); ++_iter1594) { - xfer += oprot->writeString((*_iter1592)); + xfer += oprot->writeString((*_iter1594)); } xfer += oprot->writeListEnd(); } @@ -19211,14 +19438,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_result::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1593; - ::apache::thrift::protocol::TType _etype1596; - xfer += iprot->readListBegin(_etype1596, _size1593); - this->success.resize(_size1593); - uint32_t _i1597; - for (_i1597 = 0; _i1597 < _size1593; ++_i1597) + uint32_t _size1595; + ::apache::thrift::protocol::TType _etype1598; + xfer += iprot->readListBegin(_etype1598, _size1595); + this->success.resize(_size1595); + uint32_t _i1599; + for (_i1599 = 0; _i1599 < _size1595; ++_i1599) { - xfer += this->success[_i1597].read(iprot); + xfer += this->success[_i1599].read(iprot); } xfer += iprot->readListEnd(); } @@ -19265,10 +19492,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 _iter1598; - for (_iter1598 = this->success.begin(); _iter1598 != this->success.end(); ++_iter1598) + std::vector ::const_iterator _iter1600; + for (_iter1600 = this->success.begin(); _iter1600 != this->success.end(); ++_iter1600) { - xfer += (*_iter1598).write(oprot); + xfer += (*_iter1600).write(oprot); } xfer += oprot->writeListEnd(); } @@ -19317,14 +19544,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_presult::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1599; - ::apache::thrift::protocol::TType _etype1602; - xfer += iprot->readListBegin(_etype1602, _size1599); - (*(this->success)).resize(_size1599); - uint32_t _i1603; - for (_i1603 = 0; _i1603 < _size1599; ++_i1603) + uint32_t _size1601; + ::apache::thrift::protocol::TType _etype1604; + xfer += iprot->readListBegin(_etype1604, _size1601); + (*(this->success)).resize(_size1601); + uint32_t _i1605; + for (_i1605 = 0; _i1605 < _size1601; ++_i1605) { - xfer += (*(this->success))[_i1603].read(iprot); + xfer += (*(this->success))[_i1605].read(iprot); } xfer += iprot->readListEnd(); } @@ -19407,14 +19634,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 _size1604; - ::apache::thrift::protocol::TType _etype1607; - xfer += iprot->readListBegin(_etype1607, _size1604); - this->part_vals.resize(_size1604); - uint32_t _i1608; - for (_i1608 = 0; _i1608 < _size1604; ++_i1608) + uint32_t _size1606; + ::apache::thrift::protocol::TType _etype1609; + xfer += iprot->readListBegin(_etype1609, _size1606); + this->part_vals.resize(_size1606); + uint32_t _i1610; + for (_i1610 = 0; _i1610 < _size1606; ++_i1610) { - xfer += iprot->readString(this->part_vals[_i1608]); + xfer += iprot->readString(this->part_vals[_i1610]); } xfer += iprot->readListEnd(); } @@ -19443,14 +19670,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 _size1609; - ::apache::thrift::protocol::TType _etype1612; - xfer += iprot->readListBegin(_etype1612, _size1609); - this->group_names.resize(_size1609); - uint32_t _i1613; - for (_i1613 = 0; _i1613 < _size1609; ++_i1613) + uint32_t _size1611; + ::apache::thrift::protocol::TType _etype1614; + xfer += iprot->readListBegin(_etype1614, _size1611); + this->group_names.resize(_size1611); + uint32_t _i1615; + for (_i1615 = 0; _i1615 < _size1611; ++_i1615) { - xfer += iprot->readString(this->group_names[_i1613]); + xfer += iprot->readString(this->group_names[_i1615]); } xfer += iprot->readListEnd(); } @@ -19487,10 +19714,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 _iter1614; - for (_iter1614 = this->part_vals.begin(); _iter1614 != this->part_vals.end(); ++_iter1614) + std::vector ::const_iterator _iter1616; + for (_iter1616 = this->part_vals.begin(); _iter1616 != this->part_vals.end(); ++_iter1616) { - xfer += oprot->writeString((*_iter1614)); + xfer += oprot->writeString((*_iter1616)); } xfer += oprot->writeListEnd(); } @@ -19507,10 +19734,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 _iter1615; - for (_iter1615 = this->group_names.begin(); _iter1615 != this->group_names.end(); ++_iter1615) + std::vector ::const_iterator _iter1617; + for (_iter1617 = this->group_names.begin(); _iter1617 != this->group_names.end(); ++_iter1617) { - xfer += oprot->writeString((*_iter1615)); + xfer += oprot->writeString((*_iter1617)); } xfer += oprot->writeListEnd(); } @@ -19542,10 +19769,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 _iter1616; - for (_iter1616 = (*(this->part_vals)).begin(); _iter1616 != (*(this->part_vals)).end(); ++_iter1616) + std::vector ::const_iterator _iter1618; + for (_iter1618 = (*(this->part_vals)).begin(); _iter1618 != (*(this->part_vals)).end(); ++_iter1618) { - xfer += oprot->writeString((*_iter1616)); + xfer += oprot->writeString((*_iter1618)); } xfer += oprot->writeListEnd(); } @@ -19562,10 +19789,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 _iter1617; - for (_iter1617 = (*(this->group_names)).begin(); _iter1617 != (*(this->group_names)).end(); ++_iter1617) + std::vector ::const_iterator _iter1619; + for (_iter1619 = (*(this->group_names)).begin(); _iter1619 != (*(this->group_names)).end(); ++_iter1619) { - xfer += oprot->writeString((*_iter1617)); + xfer += oprot->writeString((*_iter1619)); } xfer += oprot->writeListEnd(); } @@ -19606,14 +19833,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_result::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1618; - ::apache::thrift::protocol::TType _etype1621; - xfer += iprot->readListBegin(_etype1621, _size1618); - this->success.resize(_size1618); - uint32_t _i1622; - for (_i1622 = 0; _i1622 < _size1618; ++_i1622) + uint32_t _size1620; + ::apache::thrift::protocol::TType _etype1623; + xfer += iprot->readListBegin(_etype1623, _size1620); + this->success.resize(_size1620); + uint32_t _i1624; + for (_i1624 = 0; _i1624 < _size1620; ++_i1624) { - xfer += this->success[_i1622].read(iprot); + xfer += this->success[_i1624].read(iprot); } xfer += iprot->readListEnd(); } @@ -19660,10 +19887,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 _iter1623; - for (_iter1623 = this->success.begin(); _iter1623 != this->success.end(); ++_iter1623) + std::vector ::const_iterator _iter1625; + for (_iter1625 = this->success.begin(); _iter1625 != this->success.end(); ++_iter1625) { - xfer += (*_iter1623).write(oprot); + xfer += (*_iter1625).write(oprot); } xfer += oprot->writeListEnd(); } @@ -19712,14 +19939,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_presult::read(::apache: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1624; - ::apache::thrift::protocol::TType _etype1627; - xfer += iprot->readListBegin(_etype1627, _size1624); - (*(this->success)).resize(_size1624); - uint32_t _i1628; - for (_i1628 = 0; _i1628 < _size1624; ++_i1628) + uint32_t _size1626; + ::apache::thrift::protocol::TType _etype1629; + xfer += iprot->readListBegin(_etype1629, _size1626); + (*(this->success)).resize(_size1626); + uint32_t _i1630; + for (_i1630 = 0; _i1630 < _size1626; ++_i1630) { - xfer += (*(this->success))[_i1628].read(iprot); + xfer += (*(this->success))[_i1630].read(iprot); } xfer += iprot->readListEnd(); } @@ -19802,14 +20029,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 _size1629; - ::apache::thrift::protocol::TType _etype1632; - xfer += iprot->readListBegin(_etype1632, _size1629); - this->part_vals.resize(_size1629); - uint32_t _i1633; - for (_i1633 = 0; _i1633 < _size1629; ++_i1633) + uint32_t _size1631; + ::apache::thrift::protocol::TType _etype1634; + xfer += iprot->readListBegin(_etype1634, _size1631); + this->part_vals.resize(_size1631); + uint32_t _i1635; + for (_i1635 = 0; _i1635 < _size1631; ++_i1635) { - xfer += iprot->readString(this->part_vals[_i1633]); + xfer += iprot->readString(this->part_vals[_i1635]); } xfer += iprot->readListEnd(); } @@ -19854,10 +20081,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 _iter1634; - for (_iter1634 = this->part_vals.begin(); _iter1634 != this->part_vals.end(); ++_iter1634) + std::vector ::const_iterator _iter1636; + for (_iter1636 = this->part_vals.begin(); _iter1636 != this->part_vals.end(); ++_iter1636) { - xfer += oprot->writeString((*_iter1634)); + xfer += oprot->writeString((*_iter1636)); } xfer += oprot->writeListEnd(); } @@ -19893,10 +20120,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 _iter1635; - for (_iter1635 = (*(this->part_vals)).begin(); _iter1635 != (*(this->part_vals)).end(); ++_iter1635) + std::vector ::const_iterator _iter1637; + for (_iter1637 = (*(this->part_vals)).begin(); _iter1637 != (*(this->part_vals)).end(); ++_iter1637) { - xfer += oprot->writeString((*_iter1635)); + xfer += oprot->writeString((*_iter1637)); } xfer += oprot->writeListEnd(); } @@ -19941,14 +20168,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1636; - ::apache::thrift::protocol::TType _etype1639; - xfer += iprot->readListBegin(_etype1639, _size1636); - this->success.resize(_size1636); - uint32_t _i1640; - for (_i1640 = 0; _i1640 < _size1636; ++_i1640) + uint32_t _size1638; + ::apache::thrift::protocol::TType _etype1641; + xfer += iprot->readListBegin(_etype1641, _size1638); + this->success.resize(_size1638); + uint32_t _i1642; + for (_i1642 = 0; _i1642 < _size1638; ++_i1642) { - xfer += iprot->readString(this->success[_i1640]); + xfer += iprot->readString(this->success[_i1642]); } xfer += iprot->readListEnd(); } @@ -19995,10 +20222,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 _iter1641; - for (_iter1641 = this->success.begin(); _iter1641 != this->success.end(); ++_iter1641) + std::vector ::const_iterator _iter1643; + for (_iter1643 = this->success.begin(); _iter1643 != this->success.end(); ++_iter1643) { - xfer += oprot->writeString((*_iter1641)); + xfer += oprot->writeString((*_iter1643)); } xfer += oprot->writeListEnd(); } @@ -20047,14 +20274,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1642; - ::apache::thrift::protocol::TType _etype1645; - xfer += iprot->readListBegin(_etype1645, _size1642); - (*(this->success)).resize(_size1642); - uint32_t _i1646; - for (_i1646 = 0; _i1646 < _size1642; ++_i1646) + uint32_t _size1644; + ::apache::thrift::protocol::TType _etype1647; + xfer += iprot->readListBegin(_etype1647, _size1644); + (*(this->success)).resize(_size1644); + uint32_t _i1648; + for (_i1648 = 0; _i1648 < _size1644; ++_i1648) { - xfer += iprot->readString((*(this->success))[_i1646]); + xfer += iprot->readString((*(this->success))[_i1648]); } xfer += iprot->readListEnd(); } @@ -20248,14 +20475,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1647; - ::apache::thrift::protocol::TType _etype1650; - xfer += iprot->readListBegin(_etype1650, _size1647); - this->success.resize(_size1647); - uint32_t _i1651; - for (_i1651 = 0; _i1651 < _size1647; ++_i1651) + uint32_t _size1649; + ::apache::thrift::protocol::TType _etype1652; + xfer += iprot->readListBegin(_etype1652, _size1649); + this->success.resize(_size1649); + uint32_t _i1653; + for (_i1653 = 0; _i1653 < _size1649; ++_i1653) { - xfer += this->success[_i1651].read(iprot); + xfer += this->success[_i1653].read(iprot); } xfer += iprot->readListEnd(); } @@ -20302,10 +20529,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 _iter1652; - for (_iter1652 = this->success.begin(); _iter1652 != this->success.end(); ++_iter1652) + std::vector ::const_iterator _iter1654; + for (_iter1654 = this->success.begin(); _iter1654 != this->success.end(); ++_iter1654) { - xfer += (*_iter1652).write(oprot); + xfer += (*_iter1654).write(oprot); } xfer += oprot->writeListEnd(); } @@ -20354,14 +20581,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1653; - ::apache::thrift::protocol::TType _etype1656; - xfer += iprot->readListBegin(_etype1656, _size1653); - (*(this->success)).resize(_size1653); - uint32_t _i1657; - for (_i1657 = 0; _i1657 < _size1653; ++_i1657) + uint32_t _size1655; + ::apache::thrift::protocol::TType _etype1658; + xfer += iprot->readListBegin(_etype1658, _size1655); + (*(this->success)).resize(_size1655); + uint32_t _i1659; + for (_i1659 = 0; _i1659 < _size1655; ++_i1659) { - xfer += (*(this->success))[_i1657].read(iprot); + xfer += (*(this->success))[_i1659].read(iprot); } xfer += iprot->readListEnd(); } @@ -20555,14 +20782,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 _size1658; - ::apache::thrift::protocol::TType _etype1661; - xfer += iprot->readListBegin(_etype1661, _size1658); - this->success.resize(_size1658); - uint32_t _i1662; - for (_i1662 = 0; _i1662 < _size1658; ++_i1662) + uint32_t _size1660; + ::apache::thrift::protocol::TType _etype1663; + xfer += iprot->readListBegin(_etype1663, _size1660); + this->success.resize(_size1660); + uint32_t _i1664; + for (_i1664 = 0; _i1664 < _size1660; ++_i1664) { - xfer += this->success[_i1662].read(iprot); + xfer += this->success[_i1664].read(iprot); } xfer += iprot->readListEnd(); } @@ -20609,10 +20836,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 _iter1663; - for (_iter1663 = this->success.begin(); _iter1663 != this->success.end(); ++_iter1663) + std::vector ::const_iterator _iter1665; + for (_iter1665 = this->success.begin(); _iter1665 != this->success.end(); ++_iter1665) { - xfer += (*_iter1663).write(oprot); + xfer += (*_iter1665).write(oprot); } xfer += oprot->writeListEnd(); } @@ -20661,14 +20888,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 _size1664; - ::apache::thrift::protocol::TType _etype1667; - xfer += iprot->readListBegin(_etype1667, _size1664); - (*(this->success)).resize(_size1664); - uint32_t _i1668; - for (_i1668 = 0; _i1668 < _size1664; ++_i1668) + uint32_t _size1666; + ::apache::thrift::protocol::TType _etype1669; + xfer += iprot->readListBegin(_etype1669, _size1666); + (*(this->success)).resize(_size1666); + uint32_t _i1670; + for (_i1670 = 0; _i1670 < _size1666; ++_i1670) { - xfer += (*(this->success))[_i1668].read(iprot); + xfer += (*(this->success))[_i1670].read(iprot); } xfer += iprot->readListEnd(); } @@ -21237,14 +21464,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_args::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { this->names.clear(); - uint32_t _size1669; - ::apache::thrift::protocol::TType _etype1672; - xfer += iprot->readListBegin(_etype1672, _size1669); - this->names.resize(_size1669); - uint32_t _i1673; - for (_i1673 = 0; _i1673 < _size1669; ++_i1673) + uint32_t _size1671; + ::apache::thrift::protocol::TType _etype1674; + xfer += iprot->readListBegin(_etype1674, _size1671); + this->names.resize(_size1671); + uint32_t _i1675; + for (_i1675 = 0; _i1675 < _size1671; ++_i1675) { - xfer += iprot->readString(this->names[_i1673]); + xfer += iprot->readString(this->names[_i1675]); } xfer += iprot->readListEnd(); } @@ -21281,10 +21508,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 _iter1674; - for (_iter1674 = this->names.begin(); _iter1674 != this->names.end(); ++_iter1674) + std::vector ::const_iterator _iter1676; + for (_iter1676 = this->names.begin(); _iter1676 != this->names.end(); ++_iter1676) { - xfer += oprot->writeString((*_iter1674)); + xfer += oprot->writeString((*_iter1676)); } xfer += oprot->writeListEnd(); } @@ -21316,10 +21543,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 _iter1675; - for (_iter1675 = (*(this->names)).begin(); _iter1675 != (*(this->names)).end(); ++_iter1675) + std::vector ::const_iterator _iter1677; + for (_iter1677 = (*(this->names)).begin(); _iter1677 != (*(this->names)).end(); ++_iter1677) { - xfer += oprot->writeString((*_iter1675)); + xfer += oprot->writeString((*_iter1677)); } xfer += oprot->writeListEnd(); } @@ -21360,14 +21587,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_result::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1676; - ::apache::thrift::protocol::TType _etype1679; - xfer += iprot->readListBegin(_etype1679, _size1676); - this->success.resize(_size1676); - uint32_t _i1680; - for (_i1680 = 0; _i1680 < _size1676; ++_i1680) + uint32_t _size1678; + ::apache::thrift::protocol::TType _etype1681; + xfer += iprot->readListBegin(_etype1681, _size1678); + this->success.resize(_size1678); + uint32_t _i1682; + for (_i1682 = 0; _i1682 < _size1678; ++_i1682) { - xfer += this->success[_i1680].read(iprot); + xfer += this->success[_i1682].read(iprot); } xfer += iprot->readListEnd(); } @@ -21414,10 +21641,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 _iter1681; - for (_iter1681 = this->success.begin(); _iter1681 != this->success.end(); ++_iter1681) + std::vector ::const_iterator _iter1683; + for (_iter1683 = this->success.begin(); _iter1683 != this->success.end(); ++_iter1683) { - xfer += (*_iter1681).write(oprot); + xfer += (*_iter1683).write(oprot); } xfer += oprot->writeListEnd(); } @@ -21466,14 +21693,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_presult::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1682; - ::apache::thrift::protocol::TType _etype1685; - xfer += iprot->readListBegin(_etype1685, _size1682); - (*(this->success)).resize(_size1682); - uint32_t _i1686; - for (_i1686 = 0; _i1686 < _size1682; ++_i1686) + uint32_t _size1684; + ::apache::thrift::protocol::TType _etype1687; + xfer += iprot->readListBegin(_etype1687, _size1684); + (*(this->success)).resize(_size1684); + uint32_t _i1688; + for (_i1688 = 0; _i1688 < _size1684; ++_i1688) { - xfer += (*(this->success))[_i1686].read(iprot); + xfer += (*(this->success))[_i1688].read(iprot); } xfer += iprot->readListEnd(); } @@ -21795,14 +22022,14 @@ uint32_t ThriftHiveMetastore_alter_partitions_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size1687; - ::apache::thrift::protocol::TType _etype1690; - xfer += iprot->readListBegin(_etype1690, _size1687); - this->new_parts.resize(_size1687); - uint32_t _i1691; - for (_i1691 = 0; _i1691 < _size1687; ++_i1691) + uint32_t _size1689; + ::apache::thrift::protocol::TType _etype1692; + xfer += iprot->readListBegin(_etype1692, _size1689); + this->new_parts.resize(_size1689); + uint32_t _i1693; + for (_i1693 = 0; _i1693 < _size1689; ++_i1693) { - xfer += this->new_parts[_i1691].read(iprot); + xfer += this->new_parts[_i1693].read(iprot); } xfer += iprot->readListEnd(); } @@ -21839,10 +22066,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 _iter1692; - for (_iter1692 = this->new_parts.begin(); _iter1692 != this->new_parts.end(); ++_iter1692) + std::vector ::const_iterator _iter1694; + for (_iter1694 = this->new_parts.begin(); _iter1694 != this->new_parts.end(); ++_iter1694) { - xfer += (*_iter1692).write(oprot); + xfer += (*_iter1694).write(oprot); } xfer += oprot->writeListEnd(); } @@ -21874,10 +22101,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 _iter1693; - for (_iter1693 = (*(this->new_parts)).begin(); _iter1693 != (*(this->new_parts)).end(); ++_iter1693) + std::vector ::const_iterator _iter1695; + for (_iter1695 = (*(this->new_parts)).begin(); _iter1695 != (*(this->new_parts)).end(); ++_iter1695) { - xfer += (*_iter1693).write(oprot); + xfer += (*_iter1695).write(oprot); } xfer += oprot->writeListEnd(); } @@ -22062,14 +22289,14 @@ uint32_t ThriftHiveMetastore_alter_partitions_with_environment_context_args::rea if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size1694; - ::apache::thrift::protocol::TType _etype1697; - xfer += iprot->readListBegin(_etype1697, _size1694); - this->new_parts.resize(_size1694); - uint32_t _i1698; - for (_i1698 = 0; _i1698 < _size1694; ++_i1698) + uint32_t _size1696; + ::apache::thrift::protocol::TType _etype1699; + xfer += iprot->readListBegin(_etype1699, _size1696); + this->new_parts.resize(_size1696); + uint32_t _i1700; + for (_i1700 = 0; _i1700 < _size1696; ++_i1700) { - xfer += this->new_parts[_i1698].read(iprot); + xfer += this->new_parts[_i1700].read(iprot); } xfer += iprot->readListEnd(); } @@ -22114,10 +22341,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 _iter1699; - for (_iter1699 = this->new_parts.begin(); _iter1699 != this->new_parts.end(); ++_iter1699) + std::vector ::const_iterator _iter1701; + for (_iter1701 = this->new_parts.begin(); _iter1701 != this->new_parts.end(); ++_iter1701) { - xfer += (*_iter1699).write(oprot); + xfer += (*_iter1701).write(oprot); } xfer += oprot->writeListEnd(); } @@ -22153,10 +22380,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 _iter1700; - for (_iter1700 = (*(this->new_parts)).begin(); _iter1700 != (*(this->new_parts)).end(); ++_iter1700) + std::vector ::const_iterator _iter1702; + for (_iter1702 = (*(this->new_parts)).begin(); _iter1702 != (*(this->new_parts)).end(); ++_iter1702) { - xfer += (*_iter1700).write(oprot); + xfer += (*_iter1702).write(oprot); } xfer += oprot->writeListEnd(); } @@ -22600,14 +22827,14 @@ uint32_t ThriftHiveMetastore_rename_partition_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1701; - ::apache::thrift::protocol::TType _etype1704; - xfer += iprot->readListBegin(_etype1704, _size1701); - this->part_vals.resize(_size1701); - uint32_t _i1705; - for (_i1705 = 0; _i1705 < _size1701; ++_i1705) + uint32_t _size1703; + ::apache::thrift::protocol::TType _etype1706; + xfer += iprot->readListBegin(_etype1706, _size1703); + this->part_vals.resize(_size1703); + uint32_t _i1707; + for (_i1707 = 0; _i1707 < _size1703; ++_i1707) { - xfer += iprot->readString(this->part_vals[_i1705]); + xfer += iprot->readString(this->part_vals[_i1707]); } xfer += iprot->readListEnd(); } @@ -22652,10 +22879,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 _iter1706; - for (_iter1706 = this->part_vals.begin(); _iter1706 != this->part_vals.end(); ++_iter1706) + std::vector ::const_iterator _iter1708; + for (_iter1708 = this->part_vals.begin(); _iter1708 != this->part_vals.end(); ++_iter1708) { - xfer += oprot->writeString((*_iter1706)); + xfer += oprot->writeString((*_iter1708)); } xfer += oprot->writeListEnd(); } @@ -22691,10 +22918,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 _iter1707; - for (_iter1707 = (*(this->part_vals)).begin(); _iter1707 != (*(this->part_vals)).end(); ++_iter1707) + std::vector ::const_iterator _iter1709; + for (_iter1709 = (*(this->part_vals)).begin(); _iter1709 != (*(this->part_vals)).end(); ++_iter1709) { - xfer += oprot->writeString((*_iter1707)); + xfer += oprot->writeString((*_iter1709)); } xfer += oprot->writeListEnd(); } @@ -22867,14 +23094,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 _size1708; - ::apache::thrift::protocol::TType _etype1711; - xfer += iprot->readListBegin(_etype1711, _size1708); - this->part_vals.resize(_size1708); - uint32_t _i1712; - for (_i1712 = 0; _i1712 < _size1708; ++_i1712) + uint32_t _size1710; + ::apache::thrift::protocol::TType _etype1713; + xfer += iprot->readListBegin(_etype1713, _size1710); + this->part_vals.resize(_size1710); + uint32_t _i1714; + for (_i1714 = 0; _i1714 < _size1710; ++_i1714) { - xfer += iprot->readString(this->part_vals[_i1712]); + xfer += iprot->readString(this->part_vals[_i1714]); } xfer += iprot->readListEnd(); } @@ -22911,10 +23138,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 _iter1713; - for (_iter1713 = this->part_vals.begin(); _iter1713 != this->part_vals.end(); ++_iter1713) + std::vector ::const_iterator _iter1715; + for (_iter1715 = this->part_vals.begin(); _iter1715 != this->part_vals.end(); ++_iter1715) { - xfer += oprot->writeString((*_iter1713)); + xfer += oprot->writeString((*_iter1715)); } xfer += oprot->writeListEnd(); } @@ -22942,10 +23169,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 _iter1714; - for (_iter1714 = (*(this->part_vals)).begin(); _iter1714 != (*(this->part_vals)).end(); ++_iter1714) + std::vector ::const_iterator _iter1716; + for (_iter1716 = (*(this->part_vals)).begin(); _iter1716 != (*(this->part_vals)).end(); ++_iter1716) { - xfer += oprot->writeString((*_iter1714)); + xfer += oprot->writeString((*_iter1716)); } xfer += oprot->writeListEnd(); } @@ -23420,14 +23647,14 @@ uint32_t ThriftHiveMetastore_partition_name_to_vals_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1715; - ::apache::thrift::protocol::TType _etype1718; - xfer += iprot->readListBegin(_etype1718, _size1715); - this->success.resize(_size1715); - uint32_t _i1719; - for (_i1719 = 0; _i1719 < _size1715; ++_i1719) + uint32_t _size1717; + ::apache::thrift::protocol::TType _etype1720; + xfer += iprot->readListBegin(_etype1720, _size1717); + this->success.resize(_size1717); + uint32_t _i1721; + for (_i1721 = 0; _i1721 < _size1717; ++_i1721) { - xfer += iprot->readString(this->success[_i1719]); + xfer += iprot->readString(this->success[_i1721]); } xfer += iprot->readListEnd(); } @@ -23466,10 +23693,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 _iter1720; - for (_iter1720 = this->success.begin(); _iter1720 != this->success.end(); ++_iter1720) + std::vector ::const_iterator _iter1722; + for (_iter1722 = this->success.begin(); _iter1722 != this->success.end(); ++_iter1722) { - xfer += oprot->writeString((*_iter1720)); + xfer += oprot->writeString((*_iter1722)); } xfer += oprot->writeListEnd(); } @@ -23514,14 +23741,14 @@ uint32_t ThriftHiveMetastore_partition_name_to_vals_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1721; - ::apache::thrift::protocol::TType _etype1724; - xfer += iprot->readListBegin(_etype1724, _size1721); - (*(this->success)).resize(_size1721); - uint32_t _i1725; - for (_i1725 = 0; _i1725 < _size1721; ++_i1725) + uint32_t _size1723; + ::apache::thrift::protocol::TType _etype1726; + xfer += iprot->readListBegin(_etype1726, _size1723); + (*(this->success)).resize(_size1723); + uint32_t _i1727; + for (_i1727 = 0; _i1727 < _size1723; ++_i1727) { - xfer += iprot->readString((*(this->success))[_i1725]); + xfer += iprot->readString((*(this->success))[_i1727]); } xfer += iprot->readListEnd(); } @@ -23659,17 +23886,17 @@ uint32_t ThriftHiveMetastore_partition_name_to_spec_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_MAP) { { this->success.clear(); - uint32_t _size1726; - ::apache::thrift::protocol::TType _ktype1727; - ::apache::thrift::protocol::TType _vtype1728; - xfer += iprot->readMapBegin(_ktype1727, _vtype1728, _size1726); - uint32_t _i1730; - for (_i1730 = 0; _i1730 < _size1726; ++_i1730) + uint32_t _size1728; + ::apache::thrift::protocol::TType _ktype1729; + ::apache::thrift::protocol::TType _vtype1730; + xfer += iprot->readMapBegin(_ktype1729, _vtype1730, _size1728); + uint32_t _i1732; + for (_i1732 = 0; _i1732 < _size1728; ++_i1732) { - std::string _key1731; - xfer += iprot->readString(_key1731); - std::string& _val1732 = this->success[_key1731]; - xfer += iprot->readString(_val1732); + std::string _key1733; + xfer += iprot->readString(_key1733); + std::string& _val1734 = this->success[_key1733]; + xfer += iprot->readString(_val1734); } xfer += iprot->readMapEnd(); } @@ -23708,11 +23935,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 _iter1733; - for (_iter1733 = this->success.begin(); _iter1733 != this->success.end(); ++_iter1733) + std::map ::const_iterator _iter1735; + for (_iter1735 = this->success.begin(); _iter1735 != this->success.end(); ++_iter1735) { - xfer += oprot->writeString(_iter1733->first); - xfer += oprot->writeString(_iter1733->second); + xfer += oprot->writeString(_iter1735->first); + xfer += oprot->writeString(_iter1735->second); } xfer += oprot->writeMapEnd(); } @@ -23757,17 +23984,17 @@ uint32_t ThriftHiveMetastore_partition_name_to_spec_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_MAP) { { (*(this->success)).clear(); - uint32_t _size1734; - ::apache::thrift::protocol::TType _ktype1735; - ::apache::thrift::protocol::TType _vtype1736; - xfer += iprot->readMapBegin(_ktype1735, _vtype1736, _size1734); - uint32_t _i1738; - for (_i1738 = 0; _i1738 < _size1734; ++_i1738) + uint32_t _size1736; + ::apache::thrift::protocol::TType _ktype1737; + ::apache::thrift::protocol::TType _vtype1738; + xfer += iprot->readMapBegin(_ktype1737, _vtype1738, _size1736); + uint32_t _i1740; + for (_i1740 = 0; _i1740 < _size1736; ++_i1740) { - std::string _key1739; - xfer += iprot->readString(_key1739); - std::string& _val1740 = (*(this->success))[_key1739]; - xfer += iprot->readString(_val1740); + std::string _key1741; + xfer += iprot->readString(_key1741); + std::string& _val1742 = (*(this->success))[_key1741]; + xfer += iprot->readString(_val1742); } xfer += iprot->readMapEnd(); } @@ -23842,17 +24069,17 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_args::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_MAP) { { this->part_vals.clear(); - uint32_t _size1741; - ::apache::thrift::protocol::TType _ktype1742; - ::apache::thrift::protocol::TType _vtype1743; - xfer += iprot->readMapBegin(_ktype1742, _vtype1743, _size1741); - uint32_t _i1745; - for (_i1745 = 0; _i1745 < _size1741; ++_i1745) + uint32_t _size1743; + ::apache::thrift::protocol::TType _ktype1744; + ::apache::thrift::protocol::TType _vtype1745; + xfer += iprot->readMapBegin(_ktype1744, _vtype1745, _size1743); + uint32_t _i1747; + for (_i1747 = 0; _i1747 < _size1743; ++_i1747) { - std::string _key1746; - xfer += iprot->readString(_key1746); - std::string& _val1747 = this->part_vals[_key1746]; - xfer += iprot->readString(_val1747); + std::string _key1748; + xfer += iprot->readString(_key1748); + std::string& _val1749 = this->part_vals[_key1748]; + xfer += iprot->readString(_val1749); } xfer += iprot->readMapEnd(); } @@ -23863,9 +24090,9 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_args::read(::apache::thrift:: break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1748; - xfer += iprot->readI32(ecast1748); - this->eventType = (PartitionEventType::type)ecast1748; + int32_t ecast1750; + xfer += iprot->readI32(ecast1750); + this->eventType = (PartitionEventType::type)ecast1750; this->__isset.eventType = true; } else { xfer += iprot->skip(ftype); @@ -23899,11 +24126,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 _iter1749; - for (_iter1749 = this->part_vals.begin(); _iter1749 != this->part_vals.end(); ++_iter1749) + std::map ::const_iterator _iter1751; + for (_iter1751 = this->part_vals.begin(); _iter1751 != this->part_vals.end(); ++_iter1751) { - xfer += oprot->writeString(_iter1749->first); - xfer += oprot->writeString(_iter1749->second); + xfer += oprot->writeString(_iter1751->first); + xfer += oprot->writeString(_iter1751->second); } xfer += oprot->writeMapEnd(); } @@ -23939,11 +24166,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 _iter1750; - for (_iter1750 = (*(this->part_vals)).begin(); _iter1750 != (*(this->part_vals)).end(); ++_iter1750) + std::map ::const_iterator _iter1752; + for (_iter1752 = (*(this->part_vals)).begin(); _iter1752 != (*(this->part_vals)).end(); ++_iter1752) { - xfer += oprot->writeString(_iter1750->first); - xfer += oprot->writeString(_iter1750->second); + xfer += oprot->writeString(_iter1752->first); + xfer += oprot->writeString(_iter1752->second); } xfer += oprot->writeMapEnd(); } @@ -24212,17 +24439,17 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_MAP) { { this->part_vals.clear(); - uint32_t _size1751; - ::apache::thrift::protocol::TType _ktype1752; - ::apache::thrift::protocol::TType _vtype1753; - xfer += iprot->readMapBegin(_ktype1752, _vtype1753, _size1751); - uint32_t _i1755; - for (_i1755 = 0; _i1755 < _size1751; ++_i1755) + uint32_t _size1753; + ::apache::thrift::protocol::TType _ktype1754; + ::apache::thrift::protocol::TType _vtype1755; + xfer += iprot->readMapBegin(_ktype1754, _vtype1755, _size1753); + uint32_t _i1757; + for (_i1757 = 0; _i1757 < _size1753; ++_i1757) { - std::string _key1756; - xfer += iprot->readString(_key1756); - std::string& _val1757 = this->part_vals[_key1756]; - xfer += iprot->readString(_val1757); + std::string _key1758; + xfer += iprot->readString(_key1758); + std::string& _val1759 = this->part_vals[_key1758]; + xfer += iprot->readString(_val1759); } xfer += iprot->readMapEnd(); } @@ -24233,9 +24460,9 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::read(::apache::thri break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1758; - xfer += iprot->readI32(ecast1758); - this->eventType = (PartitionEventType::type)ecast1758; + int32_t ecast1760; + xfer += iprot->readI32(ecast1760); + this->eventType = (PartitionEventType::type)ecast1760; this->__isset.eventType = true; } else { xfer += iprot->skip(ftype); @@ -24269,11 +24496,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 _iter1759; - for (_iter1759 = this->part_vals.begin(); _iter1759 != this->part_vals.end(); ++_iter1759) + std::map ::const_iterator _iter1761; + for (_iter1761 = this->part_vals.begin(); _iter1761 != this->part_vals.end(); ++_iter1761) { - xfer += oprot->writeString(_iter1759->first); - xfer += oprot->writeString(_iter1759->second); + xfer += oprot->writeString(_iter1761->first); + xfer += oprot->writeString(_iter1761->second); } xfer += oprot->writeMapEnd(); } @@ -24309,11 +24536,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 _iter1760; - for (_iter1760 = (*(this->part_vals)).begin(); _iter1760 != (*(this->part_vals)).end(); ++_iter1760) + std::map ::const_iterator _iter1762; + for (_iter1762 = (*(this->part_vals)).begin(); _iter1762 != (*(this->part_vals)).end(); ++_iter1762) { - xfer += oprot->writeString(_iter1760->first); - xfer += oprot->writeString(_iter1760->second); + xfer += oprot->writeString(_iter1762->first); + xfer += oprot->writeString(_iter1762->second); } xfer += oprot->writeMapEnd(); } @@ -29462,14 +29689,14 @@ uint32_t ThriftHiveMetastore_get_functions_result::read(::apache::thrift::protoc if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1761; - ::apache::thrift::protocol::TType _etype1764; - xfer += iprot->readListBegin(_etype1764, _size1761); - this->success.resize(_size1761); - uint32_t _i1765; - for (_i1765 = 0; _i1765 < _size1761; ++_i1765) + uint32_t _size1763; + ::apache::thrift::protocol::TType _etype1766; + xfer += iprot->readListBegin(_etype1766, _size1763); + this->success.resize(_size1763); + uint32_t _i1767; + for (_i1767 = 0; _i1767 < _size1763; ++_i1767) { - xfer += iprot->readString(this->success[_i1765]); + xfer += iprot->readString(this->success[_i1767]); } xfer += iprot->readListEnd(); } @@ -29508,10 +29735,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 _iter1766; - for (_iter1766 = this->success.begin(); _iter1766 != this->success.end(); ++_iter1766) + std::vector ::const_iterator _iter1768; + for (_iter1768 = this->success.begin(); _iter1768 != this->success.end(); ++_iter1768) { - xfer += oprot->writeString((*_iter1766)); + xfer += oprot->writeString((*_iter1768)); } xfer += oprot->writeListEnd(); } @@ -29556,14 +29783,14 @@ uint32_t ThriftHiveMetastore_get_functions_presult::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1767; - ::apache::thrift::protocol::TType _etype1770; - xfer += iprot->readListBegin(_etype1770, _size1767); - (*(this->success)).resize(_size1767); - uint32_t _i1771; - for (_i1771 = 0; _i1771 < _size1767; ++_i1771) + uint32_t _size1769; + ::apache::thrift::protocol::TType _etype1772; + xfer += iprot->readListBegin(_etype1772, _size1769); + (*(this->success)).resize(_size1769); + uint32_t _i1773; + for (_i1773 = 0; _i1773 < _size1769; ++_i1773) { - xfer += iprot->readString((*(this->success))[_i1771]); + xfer += iprot->readString((*(this->success))[_i1773]); } xfer += iprot->readListEnd(); } @@ -30523,14 +30750,14 @@ uint32_t ThriftHiveMetastore_get_role_names_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1772; - ::apache::thrift::protocol::TType _etype1775; - xfer += iprot->readListBegin(_etype1775, _size1772); - this->success.resize(_size1772); - uint32_t _i1776; - for (_i1776 = 0; _i1776 < _size1772; ++_i1776) + uint32_t _size1774; + ::apache::thrift::protocol::TType _etype1777; + xfer += iprot->readListBegin(_etype1777, _size1774); + this->success.resize(_size1774); + uint32_t _i1778; + for (_i1778 = 0; _i1778 < _size1774; ++_i1778) { - xfer += iprot->readString(this->success[_i1776]); + xfer += iprot->readString(this->success[_i1778]); } xfer += iprot->readListEnd(); } @@ -30569,10 +30796,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 _iter1777; - for (_iter1777 = this->success.begin(); _iter1777 != this->success.end(); ++_iter1777) + std::vector ::const_iterator _iter1779; + for (_iter1779 = this->success.begin(); _iter1779 != this->success.end(); ++_iter1779) { - xfer += oprot->writeString((*_iter1777)); + xfer += oprot->writeString((*_iter1779)); } xfer += oprot->writeListEnd(); } @@ -30617,14 +30844,14 @@ uint32_t ThriftHiveMetastore_get_role_names_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1778; - ::apache::thrift::protocol::TType _etype1781; - xfer += iprot->readListBegin(_etype1781, _size1778); - (*(this->success)).resize(_size1778); - uint32_t _i1782; - for (_i1782 = 0; _i1782 < _size1778; ++_i1782) + uint32_t _size1780; + ::apache::thrift::protocol::TType _etype1783; + xfer += iprot->readListBegin(_etype1783, _size1780); + (*(this->success)).resize(_size1780); + uint32_t _i1784; + for (_i1784 = 0; _i1784 < _size1780; ++_i1784) { - xfer += iprot->readString((*(this->success))[_i1782]); + xfer += iprot->readString((*(this->success))[_i1784]); } xfer += iprot->readListEnd(); } @@ -30697,9 +30924,9 @@ uint32_t ThriftHiveMetastore_grant_role_args::read(::apache::thrift::protocol::T break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1783; - xfer += iprot->readI32(ecast1783); - this->principal_type = (PrincipalType::type)ecast1783; + int32_t ecast1785; + xfer += iprot->readI32(ecast1785); + this->principal_type = (PrincipalType::type)ecast1785; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -30715,9 +30942,9 @@ uint32_t ThriftHiveMetastore_grant_role_args::read(::apache::thrift::protocol::T break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1784; - xfer += iprot->readI32(ecast1784); - this->grantorType = (PrincipalType::type)ecast1784; + int32_t ecast1786; + xfer += iprot->readI32(ecast1786); + this->grantorType = (PrincipalType::type)ecast1786; this->__isset.grantorType = true; } else { xfer += iprot->skip(ftype); @@ -30988,9 +31215,9 @@ uint32_t ThriftHiveMetastore_revoke_role_args::read(::apache::thrift::protocol:: break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1785; - xfer += iprot->readI32(ecast1785); - this->principal_type = (PrincipalType::type)ecast1785; + int32_t ecast1787; + xfer += iprot->readI32(ecast1787); + this->principal_type = (PrincipalType::type)ecast1787; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -31221,9 +31448,9 @@ uint32_t ThriftHiveMetastore_list_roles_args::read(::apache::thrift::protocol::T break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1786; - xfer += iprot->readI32(ecast1786); - this->principal_type = (PrincipalType::type)ecast1786; + int32_t ecast1788; + xfer += iprot->readI32(ecast1788); + this->principal_type = (PrincipalType::type)ecast1788; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -31312,14 +31539,14 @@ uint32_t ThriftHiveMetastore_list_roles_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1787; - ::apache::thrift::protocol::TType _etype1790; - xfer += iprot->readListBegin(_etype1790, _size1787); - this->success.resize(_size1787); - uint32_t _i1791; - for (_i1791 = 0; _i1791 < _size1787; ++_i1791) + uint32_t _size1789; + ::apache::thrift::protocol::TType _etype1792; + xfer += iprot->readListBegin(_etype1792, _size1789); + this->success.resize(_size1789); + uint32_t _i1793; + for (_i1793 = 0; _i1793 < _size1789; ++_i1793) { - xfer += this->success[_i1791].read(iprot); + xfer += this->success[_i1793].read(iprot); } xfer += iprot->readListEnd(); } @@ -31358,10 +31585,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 _iter1792; - for (_iter1792 = this->success.begin(); _iter1792 != this->success.end(); ++_iter1792) + std::vector ::const_iterator _iter1794; + for (_iter1794 = this->success.begin(); _iter1794 != this->success.end(); ++_iter1794) { - xfer += (*_iter1792).write(oprot); + xfer += (*_iter1794).write(oprot); } xfer += oprot->writeListEnd(); } @@ -31406,14 +31633,14 @@ uint32_t ThriftHiveMetastore_list_roles_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1793; - ::apache::thrift::protocol::TType _etype1796; - xfer += iprot->readListBegin(_etype1796, _size1793); - (*(this->success)).resize(_size1793); - uint32_t _i1797; - for (_i1797 = 0; _i1797 < _size1793; ++_i1797) + uint32_t _size1795; + ::apache::thrift::protocol::TType _etype1798; + xfer += iprot->readListBegin(_etype1798, _size1795); + (*(this->success)).resize(_size1795); + uint32_t _i1799; + for (_i1799 = 0; _i1799 < _size1795; ++_i1799) { - xfer += (*(this->success))[_i1797].read(iprot); + xfer += (*(this->success))[_i1799].read(iprot); } xfer += iprot->readListEnd(); } @@ -32109,14 +32336,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 _size1798; - ::apache::thrift::protocol::TType _etype1801; - xfer += iprot->readListBegin(_etype1801, _size1798); - this->group_names.resize(_size1798); - uint32_t _i1802; - for (_i1802 = 0; _i1802 < _size1798; ++_i1802) + uint32_t _size1800; + ::apache::thrift::protocol::TType _etype1803; + xfer += iprot->readListBegin(_etype1803, _size1800); + this->group_names.resize(_size1800); + uint32_t _i1804; + for (_i1804 = 0; _i1804 < _size1800; ++_i1804) { - xfer += iprot->readString(this->group_names[_i1802]); + xfer += iprot->readString(this->group_names[_i1804]); } xfer += iprot->readListEnd(); } @@ -32153,10 +32380,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 _iter1803; - for (_iter1803 = this->group_names.begin(); _iter1803 != this->group_names.end(); ++_iter1803) + std::vector ::const_iterator _iter1805; + for (_iter1805 = this->group_names.begin(); _iter1805 != this->group_names.end(); ++_iter1805) { - xfer += oprot->writeString((*_iter1803)); + xfer += oprot->writeString((*_iter1805)); } xfer += oprot->writeListEnd(); } @@ -32188,10 +32415,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 _iter1804; - for (_iter1804 = (*(this->group_names)).begin(); _iter1804 != (*(this->group_names)).end(); ++_iter1804) + std::vector ::const_iterator _iter1806; + for (_iter1806 = (*(this->group_names)).begin(); _iter1806 != (*(this->group_names)).end(); ++_iter1806) { - xfer += oprot->writeString((*_iter1804)); + xfer += oprot->writeString((*_iter1806)); } xfer += oprot->writeListEnd(); } @@ -32366,9 +32593,9 @@ uint32_t ThriftHiveMetastore_list_privileges_args::read(::apache::thrift::protoc break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1805; - xfer += iprot->readI32(ecast1805); - this->principal_type = (PrincipalType::type)ecast1805; + int32_t ecast1807; + xfer += iprot->readI32(ecast1807); + this->principal_type = (PrincipalType::type)ecast1807; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -32473,14 +32700,14 @@ uint32_t ThriftHiveMetastore_list_privileges_result::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1806; - ::apache::thrift::protocol::TType _etype1809; - xfer += iprot->readListBegin(_etype1809, _size1806); - this->success.resize(_size1806); - uint32_t _i1810; - for (_i1810 = 0; _i1810 < _size1806; ++_i1810) + uint32_t _size1808; + ::apache::thrift::protocol::TType _etype1811; + xfer += iprot->readListBegin(_etype1811, _size1808); + this->success.resize(_size1808); + uint32_t _i1812; + for (_i1812 = 0; _i1812 < _size1808; ++_i1812) { - xfer += this->success[_i1810].read(iprot); + xfer += this->success[_i1812].read(iprot); } xfer += iprot->readListEnd(); } @@ -32519,10 +32746,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 _iter1811; - for (_iter1811 = this->success.begin(); _iter1811 != this->success.end(); ++_iter1811) + std::vector ::const_iterator _iter1813; + for (_iter1813 = this->success.begin(); _iter1813 != this->success.end(); ++_iter1813) { - xfer += (*_iter1811).write(oprot); + xfer += (*_iter1813).write(oprot); } xfer += oprot->writeListEnd(); } @@ -32567,14 +32794,14 @@ uint32_t ThriftHiveMetastore_list_privileges_presult::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1812; - ::apache::thrift::protocol::TType _etype1815; - xfer += iprot->readListBegin(_etype1815, _size1812); - (*(this->success)).resize(_size1812); - uint32_t _i1816; - for (_i1816 = 0; _i1816 < _size1812; ++_i1816) + uint32_t _size1814; + ::apache::thrift::protocol::TType _etype1817; + xfer += iprot->readListBegin(_etype1817, _size1814); + (*(this->success)).resize(_size1814); + uint32_t _i1818; + for (_i1818 = 0; _i1818 < _size1814; ++_i1818) { - xfer += (*(this->success))[_i1816].read(iprot); + xfer += (*(this->success))[_i1818].read(iprot); } xfer += iprot->readListEnd(); } @@ -33485,14 +33712,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 _size1817; - ::apache::thrift::protocol::TType _etype1820; - xfer += iprot->readListBegin(_etype1820, _size1817); - this->group_names.resize(_size1817); - uint32_t _i1821; - for (_i1821 = 0; _i1821 < _size1817; ++_i1821) + uint32_t _size1819; + ::apache::thrift::protocol::TType _etype1822; + xfer += iprot->readListBegin(_etype1822, _size1819); + this->group_names.resize(_size1819); + uint32_t _i1823; + for (_i1823 = 0; _i1823 < _size1819; ++_i1823) { - xfer += iprot->readString(this->group_names[_i1821]); + xfer += iprot->readString(this->group_names[_i1823]); } xfer += iprot->readListEnd(); } @@ -33525,10 +33752,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 _iter1822; - for (_iter1822 = this->group_names.begin(); _iter1822 != this->group_names.end(); ++_iter1822) + std::vector ::const_iterator _iter1824; + for (_iter1824 = this->group_names.begin(); _iter1824 != this->group_names.end(); ++_iter1824) { - xfer += oprot->writeString((*_iter1822)); + xfer += oprot->writeString((*_iter1824)); } xfer += oprot->writeListEnd(); } @@ -33556,10 +33783,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 _iter1823; - for (_iter1823 = (*(this->group_names)).begin(); _iter1823 != (*(this->group_names)).end(); ++_iter1823) + std::vector ::const_iterator _iter1825; + for (_iter1825 = (*(this->group_names)).begin(); _iter1825 != (*(this->group_names)).end(); ++_iter1825) { - xfer += oprot->writeString((*_iter1823)); + xfer += oprot->writeString((*_iter1825)); } xfer += oprot->writeListEnd(); } @@ -33600,14 +33827,14 @@ uint32_t ThriftHiveMetastore_set_ugi_result::read(::apache::thrift::protocol::TP if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1824; - ::apache::thrift::protocol::TType _etype1827; - xfer += iprot->readListBegin(_etype1827, _size1824); - this->success.resize(_size1824); - uint32_t _i1828; - for (_i1828 = 0; _i1828 < _size1824; ++_i1828) + uint32_t _size1826; + ::apache::thrift::protocol::TType _etype1829; + xfer += iprot->readListBegin(_etype1829, _size1826); + this->success.resize(_size1826); + uint32_t _i1830; + for (_i1830 = 0; _i1830 < _size1826; ++_i1830) { - xfer += iprot->readString(this->success[_i1828]); + xfer += iprot->readString(this->success[_i1830]); } xfer += iprot->readListEnd(); } @@ -33646,10 +33873,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 _iter1829; - for (_iter1829 = this->success.begin(); _iter1829 != this->success.end(); ++_iter1829) + std::vector ::const_iterator _iter1831; + for (_iter1831 = this->success.begin(); _iter1831 != this->success.end(); ++_iter1831) { - xfer += oprot->writeString((*_iter1829)); + xfer += oprot->writeString((*_iter1831)); } xfer += oprot->writeListEnd(); } @@ -33694,14 +33921,14 @@ uint32_t ThriftHiveMetastore_set_ugi_presult::read(::apache::thrift::protocol::T if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1830; - ::apache::thrift::protocol::TType _etype1833; - xfer += iprot->readListBegin(_etype1833, _size1830); - (*(this->success)).resize(_size1830); - uint32_t _i1834; - for (_i1834 = 0; _i1834 < _size1830; ++_i1834) + uint32_t _size1832; + ::apache::thrift::protocol::TType _etype1835; + xfer += iprot->readListBegin(_etype1835, _size1832); + (*(this->success)).resize(_size1832); + uint32_t _i1836; + for (_i1836 = 0; _i1836 < _size1832; ++_i1836) { - xfer += iprot->readString((*(this->success))[_i1834]); + xfer += iprot->readString((*(this->success))[_i1836]); } xfer += iprot->readListEnd(); } @@ -35012,14 +35239,14 @@ uint32_t ThriftHiveMetastore_get_all_token_identifiers_result::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1835; - ::apache::thrift::protocol::TType _etype1838; - xfer += iprot->readListBegin(_etype1838, _size1835); - this->success.resize(_size1835); - uint32_t _i1839; - for (_i1839 = 0; _i1839 < _size1835; ++_i1839) + uint32_t _size1837; + ::apache::thrift::protocol::TType _etype1840; + xfer += iprot->readListBegin(_etype1840, _size1837); + this->success.resize(_size1837); + uint32_t _i1841; + for (_i1841 = 0; _i1841 < _size1837; ++_i1841) { - xfer += iprot->readString(this->success[_i1839]); + xfer += iprot->readString(this->success[_i1841]); } xfer += iprot->readListEnd(); } @@ -35050,10 +35277,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 _iter1840; - for (_iter1840 = this->success.begin(); _iter1840 != this->success.end(); ++_iter1840) + std::vector ::const_iterator _iter1842; + for (_iter1842 = this->success.begin(); _iter1842 != this->success.end(); ++_iter1842) { - xfer += oprot->writeString((*_iter1840)); + xfer += oprot->writeString((*_iter1842)); } xfer += oprot->writeListEnd(); } @@ -35094,14 +35321,14 @@ uint32_t ThriftHiveMetastore_get_all_token_identifiers_presult::read(::apache::t if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1841; - ::apache::thrift::protocol::TType _etype1844; - xfer += iprot->readListBegin(_etype1844, _size1841); - (*(this->success)).resize(_size1841); - uint32_t _i1845; - for (_i1845 = 0; _i1845 < _size1841; ++_i1845) + uint32_t _size1843; + ::apache::thrift::protocol::TType _etype1846; + xfer += iprot->readListBegin(_etype1846, _size1843); + (*(this->success)).resize(_size1843); + uint32_t _i1847; + for (_i1847 = 0; _i1847 < _size1843; ++_i1847) { - xfer += iprot->readString((*(this->success))[_i1845]); + xfer += iprot->readString((*(this->success))[_i1847]); } xfer += iprot->readListEnd(); } @@ -35827,14 +36054,14 @@ uint32_t ThriftHiveMetastore_get_master_keys_result::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1846; - ::apache::thrift::protocol::TType _etype1849; - xfer += iprot->readListBegin(_etype1849, _size1846); - this->success.resize(_size1846); - uint32_t _i1850; - for (_i1850 = 0; _i1850 < _size1846; ++_i1850) + uint32_t _size1848; + ::apache::thrift::protocol::TType _etype1851; + xfer += iprot->readListBegin(_etype1851, _size1848); + this->success.resize(_size1848); + uint32_t _i1852; + for (_i1852 = 0; _i1852 < _size1848; ++_i1852) { - xfer += iprot->readString(this->success[_i1850]); + xfer += iprot->readString(this->success[_i1852]); } xfer += iprot->readListEnd(); } @@ -35865,10 +36092,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 _iter1851; - for (_iter1851 = this->success.begin(); _iter1851 != this->success.end(); ++_iter1851) + std::vector ::const_iterator _iter1853; + for (_iter1853 = this->success.begin(); _iter1853 != this->success.end(); ++_iter1853) { - xfer += oprot->writeString((*_iter1851)); + xfer += oprot->writeString((*_iter1853)); } xfer += oprot->writeListEnd(); } @@ -35909,14 +36136,14 @@ uint32_t ThriftHiveMetastore_get_master_keys_presult::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1852; - ::apache::thrift::protocol::TType _etype1855; - xfer += iprot->readListBegin(_etype1855, _size1852); - (*(this->success)).resize(_size1852); - uint32_t _i1856; - for (_i1856 = 0; _i1856 < _size1852; ++_i1856) + uint32_t _size1854; + ::apache::thrift::protocol::TType _etype1857; + xfer += iprot->readListBegin(_etype1857, _size1854); + (*(this->success)).resize(_size1854); + uint32_t _i1858; + for (_i1858 = 0; _i1858 < _size1854; ++_i1858) { - xfer += iprot->readString((*(this->success))[_i1856]); + xfer += iprot->readString((*(this->success))[_i1858]); } xfer += iprot->readListEnd(); } @@ -47713,14 +47940,14 @@ uint32_t ThriftHiveMetastore_get_schema_all_versions_result::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1857; - ::apache::thrift::protocol::TType _etype1860; - xfer += iprot->readListBegin(_etype1860, _size1857); - this->success.resize(_size1857); - uint32_t _i1861; - for (_i1861 = 0; _i1861 < _size1857; ++_i1861) + uint32_t _size1859; + ::apache::thrift::protocol::TType _etype1862; + xfer += iprot->readListBegin(_etype1862, _size1859); + this->success.resize(_size1859); + uint32_t _i1863; + for (_i1863 = 0; _i1863 < _size1859; ++_i1863) { - xfer += this->success[_i1861].read(iprot); + xfer += this->success[_i1863].read(iprot); } xfer += iprot->readListEnd(); } @@ -47767,10 +47994,10 @@ uint32_t ThriftHiveMetastore_get_schema_all_versions_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 _iter1862; - for (_iter1862 = this->success.begin(); _iter1862 != this->success.end(); ++_iter1862) + std::vector ::const_iterator _iter1864; + for (_iter1864 = this->success.begin(); _iter1864 != this->success.end(); ++_iter1864) { - xfer += (*_iter1862).write(oprot); + xfer += (*_iter1864).write(oprot); } xfer += oprot->writeListEnd(); } @@ -47819,14 +48046,14 @@ uint32_t ThriftHiveMetastore_get_schema_all_versions_presult::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1863; - ::apache::thrift::protocol::TType _etype1866; - xfer += iprot->readListBegin(_etype1866, _size1863); - (*(this->success)).resize(_size1863); - uint32_t _i1867; - for (_i1867 = 0; _i1867 < _size1863; ++_i1867) + uint32_t _size1865; + ::apache::thrift::protocol::TType _etype1868; + xfer += iprot->readListBegin(_etype1868, _size1865); + (*(this->success)).resize(_size1865); + uint32_t _i1869; + for (_i1869 = 0; _i1869 < _size1865; ++_i1869) { - xfer += (*(this->success))[_i1867].read(iprot); + xfer += (*(this->success))[_i1869].read(iprot); } xfer += iprot->readListEnd(); } @@ -49879,14 +50106,14 @@ uint32_t ThriftHiveMetastore_get_runtime_stats_result::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1868; - ::apache::thrift::protocol::TType _etype1871; - xfer += iprot->readListBegin(_etype1871, _size1868); - this->success.resize(_size1868); - uint32_t _i1872; - for (_i1872 = 0; _i1872 < _size1868; ++_i1872) + uint32_t _size1870; + ::apache::thrift::protocol::TType _etype1873; + xfer += iprot->readListBegin(_etype1873, _size1870); + this->success.resize(_size1870); + uint32_t _i1874; + for (_i1874 = 0; _i1874 < _size1870; ++_i1874) { - xfer += this->success[_i1872].read(iprot); + xfer += this->success[_i1874].read(iprot); } xfer += iprot->readListEnd(); } @@ -49925,10 +50152,10 @@ uint32_t ThriftHiveMetastore_get_runtime_stats_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 _iter1873; - for (_iter1873 = this->success.begin(); _iter1873 != this->success.end(); ++_iter1873) + std::vector ::const_iterator _iter1875; + for (_iter1875 = this->success.begin(); _iter1875 != this->success.end(); ++_iter1875) { - xfer += (*_iter1873).write(oprot); + xfer += (*_iter1875).write(oprot); } xfer += oprot->writeListEnd(); } @@ -49973,14 +50200,14 @@ uint32_t ThriftHiveMetastore_get_runtime_stats_presult::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1874; - ::apache::thrift::protocol::TType _etype1877; - xfer += iprot->readListBegin(_etype1877, _size1874); - (*(this->success)).resize(_size1874); - uint32_t _i1878; - for (_i1878 = 0; _i1878 < _size1874; ++_i1878) + uint32_t _size1876; + ::apache::thrift::protocol::TType _etype1879; + xfer += iprot->readListBegin(_etype1879, _size1876); + (*(this->success)).resize(_size1876); + uint32_t _i1880; + for (_i1880 = 0; _i1880 < _size1876; ++_i1880) { - xfer += (*(this->success))[_i1878].read(iprot); + xfer += (*(this->success))[_i1880].read(iprot); } xfer += iprot->readListEnd(); } @@ -50189,6 +50416,68 @@ void ThriftHiveMetastoreClient::recv_create_catalog() return; } +void ThriftHiveMetastoreClient::alter_catalog(const AlterCatalogRequest& rqst) +{ + send_alter_catalog(rqst); + recv_alter_catalog(); +} + +void ThriftHiveMetastoreClient::send_alter_catalog(const AlterCatalogRequest& rqst) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("alter_catalog", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_alter_catalog_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_alter_catalog() +{ + + 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("alter_catalog") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_alter_catalog_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + return; +} + void ThriftHiveMetastoreClient::get_catalog(GetCatalogResponse& _return, const GetCatalogRequest& catName) { send_get_catalog(catName); @@ -63212,6 +63501,68 @@ void ThriftHiveMetastoreProcessor::process_create_catalog(int32_t seqid, ::apach } } +void ThriftHiveMetastoreProcessor::process_alter_catalog(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.alter_catalog", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.alter_catalog"); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.alter_catalog"); + } + + ThriftHiveMetastore_alter_catalog_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.alter_catalog", bytes); + } + + ThriftHiveMetastore_alter_catalog_result result; + try { + iface_->alter_catalog(args.rqst); + } catch (NoSuchObjectException &o1) { + result.o1 = o1; + result.__isset.o1 = true; + } catch (InvalidOperationException &o2) { + result.o2 = o2; + result.__isset.o2 = true; + } catch (MetaException &o3) { + result.o3 = o3; + result.__isset.o3 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.alter_catalog"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("alter_catalog", ::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.alter_catalog"); + } + + oprot->writeMessageBegin("alter_catalog", ::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.alter_catalog", bytes); + } +} + void ThriftHiveMetastoreProcessor::process_get_catalog(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) { void* ctx = NULL; @@ -75544,6 +75895,96 @@ void ThriftHiveMetastoreConcurrentClient::recv_create_catalog(const int32_t seqi } // end while(true) } +void ThriftHiveMetastoreConcurrentClient::alter_catalog(const AlterCatalogRequest& rqst) +{ + int32_t seqid = send_alter_catalog(rqst); + recv_alter_catalog(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_alter_catalog(const AlterCatalogRequest& rqst) +{ + int32_t cseqid = this->sync_.generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); + oprot_->writeMessageBegin("alter_catalog", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_alter_catalog_pargs args; + args.rqst = &rqst; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_alter_catalog(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("alter_catalog") != 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_alter_catalog_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + sentry.commit(); + return; + } + // seqid != rseqid + this->sync_.updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_.waitForWork(seqid); + } // end while(true) +} + void ThriftHiveMetastoreConcurrentClient::get_catalog(GetCatalogResponse& _return, const GetCatalogRequest& catName) { int32_t seqid = send_get_catalog(catName); diff --git standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h index dac6983324..72cd17bb02 100644 --- standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h +++ standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h @@ -25,6 +25,7 @@ class ThriftHiveMetastoreIf : virtual public ::facebook::fb303::FacebookService virtual void getMetaConf(std::string& _return, const std::string& key) = 0; virtual void setMetaConf(const std::string& key, const std::string& value) = 0; virtual void create_catalog(const CreateCatalogRequest& catalog) = 0; + virtual void alter_catalog(const AlterCatalogRequest& rqst) = 0; virtual void get_catalog(GetCatalogResponse& _return, const GetCatalogRequest& catName) = 0; virtual void get_catalogs(GetCatalogsResponse& _return) = 0; virtual void drop_catalog(const DropCatalogRequest& catName) = 0; @@ -266,6 +267,9 @@ class ThriftHiveMetastoreNull : virtual public ThriftHiveMetastoreIf , virtual p void create_catalog(const CreateCatalogRequest& /* catalog */) { return; } + void alter_catalog(const AlterCatalogRequest& /* rqst */) { + return; + } void get_catalog(GetCatalogResponse& /* _return */, const GetCatalogRequest& /* catName */) { return; } @@ -1248,6 +1252,126 @@ class ThriftHiveMetastore_create_catalog_presult { }; +typedef struct _ThriftHiveMetastore_alter_catalog_args__isset { + _ThriftHiveMetastore_alter_catalog_args__isset() : rqst(false) {} + bool rqst :1; +} _ThriftHiveMetastore_alter_catalog_args__isset; + +class ThriftHiveMetastore_alter_catalog_args { + public: + + ThriftHiveMetastore_alter_catalog_args(const ThriftHiveMetastore_alter_catalog_args&); + ThriftHiveMetastore_alter_catalog_args& operator=(const ThriftHiveMetastore_alter_catalog_args&); + ThriftHiveMetastore_alter_catalog_args() { + } + + virtual ~ThriftHiveMetastore_alter_catalog_args() throw(); + AlterCatalogRequest rqst; + + _ThriftHiveMetastore_alter_catalog_args__isset __isset; + + void __set_rqst(const AlterCatalogRequest& val); + + bool operator == (const ThriftHiveMetastore_alter_catalog_args & rhs) const + { + if (!(rqst == rhs.rqst)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_alter_catalog_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_alter_catalog_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_alter_catalog_pargs { + public: + + + virtual ~ThriftHiveMetastore_alter_catalog_pargs() throw(); + const AlterCatalogRequest* rqst; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_alter_catalog_result__isset { + _ThriftHiveMetastore_alter_catalog_result__isset() : o1(false), o2(false), o3(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_alter_catalog_result__isset; + +class ThriftHiveMetastore_alter_catalog_result { + public: + + ThriftHiveMetastore_alter_catalog_result(const ThriftHiveMetastore_alter_catalog_result&); + ThriftHiveMetastore_alter_catalog_result& operator=(const ThriftHiveMetastore_alter_catalog_result&); + ThriftHiveMetastore_alter_catalog_result() { + } + + virtual ~ThriftHiveMetastore_alter_catalog_result() throw(); + NoSuchObjectException o1; + InvalidOperationException o2; + MetaException o3; + + _ThriftHiveMetastore_alter_catalog_result__isset __isset; + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const InvalidOperationException& val); + + void __set_o3(const MetaException& val); + + bool operator == (const ThriftHiveMetastore_alter_catalog_result & rhs) const + { + if (!(o1 == rhs.o1)) + return false; + if (!(o2 == rhs.o2)) + return false; + if (!(o3 == rhs.o3)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_alter_catalog_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_alter_catalog_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_alter_catalog_presult__isset { + _ThriftHiveMetastore_alter_catalog_presult__isset() : o1(false), o2(false), o3(false) {} + bool o1 :1; + bool o2 :1; + bool o3 :1; +} _ThriftHiveMetastore_alter_catalog_presult__isset; + +class ThriftHiveMetastore_alter_catalog_presult { + public: + + + virtual ~ThriftHiveMetastore_alter_catalog_presult() throw(); + NoSuchObjectException o1; + InvalidOperationException o2; + MetaException o3; + + _ThriftHiveMetastore_alter_catalog_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + typedef struct _ThriftHiveMetastore_get_catalog_args__isset { _ThriftHiveMetastore_get_catalog_args__isset() : catName(false) {} bool catName :1; @@ -26101,6 +26225,9 @@ class ThriftHiveMetastoreClient : virtual public ThriftHiveMetastoreIf, public void create_catalog(const CreateCatalogRequest& catalog); void send_create_catalog(const CreateCatalogRequest& catalog); void recv_create_catalog(); + void alter_catalog(const AlterCatalogRequest& rqst); + void send_alter_catalog(const AlterCatalogRequest& rqst); + void recv_alter_catalog(); void get_catalog(GetCatalogResponse& _return, const GetCatalogRequest& catName); void send_get_catalog(const GetCatalogRequest& catName); void recv_get_catalog(GetCatalogResponse& _return); @@ -26723,6 +26850,7 @@ class ThriftHiveMetastoreProcessor : public ::facebook::fb303::FacebookServiceP void process_getMetaConf(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_setMetaConf(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_create_catalog(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_alter_catalog(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_get_catalog(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_get_catalogs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_drop_catalog(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); @@ -26933,6 +27061,7 @@ class ThriftHiveMetastoreProcessor : public ::facebook::fb303::FacebookServiceP processMap_["getMetaConf"] = &ThriftHiveMetastoreProcessor::process_getMetaConf; processMap_["setMetaConf"] = &ThriftHiveMetastoreProcessor::process_setMetaConf; processMap_["create_catalog"] = &ThriftHiveMetastoreProcessor::process_create_catalog; + processMap_["alter_catalog"] = &ThriftHiveMetastoreProcessor::process_alter_catalog; processMap_["get_catalog"] = &ThriftHiveMetastoreProcessor::process_get_catalog; processMap_["get_catalogs"] = &ThriftHiveMetastoreProcessor::process_get_catalogs; processMap_["drop_catalog"] = &ThriftHiveMetastoreProcessor::process_drop_catalog; @@ -27197,6 +27326,15 @@ class ThriftHiveMetastoreMultiface : virtual public ThriftHiveMetastoreIf, publi ifaces_[i]->create_catalog(catalog); } + void alter_catalog(const AlterCatalogRequest& rqst) { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->alter_catalog(rqst); + } + ifaces_[i]->alter_catalog(rqst); + } + void get_catalog(GetCatalogResponse& _return, const GetCatalogRequest& catName) { size_t sz = ifaces_.size(); size_t i = 0; @@ -29174,6 +29312,9 @@ class ThriftHiveMetastoreConcurrentClient : virtual public ThriftHiveMetastoreIf void create_catalog(const CreateCatalogRequest& catalog); int32_t send_create_catalog(const CreateCatalogRequest& catalog); void recv_create_catalog(const int32_t seqid); + void alter_catalog(const AlterCatalogRequest& rqst); + int32_t send_alter_catalog(const AlterCatalogRequest& rqst); + void recv_alter_catalog(const int32_t seqid); void get_catalog(GetCatalogResponse& _return, const GetCatalogRequest& catName); int32_t send_get_catalog(const GetCatalogRequest& catName); void recv_get_catalog(GetCatalogResponse& _return, const int32_t seqid); diff --git standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp index c4a8baf934..34b3d80921 100644 --- standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp +++ standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp @@ -37,6 +37,11 @@ class ThriftHiveMetastoreHandler : virtual public ThriftHiveMetastoreIf { printf("create_catalog\n"); } + void alter_catalog(const AlterCatalogRequest& rqst) { + // Your implementation goes here + printf("alter_catalog\n"); + } + void get_catalog(GetCatalogResponse& _return, const GetCatalogRequest& catName) { // Your implementation goes here printf("get_catalog\n"); diff --git standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp index af975fce1b..c9d6aa01a4 100644 --- standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp +++ standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp @@ -4633,6 +4633,112 @@ void CreateCatalogRequest::printTo(std::ostream& out) const { } +AlterCatalogRequest::~AlterCatalogRequest() throw() { +} + + +void AlterCatalogRequest::__set_name(const std::string& val) { + this->name = val; +} + +void AlterCatalogRequest::__set_newCat(const Catalog& val) { + this->newCat = val; +} + +uint32_t AlterCatalogRequest::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->name); + this->__isset.name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->newCat.read(iprot); + this->__isset.newCat = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t AlterCatalogRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("AlterCatalogRequest"); + + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("newCat", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->newCat.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(AlterCatalogRequest &a, AlterCatalogRequest &b) { + using ::std::swap; + swap(a.name, b.name); + swap(a.newCat, b.newCat); + swap(a.__isset, b.__isset); +} + +AlterCatalogRequest::AlterCatalogRequest(const AlterCatalogRequest& other134) { + name = other134.name; + newCat = other134.newCat; + __isset = other134.__isset; +} +AlterCatalogRequest& AlterCatalogRequest::operator=(const AlterCatalogRequest& other135) { + name = other135.name; + newCat = other135.newCat; + __isset = other135.__isset; + return *this; +} +void AlterCatalogRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "AlterCatalogRequest("; + out << "name=" << to_string(name); + out << ", " << "newCat=" << to_string(newCat); + out << ")"; +} + + GetCatalogRequest::~GetCatalogRequest() throw() { } @@ -4702,13 +4808,13 @@ void swap(GetCatalogRequest &a, GetCatalogRequest &b) { swap(a.__isset, b.__isset); } -GetCatalogRequest::GetCatalogRequest(const GetCatalogRequest& other134) { - name = other134.name; - __isset = other134.__isset; +GetCatalogRequest::GetCatalogRequest(const GetCatalogRequest& other136) { + name = other136.name; + __isset = other136.__isset; } -GetCatalogRequest& GetCatalogRequest::operator=(const GetCatalogRequest& other135) { - name = other135.name; - __isset = other135.__isset; +GetCatalogRequest& GetCatalogRequest::operator=(const GetCatalogRequest& other137) { + name = other137.name; + __isset = other137.__isset; return *this; } void GetCatalogRequest::printTo(std::ostream& out) const { @@ -4788,13 +4894,13 @@ void swap(GetCatalogResponse &a, GetCatalogResponse &b) { swap(a.__isset, b.__isset); } -GetCatalogResponse::GetCatalogResponse(const GetCatalogResponse& other136) { - catalog = other136.catalog; - __isset = other136.__isset; +GetCatalogResponse::GetCatalogResponse(const GetCatalogResponse& other138) { + catalog = other138.catalog; + __isset = other138.__isset; } -GetCatalogResponse& GetCatalogResponse::operator=(const GetCatalogResponse& other137) { - catalog = other137.catalog; - __isset = other137.__isset; +GetCatalogResponse& GetCatalogResponse::operator=(const GetCatalogResponse& other139) { + catalog = other139.catalog; + __isset = other139.__isset; return *this; } void GetCatalogResponse::printTo(std::ostream& out) const { @@ -4838,14 +4944,14 @@ uint32_t GetCatalogsResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->names.clear(); - uint32_t _size138; - ::apache::thrift::protocol::TType _etype141; - xfer += iprot->readListBegin(_etype141, _size138); - this->names.resize(_size138); - uint32_t _i142; - for (_i142 = 0; _i142 < _size138; ++_i142) + uint32_t _size140; + ::apache::thrift::protocol::TType _etype143; + xfer += iprot->readListBegin(_etype143, _size140); + this->names.resize(_size140); + uint32_t _i144; + for (_i144 = 0; _i144 < _size140; ++_i144) { - xfer += iprot->readString(this->names[_i142]); + xfer += iprot->readString(this->names[_i144]); } xfer += iprot->readListEnd(); } @@ -4874,10 +4980,10 @@ uint32_t GetCatalogsResponse::write(::apache::thrift::protocol::TProtocol* oprot xfer += oprot->writeFieldBegin("names", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->names.size())); - std::vector ::const_iterator _iter143; - for (_iter143 = this->names.begin(); _iter143 != this->names.end(); ++_iter143) + std::vector ::const_iterator _iter145; + for (_iter145 = this->names.begin(); _iter145 != this->names.end(); ++_iter145) { - xfer += oprot->writeString((*_iter143)); + xfer += oprot->writeString((*_iter145)); } xfer += oprot->writeListEnd(); } @@ -4894,13 +5000,13 @@ void swap(GetCatalogsResponse &a, GetCatalogsResponse &b) { swap(a.__isset, b.__isset); } -GetCatalogsResponse::GetCatalogsResponse(const GetCatalogsResponse& other144) { - names = other144.names; - __isset = other144.__isset; +GetCatalogsResponse::GetCatalogsResponse(const GetCatalogsResponse& other146) { + names = other146.names; + __isset = other146.__isset; } -GetCatalogsResponse& GetCatalogsResponse::operator=(const GetCatalogsResponse& other145) { - names = other145.names; - __isset = other145.__isset; +GetCatalogsResponse& GetCatalogsResponse::operator=(const GetCatalogsResponse& other147) { + names = other147.names; + __isset = other147.__isset; return *this; } void GetCatalogsResponse::printTo(std::ostream& out) const { @@ -4980,13 +5086,13 @@ void swap(DropCatalogRequest &a, DropCatalogRequest &b) { swap(a.__isset, b.__isset); } -DropCatalogRequest::DropCatalogRequest(const DropCatalogRequest& other146) { - name = other146.name; - __isset = other146.__isset; +DropCatalogRequest::DropCatalogRequest(const DropCatalogRequest& other148) { + name = other148.name; + __isset = other148.__isset; } -DropCatalogRequest& DropCatalogRequest::operator=(const DropCatalogRequest& other147) { - name = other147.name; - __isset = other147.__isset; +DropCatalogRequest& DropCatalogRequest::operator=(const DropCatalogRequest& other149) { + name = other149.name; + __isset = other149.__isset; return *this; } void DropCatalogRequest::printTo(std::ostream& out) const { @@ -5086,17 +5192,17 @@ uint32_t Database::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size148; - ::apache::thrift::protocol::TType _ktype149; - ::apache::thrift::protocol::TType _vtype150; - xfer += iprot->readMapBegin(_ktype149, _vtype150, _size148); - uint32_t _i152; - for (_i152 = 0; _i152 < _size148; ++_i152) + uint32_t _size150; + ::apache::thrift::protocol::TType _ktype151; + ::apache::thrift::protocol::TType _vtype152; + xfer += iprot->readMapBegin(_ktype151, _vtype152, _size150); + uint32_t _i154; + for (_i154 = 0; _i154 < _size150; ++_i154) { - std::string _key153; - xfer += iprot->readString(_key153); - std::string& _val154 = this->parameters[_key153]; - xfer += iprot->readString(_val154); + std::string _key155; + xfer += iprot->readString(_key155); + std::string& _val156 = this->parameters[_key155]; + xfer += iprot->readString(_val156); } xfer += iprot->readMapEnd(); } @@ -5123,9 +5229,9 @@ uint32_t Database::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 7: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast155; - xfer += iprot->readI32(ecast155); - this->ownerType = (PrincipalType::type)ecast155; + int32_t ecast157; + xfer += iprot->readI32(ecast157); + this->ownerType = (PrincipalType::type)ecast157; this->__isset.ownerType = true; } else { xfer += iprot->skip(ftype); @@ -5171,11 +5277,11 @@ uint32_t Database::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 4); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->parameters.size())); - std::map ::const_iterator _iter156; - for (_iter156 = this->parameters.begin(); _iter156 != this->parameters.end(); ++_iter156) + std::map ::const_iterator _iter158; + for (_iter158 = this->parameters.begin(); _iter158 != this->parameters.end(); ++_iter158) { - xfer += oprot->writeString(_iter156->first); - xfer += oprot->writeString(_iter156->second); + xfer += oprot->writeString(_iter158->first); + xfer += oprot->writeString(_iter158->second); } xfer += oprot->writeMapEnd(); } @@ -5219,27 +5325,27 @@ void swap(Database &a, Database &b) { swap(a.__isset, b.__isset); } -Database::Database(const Database& other157) { - name = other157.name; - description = other157.description; - locationUri = other157.locationUri; - parameters = other157.parameters; - privileges = other157.privileges; - ownerName = other157.ownerName; - ownerType = other157.ownerType; - catalogName = other157.catalogName; - __isset = other157.__isset; -} -Database& Database::operator=(const Database& other158) { - name = other158.name; - description = other158.description; - locationUri = other158.locationUri; - parameters = other158.parameters; - privileges = other158.privileges; - ownerName = other158.ownerName; - ownerType = other158.ownerType; - catalogName = other158.catalogName; - __isset = other158.__isset; +Database::Database(const Database& other159) { + name = other159.name; + description = other159.description; + locationUri = other159.locationUri; + parameters = other159.parameters; + privileges = other159.privileges; + ownerName = other159.ownerName; + ownerType = other159.ownerType; + catalogName = other159.catalogName; + __isset = other159.__isset; +} +Database& Database::operator=(const Database& other160) { + name = other160.name; + description = other160.description; + locationUri = other160.locationUri; + parameters = other160.parameters; + privileges = other160.privileges; + ownerName = other160.ownerName; + ownerType = other160.ownerType; + catalogName = other160.catalogName; + __isset = other160.__isset; return *this; } void Database::printTo(std::ostream& out) const { @@ -5334,17 +5440,17 @@ uint32_t SerDeInfo::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size159; - ::apache::thrift::protocol::TType _ktype160; - ::apache::thrift::protocol::TType _vtype161; - xfer += iprot->readMapBegin(_ktype160, _vtype161, _size159); - uint32_t _i163; - for (_i163 = 0; _i163 < _size159; ++_i163) + uint32_t _size161; + ::apache::thrift::protocol::TType _ktype162; + ::apache::thrift::protocol::TType _vtype163; + xfer += iprot->readMapBegin(_ktype162, _vtype163, _size161); + uint32_t _i165; + for (_i165 = 0; _i165 < _size161; ++_i165) { - std::string _key164; - xfer += iprot->readString(_key164); - std::string& _val165 = this->parameters[_key164]; - xfer += iprot->readString(_val165); + std::string _key166; + xfer += iprot->readString(_key166); + std::string& _val167 = this->parameters[_key166]; + xfer += iprot->readString(_val167); } xfer += iprot->readMapEnd(); } @@ -5379,9 +5485,9 @@ uint32_t SerDeInfo::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 7: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast166; - xfer += iprot->readI32(ecast166); - this->serdeType = (SerdeType::type)ecast166; + int32_t ecast168; + xfer += iprot->readI32(ecast168); + this->serdeType = (SerdeType::type)ecast168; this->__isset.serdeType = true; } else { xfer += iprot->skip(ftype); @@ -5415,11 +5521,11 @@ uint32_t SerDeInfo::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 3); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->parameters.size())); - std::map ::const_iterator _iter167; - for (_iter167 = this->parameters.begin(); _iter167 != this->parameters.end(); ++_iter167) + std::map ::const_iterator _iter169; + for (_iter169 = this->parameters.begin(); _iter169 != this->parameters.end(); ++_iter169) { - xfer += oprot->writeString(_iter167->first); - xfer += oprot->writeString(_iter167->second); + xfer += oprot->writeString(_iter169->first); + xfer += oprot->writeString(_iter169->second); } xfer += oprot->writeMapEnd(); } @@ -5462,25 +5568,25 @@ void swap(SerDeInfo &a, SerDeInfo &b) { swap(a.__isset, b.__isset); } -SerDeInfo::SerDeInfo(const SerDeInfo& other168) { - name = other168.name; - serializationLib = other168.serializationLib; - parameters = other168.parameters; - description = other168.description; - serializerClass = other168.serializerClass; - deserializerClass = other168.deserializerClass; - serdeType = other168.serdeType; - __isset = other168.__isset; -} -SerDeInfo& SerDeInfo::operator=(const SerDeInfo& other169) { - name = other169.name; - serializationLib = other169.serializationLib; - parameters = other169.parameters; - description = other169.description; - serializerClass = other169.serializerClass; - deserializerClass = other169.deserializerClass; - serdeType = other169.serdeType; - __isset = other169.__isset; +SerDeInfo::SerDeInfo(const SerDeInfo& other170) { + name = other170.name; + serializationLib = other170.serializationLib; + parameters = other170.parameters; + description = other170.description; + serializerClass = other170.serializerClass; + deserializerClass = other170.deserializerClass; + serdeType = other170.serdeType; + __isset = other170.__isset; +} +SerDeInfo& SerDeInfo::operator=(const SerDeInfo& other171) { + name = other171.name; + serializationLib = other171.serializationLib; + parameters = other171.parameters; + description = other171.description; + serializerClass = other171.serializerClass; + deserializerClass = other171.deserializerClass; + serdeType = other171.serdeType; + __isset = other171.__isset; return *this; } void SerDeInfo::printTo(std::ostream& out) const { @@ -5583,15 +5689,15 @@ void swap(Order &a, Order &b) { swap(a.__isset, b.__isset); } -Order::Order(const Order& other170) { - col = other170.col; - order = other170.order; - __isset = other170.__isset; +Order::Order(const Order& other172) { + col = other172.col; + order = other172.order; + __isset = other172.__isset; } -Order& Order::operator=(const Order& other171) { - col = other171.col; - order = other171.order; - __isset = other171.__isset; +Order& Order::operator=(const Order& other173) { + col = other173.col; + order = other173.order; + __isset = other173.__isset; return *this; } void Order::printTo(std::ostream& out) const { @@ -5644,14 +5750,14 @@ uint32_t SkewedInfo::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->skewedColNames.clear(); - uint32_t _size172; - ::apache::thrift::protocol::TType _etype175; - xfer += iprot->readListBegin(_etype175, _size172); - this->skewedColNames.resize(_size172); - uint32_t _i176; - for (_i176 = 0; _i176 < _size172; ++_i176) + uint32_t _size174; + ::apache::thrift::protocol::TType _etype177; + xfer += iprot->readListBegin(_etype177, _size174); + this->skewedColNames.resize(_size174); + uint32_t _i178; + for (_i178 = 0; _i178 < _size174; ++_i178) { - xfer += iprot->readString(this->skewedColNames[_i176]); + xfer += iprot->readString(this->skewedColNames[_i178]); } xfer += iprot->readListEnd(); } @@ -5664,23 +5770,23 @@ uint32_t SkewedInfo::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->skewedColValues.clear(); - uint32_t _size177; - ::apache::thrift::protocol::TType _etype180; - xfer += iprot->readListBegin(_etype180, _size177); - this->skewedColValues.resize(_size177); - uint32_t _i181; - for (_i181 = 0; _i181 < _size177; ++_i181) + uint32_t _size179; + ::apache::thrift::protocol::TType _etype182; + xfer += iprot->readListBegin(_etype182, _size179); + this->skewedColValues.resize(_size179); + uint32_t _i183; + for (_i183 = 0; _i183 < _size179; ++_i183) { { - this->skewedColValues[_i181].clear(); - uint32_t _size182; - ::apache::thrift::protocol::TType _etype185; - xfer += iprot->readListBegin(_etype185, _size182); - this->skewedColValues[_i181].resize(_size182); - uint32_t _i186; - for (_i186 = 0; _i186 < _size182; ++_i186) + this->skewedColValues[_i183].clear(); + uint32_t _size184; + ::apache::thrift::protocol::TType _etype187; + xfer += iprot->readListBegin(_etype187, _size184); + this->skewedColValues[_i183].resize(_size184); + uint32_t _i188; + for (_i188 = 0; _i188 < _size184; ++_i188) { - xfer += iprot->readString(this->skewedColValues[_i181][_i186]); + xfer += iprot->readString(this->skewedColValues[_i183][_i188]); } xfer += iprot->readListEnd(); } @@ -5696,29 +5802,29 @@ uint32_t SkewedInfo::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->skewedColValueLocationMaps.clear(); - uint32_t _size187; - ::apache::thrift::protocol::TType _ktype188; - ::apache::thrift::protocol::TType _vtype189; - xfer += iprot->readMapBegin(_ktype188, _vtype189, _size187); - uint32_t _i191; - for (_i191 = 0; _i191 < _size187; ++_i191) + uint32_t _size189; + ::apache::thrift::protocol::TType _ktype190; + ::apache::thrift::protocol::TType _vtype191; + xfer += iprot->readMapBegin(_ktype190, _vtype191, _size189); + uint32_t _i193; + for (_i193 = 0; _i193 < _size189; ++_i193) { - std::vector _key192; + std::vector _key194; { - _key192.clear(); - uint32_t _size194; - ::apache::thrift::protocol::TType _etype197; - xfer += iprot->readListBegin(_etype197, _size194); - _key192.resize(_size194); - uint32_t _i198; - for (_i198 = 0; _i198 < _size194; ++_i198) + _key194.clear(); + uint32_t _size196; + ::apache::thrift::protocol::TType _etype199; + xfer += iprot->readListBegin(_etype199, _size196); + _key194.resize(_size196); + uint32_t _i200; + for (_i200 = 0; _i200 < _size196; ++_i200) { - xfer += iprot->readString(_key192[_i198]); + xfer += iprot->readString(_key194[_i200]); } xfer += iprot->readListEnd(); } - std::string& _val193 = this->skewedColValueLocationMaps[_key192]; - xfer += iprot->readString(_val193); + std::string& _val195 = this->skewedColValueLocationMaps[_key194]; + xfer += iprot->readString(_val195); } xfer += iprot->readMapEnd(); } @@ -5747,10 +5853,10 @@ uint32_t SkewedInfo::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("skewedColNames", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->skewedColNames.size())); - std::vector ::const_iterator _iter199; - for (_iter199 = this->skewedColNames.begin(); _iter199 != this->skewedColNames.end(); ++_iter199) + std::vector ::const_iterator _iter201; + for (_iter201 = this->skewedColNames.begin(); _iter201 != this->skewedColNames.end(); ++_iter201) { - xfer += oprot->writeString((*_iter199)); + xfer += oprot->writeString((*_iter201)); } xfer += oprot->writeListEnd(); } @@ -5759,15 +5865,15 @@ uint32_t SkewedInfo::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("skewedColValues", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_LIST, static_cast(this->skewedColValues.size())); - std::vector > ::const_iterator _iter200; - for (_iter200 = this->skewedColValues.begin(); _iter200 != this->skewedColValues.end(); ++_iter200) + std::vector > ::const_iterator _iter202; + for (_iter202 = this->skewedColValues.begin(); _iter202 != this->skewedColValues.end(); ++_iter202) { { - xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*_iter200).size())); - std::vector ::const_iterator _iter201; - for (_iter201 = (*_iter200).begin(); _iter201 != (*_iter200).end(); ++_iter201) + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*_iter202).size())); + std::vector ::const_iterator _iter203; + for (_iter203 = (*_iter202).begin(); _iter203 != (*_iter202).end(); ++_iter203) { - xfer += oprot->writeString((*_iter201)); + xfer += oprot->writeString((*_iter203)); } xfer += oprot->writeListEnd(); } @@ -5779,19 +5885,19 @@ uint32_t SkewedInfo::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("skewedColValueLocationMaps", ::apache::thrift::protocol::T_MAP, 3); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_LIST, ::apache::thrift::protocol::T_STRING, static_cast(this->skewedColValueLocationMaps.size())); - std::map , std::string> ::const_iterator _iter202; - for (_iter202 = this->skewedColValueLocationMaps.begin(); _iter202 != this->skewedColValueLocationMaps.end(); ++_iter202) + std::map , std::string> ::const_iterator _iter204; + for (_iter204 = this->skewedColValueLocationMaps.begin(); _iter204 != this->skewedColValueLocationMaps.end(); ++_iter204) { { - xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(_iter202->first.size())); - std::vector ::const_iterator _iter203; - for (_iter203 = _iter202->first.begin(); _iter203 != _iter202->first.end(); ++_iter203) + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(_iter204->first.size())); + std::vector ::const_iterator _iter205; + for (_iter205 = _iter204->first.begin(); _iter205 != _iter204->first.end(); ++_iter205) { - xfer += oprot->writeString((*_iter203)); + xfer += oprot->writeString((*_iter205)); } xfer += oprot->writeListEnd(); } - xfer += oprot->writeString(_iter202->second); + xfer += oprot->writeString(_iter204->second); } xfer += oprot->writeMapEnd(); } @@ -5810,17 +5916,17 @@ void swap(SkewedInfo &a, SkewedInfo &b) { swap(a.__isset, b.__isset); } -SkewedInfo::SkewedInfo(const SkewedInfo& other204) { - skewedColNames = other204.skewedColNames; - skewedColValues = other204.skewedColValues; - skewedColValueLocationMaps = other204.skewedColValueLocationMaps; - __isset = other204.__isset; +SkewedInfo::SkewedInfo(const SkewedInfo& other206) { + skewedColNames = other206.skewedColNames; + skewedColValues = other206.skewedColValues; + skewedColValueLocationMaps = other206.skewedColValueLocationMaps; + __isset = other206.__isset; } -SkewedInfo& SkewedInfo::operator=(const SkewedInfo& other205) { - skewedColNames = other205.skewedColNames; - skewedColValues = other205.skewedColValues; - skewedColValueLocationMaps = other205.skewedColValueLocationMaps; - __isset = other205.__isset; +SkewedInfo& SkewedInfo::operator=(const SkewedInfo& other207) { + skewedColNames = other207.skewedColNames; + skewedColValues = other207.skewedColValues; + skewedColValueLocationMaps = other207.skewedColValueLocationMaps; + __isset = other207.__isset; return *this; } void SkewedInfo::printTo(std::ostream& out) const { @@ -5912,14 +6018,14 @@ uint32_t StorageDescriptor::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->cols.clear(); - uint32_t _size206; - ::apache::thrift::protocol::TType _etype209; - xfer += iprot->readListBegin(_etype209, _size206); - this->cols.resize(_size206); - uint32_t _i210; - for (_i210 = 0; _i210 < _size206; ++_i210) + uint32_t _size208; + ::apache::thrift::protocol::TType _etype211; + xfer += iprot->readListBegin(_etype211, _size208); + this->cols.resize(_size208); + uint32_t _i212; + for (_i212 = 0; _i212 < _size208; ++_i212) { - xfer += this->cols[_i210].read(iprot); + xfer += this->cols[_i212].read(iprot); } xfer += iprot->readListEnd(); } @@ -5980,14 +6086,14 @@ uint32_t StorageDescriptor::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->bucketCols.clear(); - uint32_t _size211; - ::apache::thrift::protocol::TType _etype214; - xfer += iprot->readListBegin(_etype214, _size211); - this->bucketCols.resize(_size211); - uint32_t _i215; - for (_i215 = 0; _i215 < _size211; ++_i215) + uint32_t _size213; + ::apache::thrift::protocol::TType _etype216; + xfer += iprot->readListBegin(_etype216, _size213); + this->bucketCols.resize(_size213); + uint32_t _i217; + for (_i217 = 0; _i217 < _size213; ++_i217) { - xfer += iprot->readString(this->bucketCols[_i215]); + xfer += iprot->readString(this->bucketCols[_i217]); } xfer += iprot->readListEnd(); } @@ -6000,14 +6106,14 @@ uint32_t StorageDescriptor::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->sortCols.clear(); - uint32_t _size216; - ::apache::thrift::protocol::TType _etype219; - xfer += iprot->readListBegin(_etype219, _size216); - this->sortCols.resize(_size216); - uint32_t _i220; - for (_i220 = 0; _i220 < _size216; ++_i220) + uint32_t _size218; + ::apache::thrift::protocol::TType _etype221; + xfer += iprot->readListBegin(_etype221, _size218); + this->sortCols.resize(_size218); + uint32_t _i222; + for (_i222 = 0; _i222 < _size218; ++_i222) { - xfer += this->sortCols[_i220].read(iprot); + xfer += this->sortCols[_i222].read(iprot); } xfer += iprot->readListEnd(); } @@ -6020,17 +6126,17 @@ uint32_t StorageDescriptor::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size221; - ::apache::thrift::protocol::TType _ktype222; - ::apache::thrift::protocol::TType _vtype223; - xfer += iprot->readMapBegin(_ktype222, _vtype223, _size221); - uint32_t _i225; - for (_i225 = 0; _i225 < _size221; ++_i225) + uint32_t _size223; + ::apache::thrift::protocol::TType _ktype224; + ::apache::thrift::protocol::TType _vtype225; + xfer += iprot->readMapBegin(_ktype224, _vtype225, _size223); + uint32_t _i227; + for (_i227 = 0; _i227 < _size223; ++_i227) { - std::string _key226; - xfer += iprot->readString(_key226); - std::string& _val227 = this->parameters[_key226]; - xfer += iprot->readString(_val227); + std::string _key228; + xfer += iprot->readString(_key228); + std::string& _val229 = this->parameters[_key228]; + xfer += iprot->readString(_val229); } xfer += iprot->readMapEnd(); } @@ -6075,10 +6181,10 @@ uint32_t StorageDescriptor::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("cols", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->cols.size())); - std::vector ::const_iterator _iter228; - for (_iter228 = this->cols.begin(); _iter228 != this->cols.end(); ++_iter228) + std::vector ::const_iterator _iter230; + for (_iter230 = this->cols.begin(); _iter230 != this->cols.end(); ++_iter230) { - xfer += (*_iter228).write(oprot); + xfer += (*_iter230).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6111,10 +6217,10 @@ uint32_t StorageDescriptor::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("bucketCols", ::apache::thrift::protocol::T_LIST, 8); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->bucketCols.size())); - std::vector ::const_iterator _iter229; - for (_iter229 = this->bucketCols.begin(); _iter229 != this->bucketCols.end(); ++_iter229) + std::vector ::const_iterator _iter231; + for (_iter231 = this->bucketCols.begin(); _iter231 != this->bucketCols.end(); ++_iter231) { - xfer += oprot->writeString((*_iter229)); + xfer += oprot->writeString((*_iter231)); } xfer += oprot->writeListEnd(); } @@ -6123,10 +6229,10 @@ uint32_t StorageDescriptor::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("sortCols", ::apache::thrift::protocol::T_LIST, 9); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->sortCols.size())); - std::vector ::const_iterator _iter230; - for (_iter230 = this->sortCols.begin(); _iter230 != this->sortCols.end(); ++_iter230) + std::vector ::const_iterator _iter232; + for (_iter232 = this->sortCols.begin(); _iter232 != this->sortCols.end(); ++_iter232) { - xfer += (*_iter230).write(oprot); + xfer += (*_iter232).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6135,11 +6241,11 @@ uint32_t StorageDescriptor::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 10); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->parameters.size())); - std::map ::const_iterator _iter231; - for (_iter231 = this->parameters.begin(); _iter231 != this->parameters.end(); ++_iter231) + std::map ::const_iterator _iter233; + for (_iter233 = this->parameters.begin(); _iter233 != this->parameters.end(); ++_iter233) { - xfer += oprot->writeString(_iter231->first); - xfer += oprot->writeString(_iter231->second); + xfer += oprot->writeString(_iter233->first); + xfer += oprot->writeString(_iter233->second); } xfer += oprot->writeMapEnd(); } @@ -6177,35 +6283,35 @@ void swap(StorageDescriptor &a, StorageDescriptor &b) { swap(a.__isset, b.__isset); } -StorageDescriptor::StorageDescriptor(const StorageDescriptor& other232) { - cols = other232.cols; - location = other232.location; - inputFormat = other232.inputFormat; - outputFormat = other232.outputFormat; - compressed = other232.compressed; - numBuckets = other232.numBuckets; - serdeInfo = other232.serdeInfo; - bucketCols = other232.bucketCols; - sortCols = other232.sortCols; - parameters = other232.parameters; - skewedInfo = other232.skewedInfo; - storedAsSubDirectories = other232.storedAsSubDirectories; - __isset = other232.__isset; -} -StorageDescriptor& StorageDescriptor::operator=(const StorageDescriptor& other233) { - cols = other233.cols; - location = other233.location; - inputFormat = other233.inputFormat; - outputFormat = other233.outputFormat; - compressed = other233.compressed; - numBuckets = other233.numBuckets; - serdeInfo = other233.serdeInfo; - bucketCols = other233.bucketCols; - sortCols = other233.sortCols; - parameters = other233.parameters; - skewedInfo = other233.skewedInfo; - storedAsSubDirectories = other233.storedAsSubDirectories; - __isset = other233.__isset; +StorageDescriptor::StorageDescriptor(const StorageDescriptor& other234) { + cols = other234.cols; + location = other234.location; + inputFormat = other234.inputFormat; + outputFormat = other234.outputFormat; + compressed = other234.compressed; + numBuckets = other234.numBuckets; + serdeInfo = other234.serdeInfo; + bucketCols = other234.bucketCols; + sortCols = other234.sortCols; + parameters = other234.parameters; + skewedInfo = other234.skewedInfo; + storedAsSubDirectories = other234.storedAsSubDirectories; + __isset = other234.__isset; +} +StorageDescriptor& StorageDescriptor::operator=(const StorageDescriptor& other235) { + cols = other235.cols; + location = other235.location; + inputFormat = other235.inputFormat; + outputFormat = other235.outputFormat; + compressed = other235.compressed; + numBuckets = other235.numBuckets; + serdeInfo = other235.serdeInfo; + bucketCols = other235.bucketCols; + sortCols = other235.sortCols; + parameters = other235.parameters; + skewedInfo = other235.skewedInfo; + storedAsSubDirectories = other235.storedAsSubDirectories; + __isset = other235.__isset; return *this; } void StorageDescriptor::printTo(std::ostream& out) const { @@ -6390,14 +6496,14 @@ uint32_t Table::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionKeys.clear(); - uint32_t _size234; - ::apache::thrift::protocol::TType _etype237; - xfer += iprot->readListBegin(_etype237, _size234); - this->partitionKeys.resize(_size234); - uint32_t _i238; - for (_i238 = 0; _i238 < _size234; ++_i238) + uint32_t _size236; + ::apache::thrift::protocol::TType _etype239; + xfer += iprot->readListBegin(_etype239, _size236); + this->partitionKeys.resize(_size236); + uint32_t _i240; + for (_i240 = 0; _i240 < _size236; ++_i240) { - xfer += this->partitionKeys[_i238].read(iprot); + xfer += this->partitionKeys[_i240].read(iprot); } xfer += iprot->readListEnd(); } @@ -6410,17 +6516,17 @@ uint32_t Table::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size239; - ::apache::thrift::protocol::TType _ktype240; - ::apache::thrift::protocol::TType _vtype241; - xfer += iprot->readMapBegin(_ktype240, _vtype241, _size239); - uint32_t _i243; - for (_i243 = 0; _i243 < _size239; ++_i243) + uint32_t _size241; + ::apache::thrift::protocol::TType _ktype242; + ::apache::thrift::protocol::TType _vtype243; + xfer += iprot->readMapBegin(_ktype242, _vtype243, _size241); + uint32_t _i245; + for (_i245 = 0; _i245 < _size241; ++_i245) { - std::string _key244; - xfer += iprot->readString(_key244); - std::string& _val245 = this->parameters[_key244]; - xfer += iprot->readString(_val245); + std::string _key246; + xfer += iprot->readString(_key246); + std::string& _val247 = this->parameters[_key246]; + xfer += iprot->readString(_val247); } xfer += iprot->readMapEnd(); } @@ -6495,9 +6601,9 @@ uint32_t Table::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 18: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast246; - xfer += iprot->readI32(ecast246); - this->ownerType = (PrincipalType::type)ecast246; + int32_t ecast248; + xfer += iprot->readI32(ecast248); + this->ownerType = (PrincipalType::type)ecast248; this->__isset.ownerType = true; } else { xfer += iprot->skip(ftype); @@ -6551,10 +6657,10 @@ uint32_t Table::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("partitionKeys", ::apache::thrift::protocol::T_LIST, 8); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitionKeys.size())); - std::vector ::const_iterator _iter247; - for (_iter247 = this->partitionKeys.begin(); _iter247 != this->partitionKeys.end(); ++_iter247) + std::vector ::const_iterator _iter249; + for (_iter249 = this->partitionKeys.begin(); _iter249 != this->partitionKeys.end(); ++_iter249) { - xfer += (*_iter247).write(oprot); + xfer += (*_iter249).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6563,11 +6669,11 @@ uint32_t Table::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 9); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->parameters.size())); - std::map ::const_iterator _iter248; - for (_iter248 = this->parameters.begin(); _iter248 != this->parameters.end(); ++_iter248) + std::map ::const_iterator _iter250; + for (_iter250 = this->parameters.begin(); _iter250 != this->parameters.end(); ++_iter250) { - xfer += oprot->writeString(_iter248->first); - xfer += oprot->writeString(_iter248->second); + xfer += oprot->writeString(_iter250->first); + xfer += oprot->writeString(_iter250->second); } xfer += oprot->writeMapEnd(); } @@ -6643,47 +6749,47 @@ void swap(Table &a, Table &b) { swap(a.__isset, b.__isset); } -Table::Table(const Table& other249) { - tableName = other249.tableName; - dbName = other249.dbName; - owner = other249.owner; - createTime = other249.createTime; - lastAccessTime = other249.lastAccessTime; - retention = other249.retention; - sd = other249.sd; - partitionKeys = other249.partitionKeys; - parameters = other249.parameters; - viewOriginalText = other249.viewOriginalText; - viewExpandedText = other249.viewExpandedText; - tableType = other249.tableType; - privileges = other249.privileges; - temporary = other249.temporary; - rewriteEnabled = other249.rewriteEnabled; - creationMetadata = other249.creationMetadata; - catName = other249.catName; - ownerType = other249.ownerType; - __isset = other249.__isset; -} -Table& Table::operator=(const Table& other250) { - tableName = other250.tableName; - dbName = other250.dbName; - owner = other250.owner; - createTime = other250.createTime; - lastAccessTime = other250.lastAccessTime; - retention = other250.retention; - sd = other250.sd; - partitionKeys = other250.partitionKeys; - parameters = other250.parameters; - viewOriginalText = other250.viewOriginalText; - viewExpandedText = other250.viewExpandedText; - tableType = other250.tableType; - privileges = other250.privileges; - temporary = other250.temporary; - rewriteEnabled = other250.rewriteEnabled; - creationMetadata = other250.creationMetadata; - catName = other250.catName; - ownerType = other250.ownerType; - __isset = other250.__isset; +Table::Table(const Table& other251) { + tableName = other251.tableName; + dbName = other251.dbName; + owner = other251.owner; + createTime = other251.createTime; + lastAccessTime = other251.lastAccessTime; + retention = other251.retention; + sd = other251.sd; + partitionKeys = other251.partitionKeys; + parameters = other251.parameters; + viewOriginalText = other251.viewOriginalText; + viewExpandedText = other251.viewExpandedText; + tableType = other251.tableType; + privileges = other251.privileges; + temporary = other251.temporary; + rewriteEnabled = other251.rewriteEnabled; + creationMetadata = other251.creationMetadata; + catName = other251.catName; + ownerType = other251.ownerType; + __isset = other251.__isset; +} +Table& Table::operator=(const Table& other252) { + tableName = other252.tableName; + dbName = other252.dbName; + owner = other252.owner; + createTime = other252.createTime; + lastAccessTime = other252.lastAccessTime; + retention = other252.retention; + sd = other252.sd; + partitionKeys = other252.partitionKeys; + parameters = other252.parameters; + viewOriginalText = other252.viewOriginalText; + viewExpandedText = other252.viewExpandedText; + tableType = other252.tableType; + privileges = other252.privileges; + temporary = other252.temporary; + rewriteEnabled = other252.rewriteEnabled; + creationMetadata = other252.creationMetadata; + catName = other252.catName; + ownerType = other252.ownerType; + __isset = other252.__isset; return *this; } void Table::printTo(std::ostream& out) const { @@ -6778,14 +6884,14 @@ uint32_t Partition::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->values.clear(); - uint32_t _size251; - ::apache::thrift::protocol::TType _etype254; - xfer += iprot->readListBegin(_etype254, _size251); - this->values.resize(_size251); - uint32_t _i255; - for (_i255 = 0; _i255 < _size251; ++_i255) + uint32_t _size253; + ::apache::thrift::protocol::TType _etype256; + xfer += iprot->readListBegin(_etype256, _size253); + this->values.resize(_size253); + uint32_t _i257; + for (_i257 = 0; _i257 < _size253; ++_i257) { - xfer += iprot->readString(this->values[_i255]); + xfer += iprot->readString(this->values[_i257]); } xfer += iprot->readListEnd(); } @@ -6838,17 +6944,17 @@ uint32_t Partition::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size256; - ::apache::thrift::protocol::TType _ktype257; - ::apache::thrift::protocol::TType _vtype258; - xfer += iprot->readMapBegin(_ktype257, _vtype258, _size256); - uint32_t _i260; - for (_i260 = 0; _i260 < _size256; ++_i260) + uint32_t _size258; + ::apache::thrift::protocol::TType _ktype259; + ::apache::thrift::protocol::TType _vtype260; + xfer += iprot->readMapBegin(_ktype259, _vtype260, _size258); + uint32_t _i262; + for (_i262 = 0; _i262 < _size258; ++_i262) { - std::string _key261; - xfer += iprot->readString(_key261); - std::string& _val262 = this->parameters[_key261]; - xfer += iprot->readString(_val262); + std::string _key263; + xfer += iprot->readString(_key263); + std::string& _val264 = this->parameters[_key263]; + xfer += iprot->readString(_val264); } xfer += iprot->readMapEnd(); } @@ -6893,10 +6999,10 @@ uint32_t Partition::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->values.size())); - std::vector ::const_iterator _iter263; - for (_iter263 = this->values.begin(); _iter263 != this->values.end(); ++_iter263) + std::vector ::const_iterator _iter265; + for (_iter265 = this->values.begin(); _iter265 != this->values.end(); ++_iter265) { - xfer += oprot->writeString((*_iter263)); + xfer += oprot->writeString((*_iter265)); } xfer += oprot->writeListEnd(); } @@ -6925,11 +7031,11 @@ uint32_t Partition::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 7); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->parameters.size())); - std::map ::const_iterator _iter264; - for (_iter264 = this->parameters.begin(); _iter264 != this->parameters.end(); ++_iter264) + std::map ::const_iterator _iter266; + for (_iter266 = this->parameters.begin(); _iter266 != this->parameters.end(); ++_iter266) { - xfer += oprot->writeString(_iter264->first); - xfer += oprot->writeString(_iter264->second); + xfer += oprot->writeString(_iter266->first); + xfer += oprot->writeString(_iter266->second); } xfer += oprot->writeMapEnd(); } @@ -6964,29 +7070,29 @@ void swap(Partition &a, Partition &b) { swap(a.__isset, b.__isset); } -Partition::Partition(const Partition& other265) { - values = other265.values; - dbName = other265.dbName; - tableName = other265.tableName; - createTime = other265.createTime; - lastAccessTime = other265.lastAccessTime; - sd = other265.sd; - parameters = other265.parameters; - privileges = other265.privileges; - catName = other265.catName; - __isset = other265.__isset; -} -Partition& Partition::operator=(const Partition& other266) { - values = other266.values; - dbName = other266.dbName; - tableName = other266.tableName; - createTime = other266.createTime; - lastAccessTime = other266.lastAccessTime; - sd = other266.sd; - parameters = other266.parameters; - privileges = other266.privileges; - catName = other266.catName; - __isset = other266.__isset; +Partition::Partition(const Partition& other267) { + values = other267.values; + dbName = other267.dbName; + tableName = other267.tableName; + createTime = other267.createTime; + lastAccessTime = other267.lastAccessTime; + sd = other267.sd; + parameters = other267.parameters; + privileges = other267.privileges; + catName = other267.catName; + __isset = other267.__isset; +} +Partition& Partition::operator=(const Partition& other268) { + values = other268.values; + dbName = other268.dbName; + tableName = other268.tableName; + createTime = other268.createTime; + lastAccessTime = other268.lastAccessTime; + sd = other268.sd; + parameters = other268.parameters; + privileges = other268.privileges; + catName = other268.catName; + __isset = other268.__isset; return *this; } void Partition::printTo(std::ostream& out) const { @@ -7059,14 +7165,14 @@ uint32_t PartitionWithoutSD::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->values.clear(); - uint32_t _size267; - ::apache::thrift::protocol::TType _etype270; - xfer += iprot->readListBegin(_etype270, _size267); - this->values.resize(_size267); - uint32_t _i271; - for (_i271 = 0; _i271 < _size267; ++_i271) + uint32_t _size269; + ::apache::thrift::protocol::TType _etype272; + xfer += iprot->readListBegin(_etype272, _size269); + this->values.resize(_size269); + uint32_t _i273; + for (_i273 = 0; _i273 < _size269; ++_i273) { - xfer += iprot->readString(this->values[_i271]); + xfer += iprot->readString(this->values[_i273]); } xfer += iprot->readListEnd(); } @@ -7103,17 +7209,17 @@ uint32_t PartitionWithoutSD::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size272; - ::apache::thrift::protocol::TType _ktype273; - ::apache::thrift::protocol::TType _vtype274; - xfer += iprot->readMapBegin(_ktype273, _vtype274, _size272); - uint32_t _i276; - for (_i276 = 0; _i276 < _size272; ++_i276) + uint32_t _size274; + ::apache::thrift::protocol::TType _ktype275; + ::apache::thrift::protocol::TType _vtype276; + xfer += iprot->readMapBegin(_ktype275, _vtype276, _size274); + uint32_t _i278; + for (_i278 = 0; _i278 < _size274; ++_i278) { - std::string _key277; - xfer += iprot->readString(_key277); - std::string& _val278 = this->parameters[_key277]; - xfer += iprot->readString(_val278); + std::string _key279; + xfer += iprot->readString(_key279); + std::string& _val280 = this->parameters[_key279]; + xfer += iprot->readString(_val280); } xfer += iprot->readMapEnd(); } @@ -7150,10 +7256,10 @@ uint32_t PartitionWithoutSD::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->values.size())); - std::vector ::const_iterator _iter279; - for (_iter279 = this->values.begin(); _iter279 != this->values.end(); ++_iter279) + std::vector ::const_iterator _iter281; + for (_iter281 = this->values.begin(); _iter281 != this->values.end(); ++_iter281) { - xfer += oprot->writeString((*_iter279)); + xfer += oprot->writeString((*_iter281)); } xfer += oprot->writeListEnd(); } @@ -7174,11 +7280,11 @@ uint32_t PartitionWithoutSD::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 5); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->parameters.size())); - std::map ::const_iterator _iter280; - for (_iter280 = this->parameters.begin(); _iter280 != this->parameters.end(); ++_iter280) + std::map ::const_iterator _iter282; + for (_iter282 = this->parameters.begin(); _iter282 != this->parameters.end(); ++_iter282) { - xfer += oprot->writeString(_iter280->first); - xfer += oprot->writeString(_iter280->second); + xfer += oprot->writeString(_iter282->first); + xfer += oprot->writeString(_iter282->second); } xfer += oprot->writeMapEnd(); } @@ -7205,23 +7311,23 @@ void swap(PartitionWithoutSD &a, PartitionWithoutSD &b) { swap(a.__isset, b.__isset); } -PartitionWithoutSD::PartitionWithoutSD(const PartitionWithoutSD& other281) { - values = other281.values; - createTime = other281.createTime; - lastAccessTime = other281.lastAccessTime; - relativePath = other281.relativePath; - parameters = other281.parameters; - privileges = other281.privileges; - __isset = other281.__isset; -} -PartitionWithoutSD& PartitionWithoutSD::operator=(const PartitionWithoutSD& other282) { - values = other282.values; - createTime = other282.createTime; - lastAccessTime = other282.lastAccessTime; - relativePath = other282.relativePath; - parameters = other282.parameters; - privileges = other282.privileges; - __isset = other282.__isset; +PartitionWithoutSD::PartitionWithoutSD(const PartitionWithoutSD& other283) { + values = other283.values; + createTime = other283.createTime; + lastAccessTime = other283.lastAccessTime; + relativePath = other283.relativePath; + parameters = other283.parameters; + privileges = other283.privileges; + __isset = other283.__isset; +} +PartitionWithoutSD& PartitionWithoutSD::operator=(const PartitionWithoutSD& other284) { + values = other284.values; + createTime = other284.createTime; + lastAccessTime = other284.lastAccessTime; + relativePath = other284.relativePath; + parameters = other284.parameters; + privileges = other284.privileges; + __isset = other284.__isset; return *this; } void PartitionWithoutSD::printTo(std::ostream& out) const { @@ -7274,14 +7380,14 @@ uint32_t PartitionSpecWithSharedSD::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size283; - ::apache::thrift::protocol::TType _etype286; - xfer += iprot->readListBegin(_etype286, _size283); - this->partitions.resize(_size283); - uint32_t _i287; - for (_i287 = 0; _i287 < _size283; ++_i287) + uint32_t _size285; + ::apache::thrift::protocol::TType _etype288; + xfer += iprot->readListBegin(_etype288, _size285); + this->partitions.resize(_size285); + uint32_t _i289; + for (_i289 = 0; _i289 < _size285; ++_i289) { - xfer += this->partitions[_i287].read(iprot); + xfer += this->partitions[_i289].read(iprot); } xfer += iprot->readListEnd(); } @@ -7318,10 +7424,10 @@ uint32_t PartitionSpecWithSharedSD::write(::apache::thrift::protocol::TProtocol* xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitions.size())); - std::vector ::const_iterator _iter288; - for (_iter288 = this->partitions.begin(); _iter288 != this->partitions.end(); ++_iter288) + std::vector ::const_iterator _iter290; + for (_iter290 = this->partitions.begin(); _iter290 != this->partitions.end(); ++_iter290) { - xfer += (*_iter288).write(oprot); + xfer += (*_iter290).write(oprot); } xfer += oprot->writeListEnd(); } @@ -7343,15 +7449,15 @@ void swap(PartitionSpecWithSharedSD &a, PartitionSpecWithSharedSD &b) { swap(a.__isset, b.__isset); } -PartitionSpecWithSharedSD::PartitionSpecWithSharedSD(const PartitionSpecWithSharedSD& other289) { - partitions = other289.partitions; - sd = other289.sd; - __isset = other289.__isset; +PartitionSpecWithSharedSD::PartitionSpecWithSharedSD(const PartitionSpecWithSharedSD& other291) { + partitions = other291.partitions; + sd = other291.sd; + __isset = other291.__isset; } -PartitionSpecWithSharedSD& PartitionSpecWithSharedSD::operator=(const PartitionSpecWithSharedSD& other290) { - partitions = other290.partitions; - sd = other290.sd; - __isset = other290.__isset; +PartitionSpecWithSharedSD& PartitionSpecWithSharedSD::operator=(const PartitionSpecWithSharedSD& other292) { + partitions = other292.partitions; + sd = other292.sd; + __isset = other292.__isset; return *this; } void PartitionSpecWithSharedSD::printTo(std::ostream& out) const { @@ -7396,14 +7502,14 @@ uint32_t PartitionListComposingSpec::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size291; - ::apache::thrift::protocol::TType _etype294; - xfer += iprot->readListBegin(_etype294, _size291); - this->partitions.resize(_size291); - uint32_t _i295; - for (_i295 = 0; _i295 < _size291; ++_i295) + uint32_t _size293; + ::apache::thrift::protocol::TType _etype296; + xfer += iprot->readListBegin(_etype296, _size293); + this->partitions.resize(_size293); + uint32_t _i297; + for (_i297 = 0; _i297 < _size293; ++_i297) { - xfer += this->partitions[_i295].read(iprot); + xfer += this->partitions[_i297].read(iprot); } xfer += iprot->readListEnd(); } @@ -7432,10 +7538,10 @@ uint32_t PartitionListComposingSpec::write(::apache::thrift::protocol::TProtocol xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitions.size())); - std::vector ::const_iterator _iter296; - for (_iter296 = this->partitions.begin(); _iter296 != this->partitions.end(); ++_iter296) + std::vector ::const_iterator _iter298; + for (_iter298 = this->partitions.begin(); _iter298 != this->partitions.end(); ++_iter298) { - xfer += (*_iter296).write(oprot); + xfer += (*_iter298).write(oprot); } xfer += oprot->writeListEnd(); } @@ -7452,13 +7558,13 @@ void swap(PartitionListComposingSpec &a, PartitionListComposingSpec &b) { swap(a.__isset, b.__isset); } -PartitionListComposingSpec::PartitionListComposingSpec(const PartitionListComposingSpec& other297) { - partitions = other297.partitions; - __isset = other297.__isset; +PartitionListComposingSpec::PartitionListComposingSpec(const PartitionListComposingSpec& other299) { + partitions = other299.partitions; + __isset = other299.__isset; } -PartitionListComposingSpec& PartitionListComposingSpec::operator=(const PartitionListComposingSpec& other298) { - partitions = other298.partitions; - __isset = other298.__isset; +PartitionListComposingSpec& PartitionListComposingSpec::operator=(const PartitionListComposingSpec& other300) { + partitions = other300.partitions; + __isset = other300.__isset; return *this; } void PartitionListComposingSpec::printTo(std::ostream& out) const { @@ -7629,23 +7735,23 @@ void swap(PartitionSpec &a, PartitionSpec &b) { swap(a.__isset, b.__isset); } -PartitionSpec::PartitionSpec(const PartitionSpec& other299) { - dbName = other299.dbName; - tableName = other299.tableName; - rootPath = other299.rootPath; - sharedSDPartitionSpec = other299.sharedSDPartitionSpec; - partitionList = other299.partitionList; - catName = other299.catName; - __isset = other299.__isset; +PartitionSpec::PartitionSpec(const PartitionSpec& other301) { + dbName = other301.dbName; + tableName = other301.tableName; + rootPath = other301.rootPath; + sharedSDPartitionSpec = other301.sharedSDPartitionSpec; + partitionList = other301.partitionList; + catName = other301.catName; + __isset = other301.__isset; } -PartitionSpec& PartitionSpec::operator=(const PartitionSpec& other300) { - dbName = other300.dbName; - tableName = other300.tableName; - rootPath = other300.rootPath; - sharedSDPartitionSpec = other300.sharedSDPartitionSpec; - partitionList = other300.partitionList; - catName = other300.catName; - __isset = other300.__isset; +PartitionSpec& PartitionSpec::operator=(const PartitionSpec& other302) { + dbName = other302.dbName; + tableName = other302.tableName; + rootPath = other302.rootPath; + sharedSDPartitionSpec = other302.sharedSDPartitionSpec; + partitionList = other302.partitionList; + catName = other302.catName; + __isset = other302.__isset; return *this; } void PartitionSpec::printTo(std::ostream& out) const { @@ -7792,19 +7898,19 @@ void swap(BooleanColumnStatsData &a, BooleanColumnStatsData &b) { swap(a.__isset, b.__isset); } -BooleanColumnStatsData::BooleanColumnStatsData(const BooleanColumnStatsData& other301) { - numTrues = other301.numTrues; - numFalses = other301.numFalses; - numNulls = other301.numNulls; - bitVectors = other301.bitVectors; - __isset = other301.__isset; +BooleanColumnStatsData::BooleanColumnStatsData(const BooleanColumnStatsData& other303) { + numTrues = other303.numTrues; + numFalses = other303.numFalses; + numNulls = other303.numNulls; + bitVectors = other303.bitVectors; + __isset = other303.__isset; } -BooleanColumnStatsData& BooleanColumnStatsData::operator=(const BooleanColumnStatsData& other302) { - numTrues = other302.numTrues; - numFalses = other302.numFalses; - numNulls = other302.numNulls; - bitVectors = other302.bitVectors; - __isset = other302.__isset; +BooleanColumnStatsData& BooleanColumnStatsData::operator=(const BooleanColumnStatsData& other304) { + numTrues = other304.numTrues; + numFalses = other304.numFalses; + numNulls = other304.numNulls; + bitVectors = other304.bitVectors; + __isset = other304.__isset; return *this; } void BooleanColumnStatsData::printTo(std::ostream& out) const { @@ -7967,21 +8073,21 @@ void swap(DoubleColumnStatsData &a, DoubleColumnStatsData &b) { swap(a.__isset, b.__isset); } -DoubleColumnStatsData::DoubleColumnStatsData(const DoubleColumnStatsData& other303) { - lowValue = other303.lowValue; - highValue = other303.highValue; - numNulls = other303.numNulls; - numDVs = other303.numDVs; - bitVectors = other303.bitVectors; - __isset = other303.__isset; +DoubleColumnStatsData::DoubleColumnStatsData(const DoubleColumnStatsData& other305) { + lowValue = other305.lowValue; + highValue = other305.highValue; + numNulls = other305.numNulls; + numDVs = other305.numDVs; + bitVectors = other305.bitVectors; + __isset = other305.__isset; } -DoubleColumnStatsData& DoubleColumnStatsData::operator=(const DoubleColumnStatsData& other304) { - lowValue = other304.lowValue; - highValue = other304.highValue; - numNulls = other304.numNulls; - numDVs = other304.numDVs; - bitVectors = other304.bitVectors; - __isset = other304.__isset; +DoubleColumnStatsData& DoubleColumnStatsData::operator=(const DoubleColumnStatsData& other306) { + lowValue = other306.lowValue; + highValue = other306.highValue; + numNulls = other306.numNulls; + numDVs = other306.numDVs; + bitVectors = other306.bitVectors; + __isset = other306.__isset; return *this; } void DoubleColumnStatsData::printTo(std::ostream& out) const { @@ -8145,21 +8251,21 @@ void swap(LongColumnStatsData &a, LongColumnStatsData &b) { swap(a.__isset, b.__isset); } -LongColumnStatsData::LongColumnStatsData(const LongColumnStatsData& other305) { - lowValue = other305.lowValue; - highValue = other305.highValue; - numNulls = other305.numNulls; - numDVs = other305.numDVs; - bitVectors = other305.bitVectors; - __isset = other305.__isset; +LongColumnStatsData::LongColumnStatsData(const LongColumnStatsData& other307) { + lowValue = other307.lowValue; + highValue = other307.highValue; + numNulls = other307.numNulls; + numDVs = other307.numDVs; + bitVectors = other307.bitVectors; + __isset = other307.__isset; } -LongColumnStatsData& LongColumnStatsData::operator=(const LongColumnStatsData& other306) { - lowValue = other306.lowValue; - highValue = other306.highValue; - numNulls = other306.numNulls; - numDVs = other306.numDVs; - bitVectors = other306.bitVectors; - __isset = other306.__isset; +LongColumnStatsData& LongColumnStatsData::operator=(const LongColumnStatsData& other308) { + lowValue = other308.lowValue; + highValue = other308.highValue; + numNulls = other308.numNulls; + numDVs = other308.numDVs; + bitVectors = other308.bitVectors; + __isset = other308.__isset; return *this; } void LongColumnStatsData::printTo(std::ostream& out) const { @@ -8325,21 +8431,21 @@ void swap(StringColumnStatsData &a, StringColumnStatsData &b) { swap(a.__isset, b.__isset); } -StringColumnStatsData::StringColumnStatsData(const StringColumnStatsData& other307) { - maxColLen = other307.maxColLen; - avgColLen = other307.avgColLen; - numNulls = other307.numNulls; - numDVs = other307.numDVs; - bitVectors = other307.bitVectors; - __isset = other307.__isset; +StringColumnStatsData::StringColumnStatsData(const StringColumnStatsData& other309) { + maxColLen = other309.maxColLen; + avgColLen = other309.avgColLen; + numNulls = other309.numNulls; + numDVs = other309.numDVs; + bitVectors = other309.bitVectors; + __isset = other309.__isset; } -StringColumnStatsData& StringColumnStatsData::operator=(const StringColumnStatsData& other308) { - maxColLen = other308.maxColLen; - avgColLen = other308.avgColLen; - numNulls = other308.numNulls; - numDVs = other308.numDVs; - bitVectors = other308.bitVectors; - __isset = other308.__isset; +StringColumnStatsData& StringColumnStatsData::operator=(const StringColumnStatsData& other310) { + maxColLen = other310.maxColLen; + avgColLen = other310.avgColLen; + numNulls = other310.numNulls; + numDVs = other310.numDVs; + bitVectors = other310.bitVectors; + __isset = other310.__isset; return *this; } void StringColumnStatsData::printTo(std::ostream& out) const { @@ -8485,19 +8591,19 @@ void swap(BinaryColumnStatsData &a, BinaryColumnStatsData &b) { swap(a.__isset, b.__isset); } -BinaryColumnStatsData::BinaryColumnStatsData(const BinaryColumnStatsData& other309) { - maxColLen = other309.maxColLen; - avgColLen = other309.avgColLen; - numNulls = other309.numNulls; - bitVectors = other309.bitVectors; - __isset = other309.__isset; +BinaryColumnStatsData::BinaryColumnStatsData(const BinaryColumnStatsData& other311) { + maxColLen = other311.maxColLen; + avgColLen = other311.avgColLen; + numNulls = other311.numNulls; + bitVectors = other311.bitVectors; + __isset = other311.__isset; } -BinaryColumnStatsData& BinaryColumnStatsData::operator=(const BinaryColumnStatsData& other310) { - maxColLen = other310.maxColLen; - avgColLen = other310.avgColLen; - numNulls = other310.numNulls; - bitVectors = other310.bitVectors; - __isset = other310.__isset; +BinaryColumnStatsData& BinaryColumnStatsData::operator=(const BinaryColumnStatsData& other312) { + maxColLen = other312.maxColLen; + avgColLen = other312.avgColLen; + numNulls = other312.numNulls; + bitVectors = other312.bitVectors; + __isset = other312.__isset; return *this; } void BinaryColumnStatsData::printTo(std::ostream& out) const { @@ -8602,13 +8708,13 @@ void swap(Decimal &a, Decimal &b) { swap(a.unscaled, b.unscaled); } -Decimal::Decimal(const Decimal& other311) { - scale = other311.scale; - unscaled = other311.unscaled; +Decimal::Decimal(const Decimal& other313) { + scale = other313.scale; + unscaled = other313.unscaled; } -Decimal& Decimal::operator=(const Decimal& other312) { - scale = other312.scale; - unscaled = other312.unscaled; +Decimal& Decimal::operator=(const Decimal& other314) { + scale = other314.scale; + unscaled = other314.unscaled; return *this; } void Decimal::printTo(std::ostream& out) const { @@ -8769,21 +8875,21 @@ void swap(DecimalColumnStatsData &a, DecimalColumnStatsData &b) { swap(a.__isset, b.__isset); } -DecimalColumnStatsData::DecimalColumnStatsData(const DecimalColumnStatsData& other313) { - lowValue = other313.lowValue; - highValue = other313.highValue; - numNulls = other313.numNulls; - numDVs = other313.numDVs; - bitVectors = other313.bitVectors; - __isset = other313.__isset; -} -DecimalColumnStatsData& DecimalColumnStatsData::operator=(const DecimalColumnStatsData& other314) { - lowValue = other314.lowValue; - highValue = other314.highValue; - numNulls = other314.numNulls; - numDVs = other314.numDVs; - bitVectors = other314.bitVectors; - __isset = other314.__isset; +DecimalColumnStatsData::DecimalColumnStatsData(const DecimalColumnStatsData& other315) { + lowValue = other315.lowValue; + highValue = other315.highValue; + numNulls = other315.numNulls; + numDVs = other315.numDVs; + bitVectors = other315.bitVectors; + __isset = other315.__isset; +} +DecimalColumnStatsData& DecimalColumnStatsData::operator=(const DecimalColumnStatsData& other316) { + lowValue = other316.lowValue; + highValue = other316.highValue; + numNulls = other316.numNulls; + numDVs = other316.numDVs; + bitVectors = other316.bitVectors; + __isset = other316.__isset; return *this; } void DecimalColumnStatsData::printTo(std::ostream& out) const { @@ -8869,11 +8975,11 @@ void swap(Date &a, Date &b) { swap(a.daysSinceEpoch, b.daysSinceEpoch); } -Date::Date(const Date& other315) { - daysSinceEpoch = other315.daysSinceEpoch; +Date::Date(const Date& other317) { + daysSinceEpoch = other317.daysSinceEpoch; } -Date& Date::operator=(const Date& other316) { - daysSinceEpoch = other316.daysSinceEpoch; +Date& Date::operator=(const Date& other318) { + daysSinceEpoch = other318.daysSinceEpoch; return *this; } void Date::printTo(std::ostream& out) const { @@ -9033,21 +9139,21 @@ void swap(DateColumnStatsData &a, DateColumnStatsData &b) { swap(a.__isset, b.__isset); } -DateColumnStatsData::DateColumnStatsData(const DateColumnStatsData& other317) { - lowValue = other317.lowValue; - highValue = other317.highValue; - numNulls = other317.numNulls; - numDVs = other317.numDVs; - bitVectors = other317.bitVectors; - __isset = other317.__isset; -} -DateColumnStatsData& DateColumnStatsData::operator=(const DateColumnStatsData& other318) { - lowValue = other318.lowValue; - highValue = other318.highValue; - numNulls = other318.numNulls; - numDVs = other318.numDVs; - bitVectors = other318.bitVectors; - __isset = other318.__isset; +DateColumnStatsData::DateColumnStatsData(const DateColumnStatsData& other319) { + lowValue = other319.lowValue; + highValue = other319.highValue; + numNulls = other319.numNulls; + numDVs = other319.numDVs; + bitVectors = other319.bitVectors; + __isset = other319.__isset; +} +DateColumnStatsData& DateColumnStatsData::operator=(const DateColumnStatsData& other320) { + lowValue = other320.lowValue; + highValue = other320.highValue; + numNulls = other320.numNulls; + numDVs = other320.numDVs; + bitVectors = other320.bitVectors; + __isset = other320.__isset; return *this; } void DateColumnStatsData::printTo(std::ostream& out) const { @@ -9233,25 +9339,25 @@ void swap(ColumnStatisticsData &a, ColumnStatisticsData &b) { swap(a.__isset, b.__isset); } -ColumnStatisticsData::ColumnStatisticsData(const ColumnStatisticsData& other319) { - booleanStats = other319.booleanStats; - longStats = other319.longStats; - doubleStats = other319.doubleStats; - stringStats = other319.stringStats; - binaryStats = other319.binaryStats; - decimalStats = other319.decimalStats; - dateStats = other319.dateStats; - __isset = other319.__isset; -} -ColumnStatisticsData& ColumnStatisticsData::operator=(const ColumnStatisticsData& other320) { - booleanStats = other320.booleanStats; - longStats = other320.longStats; - doubleStats = other320.doubleStats; - stringStats = other320.stringStats; - binaryStats = other320.binaryStats; - decimalStats = other320.decimalStats; - dateStats = other320.dateStats; - __isset = other320.__isset; +ColumnStatisticsData::ColumnStatisticsData(const ColumnStatisticsData& other321) { + booleanStats = other321.booleanStats; + longStats = other321.longStats; + doubleStats = other321.doubleStats; + stringStats = other321.stringStats; + binaryStats = other321.binaryStats; + decimalStats = other321.decimalStats; + dateStats = other321.dateStats; + __isset = other321.__isset; +} +ColumnStatisticsData& ColumnStatisticsData::operator=(const ColumnStatisticsData& other322) { + booleanStats = other322.booleanStats; + longStats = other322.longStats; + doubleStats = other322.doubleStats; + stringStats = other322.stringStats; + binaryStats = other322.binaryStats; + decimalStats = other322.decimalStats; + dateStats = other322.dateStats; + __isset = other322.__isset; return *this; } void ColumnStatisticsData::printTo(std::ostream& out) const { @@ -9379,15 +9485,15 @@ void swap(ColumnStatisticsObj &a, ColumnStatisticsObj &b) { swap(a.statsData, b.statsData); } -ColumnStatisticsObj::ColumnStatisticsObj(const ColumnStatisticsObj& other321) { - colName = other321.colName; - colType = other321.colType; - statsData = other321.statsData; +ColumnStatisticsObj::ColumnStatisticsObj(const ColumnStatisticsObj& other323) { + colName = other323.colName; + colType = other323.colType; + statsData = other323.statsData; } -ColumnStatisticsObj& ColumnStatisticsObj::operator=(const ColumnStatisticsObj& other322) { - colName = other322.colName; - colType = other322.colType; - statsData = other322.statsData; +ColumnStatisticsObj& ColumnStatisticsObj::operator=(const ColumnStatisticsObj& other324) { + colName = other324.colName; + colType = other324.colType; + statsData = other324.statsData; return *this; } void ColumnStatisticsObj::printTo(std::ostream& out) const { @@ -9569,23 +9675,23 @@ void swap(ColumnStatisticsDesc &a, ColumnStatisticsDesc &b) { swap(a.__isset, b.__isset); } -ColumnStatisticsDesc::ColumnStatisticsDesc(const ColumnStatisticsDesc& other323) { - isTblLevel = other323.isTblLevel; - dbName = other323.dbName; - tableName = other323.tableName; - partName = other323.partName; - lastAnalyzed = other323.lastAnalyzed; - catName = other323.catName; - __isset = other323.__isset; -} -ColumnStatisticsDesc& ColumnStatisticsDesc::operator=(const ColumnStatisticsDesc& other324) { - isTblLevel = other324.isTblLevel; - dbName = other324.dbName; - tableName = other324.tableName; - partName = other324.partName; - lastAnalyzed = other324.lastAnalyzed; - catName = other324.catName; - __isset = other324.__isset; +ColumnStatisticsDesc::ColumnStatisticsDesc(const ColumnStatisticsDesc& other325) { + isTblLevel = other325.isTblLevel; + dbName = other325.dbName; + tableName = other325.tableName; + partName = other325.partName; + lastAnalyzed = other325.lastAnalyzed; + catName = other325.catName; + __isset = other325.__isset; +} +ColumnStatisticsDesc& ColumnStatisticsDesc::operator=(const ColumnStatisticsDesc& other326) { + isTblLevel = other326.isTblLevel; + dbName = other326.dbName; + tableName = other326.tableName; + partName = other326.partName; + lastAnalyzed = other326.lastAnalyzed; + catName = other326.catName; + __isset = other326.__isset; return *this; } void ColumnStatisticsDesc::printTo(std::ostream& out) const { @@ -9648,14 +9754,14 @@ uint32_t ColumnStatistics::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->statsObj.clear(); - uint32_t _size325; - ::apache::thrift::protocol::TType _etype328; - xfer += iprot->readListBegin(_etype328, _size325); - this->statsObj.resize(_size325); - uint32_t _i329; - for (_i329 = 0; _i329 < _size325; ++_i329) + uint32_t _size327; + ::apache::thrift::protocol::TType _etype330; + xfer += iprot->readListBegin(_etype330, _size327); + this->statsObj.resize(_size327); + uint32_t _i331; + for (_i331 = 0; _i331 < _size327; ++_i331) { - xfer += this->statsObj[_i329].read(iprot); + xfer += this->statsObj[_i331].read(iprot); } xfer += iprot->readListEnd(); } @@ -9692,10 +9798,10 @@ uint32_t ColumnStatistics::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("statsObj", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->statsObj.size())); - std::vector ::const_iterator _iter330; - for (_iter330 = this->statsObj.begin(); _iter330 != this->statsObj.end(); ++_iter330) + std::vector ::const_iterator _iter332; + for (_iter332 = this->statsObj.begin(); _iter332 != this->statsObj.end(); ++_iter332) { - xfer += (*_iter330).write(oprot); + xfer += (*_iter332).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9712,13 +9818,13 @@ void swap(ColumnStatistics &a, ColumnStatistics &b) { swap(a.statsObj, b.statsObj); } -ColumnStatistics::ColumnStatistics(const ColumnStatistics& other331) { - statsDesc = other331.statsDesc; - statsObj = other331.statsObj; +ColumnStatistics::ColumnStatistics(const ColumnStatistics& other333) { + statsDesc = other333.statsDesc; + statsObj = other333.statsObj; } -ColumnStatistics& ColumnStatistics::operator=(const ColumnStatistics& other332) { - statsDesc = other332.statsDesc; - statsObj = other332.statsObj; +ColumnStatistics& ColumnStatistics::operator=(const ColumnStatistics& other334) { + statsDesc = other334.statsDesc; + statsObj = other334.statsObj; return *this; } void ColumnStatistics::printTo(std::ostream& out) const { @@ -9769,14 +9875,14 @@ uint32_t AggrStats::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->colStats.clear(); - uint32_t _size333; - ::apache::thrift::protocol::TType _etype336; - xfer += iprot->readListBegin(_etype336, _size333); - this->colStats.resize(_size333); - uint32_t _i337; - for (_i337 = 0; _i337 < _size333; ++_i337) + uint32_t _size335; + ::apache::thrift::protocol::TType _etype338; + xfer += iprot->readListBegin(_etype338, _size335); + this->colStats.resize(_size335); + uint32_t _i339; + for (_i339 = 0; _i339 < _size335; ++_i339) { - xfer += this->colStats[_i337].read(iprot); + xfer += this->colStats[_i339].read(iprot); } xfer += iprot->readListEnd(); } @@ -9817,10 +9923,10 @@ uint32_t AggrStats::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("colStats", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->colStats.size())); - std::vector ::const_iterator _iter338; - for (_iter338 = this->colStats.begin(); _iter338 != this->colStats.end(); ++_iter338) + std::vector ::const_iterator _iter340; + for (_iter340 = this->colStats.begin(); _iter340 != this->colStats.end(); ++_iter340) { - xfer += (*_iter338).write(oprot); + xfer += (*_iter340).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9841,13 +9947,13 @@ void swap(AggrStats &a, AggrStats &b) { swap(a.partsFound, b.partsFound); } -AggrStats::AggrStats(const AggrStats& other339) { - colStats = other339.colStats; - partsFound = other339.partsFound; +AggrStats::AggrStats(const AggrStats& other341) { + colStats = other341.colStats; + partsFound = other341.partsFound; } -AggrStats& AggrStats::operator=(const AggrStats& other340) { - colStats = other340.colStats; - partsFound = other340.partsFound; +AggrStats& AggrStats::operator=(const AggrStats& other342) { + colStats = other342.colStats; + partsFound = other342.partsFound; return *this; } void AggrStats::printTo(std::ostream& out) const { @@ -9898,14 +10004,14 @@ uint32_t SetPartitionsStatsRequest::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->colStats.clear(); - uint32_t _size341; - ::apache::thrift::protocol::TType _etype344; - xfer += iprot->readListBegin(_etype344, _size341); - this->colStats.resize(_size341); - uint32_t _i345; - for (_i345 = 0; _i345 < _size341; ++_i345) + uint32_t _size343; + ::apache::thrift::protocol::TType _etype346; + xfer += iprot->readListBegin(_etype346, _size343); + this->colStats.resize(_size343); + uint32_t _i347; + for (_i347 = 0; _i347 < _size343; ++_i347) { - xfer += this->colStats[_i345].read(iprot); + xfer += this->colStats[_i347].read(iprot); } xfer += iprot->readListEnd(); } @@ -9944,10 +10050,10 @@ uint32_t SetPartitionsStatsRequest::write(::apache::thrift::protocol::TProtocol* xfer += oprot->writeFieldBegin("colStats", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->colStats.size())); - std::vector ::const_iterator _iter346; - for (_iter346 = this->colStats.begin(); _iter346 != this->colStats.end(); ++_iter346) + std::vector ::const_iterator _iter348; + for (_iter348 = this->colStats.begin(); _iter348 != this->colStats.end(); ++_iter348) { - xfer += (*_iter346).write(oprot); + xfer += (*_iter348).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9970,15 +10076,15 @@ void swap(SetPartitionsStatsRequest &a, SetPartitionsStatsRequest &b) { swap(a.__isset, b.__isset); } -SetPartitionsStatsRequest::SetPartitionsStatsRequest(const SetPartitionsStatsRequest& other347) { - colStats = other347.colStats; - needMerge = other347.needMerge; - __isset = other347.__isset; +SetPartitionsStatsRequest::SetPartitionsStatsRequest(const SetPartitionsStatsRequest& other349) { + colStats = other349.colStats; + needMerge = other349.needMerge; + __isset = other349.__isset; } -SetPartitionsStatsRequest& SetPartitionsStatsRequest::operator=(const SetPartitionsStatsRequest& other348) { - colStats = other348.colStats; - needMerge = other348.needMerge; - __isset = other348.__isset; +SetPartitionsStatsRequest& SetPartitionsStatsRequest::operator=(const SetPartitionsStatsRequest& other350) { + colStats = other350.colStats; + needMerge = other350.needMerge; + __isset = other350.__isset; return *this; } void SetPartitionsStatsRequest::printTo(std::ostream& out) const { @@ -10027,14 +10133,14 @@ uint32_t Schema::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fieldSchemas.clear(); - uint32_t _size349; - ::apache::thrift::protocol::TType _etype352; - xfer += iprot->readListBegin(_etype352, _size349); - this->fieldSchemas.resize(_size349); - uint32_t _i353; - for (_i353 = 0; _i353 < _size349; ++_i353) + uint32_t _size351; + ::apache::thrift::protocol::TType _etype354; + xfer += iprot->readListBegin(_etype354, _size351); + this->fieldSchemas.resize(_size351); + uint32_t _i355; + for (_i355 = 0; _i355 < _size351; ++_i355) { - xfer += this->fieldSchemas[_i353].read(iprot); + xfer += this->fieldSchemas[_i355].read(iprot); } xfer += iprot->readListEnd(); } @@ -10047,17 +10153,17 @@ uint32_t Schema::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->properties.clear(); - uint32_t _size354; - ::apache::thrift::protocol::TType _ktype355; - ::apache::thrift::protocol::TType _vtype356; - xfer += iprot->readMapBegin(_ktype355, _vtype356, _size354); - uint32_t _i358; - for (_i358 = 0; _i358 < _size354; ++_i358) + uint32_t _size356; + ::apache::thrift::protocol::TType _ktype357; + ::apache::thrift::protocol::TType _vtype358; + xfer += iprot->readMapBegin(_ktype357, _vtype358, _size356); + uint32_t _i360; + for (_i360 = 0; _i360 < _size356; ++_i360) { - std::string _key359; - xfer += iprot->readString(_key359); - std::string& _val360 = this->properties[_key359]; - xfer += iprot->readString(_val360); + std::string _key361; + xfer += iprot->readString(_key361); + std::string& _val362 = this->properties[_key361]; + xfer += iprot->readString(_val362); } xfer += iprot->readMapEnd(); } @@ -10086,10 +10192,10 @@ uint32_t Schema::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("fieldSchemas", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->fieldSchemas.size())); - std::vector ::const_iterator _iter361; - for (_iter361 = this->fieldSchemas.begin(); _iter361 != this->fieldSchemas.end(); ++_iter361) + std::vector ::const_iterator _iter363; + for (_iter363 = this->fieldSchemas.begin(); _iter363 != this->fieldSchemas.end(); ++_iter363) { - xfer += (*_iter361).write(oprot); + xfer += (*_iter363).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10098,11 +10204,11 @@ uint32_t Schema::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("properties", ::apache::thrift::protocol::T_MAP, 2); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->properties.size())); - std::map ::const_iterator _iter362; - for (_iter362 = this->properties.begin(); _iter362 != this->properties.end(); ++_iter362) + std::map ::const_iterator _iter364; + for (_iter364 = this->properties.begin(); _iter364 != this->properties.end(); ++_iter364) { - xfer += oprot->writeString(_iter362->first); - xfer += oprot->writeString(_iter362->second); + xfer += oprot->writeString(_iter364->first); + xfer += oprot->writeString(_iter364->second); } xfer += oprot->writeMapEnd(); } @@ -10120,15 +10226,15 @@ void swap(Schema &a, Schema &b) { swap(a.__isset, b.__isset); } -Schema::Schema(const Schema& other363) { - fieldSchemas = other363.fieldSchemas; - properties = other363.properties; - __isset = other363.__isset; +Schema::Schema(const Schema& other365) { + fieldSchemas = other365.fieldSchemas; + properties = other365.properties; + __isset = other365.__isset; } -Schema& Schema::operator=(const Schema& other364) { - fieldSchemas = other364.fieldSchemas; - properties = other364.properties; - __isset = other364.__isset; +Schema& Schema::operator=(const Schema& other366) { + fieldSchemas = other366.fieldSchemas; + properties = other366.properties; + __isset = other366.__isset; return *this; } void Schema::printTo(std::ostream& out) const { @@ -10173,17 +10279,17 @@ uint32_t EnvironmentContext::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_MAP) { { this->properties.clear(); - uint32_t _size365; - ::apache::thrift::protocol::TType _ktype366; - ::apache::thrift::protocol::TType _vtype367; - xfer += iprot->readMapBegin(_ktype366, _vtype367, _size365); - uint32_t _i369; - for (_i369 = 0; _i369 < _size365; ++_i369) + uint32_t _size367; + ::apache::thrift::protocol::TType _ktype368; + ::apache::thrift::protocol::TType _vtype369; + xfer += iprot->readMapBegin(_ktype368, _vtype369, _size367); + uint32_t _i371; + for (_i371 = 0; _i371 < _size367; ++_i371) { - std::string _key370; - xfer += iprot->readString(_key370); - std::string& _val371 = this->properties[_key370]; - xfer += iprot->readString(_val371); + std::string _key372; + xfer += iprot->readString(_key372); + std::string& _val373 = this->properties[_key372]; + xfer += iprot->readString(_val373); } xfer += iprot->readMapEnd(); } @@ -10212,11 +10318,11 @@ uint32_t EnvironmentContext::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("properties", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->properties.size())); - std::map ::const_iterator _iter372; - for (_iter372 = this->properties.begin(); _iter372 != this->properties.end(); ++_iter372) + std::map ::const_iterator _iter374; + for (_iter374 = this->properties.begin(); _iter374 != this->properties.end(); ++_iter374) { - xfer += oprot->writeString(_iter372->first); - xfer += oprot->writeString(_iter372->second); + xfer += oprot->writeString(_iter374->first); + xfer += oprot->writeString(_iter374->second); } xfer += oprot->writeMapEnd(); } @@ -10233,13 +10339,13 @@ void swap(EnvironmentContext &a, EnvironmentContext &b) { swap(a.__isset, b.__isset); } -EnvironmentContext::EnvironmentContext(const EnvironmentContext& other373) { - properties = other373.properties; - __isset = other373.__isset; +EnvironmentContext::EnvironmentContext(const EnvironmentContext& other375) { + properties = other375.properties; + __isset = other375.__isset; } -EnvironmentContext& EnvironmentContext::operator=(const EnvironmentContext& other374) { - properties = other374.properties; - __isset = other374.__isset; +EnvironmentContext& EnvironmentContext::operator=(const EnvironmentContext& other376) { + properties = other376.properties; + __isset = other376.__isset; return *this; } void EnvironmentContext::printTo(std::ostream& out) const { @@ -10361,17 +10467,17 @@ void swap(PrimaryKeysRequest &a, PrimaryKeysRequest &b) { swap(a.__isset, b.__isset); } -PrimaryKeysRequest::PrimaryKeysRequest(const PrimaryKeysRequest& other375) { - db_name = other375.db_name; - tbl_name = other375.tbl_name; - catName = other375.catName; - __isset = other375.__isset; +PrimaryKeysRequest::PrimaryKeysRequest(const PrimaryKeysRequest& other377) { + db_name = other377.db_name; + tbl_name = other377.tbl_name; + catName = other377.catName; + __isset = other377.__isset; } -PrimaryKeysRequest& PrimaryKeysRequest::operator=(const PrimaryKeysRequest& other376) { - db_name = other376.db_name; - tbl_name = other376.tbl_name; - catName = other376.catName; - __isset = other376.__isset; +PrimaryKeysRequest& PrimaryKeysRequest::operator=(const PrimaryKeysRequest& other378) { + db_name = other378.db_name; + tbl_name = other378.tbl_name; + catName = other378.catName; + __isset = other378.__isset; return *this; } void PrimaryKeysRequest::printTo(std::ostream& out) const { @@ -10418,14 +10524,14 @@ uint32_t PrimaryKeysResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->primaryKeys.clear(); - uint32_t _size377; - ::apache::thrift::protocol::TType _etype380; - xfer += iprot->readListBegin(_etype380, _size377); - this->primaryKeys.resize(_size377); - uint32_t _i381; - for (_i381 = 0; _i381 < _size377; ++_i381) + uint32_t _size379; + ::apache::thrift::protocol::TType _etype382; + xfer += iprot->readListBegin(_etype382, _size379); + this->primaryKeys.resize(_size379); + uint32_t _i383; + for (_i383 = 0; _i383 < _size379; ++_i383) { - xfer += this->primaryKeys[_i381].read(iprot); + xfer += this->primaryKeys[_i383].read(iprot); } xfer += iprot->readListEnd(); } @@ -10456,10 +10562,10 @@ uint32_t PrimaryKeysResponse::write(::apache::thrift::protocol::TProtocol* oprot xfer += oprot->writeFieldBegin("primaryKeys", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->primaryKeys.size())); - std::vector ::const_iterator _iter382; - for (_iter382 = this->primaryKeys.begin(); _iter382 != this->primaryKeys.end(); ++_iter382) + std::vector ::const_iterator _iter384; + for (_iter384 = this->primaryKeys.begin(); _iter384 != this->primaryKeys.end(); ++_iter384) { - xfer += (*_iter382).write(oprot); + xfer += (*_iter384).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10475,11 +10581,11 @@ void swap(PrimaryKeysResponse &a, PrimaryKeysResponse &b) { swap(a.primaryKeys, b.primaryKeys); } -PrimaryKeysResponse::PrimaryKeysResponse(const PrimaryKeysResponse& other383) { - primaryKeys = other383.primaryKeys; +PrimaryKeysResponse::PrimaryKeysResponse(const PrimaryKeysResponse& other385) { + primaryKeys = other385.primaryKeys; } -PrimaryKeysResponse& PrimaryKeysResponse::operator=(const PrimaryKeysResponse& other384) { - primaryKeys = other384.primaryKeys; +PrimaryKeysResponse& PrimaryKeysResponse::operator=(const PrimaryKeysResponse& other386) { + primaryKeys = other386.primaryKeys; return *this; } void PrimaryKeysResponse::printTo(std::ostream& out) const { @@ -10629,21 +10735,21 @@ void swap(ForeignKeysRequest &a, ForeignKeysRequest &b) { swap(a.__isset, b.__isset); } -ForeignKeysRequest::ForeignKeysRequest(const ForeignKeysRequest& other385) { - parent_db_name = other385.parent_db_name; - parent_tbl_name = other385.parent_tbl_name; - foreign_db_name = other385.foreign_db_name; - foreign_tbl_name = other385.foreign_tbl_name; - catName = other385.catName; - __isset = other385.__isset; -} -ForeignKeysRequest& ForeignKeysRequest::operator=(const ForeignKeysRequest& other386) { - parent_db_name = other386.parent_db_name; - parent_tbl_name = other386.parent_tbl_name; - foreign_db_name = other386.foreign_db_name; - foreign_tbl_name = other386.foreign_tbl_name; - catName = other386.catName; - __isset = other386.__isset; +ForeignKeysRequest::ForeignKeysRequest(const ForeignKeysRequest& other387) { + parent_db_name = other387.parent_db_name; + parent_tbl_name = other387.parent_tbl_name; + foreign_db_name = other387.foreign_db_name; + foreign_tbl_name = other387.foreign_tbl_name; + catName = other387.catName; + __isset = other387.__isset; +} +ForeignKeysRequest& ForeignKeysRequest::operator=(const ForeignKeysRequest& other388) { + parent_db_name = other388.parent_db_name; + parent_tbl_name = other388.parent_tbl_name; + foreign_db_name = other388.foreign_db_name; + foreign_tbl_name = other388.foreign_tbl_name; + catName = other388.catName; + __isset = other388.__isset; return *this; } void ForeignKeysRequest::printTo(std::ostream& out) const { @@ -10692,14 +10798,14 @@ uint32_t ForeignKeysResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->foreignKeys.clear(); - uint32_t _size387; - ::apache::thrift::protocol::TType _etype390; - xfer += iprot->readListBegin(_etype390, _size387); - this->foreignKeys.resize(_size387); - uint32_t _i391; - for (_i391 = 0; _i391 < _size387; ++_i391) + uint32_t _size389; + ::apache::thrift::protocol::TType _etype392; + xfer += iprot->readListBegin(_etype392, _size389); + this->foreignKeys.resize(_size389); + uint32_t _i393; + for (_i393 = 0; _i393 < _size389; ++_i393) { - xfer += this->foreignKeys[_i391].read(iprot); + xfer += this->foreignKeys[_i393].read(iprot); } xfer += iprot->readListEnd(); } @@ -10730,10 +10836,10 @@ uint32_t ForeignKeysResponse::write(::apache::thrift::protocol::TProtocol* oprot xfer += oprot->writeFieldBegin("foreignKeys", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->foreignKeys.size())); - std::vector ::const_iterator _iter392; - for (_iter392 = this->foreignKeys.begin(); _iter392 != this->foreignKeys.end(); ++_iter392) + std::vector ::const_iterator _iter394; + for (_iter394 = this->foreignKeys.begin(); _iter394 != this->foreignKeys.end(); ++_iter394) { - xfer += (*_iter392).write(oprot); + xfer += (*_iter394).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10749,11 +10855,11 @@ void swap(ForeignKeysResponse &a, ForeignKeysResponse &b) { swap(a.foreignKeys, b.foreignKeys); } -ForeignKeysResponse::ForeignKeysResponse(const ForeignKeysResponse& other393) { - foreignKeys = other393.foreignKeys; +ForeignKeysResponse::ForeignKeysResponse(const ForeignKeysResponse& other395) { + foreignKeys = other395.foreignKeys; } -ForeignKeysResponse& ForeignKeysResponse::operator=(const ForeignKeysResponse& other394) { - foreignKeys = other394.foreignKeys; +ForeignKeysResponse& ForeignKeysResponse::operator=(const ForeignKeysResponse& other396) { + foreignKeys = other396.foreignKeys; return *this; } void ForeignKeysResponse::printTo(std::ostream& out) const { @@ -10875,15 +10981,15 @@ void swap(UniqueConstraintsRequest &a, UniqueConstraintsRequest &b) { swap(a.tbl_name, b.tbl_name); } -UniqueConstraintsRequest::UniqueConstraintsRequest(const UniqueConstraintsRequest& other395) { - catName = other395.catName; - db_name = other395.db_name; - tbl_name = other395.tbl_name; +UniqueConstraintsRequest::UniqueConstraintsRequest(const UniqueConstraintsRequest& other397) { + catName = other397.catName; + db_name = other397.db_name; + tbl_name = other397.tbl_name; } -UniqueConstraintsRequest& UniqueConstraintsRequest::operator=(const UniqueConstraintsRequest& other396) { - catName = other396.catName; - db_name = other396.db_name; - tbl_name = other396.tbl_name; +UniqueConstraintsRequest& UniqueConstraintsRequest::operator=(const UniqueConstraintsRequest& other398) { + catName = other398.catName; + db_name = other398.db_name; + tbl_name = other398.tbl_name; return *this; } void UniqueConstraintsRequest::printTo(std::ostream& out) const { @@ -10930,14 +11036,14 @@ uint32_t UniqueConstraintsResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->uniqueConstraints.clear(); - uint32_t _size397; - ::apache::thrift::protocol::TType _etype400; - xfer += iprot->readListBegin(_etype400, _size397); - this->uniqueConstraints.resize(_size397); - uint32_t _i401; - for (_i401 = 0; _i401 < _size397; ++_i401) + uint32_t _size399; + ::apache::thrift::protocol::TType _etype402; + xfer += iprot->readListBegin(_etype402, _size399); + this->uniqueConstraints.resize(_size399); + uint32_t _i403; + for (_i403 = 0; _i403 < _size399; ++_i403) { - xfer += this->uniqueConstraints[_i401].read(iprot); + xfer += this->uniqueConstraints[_i403].read(iprot); } xfer += iprot->readListEnd(); } @@ -10968,10 +11074,10 @@ uint32_t UniqueConstraintsResponse::write(::apache::thrift::protocol::TProtocol* xfer += oprot->writeFieldBegin("uniqueConstraints", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->uniqueConstraints.size())); - std::vector ::const_iterator _iter402; - for (_iter402 = this->uniqueConstraints.begin(); _iter402 != this->uniqueConstraints.end(); ++_iter402) + std::vector ::const_iterator _iter404; + for (_iter404 = this->uniqueConstraints.begin(); _iter404 != this->uniqueConstraints.end(); ++_iter404) { - xfer += (*_iter402).write(oprot); + xfer += (*_iter404).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10987,11 +11093,11 @@ void swap(UniqueConstraintsResponse &a, UniqueConstraintsResponse &b) { swap(a.uniqueConstraints, b.uniqueConstraints); } -UniqueConstraintsResponse::UniqueConstraintsResponse(const UniqueConstraintsResponse& other403) { - uniqueConstraints = other403.uniqueConstraints; +UniqueConstraintsResponse::UniqueConstraintsResponse(const UniqueConstraintsResponse& other405) { + uniqueConstraints = other405.uniqueConstraints; } -UniqueConstraintsResponse& UniqueConstraintsResponse::operator=(const UniqueConstraintsResponse& other404) { - uniqueConstraints = other404.uniqueConstraints; +UniqueConstraintsResponse& UniqueConstraintsResponse::operator=(const UniqueConstraintsResponse& other406) { + uniqueConstraints = other406.uniqueConstraints; return *this; } void UniqueConstraintsResponse::printTo(std::ostream& out) const { @@ -11113,15 +11219,15 @@ void swap(NotNullConstraintsRequest &a, NotNullConstraintsRequest &b) { swap(a.tbl_name, b.tbl_name); } -NotNullConstraintsRequest::NotNullConstraintsRequest(const NotNullConstraintsRequest& other405) { - catName = other405.catName; - db_name = other405.db_name; - tbl_name = other405.tbl_name; +NotNullConstraintsRequest::NotNullConstraintsRequest(const NotNullConstraintsRequest& other407) { + catName = other407.catName; + db_name = other407.db_name; + tbl_name = other407.tbl_name; } -NotNullConstraintsRequest& NotNullConstraintsRequest::operator=(const NotNullConstraintsRequest& other406) { - catName = other406.catName; - db_name = other406.db_name; - tbl_name = other406.tbl_name; +NotNullConstraintsRequest& NotNullConstraintsRequest::operator=(const NotNullConstraintsRequest& other408) { + catName = other408.catName; + db_name = other408.db_name; + tbl_name = other408.tbl_name; return *this; } void NotNullConstraintsRequest::printTo(std::ostream& out) const { @@ -11168,14 +11274,14 @@ uint32_t NotNullConstraintsResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->notNullConstraints.clear(); - uint32_t _size407; - ::apache::thrift::protocol::TType _etype410; - xfer += iprot->readListBegin(_etype410, _size407); - this->notNullConstraints.resize(_size407); - uint32_t _i411; - for (_i411 = 0; _i411 < _size407; ++_i411) + uint32_t _size409; + ::apache::thrift::protocol::TType _etype412; + xfer += iprot->readListBegin(_etype412, _size409); + this->notNullConstraints.resize(_size409); + uint32_t _i413; + for (_i413 = 0; _i413 < _size409; ++_i413) { - xfer += this->notNullConstraints[_i411].read(iprot); + xfer += this->notNullConstraints[_i413].read(iprot); } xfer += iprot->readListEnd(); } @@ -11206,10 +11312,10 @@ uint32_t NotNullConstraintsResponse::write(::apache::thrift::protocol::TProtocol xfer += oprot->writeFieldBegin("notNullConstraints", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->notNullConstraints.size())); - std::vector ::const_iterator _iter412; - for (_iter412 = this->notNullConstraints.begin(); _iter412 != this->notNullConstraints.end(); ++_iter412) + std::vector ::const_iterator _iter414; + for (_iter414 = this->notNullConstraints.begin(); _iter414 != this->notNullConstraints.end(); ++_iter414) { - xfer += (*_iter412).write(oprot); + xfer += (*_iter414).write(oprot); } xfer += oprot->writeListEnd(); } @@ -11225,11 +11331,11 @@ void swap(NotNullConstraintsResponse &a, NotNullConstraintsResponse &b) { swap(a.notNullConstraints, b.notNullConstraints); } -NotNullConstraintsResponse::NotNullConstraintsResponse(const NotNullConstraintsResponse& other413) { - notNullConstraints = other413.notNullConstraints; +NotNullConstraintsResponse::NotNullConstraintsResponse(const NotNullConstraintsResponse& other415) { + notNullConstraints = other415.notNullConstraints; } -NotNullConstraintsResponse& NotNullConstraintsResponse::operator=(const NotNullConstraintsResponse& other414) { - notNullConstraints = other414.notNullConstraints; +NotNullConstraintsResponse& NotNullConstraintsResponse::operator=(const NotNullConstraintsResponse& other416) { + notNullConstraints = other416.notNullConstraints; return *this; } void NotNullConstraintsResponse::printTo(std::ostream& out) const { @@ -11351,15 +11457,15 @@ void swap(DefaultConstraintsRequest &a, DefaultConstraintsRequest &b) { swap(a.tbl_name, b.tbl_name); } -DefaultConstraintsRequest::DefaultConstraintsRequest(const DefaultConstraintsRequest& other415) { - catName = other415.catName; - db_name = other415.db_name; - tbl_name = other415.tbl_name; +DefaultConstraintsRequest::DefaultConstraintsRequest(const DefaultConstraintsRequest& other417) { + catName = other417.catName; + db_name = other417.db_name; + tbl_name = other417.tbl_name; } -DefaultConstraintsRequest& DefaultConstraintsRequest::operator=(const DefaultConstraintsRequest& other416) { - catName = other416.catName; - db_name = other416.db_name; - tbl_name = other416.tbl_name; +DefaultConstraintsRequest& DefaultConstraintsRequest::operator=(const DefaultConstraintsRequest& other418) { + catName = other418.catName; + db_name = other418.db_name; + tbl_name = other418.tbl_name; return *this; } void DefaultConstraintsRequest::printTo(std::ostream& out) const { @@ -11406,14 +11512,14 @@ uint32_t DefaultConstraintsResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->defaultConstraints.clear(); - uint32_t _size417; - ::apache::thrift::protocol::TType _etype420; - xfer += iprot->readListBegin(_etype420, _size417); - this->defaultConstraints.resize(_size417); - uint32_t _i421; - for (_i421 = 0; _i421 < _size417; ++_i421) + uint32_t _size419; + ::apache::thrift::protocol::TType _etype422; + xfer += iprot->readListBegin(_etype422, _size419); + this->defaultConstraints.resize(_size419); + uint32_t _i423; + for (_i423 = 0; _i423 < _size419; ++_i423) { - xfer += this->defaultConstraints[_i421].read(iprot); + xfer += this->defaultConstraints[_i423].read(iprot); } xfer += iprot->readListEnd(); } @@ -11444,10 +11550,10 @@ uint32_t DefaultConstraintsResponse::write(::apache::thrift::protocol::TProtocol xfer += oprot->writeFieldBegin("defaultConstraints", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->defaultConstraints.size())); - std::vector ::const_iterator _iter422; - for (_iter422 = this->defaultConstraints.begin(); _iter422 != this->defaultConstraints.end(); ++_iter422) + std::vector ::const_iterator _iter424; + for (_iter424 = this->defaultConstraints.begin(); _iter424 != this->defaultConstraints.end(); ++_iter424) { - xfer += (*_iter422).write(oprot); + xfer += (*_iter424).write(oprot); } xfer += oprot->writeListEnd(); } @@ -11463,11 +11569,11 @@ void swap(DefaultConstraintsResponse &a, DefaultConstraintsResponse &b) { swap(a.defaultConstraints, b.defaultConstraints); } -DefaultConstraintsResponse::DefaultConstraintsResponse(const DefaultConstraintsResponse& other423) { - defaultConstraints = other423.defaultConstraints; +DefaultConstraintsResponse::DefaultConstraintsResponse(const DefaultConstraintsResponse& other425) { + defaultConstraints = other425.defaultConstraints; } -DefaultConstraintsResponse& DefaultConstraintsResponse::operator=(const DefaultConstraintsResponse& other424) { - defaultConstraints = other424.defaultConstraints; +DefaultConstraintsResponse& DefaultConstraintsResponse::operator=(const DefaultConstraintsResponse& other426) { + defaultConstraints = other426.defaultConstraints; return *this; } void DefaultConstraintsResponse::printTo(std::ostream& out) const { @@ -11589,15 +11695,15 @@ void swap(CheckConstraintsRequest &a, CheckConstraintsRequest &b) { swap(a.tbl_name, b.tbl_name); } -CheckConstraintsRequest::CheckConstraintsRequest(const CheckConstraintsRequest& other425) { - catName = other425.catName; - db_name = other425.db_name; - tbl_name = other425.tbl_name; +CheckConstraintsRequest::CheckConstraintsRequest(const CheckConstraintsRequest& other427) { + catName = other427.catName; + db_name = other427.db_name; + tbl_name = other427.tbl_name; } -CheckConstraintsRequest& CheckConstraintsRequest::operator=(const CheckConstraintsRequest& other426) { - catName = other426.catName; - db_name = other426.db_name; - tbl_name = other426.tbl_name; +CheckConstraintsRequest& CheckConstraintsRequest::operator=(const CheckConstraintsRequest& other428) { + catName = other428.catName; + db_name = other428.db_name; + tbl_name = other428.tbl_name; return *this; } void CheckConstraintsRequest::printTo(std::ostream& out) const { @@ -11644,14 +11750,14 @@ uint32_t CheckConstraintsResponse::read(::apache::thrift::protocol::TProtocol* i if (ftype == ::apache::thrift::protocol::T_LIST) { { this->checkConstraints.clear(); - uint32_t _size427; - ::apache::thrift::protocol::TType _etype430; - xfer += iprot->readListBegin(_etype430, _size427); - this->checkConstraints.resize(_size427); - uint32_t _i431; - for (_i431 = 0; _i431 < _size427; ++_i431) + uint32_t _size429; + ::apache::thrift::protocol::TType _etype432; + xfer += iprot->readListBegin(_etype432, _size429); + this->checkConstraints.resize(_size429); + uint32_t _i433; + for (_i433 = 0; _i433 < _size429; ++_i433) { - xfer += this->checkConstraints[_i431].read(iprot); + xfer += this->checkConstraints[_i433].read(iprot); } xfer += iprot->readListEnd(); } @@ -11682,10 +11788,10 @@ uint32_t CheckConstraintsResponse::write(::apache::thrift::protocol::TProtocol* xfer += oprot->writeFieldBegin("checkConstraints", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->checkConstraints.size())); - std::vector ::const_iterator _iter432; - for (_iter432 = this->checkConstraints.begin(); _iter432 != this->checkConstraints.end(); ++_iter432) + std::vector ::const_iterator _iter434; + for (_iter434 = this->checkConstraints.begin(); _iter434 != this->checkConstraints.end(); ++_iter434) { - xfer += (*_iter432).write(oprot); + xfer += (*_iter434).write(oprot); } xfer += oprot->writeListEnd(); } @@ -11701,11 +11807,11 @@ void swap(CheckConstraintsResponse &a, CheckConstraintsResponse &b) { swap(a.checkConstraints, b.checkConstraints); } -CheckConstraintsResponse::CheckConstraintsResponse(const CheckConstraintsResponse& other433) { - checkConstraints = other433.checkConstraints; +CheckConstraintsResponse::CheckConstraintsResponse(const CheckConstraintsResponse& other435) { + checkConstraints = other435.checkConstraints; } -CheckConstraintsResponse& CheckConstraintsResponse::operator=(const CheckConstraintsResponse& other434) { - checkConstraints = other434.checkConstraints; +CheckConstraintsResponse& CheckConstraintsResponse::operator=(const CheckConstraintsResponse& other436) { + checkConstraints = other436.checkConstraints; return *this; } void CheckConstraintsResponse::printTo(std::ostream& out) const { @@ -11847,19 +11953,19 @@ void swap(DropConstraintRequest &a, DropConstraintRequest &b) { swap(a.__isset, b.__isset); } -DropConstraintRequest::DropConstraintRequest(const DropConstraintRequest& other435) { - dbname = other435.dbname; - tablename = other435.tablename; - constraintname = other435.constraintname; - catName = other435.catName; - __isset = other435.__isset; +DropConstraintRequest::DropConstraintRequest(const DropConstraintRequest& other437) { + dbname = other437.dbname; + tablename = other437.tablename; + constraintname = other437.constraintname; + catName = other437.catName; + __isset = other437.__isset; } -DropConstraintRequest& DropConstraintRequest::operator=(const DropConstraintRequest& other436) { - dbname = other436.dbname; - tablename = other436.tablename; - constraintname = other436.constraintname; - catName = other436.catName; - __isset = other436.__isset; +DropConstraintRequest& DropConstraintRequest::operator=(const DropConstraintRequest& other438) { + dbname = other438.dbname; + tablename = other438.tablename; + constraintname = other438.constraintname; + catName = other438.catName; + __isset = other438.__isset; return *this; } void DropConstraintRequest::printTo(std::ostream& out) const { @@ -11907,14 +12013,14 @@ uint32_t AddPrimaryKeyRequest::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->primaryKeyCols.clear(); - uint32_t _size437; - ::apache::thrift::protocol::TType _etype440; - xfer += iprot->readListBegin(_etype440, _size437); - this->primaryKeyCols.resize(_size437); - uint32_t _i441; - for (_i441 = 0; _i441 < _size437; ++_i441) + uint32_t _size439; + ::apache::thrift::protocol::TType _etype442; + xfer += iprot->readListBegin(_etype442, _size439); + this->primaryKeyCols.resize(_size439); + uint32_t _i443; + for (_i443 = 0; _i443 < _size439; ++_i443) { - xfer += this->primaryKeyCols[_i441].read(iprot); + xfer += this->primaryKeyCols[_i443].read(iprot); } xfer += iprot->readListEnd(); } @@ -11945,10 +12051,10 @@ uint32_t AddPrimaryKeyRequest::write(::apache::thrift::protocol::TProtocol* opro xfer += oprot->writeFieldBegin("primaryKeyCols", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->primaryKeyCols.size())); - std::vector ::const_iterator _iter442; - for (_iter442 = this->primaryKeyCols.begin(); _iter442 != this->primaryKeyCols.end(); ++_iter442) + std::vector ::const_iterator _iter444; + for (_iter444 = this->primaryKeyCols.begin(); _iter444 != this->primaryKeyCols.end(); ++_iter444) { - xfer += (*_iter442).write(oprot); + xfer += (*_iter444).write(oprot); } xfer += oprot->writeListEnd(); } @@ -11964,11 +12070,11 @@ void swap(AddPrimaryKeyRequest &a, AddPrimaryKeyRequest &b) { swap(a.primaryKeyCols, b.primaryKeyCols); } -AddPrimaryKeyRequest::AddPrimaryKeyRequest(const AddPrimaryKeyRequest& other443) { - primaryKeyCols = other443.primaryKeyCols; +AddPrimaryKeyRequest::AddPrimaryKeyRequest(const AddPrimaryKeyRequest& other445) { + primaryKeyCols = other445.primaryKeyCols; } -AddPrimaryKeyRequest& AddPrimaryKeyRequest::operator=(const AddPrimaryKeyRequest& other444) { - primaryKeyCols = other444.primaryKeyCols; +AddPrimaryKeyRequest& AddPrimaryKeyRequest::operator=(const AddPrimaryKeyRequest& other446) { + primaryKeyCols = other446.primaryKeyCols; return *this; } void AddPrimaryKeyRequest::printTo(std::ostream& out) const { @@ -12013,14 +12119,14 @@ uint32_t AddForeignKeyRequest::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->foreignKeyCols.clear(); - uint32_t _size445; - ::apache::thrift::protocol::TType _etype448; - xfer += iprot->readListBegin(_etype448, _size445); - this->foreignKeyCols.resize(_size445); - uint32_t _i449; - for (_i449 = 0; _i449 < _size445; ++_i449) + uint32_t _size447; + ::apache::thrift::protocol::TType _etype450; + xfer += iprot->readListBegin(_etype450, _size447); + this->foreignKeyCols.resize(_size447); + uint32_t _i451; + for (_i451 = 0; _i451 < _size447; ++_i451) { - xfer += this->foreignKeyCols[_i449].read(iprot); + xfer += this->foreignKeyCols[_i451].read(iprot); } xfer += iprot->readListEnd(); } @@ -12051,10 +12157,10 @@ uint32_t AddForeignKeyRequest::write(::apache::thrift::protocol::TProtocol* opro xfer += oprot->writeFieldBegin("foreignKeyCols", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->foreignKeyCols.size())); - std::vector ::const_iterator _iter450; - for (_iter450 = this->foreignKeyCols.begin(); _iter450 != this->foreignKeyCols.end(); ++_iter450) + std::vector ::const_iterator _iter452; + for (_iter452 = this->foreignKeyCols.begin(); _iter452 != this->foreignKeyCols.end(); ++_iter452) { - xfer += (*_iter450).write(oprot); + xfer += (*_iter452).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12070,11 +12176,11 @@ void swap(AddForeignKeyRequest &a, AddForeignKeyRequest &b) { swap(a.foreignKeyCols, b.foreignKeyCols); } -AddForeignKeyRequest::AddForeignKeyRequest(const AddForeignKeyRequest& other451) { - foreignKeyCols = other451.foreignKeyCols; +AddForeignKeyRequest::AddForeignKeyRequest(const AddForeignKeyRequest& other453) { + foreignKeyCols = other453.foreignKeyCols; } -AddForeignKeyRequest& AddForeignKeyRequest::operator=(const AddForeignKeyRequest& other452) { - foreignKeyCols = other452.foreignKeyCols; +AddForeignKeyRequest& AddForeignKeyRequest::operator=(const AddForeignKeyRequest& other454) { + foreignKeyCols = other454.foreignKeyCols; return *this; } void AddForeignKeyRequest::printTo(std::ostream& out) const { @@ -12119,14 +12225,14 @@ uint32_t AddUniqueConstraintRequest::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->uniqueConstraintCols.clear(); - uint32_t _size453; - ::apache::thrift::protocol::TType _etype456; - xfer += iprot->readListBegin(_etype456, _size453); - this->uniqueConstraintCols.resize(_size453); - uint32_t _i457; - for (_i457 = 0; _i457 < _size453; ++_i457) + uint32_t _size455; + ::apache::thrift::protocol::TType _etype458; + xfer += iprot->readListBegin(_etype458, _size455); + this->uniqueConstraintCols.resize(_size455); + uint32_t _i459; + for (_i459 = 0; _i459 < _size455; ++_i459) { - xfer += this->uniqueConstraintCols[_i457].read(iprot); + xfer += this->uniqueConstraintCols[_i459].read(iprot); } xfer += iprot->readListEnd(); } @@ -12157,10 +12263,10 @@ uint32_t AddUniqueConstraintRequest::write(::apache::thrift::protocol::TProtocol xfer += oprot->writeFieldBegin("uniqueConstraintCols", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->uniqueConstraintCols.size())); - std::vector ::const_iterator _iter458; - for (_iter458 = this->uniqueConstraintCols.begin(); _iter458 != this->uniqueConstraintCols.end(); ++_iter458) + std::vector ::const_iterator _iter460; + for (_iter460 = this->uniqueConstraintCols.begin(); _iter460 != this->uniqueConstraintCols.end(); ++_iter460) { - xfer += (*_iter458).write(oprot); + xfer += (*_iter460).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12176,11 +12282,11 @@ void swap(AddUniqueConstraintRequest &a, AddUniqueConstraintRequest &b) { swap(a.uniqueConstraintCols, b.uniqueConstraintCols); } -AddUniqueConstraintRequest::AddUniqueConstraintRequest(const AddUniqueConstraintRequest& other459) { - uniqueConstraintCols = other459.uniqueConstraintCols; +AddUniqueConstraintRequest::AddUniqueConstraintRequest(const AddUniqueConstraintRequest& other461) { + uniqueConstraintCols = other461.uniqueConstraintCols; } -AddUniqueConstraintRequest& AddUniqueConstraintRequest::operator=(const AddUniqueConstraintRequest& other460) { - uniqueConstraintCols = other460.uniqueConstraintCols; +AddUniqueConstraintRequest& AddUniqueConstraintRequest::operator=(const AddUniqueConstraintRequest& other462) { + uniqueConstraintCols = other462.uniqueConstraintCols; return *this; } void AddUniqueConstraintRequest::printTo(std::ostream& out) const { @@ -12225,14 +12331,14 @@ uint32_t AddNotNullConstraintRequest::read(::apache::thrift::protocol::TProtocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->notNullConstraintCols.clear(); - uint32_t _size461; - ::apache::thrift::protocol::TType _etype464; - xfer += iprot->readListBegin(_etype464, _size461); - this->notNullConstraintCols.resize(_size461); - uint32_t _i465; - for (_i465 = 0; _i465 < _size461; ++_i465) + uint32_t _size463; + ::apache::thrift::protocol::TType _etype466; + xfer += iprot->readListBegin(_etype466, _size463); + this->notNullConstraintCols.resize(_size463); + uint32_t _i467; + for (_i467 = 0; _i467 < _size463; ++_i467) { - xfer += this->notNullConstraintCols[_i465].read(iprot); + xfer += this->notNullConstraintCols[_i467].read(iprot); } xfer += iprot->readListEnd(); } @@ -12263,10 +12369,10 @@ uint32_t AddNotNullConstraintRequest::write(::apache::thrift::protocol::TProtoco xfer += oprot->writeFieldBegin("notNullConstraintCols", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->notNullConstraintCols.size())); - std::vector ::const_iterator _iter466; - for (_iter466 = this->notNullConstraintCols.begin(); _iter466 != this->notNullConstraintCols.end(); ++_iter466) + std::vector ::const_iterator _iter468; + for (_iter468 = this->notNullConstraintCols.begin(); _iter468 != this->notNullConstraintCols.end(); ++_iter468) { - xfer += (*_iter466).write(oprot); + xfer += (*_iter468).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12282,11 +12388,11 @@ void swap(AddNotNullConstraintRequest &a, AddNotNullConstraintRequest &b) { swap(a.notNullConstraintCols, b.notNullConstraintCols); } -AddNotNullConstraintRequest::AddNotNullConstraintRequest(const AddNotNullConstraintRequest& other467) { - notNullConstraintCols = other467.notNullConstraintCols; +AddNotNullConstraintRequest::AddNotNullConstraintRequest(const AddNotNullConstraintRequest& other469) { + notNullConstraintCols = other469.notNullConstraintCols; } -AddNotNullConstraintRequest& AddNotNullConstraintRequest::operator=(const AddNotNullConstraintRequest& other468) { - notNullConstraintCols = other468.notNullConstraintCols; +AddNotNullConstraintRequest& AddNotNullConstraintRequest::operator=(const AddNotNullConstraintRequest& other470) { + notNullConstraintCols = other470.notNullConstraintCols; return *this; } void AddNotNullConstraintRequest::printTo(std::ostream& out) const { @@ -12331,14 +12437,14 @@ uint32_t AddDefaultConstraintRequest::read(::apache::thrift::protocol::TProtocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->defaultConstraintCols.clear(); - uint32_t _size469; - ::apache::thrift::protocol::TType _etype472; - xfer += iprot->readListBegin(_etype472, _size469); - this->defaultConstraintCols.resize(_size469); - uint32_t _i473; - for (_i473 = 0; _i473 < _size469; ++_i473) + uint32_t _size471; + ::apache::thrift::protocol::TType _etype474; + xfer += iprot->readListBegin(_etype474, _size471); + this->defaultConstraintCols.resize(_size471); + uint32_t _i475; + for (_i475 = 0; _i475 < _size471; ++_i475) { - xfer += this->defaultConstraintCols[_i473].read(iprot); + xfer += this->defaultConstraintCols[_i475].read(iprot); } xfer += iprot->readListEnd(); } @@ -12369,10 +12475,10 @@ uint32_t AddDefaultConstraintRequest::write(::apache::thrift::protocol::TProtoco xfer += oprot->writeFieldBegin("defaultConstraintCols", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->defaultConstraintCols.size())); - std::vector ::const_iterator _iter474; - for (_iter474 = this->defaultConstraintCols.begin(); _iter474 != this->defaultConstraintCols.end(); ++_iter474) + std::vector ::const_iterator _iter476; + for (_iter476 = this->defaultConstraintCols.begin(); _iter476 != this->defaultConstraintCols.end(); ++_iter476) { - xfer += (*_iter474).write(oprot); + xfer += (*_iter476).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12388,11 +12494,11 @@ void swap(AddDefaultConstraintRequest &a, AddDefaultConstraintRequest &b) { swap(a.defaultConstraintCols, b.defaultConstraintCols); } -AddDefaultConstraintRequest::AddDefaultConstraintRequest(const AddDefaultConstraintRequest& other475) { - defaultConstraintCols = other475.defaultConstraintCols; +AddDefaultConstraintRequest::AddDefaultConstraintRequest(const AddDefaultConstraintRequest& other477) { + defaultConstraintCols = other477.defaultConstraintCols; } -AddDefaultConstraintRequest& AddDefaultConstraintRequest::operator=(const AddDefaultConstraintRequest& other476) { - defaultConstraintCols = other476.defaultConstraintCols; +AddDefaultConstraintRequest& AddDefaultConstraintRequest::operator=(const AddDefaultConstraintRequest& other478) { + defaultConstraintCols = other478.defaultConstraintCols; return *this; } void AddDefaultConstraintRequest::printTo(std::ostream& out) const { @@ -12437,14 +12543,14 @@ uint32_t AddCheckConstraintRequest::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->checkConstraintCols.clear(); - uint32_t _size477; - ::apache::thrift::protocol::TType _etype480; - xfer += iprot->readListBegin(_etype480, _size477); - this->checkConstraintCols.resize(_size477); - uint32_t _i481; - for (_i481 = 0; _i481 < _size477; ++_i481) + uint32_t _size479; + ::apache::thrift::protocol::TType _etype482; + xfer += iprot->readListBegin(_etype482, _size479); + this->checkConstraintCols.resize(_size479); + uint32_t _i483; + for (_i483 = 0; _i483 < _size479; ++_i483) { - xfer += this->checkConstraintCols[_i481].read(iprot); + xfer += this->checkConstraintCols[_i483].read(iprot); } xfer += iprot->readListEnd(); } @@ -12475,10 +12581,10 @@ uint32_t AddCheckConstraintRequest::write(::apache::thrift::protocol::TProtocol* xfer += oprot->writeFieldBegin("checkConstraintCols", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->checkConstraintCols.size())); - std::vector ::const_iterator _iter482; - for (_iter482 = this->checkConstraintCols.begin(); _iter482 != this->checkConstraintCols.end(); ++_iter482) + std::vector ::const_iterator _iter484; + for (_iter484 = this->checkConstraintCols.begin(); _iter484 != this->checkConstraintCols.end(); ++_iter484) { - xfer += (*_iter482).write(oprot); + xfer += (*_iter484).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12494,11 +12600,11 @@ void swap(AddCheckConstraintRequest &a, AddCheckConstraintRequest &b) { swap(a.checkConstraintCols, b.checkConstraintCols); } -AddCheckConstraintRequest::AddCheckConstraintRequest(const AddCheckConstraintRequest& other483) { - checkConstraintCols = other483.checkConstraintCols; +AddCheckConstraintRequest::AddCheckConstraintRequest(const AddCheckConstraintRequest& other485) { + checkConstraintCols = other485.checkConstraintCols; } -AddCheckConstraintRequest& AddCheckConstraintRequest::operator=(const AddCheckConstraintRequest& other484) { - checkConstraintCols = other484.checkConstraintCols; +AddCheckConstraintRequest& AddCheckConstraintRequest::operator=(const AddCheckConstraintRequest& other486) { + checkConstraintCols = other486.checkConstraintCols; return *this; } void AddCheckConstraintRequest::printTo(std::ostream& out) const { @@ -12548,14 +12654,14 @@ uint32_t PartitionsByExprResult::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size485; - ::apache::thrift::protocol::TType _etype488; - xfer += iprot->readListBegin(_etype488, _size485); - this->partitions.resize(_size485); - uint32_t _i489; - for (_i489 = 0; _i489 < _size485; ++_i489) + uint32_t _size487; + ::apache::thrift::protocol::TType _etype490; + xfer += iprot->readListBegin(_etype490, _size487); + this->partitions.resize(_size487); + uint32_t _i491; + for (_i491 = 0; _i491 < _size487; ++_i491) { - xfer += this->partitions[_i489].read(iprot); + xfer += this->partitions[_i491].read(iprot); } xfer += iprot->readListEnd(); } @@ -12596,10 +12702,10 @@ uint32_t PartitionsByExprResult::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitions.size())); - std::vector ::const_iterator _iter490; - for (_iter490 = this->partitions.begin(); _iter490 != this->partitions.end(); ++_iter490) + std::vector ::const_iterator _iter492; + for (_iter492 = this->partitions.begin(); _iter492 != this->partitions.end(); ++_iter492) { - xfer += (*_iter490).write(oprot); + xfer += (*_iter492).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12620,13 +12726,13 @@ void swap(PartitionsByExprResult &a, PartitionsByExprResult &b) { swap(a.hasUnknownPartitions, b.hasUnknownPartitions); } -PartitionsByExprResult::PartitionsByExprResult(const PartitionsByExprResult& other491) { - partitions = other491.partitions; - hasUnknownPartitions = other491.hasUnknownPartitions; +PartitionsByExprResult::PartitionsByExprResult(const PartitionsByExprResult& other493) { + partitions = other493.partitions; + hasUnknownPartitions = other493.hasUnknownPartitions; } -PartitionsByExprResult& PartitionsByExprResult::operator=(const PartitionsByExprResult& other492) { - partitions = other492.partitions; - hasUnknownPartitions = other492.hasUnknownPartitions; +PartitionsByExprResult& PartitionsByExprResult::operator=(const PartitionsByExprResult& other494) { + partitions = other494.partitions; + hasUnknownPartitions = other494.hasUnknownPartitions; return *this; } void PartitionsByExprResult::printTo(std::ostream& out) const { @@ -12807,23 +12913,23 @@ void swap(PartitionsByExprRequest &a, PartitionsByExprRequest &b) { swap(a.__isset, b.__isset); } -PartitionsByExprRequest::PartitionsByExprRequest(const PartitionsByExprRequest& other493) { - dbName = other493.dbName; - tblName = other493.tblName; - expr = other493.expr; - defaultPartitionName = other493.defaultPartitionName; - maxParts = other493.maxParts; - catName = other493.catName; - __isset = other493.__isset; -} -PartitionsByExprRequest& PartitionsByExprRequest::operator=(const PartitionsByExprRequest& other494) { - dbName = other494.dbName; - tblName = other494.tblName; - expr = other494.expr; - defaultPartitionName = other494.defaultPartitionName; - maxParts = other494.maxParts; - catName = other494.catName; - __isset = other494.__isset; +PartitionsByExprRequest::PartitionsByExprRequest(const PartitionsByExprRequest& other495) { + dbName = other495.dbName; + tblName = other495.tblName; + expr = other495.expr; + defaultPartitionName = other495.defaultPartitionName; + maxParts = other495.maxParts; + catName = other495.catName; + __isset = other495.__isset; +} +PartitionsByExprRequest& PartitionsByExprRequest::operator=(const PartitionsByExprRequest& other496) { + dbName = other496.dbName; + tblName = other496.tblName; + expr = other496.expr; + defaultPartitionName = other496.defaultPartitionName; + maxParts = other496.maxParts; + catName = other496.catName; + __isset = other496.__isset; return *this; } void PartitionsByExprRequest::printTo(std::ostream& out) const { @@ -12873,14 +12979,14 @@ uint32_t TableStatsResult::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tableStats.clear(); - uint32_t _size495; - ::apache::thrift::protocol::TType _etype498; - xfer += iprot->readListBegin(_etype498, _size495); - this->tableStats.resize(_size495); - uint32_t _i499; - for (_i499 = 0; _i499 < _size495; ++_i499) + uint32_t _size497; + ::apache::thrift::protocol::TType _etype500; + xfer += iprot->readListBegin(_etype500, _size497); + this->tableStats.resize(_size497); + uint32_t _i501; + for (_i501 = 0; _i501 < _size497; ++_i501) { - xfer += this->tableStats[_i499].read(iprot); + xfer += this->tableStats[_i501].read(iprot); } xfer += iprot->readListEnd(); } @@ -12911,10 +13017,10 @@ uint32_t TableStatsResult::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("tableStats", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->tableStats.size())); - std::vector ::const_iterator _iter500; - for (_iter500 = this->tableStats.begin(); _iter500 != this->tableStats.end(); ++_iter500) + std::vector ::const_iterator _iter502; + for (_iter502 = this->tableStats.begin(); _iter502 != this->tableStats.end(); ++_iter502) { - xfer += (*_iter500).write(oprot); + xfer += (*_iter502).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12930,11 +13036,11 @@ void swap(TableStatsResult &a, TableStatsResult &b) { swap(a.tableStats, b.tableStats); } -TableStatsResult::TableStatsResult(const TableStatsResult& other501) { - tableStats = other501.tableStats; +TableStatsResult::TableStatsResult(const TableStatsResult& other503) { + tableStats = other503.tableStats; } -TableStatsResult& TableStatsResult::operator=(const TableStatsResult& other502) { - tableStats = other502.tableStats; +TableStatsResult& TableStatsResult::operator=(const TableStatsResult& other504) { + tableStats = other504.tableStats; return *this; } void TableStatsResult::printTo(std::ostream& out) const { @@ -12979,26 +13085,26 @@ uint32_t PartitionsStatsResult::read(::apache::thrift::protocol::TProtocol* ipro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partStats.clear(); - uint32_t _size503; - ::apache::thrift::protocol::TType _ktype504; - ::apache::thrift::protocol::TType _vtype505; - xfer += iprot->readMapBegin(_ktype504, _vtype505, _size503); - uint32_t _i507; - for (_i507 = 0; _i507 < _size503; ++_i507) + uint32_t _size505; + ::apache::thrift::protocol::TType _ktype506; + ::apache::thrift::protocol::TType _vtype507; + xfer += iprot->readMapBegin(_ktype506, _vtype507, _size505); + uint32_t _i509; + for (_i509 = 0; _i509 < _size505; ++_i509) { - std::string _key508; - xfer += iprot->readString(_key508); - std::vector & _val509 = this->partStats[_key508]; + std::string _key510; + xfer += iprot->readString(_key510); + std::vector & _val511 = this->partStats[_key510]; { - _val509.clear(); - uint32_t _size510; - ::apache::thrift::protocol::TType _etype513; - xfer += iprot->readListBegin(_etype513, _size510); - _val509.resize(_size510); - uint32_t _i514; - for (_i514 = 0; _i514 < _size510; ++_i514) + _val511.clear(); + uint32_t _size512; + ::apache::thrift::protocol::TType _etype515; + xfer += iprot->readListBegin(_etype515, _size512); + _val511.resize(_size512); + uint32_t _i516; + for (_i516 = 0; _i516 < _size512; ++_i516) { - xfer += _val509[_i514].read(iprot); + xfer += _val511[_i516].read(iprot); } xfer += iprot->readListEnd(); } @@ -13032,16 +13138,16 @@ uint32_t PartitionsStatsResult::write(::apache::thrift::protocol::TProtocol* opr xfer += oprot->writeFieldBegin("partStats", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_LIST, static_cast(this->partStats.size())); - std::map > ::const_iterator _iter515; - for (_iter515 = this->partStats.begin(); _iter515 != this->partStats.end(); ++_iter515) + std::map > ::const_iterator _iter517; + for (_iter517 = this->partStats.begin(); _iter517 != this->partStats.end(); ++_iter517) { - xfer += oprot->writeString(_iter515->first); + xfer += oprot->writeString(_iter517->first); { - xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(_iter515->second.size())); - std::vector ::const_iterator _iter516; - for (_iter516 = _iter515->second.begin(); _iter516 != _iter515->second.end(); ++_iter516) + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(_iter517->second.size())); + std::vector ::const_iterator _iter518; + for (_iter518 = _iter517->second.begin(); _iter518 != _iter517->second.end(); ++_iter518) { - xfer += (*_iter516).write(oprot); + xfer += (*_iter518).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13060,11 +13166,11 @@ void swap(PartitionsStatsResult &a, PartitionsStatsResult &b) { swap(a.partStats, b.partStats); } -PartitionsStatsResult::PartitionsStatsResult(const PartitionsStatsResult& other517) { - partStats = other517.partStats; +PartitionsStatsResult::PartitionsStatsResult(const PartitionsStatsResult& other519) { + partStats = other519.partStats; } -PartitionsStatsResult& PartitionsStatsResult::operator=(const PartitionsStatsResult& other518) { - partStats = other518.partStats; +PartitionsStatsResult& PartitionsStatsResult::operator=(const PartitionsStatsResult& other520) { + partStats = other520.partStats; return *this; } void PartitionsStatsResult::printTo(std::ostream& out) const { @@ -13140,14 +13246,14 @@ uint32_t TableStatsRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->colNames.clear(); - uint32_t _size519; - ::apache::thrift::protocol::TType _etype522; - xfer += iprot->readListBegin(_etype522, _size519); - this->colNames.resize(_size519); - uint32_t _i523; - for (_i523 = 0; _i523 < _size519; ++_i523) + uint32_t _size521; + ::apache::thrift::protocol::TType _etype524; + xfer += iprot->readListBegin(_etype524, _size521); + this->colNames.resize(_size521); + uint32_t _i525; + for (_i525 = 0; _i525 < _size521; ++_i525) { - xfer += iprot->readString(this->colNames[_i523]); + xfer += iprot->readString(this->colNames[_i525]); } xfer += iprot->readListEnd(); } @@ -13198,10 +13304,10 @@ uint32_t TableStatsRequest::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("colNames", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->colNames.size())); - std::vector ::const_iterator _iter524; - for (_iter524 = this->colNames.begin(); _iter524 != this->colNames.end(); ++_iter524) + std::vector ::const_iterator _iter526; + for (_iter526 = this->colNames.begin(); _iter526 != this->colNames.end(); ++_iter526) { - xfer += oprot->writeString((*_iter524)); + xfer += oprot->writeString((*_iter526)); } xfer += oprot->writeListEnd(); } @@ -13226,19 +13332,19 @@ void swap(TableStatsRequest &a, TableStatsRequest &b) { swap(a.__isset, b.__isset); } -TableStatsRequest::TableStatsRequest(const TableStatsRequest& other525) { - dbName = other525.dbName; - tblName = other525.tblName; - colNames = other525.colNames; - catName = other525.catName; - __isset = other525.__isset; +TableStatsRequest::TableStatsRequest(const TableStatsRequest& other527) { + dbName = other527.dbName; + tblName = other527.tblName; + colNames = other527.colNames; + catName = other527.catName; + __isset = other527.__isset; } -TableStatsRequest& TableStatsRequest::operator=(const TableStatsRequest& other526) { - dbName = other526.dbName; - tblName = other526.tblName; - colNames = other526.colNames; - catName = other526.catName; - __isset = other526.__isset; +TableStatsRequest& TableStatsRequest::operator=(const TableStatsRequest& other528) { + dbName = other528.dbName; + tblName = other528.tblName; + colNames = other528.colNames; + catName = other528.catName; + __isset = other528.__isset; return *this; } void TableStatsRequest::printTo(std::ostream& out) const { @@ -13322,14 +13428,14 @@ uint32_t PartitionsStatsRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->colNames.clear(); - uint32_t _size527; - ::apache::thrift::protocol::TType _etype530; - xfer += iprot->readListBegin(_etype530, _size527); - this->colNames.resize(_size527); - uint32_t _i531; - for (_i531 = 0; _i531 < _size527; ++_i531) + uint32_t _size529; + ::apache::thrift::protocol::TType _etype532; + xfer += iprot->readListBegin(_etype532, _size529); + this->colNames.resize(_size529); + uint32_t _i533; + for (_i533 = 0; _i533 < _size529; ++_i533) { - xfer += iprot->readString(this->colNames[_i531]); + xfer += iprot->readString(this->colNames[_i533]); } xfer += iprot->readListEnd(); } @@ -13342,14 +13448,14 @@ uint32_t PartitionsStatsRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partNames.clear(); - uint32_t _size532; - ::apache::thrift::protocol::TType _etype535; - xfer += iprot->readListBegin(_etype535, _size532); - this->partNames.resize(_size532); - uint32_t _i536; - for (_i536 = 0; _i536 < _size532; ++_i536) + uint32_t _size534; + ::apache::thrift::protocol::TType _etype537; + xfer += iprot->readListBegin(_etype537, _size534); + this->partNames.resize(_size534); + uint32_t _i538; + for (_i538 = 0; _i538 < _size534; ++_i538) { - xfer += iprot->readString(this->partNames[_i536]); + xfer += iprot->readString(this->partNames[_i538]); } xfer += iprot->readListEnd(); } @@ -13402,10 +13508,10 @@ uint32_t PartitionsStatsRequest::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("colNames", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->colNames.size())); - std::vector ::const_iterator _iter537; - for (_iter537 = this->colNames.begin(); _iter537 != this->colNames.end(); ++_iter537) + std::vector ::const_iterator _iter539; + for (_iter539 = this->colNames.begin(); _iter539 != this->colNames.end(); ++_iter539) { - xfer += oprot->writeString((*_iter537)); + xfer += oprot->writeString((*_iter539)); } xfer += oprot->writeListEnd(); } @@ -13414,10 +13520,10 @@ uint32_t PartitionsStatsRequest::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("partNames", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partNames.size())); - std::vector ::const_iterator _iter538; - for (_iter538 = this->partNames.begin(); _iter538 != this->partNames.end(); ++_iter538) + std::vector ::const_iterator _iter540; + for (_iter540 = this->partNames.begin(); _iter540 != this->partNames.end(); ++_iter540) { - xfer += oprot->writeString((*_iter538)); + xfer += oprot->writeString((*_iter540)); } xfer += oprot->writeListEnd(); } @@ -13443,21 +13549,21 @@ void swap(PartitionsStatsRequest &a, PartitionsStatsRequest &b) { swap(a.__isset, b.__isset); } -PartitionsStatsRequest::PartitionsStatsRequest(const PartitionsStatsRequest& other539) { - dbName = other539.dbName; - tblName = other539.tblName; - colNames = other539.colNames; - partNames = other539.partNames; - catName = other539.catName; - __isset = other539.__isset; -} -PartitionsStatsRequest& PartitionsStatsRequest::operator=(const PartitionsStatsRequest& other540) { - dbName = other540.dbName; - tblName = other540.tblName; - colNames = other540.colNames; - partNames = other540.partNames; - catName = other540.catName; - __isset = other540.__isset; +PartitionsStatsRequest::PartitionsStatsRequest(const PartitionsStatsRequest& other541) { + dbName = other541.dbName; + tblName = other541.tblName; + colNames = other541.colNames; + partNames = other541.partNames; + catName = other541.catName; + __isset = other541.__isset; +} +PartitionsStatsRequest& PartitionsStatsRequest::operator=(const PartitionsStatsRequest& other542) { + dbName = other542.dbName; + tblName = other542.tblName; + colNames = other542.colNames; + partNames = other542.partNames; + catName = other542.catName; + __isset = other542.__isset; return *this; } void PartitionsStatsRequest::printTo(std::ostream& out) const { @@ -13506,14 +13612,14 @@ uint32_t AddPartitionsResult::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size541; - ::apache::thrift::protocol::TType _etype544; - xfer += iprot->readListBegin(_etype544, _size541); - this->partitions.resize(_size541); - uint32_t _i545; - for (_i545 = 0; _i545 < _size541; ++_i545) + uint32_t _size543; + ::apache::thrift::protocol::TType _etype546; + xfer += iprot->readListBegin(_etype546, _size543); + this->partitions.resize(_size543); + uint32_t _i547; + for (_i547 = 0; _i547 < _size543; ++_i547) { - xfer += this->partitions[_i545].read(iprot); + xfer += this->partitions[_i547].read(iprot); } xfer += iprot->readListEnd(); } @@ -13543,10 +13649,10 @@ uint32_t AddPartitionsResult::write(::apache::thrift::protocol::TProtocol* oprot xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitions.size())); - std::vector ::const_iterator _iter546; - for (_iter546 = this->partitions.begin(); _iter546 != this->partitions.end(); ++_iter546) + std::vector ::const_iterator _iter548; + for (_iter548 = this->partitions.begin(); _iter548 != this->partitions.end(); ++_iter548) { - xfer += (*_iter546).write(oprot); + xfer += (*_iter548).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13563,13 +13669,13 @@ void swap(AddPartitionsResult &a, AddPartitionsResult &b) { swap(a.__isset, b.__isset); } -AddPartitionsResult::AddPartitionsResult(const AddPartitionsResult& other547) { - partitions = other547.partitions; - __isset = other547.__isset; +AddPartitionsResult::AddPartitionsResult(const AddPartitionsResult& other549) { + partitions = other549.partitions; + __isset = other549.__isset; } -AddPartitionsResult& AddPartitionsResult::operator=(const AddPartitionsResult& other548) { - partitions = other548.partitions; - __isset = other548.__isset; +AddPartitionsResult& AddPartitionsResult::operator=(const AddPartitionsResult& other550) { + partitions = other550.partitions; + __isset = other550.__isset; return *this; } void AddPartitionsResult::printTo(std::ostream& out) const { @@ -13655,14 +13761,14 @@ uint32_t AddPartitionsRequest::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->parts.clear(); - uint32_t _size549; - ::apache::thrift::protocol::TType _etype552; - xfer += iprot->readListBegin(_etype552, _size549); - this->parts.resize(_size549); - uint32_t _i553; - for (_i553 = 0; _i553 < _size549; ++_i553) + uint32_t _size551; + ::apache::thrift::protocol::TType _etype554; + xfer += iprot->readListBegin(_etype554, _size551); + this->parts.resize(_size551); + uint32_t _i555; + for (_i555 = 0; _i555 < _size551; ++_i555) { - xfer += this->parts[_i553].read(iprot); + xfer += this->parts[_i555].read(iprot); } xfer += iprot->readListEnd(); } @@ -13731,10 +13837,10 @@ uint32_t AddPartitionsRequest::write(::apache::thrift::protocol::TProtocol* opro xfer += oprot->writeFieldBegin("parts", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->parts.size())); - std::vector ::const_iterator _iter554; - for (_iter554 = this->parts.begin(); _iter554 != this->parts.end(); ++_iter554) + std::vector ::const_iterator _iter556; + for (_iter556 = this->parts.begin(); _iter556 != this->parts.end(); ++_iter556) { - xfer += (*_iter554).write(oprot); + xfer += (*_iter556).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13770,23 +13876,23 @@ void swap(AddPartitionsRequest &a, AddPartitionsRequest &b) { swap(a.__isset, b.__isset); } -AddPartitionsRequest::AddPartitionsRequest(const AddPartitionsRequest& other555) { - dbName = other555.dbName; - tblName = other555.tblName; - parts = other555.parts; - ifNotExists = other555.ifNotExists; - needResult = other555.needResult; - catName = other555.catName; - __isset = other555.__isset; -} -AddPartitionsRequest& AddPartitionsRequest::operator=(const AddPartitionsRequest& other556) { - dbName = other556.dbName; - tblName = other556.tblName; - parts = other556.parts; - ifNotExists = other556.ifNotExists; - needResult = other556.needResult; - catName = other556.catName; - __isset = other556.__isset; +AddPartitionsRequest::AddPartitionsRequest(const AddPartitionsRequest& other557) { + dbName = other557.dbName; + tblName = other557.tblName; + parts = other557.parts; + ifNotExists = other557.ifNotExists; + needResult = other557.needResult; + catName = other557.catName; + __isset = other557.__isset; +} +AddPartitionsRequest& AddPartitionsRequest::operator=(const AddPartitionsRequest& other558) { + dbName = other558.dbName; + tblName = other558.tblName; + parts = other558.parts; + ifNotExists = other558.ifNotExists; + needResult = other558.needResult; + catName = other558.catName; + __isset = other558.__isset; return *this; } void AddPartitionsRequest::printTo(std::ostream& out) const { @@ -13836,14 +13942,14 @@ uint32_t DropPartitionsResult::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size557; - ::apache::thrift::protocol::TType _etype560; - xfer += iprot->readListBegin(_etype560, _size557); - this->partitions.resize(_size557); - uint32_t _i561; - for (_i561 = 0; _i561 < _size557; ++_i561) + uint32_t _size559; + ::apache::thrift::protocol::TType _etype562; + xfer += iprot->readListBegin(_etype562, _size559); + this->partitions.resize(_size559); + uint32_t _i563; + for (_i563 = 0; _i563 < _size559; ++_i563) { - xfer += this->partitions[_i561].read(iprot); + xfer += this->partitions[_i563].read(iprot); } xfer += iprot->readListEnd(); } @@ -13873,10 +13979,10 @@ uint32_t DropPartitionsResult::write(::apache::thrift::protocol::TProtocol* opro xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitions.size())); - std::vector ::const_iterator _iter562; - for (_iter562 = this->partitions.begin(); _iter562 != this->partitions.end(); ++_iter562) + std::vector ::const_iterator _iter564; + for (_iter564 = this->partitions.begin(); _iter564 != this->partitions.end(); ++_iter564) { - xfer += (*_iter562).write(oprot); + xfer += (*_iter564).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13893,13 +13999,13 @@ void swap(DropPartitionsResult &a, DropPartitionsResult &b) { swap(a.__isset, b.__isset); } -DropPartitionsResult::DropPartitionsResult(const DropPartitionsResult& other563) { - partitions = other563.partitions; - __isset = other563.__isset; +DropPartitionsResult::DropPartitionsResult(const DropPartitionsResult& other565) { + partitions = other565.partitions; + __isset = other565.__isset; } -DropPartitionsResult& DropPartitionsResult::operator=(const DropPartitionsResult& other564) { - partitions = other564.partitions; - __isset = other564.__isset; +DropPartitionsResult& DropPartitionsResult::operator=(const DropPartitionsResult& other566) { + partitions = other566.partitions; + __isset = other566.__isset; return *this; } void DropPartitionsResult::printTo(std::ostream& out) const { @@ -14001,15 +14107,15 @@ void swap(DropPartitionsExpr &a, DropPartitionsExpr &b) { swap(a.__isset, b.__isset); } -DropPartitionsExpr::DropPartitionsExpr(const DropPartitionsExpr& other565) { - expr = other565.expr; - partArchiveLevel = other565.partArchiveLevel; - __isset = other565.__isset; +DropPartitionsExpr::DropPartitionsExpr(const DropPartitionsExpr& other567) { + expr = other567.expr; + partArchiveLevel = other567.partArchiveLevel; + __isset = other567.__isset; } -DropPartitionsExpr& DropPartitionsExpr::operator=(const DropPartitionsExpr& other566) { - expr = other566.expr; - partArchiveLevel = other566.partArchiveLevel; - __isset = other566.__isset; +DropPartitionsExpr& DropPartitionsExpr::operator=(const DropPartitionsExpr& other568) { + expr = other568.expr; + partArchiveLevel = other568.partArchiveLevel; + __isset = other568.__isset; return *this; } void DropPartitionsExpr::printTo(std::ostream& out) const { @@ -14058,14 +14164,14 @@ uint32_t RequestPartsSpec::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->names.clear(); - uint32_t _size567; - ::apache::thrift::protocol::TType _etype570; - xfer += iprot->readListBegin(_etype570, _size567); - this->names.resize(_size567); - uint32_t _i571; - for (_i571 = 0; _i571 < _size567; ++_i571) + uint32_t _size569; + ::apache::thrift::protocol::TType _etype572; + xfer += iprot->readListBegin(_etype572, _size569); + this->names.resize(_size569); + uint32_t _i573; + for (_i573 = 0; _i573 < _size569; ++_i573) { - xfer += iprot->readString(this->names[_i571]); + xfer += iprot->readString(this->names[_i573]); } xfer += iprot->readListEnd(); } @@ -14078,14 +14184,14 @@ uint32_t RequestPartsSpec::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->exprs.clear(); - uint32_t _size572; - ::apache::thrift::protocol::TType _etype575; - xfer += iprot->readListBegin(_etype575, _size572); - this->exprs.resize(_size572); - uint32_t _i576; - for (_i576 = 0; _i576 < _size572; ++_i576) + uint32_t _size574; + ::apache::thrift::protocol::TType _etype577; + xfer += iprot->readListBegin(_etype577, _size574); + this->exprs.resize(_size574); + uint32_t _i578; + for (_i578 = 0; _i578 < _size574; ++_i578) { - xfer += this->exprs[_i576].read(iprot); + xfer += this->exprs[_i578].read(iprot); } xfer += iprot->readListEnd(); } @@ -14114,10 +14220,10 @@ uint32_t RequestPartsSpec::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("names", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->names.size())); - std::vector ::const_iterator _iter577; - for (_iter577 = this->names.begin(); _iter577 != this->names.end(); ++_iter577) + std::vector ::const_iterator _iter579; + for (_iter579 = this->names.begin(); _iter579 != this->names.end(); ++_iter579) { - xfer += oprot->writeString((*_iter577)); + xfer += oprot->writeString((*_iter579)); } xfer += oprot->writeListEnd(); } @@ -14126,10 +14232,10 @@ uint32_t RequestPartsSpec::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("exprs", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->exprs.size())); - std::vector ::const_iterator _iter578; - for (_iter578 = this->exprs.begin(); _iter578 != this->exprs.end(); ++_iter578) + std::vector ::const_iterator _iter580; + for (_iter580 = this->exprs.begin(); _iter580 != this->exprs.end(); ++_iter580) { - xfer += (*_iter578).write(oprot); + xfer += (*_iter580).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14147,15 +14253,15 @@ void swap(RequestPartsSpec &a, RequestPartsSpec &b) { swap(a.__isset, b.__isset); } -RequestPartsSpec::RequestPartsSpec(const RequestPartsSpec& other579) { - names = other579.names; - exprs = other579.exprs; - __isset = other579.__isset; +RequestPartsSpec::RequestPartsSpec(const RequestPartsSpec& other581) { + names = other581.names; + exprs = other581.exprs; + __isset = other581.__isset; } -RequestPartsSpec& RequestPartsSpec::operator=(const RequestPartsSpec& other580) { - names = other580.names; - exprs = other580.exprs; - __isset = other580.__isset; +RequestPartsSpec& RequestPartsSpec::operator=(const RequestPartsSpec& other582) { + names = other582.names; + exprs = other582.exprs; + __isset = other582.__isset; return *this; } void RequestPartsSpec::printTo(std::ostream& out) const { @@ -14393,29 +14499,29 @@ void swap(DropPartitionsRequest &a, DropPartitionsRequest &b) { swap(a.__isset, b.__isset); } -DropPartitionsRequest::DropPartitionsRequest(const DropPartitionsRequest& other581) { - dbName = other581.dbName; - tblName = other581.tblName; - parts = other581.parts; - deleteData = other581.deleteData; - ifExists = other581.ifExists; - ignoreProtection = other581.ignoreProtection; - environmentContext = other581.environmentContext; - needResult = other581.needResult; - catName = other581.catName; - __isset = other581.__isset; -} -DropPartitionsRequest& DropPartitionsRequest::operator=(const DropPartitionsRequest& other582) { - dbName = other582.dbName; - tblName = other582.tblName; - parts = other582.parts; - deleteData = other582.deleteData; - ifExists = other582.ifExists; - ignoreProtection = other582.ignoreProtection; - environmentContext = other582.environmentContext; - needResult = other582.needResult; - catName = other582.catName; - __isset = other582.__isset; +DropPartitionsRequest::DropPartitionsRequest(const DropPartitionsRequest& other583) { + dbName = other583.dbName; + tblName = other583.tblName; + parts = other583.parts; + deleteData = other583.deleteData; + ifExists = other583.ifExists; + ignoreProtection = other583.ignoreProtection; + environmentContext = other583.environmentContext; + needResult = other583.needResult; + catName = other583.catName; + __isset = other583.__isset; +} +DropPartitionsRequest& DropPartitionsRequest::operator=(const DropPartitionsRequest& other584) { + dbName = other584.dbName; + tblName = other584.tblName; + parts = other584.parts; + deleteData = other584.deleteData; + ifExists = other584.ifExists; + ignoreProtection = other584.ignoreProtection; + environmentContext = other584.environmentContext; + needResult = other584.needResult; + catName = other584.catName; + __isset = other584.__isset; return *this; } void DropPartitionsRequest::printTo(std::ostream& out) const { @@ -14524,14 +14630,14 @@ uint32_t PartitionValuesRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionKeys.clear(); - uint32_t _size583; - ::apache::thrift::protocol::TType _etype586; - xfer += iprot->readListBegin(_etype586, _size583); - this->partitionKeys.resize(_size583); - uint32_t _i587; - for (_i587 = 0; _i587 < _size583; ++_i587) + uint32_t _size585; + ::apache::thrift::protocol::TType _etype588; + xfer += iprot->readListBegin(_etype588, _size585); + this->partitionKeys.resize(_size585); + uint32_t _i589; + for (_i589 = 0; _i589 < _size585; ++_i589) { - xfer += this->partitionKeys[_i587].read(iprot); + xfer += this->partitionKeys[_i589].read(iprot); } xfer += iprot->readListEnd(); } @@ -14560,14 +14666,14 @@ uint32_t PartitionValuesRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionOrder.clear(); - uint32_t _size588; - ::apache::thrift::protocol::TType _etype591; - xfer += iprot->readListBegin(_etype591, _size588); - this->partitionOrder.resize(_size588); - uint32_t _i592; - for (_i592 = 0; _i592 < _size588; ++_i592) + uint32_t _size590; + ::apache::thrift::protocol::TType _etype593; + xfer += iprot->readListBegin(_etype593, _size590); + this->partitionOrder.resize(_size590); + uint32_t _i594; + for (_i594 = 0; _i594 < _size590; ++_i594) { - xfer += this->partitionOrder[_i592].read(iprot); + xfer += this->partitionOrder[_i594].read(iprot); } xfer += iprot->readListEnd(); } @@ -14634,10 +14740,10 @@ uint32_t PartitionValuesRequest::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("partitionKeys", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitionKeys.size())); - std::vector ::const_iterator _iter593; - for (_iter593 = this->partitionKeys.begin(); _iter593 != this->partitionKeys.end(); ++_iter593) + std::vector ::const_iterator _iter595; + for (_iter595 = this->partitionKeys.begin(); _iter595 != this->partitionKeys.end(); ++_iter595) { - xfer += (*_iter593).write(oprot); + xfer += (*_iter595).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14657,10 +14763,10 @@ uint32_t PartitionValuesRequest::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("partitionOrder", ::apache::thrift::protocol::T_LIST, 6); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitionOrder.size())); - std::vector ::const_iterator _iter594; - for (_iter594 = this->partitionOrder.begin(); _iter594 != this->partitionOrder.end(); ++_iter594) + std::vector ::const_iterator _iter596; + for (_iter596 = this->partitionOrder.begin(); _iter596 != this->partitionOrder.end(); ++_iter596) { - xfer += (*_iter594).write(oprot); + xfer += (*_iter596).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14700,29 +14806,29 @@ void swap(PartitionValuesRequest &a, PartitionValuesRequest &b) { swap(a.__isset, b.__isset); } -PartitionValuesRequest::PartitionValuesRequest(const PartitionValuesRequest& other595) { - dbName = other595.dbName; - tblName = other595.tblName; - partitionKeys = other595.partitionKeys; - applyDistinct = other595.applyDistinct; - filter = other595.filter; - partitionOrder = other595.partitionOrder; - ascending = other595.ascending; - maxParts = other595.maxParts; - catName = other595.catName; - __isset = other595.__isset; -} -PartitionValuesRequest& PartitionValuesRequest::operator=(const PartitionValuesRequest& other596) { - dbName = other596.dbName; - tblName = other596.tblName; - partitionKeys = other596.partitionKeys; - applyDistinct = other596.applyDistinct; - filter = other596.filter; - partitionOrder = other596.partitionOrder; - ascending = other596.ascending; - maxParts = other596.maxParts; - catName = other596.catName; - __isset = other596.__isset; +PartitionValuesRequest::PartitionValuesRequest(const PartitionValuesRequest& other597) { + dbName = other597.dbName; + tblName = other597.tblName; + partitionKeys = other597.partitionKeys; + applyDistinct = other597.applyDistinct; + filter = other597.filter; + partitionOrder = other597.partitionOrder; + ascending = other597.ascending; + maxParts = other597.maxParts; + catName = other597.catName; + __isset = other597.__isset; +} +PartitionValuesRequest& PartitionValuesRequest::operator=(const PartitionValuesRequest& other598) { + dbName = other598.dbName; + tblName = other598.tblName; + partitionKeys = other598.partitionKeys; + applyDistinct = other598.applyDistinct; + filter = other598.filter; + partitionOrder = other598.partitionOrder; + ascending = other598.ascending; + maxParts = other598.maxParts; + catName = other598.catName; + __isset = other598.__isset; return *this; } void PartitionValuesRequest::printTo(std::ostream& out) const { @@ -14775,14 +14881,14 @@ uint32_t PartitionValuesRow::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->row.clear(); - uint32_t _size597; - ::apache::thrift::protocol::TType _etype600; - xfer += iprot->readListBegin(_etype600, _size597); - this->row.resize(_size597); - uint32_t _i601; - for (_i601 = 0; _i601 < _size597; ++_i601) + uint32_t _size599; + ::apache::thrift::protocol::TType _etype602; + xfer += iprot->readListBegin(_etype602, _size599); + this->row.resize(_size599); + uint32_t _i603; + for (_i603 = 0; _i603 < _size599; ++_i603) { - xfer += iprot->readString(this->row[_i601]); + xfer += iprot->readString(this->row[_i603]); } xfer += iprot->readListEnd(); } @@ -14813,10 +14919,10 @@ uint32_t PartitionValuesRow::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->row.size())); - std::vector ::const_iterator _iter602; - for (_iter602 = this->row.begin(); _iter602 != this->row.end(); ++_iter602) + std::vector ::const_iterator _iter604; + for (_iter604 = this->row.begin(); _iter604 != this->row.end(); ++_iter604) { - xfer += oprot->writeString((*_iter602)); + xfer += oprot->writeString((*_iter604)); } xfer += oprot->writeListEnd(); } @@ -14832,11 +14938,11 @@ void swap(PartitionValuesRow &a, PartitionValuesRow &b) { swap(a.row, b.row); } -PartitionValuesRow::PartitionValuesRow(const PartitionValuesRow& other603) { - row = other603.row; +PartitionValuesRow::PartitionValuesRow(const PartitionValuesRow& other605) { + row = other605.row; } -PartitionValuesRow& PartitionValuesRow::operator=(const PartitionValuesRow& other604) { - row = other604.row; +PartitionValuesRow& PartitionValuesRow::operator=(const PartitionValuesRow& other606) { + row = other606.row; return *this; } void PartitionValuesRow::printTo(std::ostream& out) const { @@ -14881,14 +14987,14 @@ uint32_t PartitionValuesResponse::read(::apache::thrift::protocol::TProtocol* ip if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionValues.clear(); - uint32_t _size605; - ::apache::thrift::protocol::TType _etype608; - xfer += iprot->readListBegin(_etype608, _size605); - this->partitionValues.resize(_size605); - uint32_t _i609; - for (_i609 = 0; _i609 < _size605; ++_i609) + uint32_t _size607; + ::apache::thrift::protocol::TType _etype610; + xfer += iprot->readListBegin(_etype610, _size607); + this->partitionValues.resize(_size607); + uint32_t _i611; + for (_i611 = 0; _i611 < _size607; ++_i611) { - xfer += this->partitionValues[_i609].read(iprot); + xfer += this->partitionValues[_i611].read(iprot); } xfer += iprot->readListEnd(); } @@ -14919,10 +15025,10 @@ uint32_t PartitionValuesResponse::write(::apache::thrift::protocol::TProtocol* o xfer += oprot->writeFieldBegin("partitionValues", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitionValues.size())); - std::vector ::const_iterator _iter610; - for (_iter610 = this->partitionValues.begin(); _iter610 != this->partitionValues.end(); ++_iter610) + std::vector ::const_iterator _iter612; + for (_iter612 = this->partitionValues.begin(); _iter612 != this->partitionValues.end(); ++_iter612) { - xfer += (*_iter610).write(oprot); + xfer += (*_iter612).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14938,11 +15044,11 @@ void swap(PartitionValuesResponse &a, PartitionValuesResponse &b) { swap(a.partitionValues, b.partitionValues); } -PartitionValuesResponse::PartitionValuesResponse(const PartitionValuesResponse& other611) { - partitionValues = other611.partitionValues; +PartitionValuesResponse::PartitionValuesResponse(const PartitionValuesResponse& other613) { + partitionValues = other613.partitionValues; } -PartitionValuesResponse& PartitionValuesResponse::operator=(const PartitionValuesResponse& other612) { - partitionValues = other612.partitionValues; +PartitionValuesResponse& PartitionValuesResponse::operator=(const PartitionValuesResponse& other614) { + partitionValues = other614.partitionValues; return *this; } void PartitionValuesResponse::printTo(std::ostream& out) const { @@ -14988,9 +15094,9 @@ uint32_t ResourceUri::read(::apache::thrift::protocol::TProtocol* iprot) { { case 1: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast613; - xfer += iprot->readI32(ecast613); - this->resourceType = (ResourceType::type)ecast613; + int32_t ecast615; + xfer += iprot->readI32(ecast615); + this->resourceType = (ResourceType::type)ecast615; this->__isset.resourceType = true; } else { xfer += iprot->skip(ftype); @@ -15041,15 +15147,15 @@ void swap(ResourceUri &a, ResourceUri &b) { swap(a.__isset, b.__isset); } -ResourceUri::ResourceUri(const ResourceUri& other614) { - resourceType = other614.resourceType; - uri = other614.uri; - __isset = other614.__isset; +ResourceUri::ResourceUri(const ResourceUri& other616) { + resourceType = other616.resourceType; + uri = other616.uri; + __isset = other616.__isset; } -ResourceUri& ResourceUri::operator=(const ResourceUri& other615) { - resourceType = other615.resourceType; - uri = other615.uri; - __isset = other615.__isset; +ResourceUri& ResourceUri::operator=(const ResourceUri& other617) { + resourceType = other617.resourceType; + uri = other617.uri; + __isset = other617.__isset; return *this; } void ResourceUri::printTo(std::ostream& out) const { @@ -15157,9 +15263,9 @@ uint32_t Function::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast616; - xfer += iprot->readI32(ecast616); - this->ownerType = (PrincipalType::type)ecast616; + int32_t ecast618; + xfer += iprot->readI32(ecast618); + this->ownerType = (PrincipalType::type)ecast618; this->__isset.ownerType = true; } else { xfer += iprot->skip(ftype); @@ -15175,9 +15281,9 @@ uint32_t Function::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 7: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast617; - xfer += iprot->readI32(ecast617); - this->functionType = (FunctionType::type)ecast617; + int32_t ecast619; + xfer += iprot->readI32(ecast619); + this->functionType = (FunctionType::type)ecast619; this->__isset.functionType = true; } else { xfer += iprot->skip(ftype); @@ -15187,14 +15293,14 @@ uint32_t Function::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->resourceUris.clear(); - uint32_t _size618; - ::apache::thrift::protocol::TType _etype621; - xfer += iprot->readListBegin(_etype621, _size618); - this->resourceUris.resize(_size618); - uint32_t _i622; - for (_i622 = 0; _i622 < _size618; ++_i622) + uint32_t _size620; + ::apache::thrift::protocol::TType _etype623; + xfer += iprot->readListBegin(_etype623, _size620); + this->resourceUris.resize(_size620); + uint32_t _i624; + for (_i624 = 0; _i624 < _size620; ++_i624) { - xfer += this->resourceUris[_i622].read(iprot); + xfer += this->resourceUris[_i624].read(iprot); } xfer += iprot->readListEnd(); } @@ -15259,10 +15365,10 @@ uint32_t Function::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("resourceUris", ::apache::thrift::protocol::T_LIST, 8); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->resourceUris.size())); - std::vector ::const_iterator _iter623; - for (_iter623 = this->resourceUris.begin(); _iter623 != this->resourceUris.end(); ++_iter623) + std::vector ::const_iterator _iter625; + for (_iter625 = this->resourceUris.begin(); _iter625 != this->resourceUris.end(); ++_iter625) { - xfer += (*_iter623).write(oprot); + xfer += (*_iter625).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15292,29 +15398,29 @@ void swap(Function &a, Function &b) { swap(a.__isset, b.__isset); } -Function::Function(const Function& other624) { - functionName = other624.functionName; - dbName = other624.dbName; - className = other624.className; - ownerName = other624.ownerName; - ownerType = other624.ownerType; - createTime = other624.createTime; - functionType = other624.functionType; - resourceUris = other624.resourceUris; - catName = other624.catName; - __isset = other624.__isset; -} -Function& Function::operator=(const Function& other625) { - functionName = other625.functionName; - dbName = other625.dbName; - className = other625.className; - ownerName = other625.ownerName; - ownerType = other625.ownerType; - createTime = other625.createTime; - functionType = other625.functionType; - resourceUris = other625.resourceUris; - catName = other625.catName; - __isset = other625.__isset; +Function::Function(const Function& other626) { + functionName = other626.functionName; + dbName = other626.dbName; + className = other626.className; + ownerName = other626.ownerName; + ownerType = other626.ownerType; + createTime = other626.createTime; + functionType = other626.functionType; + resourceUris = other626.resourceUris; + catName = other626.catName; + __isset = other626.__isset; +} +Function& Function::operator=(const Function& other627) { + functionName = other627.functionName; + dbName = other627.dbName; + className = other627.className; + ownerName = other627.ownerName; + ownerType = other627.ownerType; + createTime = other627.createTime; + functionType = other627.functionType; + resourceUris = other627.resourceUris; + catName = other627.catName; + __isset = other627.__isset; return *this; } void Function::printTo(std::ostream& out) const { @@ -15413,9 +15519,9 @@ uint32_t TxnInfo::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast626; - xfer += iprot->readI32(ecast626); - this->state = (TxnState::type)ecast626; + int32_t ecast628; + xfer += iprot->readI32(ecast628); + this->state = (TxnState::type)ecast628; isset_state = true; } else { xfer += iprot->skip(ftype); @@ -15562,29 +15668,29 @@ void swap(TxnInfo &a, TxnInfo &b) { swap(a.__isset, b.__isset); } -TxnInfo::TxnInfo(const TxnInfo& other627) { - id = other627.id; - state = other627.state; - user = other627.user; - hostname = other627.hostname; - agentInfo = other627.agentInfo; - heartbeatCount = other627.heartbeatCount; - metaInfo = other627.metaInfo; - startedTime = other627.startedTime; - lastHeartbeatTime = other627.lastHeartbeatTime; - __isset = other627.__isset; -} -TxnInfo& TxnInfo::operator=(const TxnInfo& other628) { - id = other628.id; - state = other628.state; - user = other628.user; - hostname = other628.hostname; - agentInfo = other628.agentInfo; - heartbeatCount = other628.heartbeatCount; - metaInfo = other628.metaInfo; - startedTime = other628.startedTime; - lastHeartbeatTime = other628.lastHeartbeatTime; - __isset = other628.__isset; +TxnInfo::TxnInfo(const TxnInfo& other629) { + id = other629.id; + state = other629.state; + user = other629.user; + hostname = other629.hostname; + agentInfo = other629.agentInfo; + heartbeatCount = other629.heartbeatCount; + metaInfo = other629.metaInfo; + startedTime = other629.startedTime; + lastHeartbeatTime = other629.lastHeartbeatTime; + __isset = other629.__isset; +} +TxnInfo& TxnInfo::operator=(const TxnInfo& other630) { + id = other630.id; + state = other630.state; + user = other630.user; + hostname = other630.hostname; + agentInfo = other630.agentInfo; + heartbeatCount = other630.heartbeatCount; + metaInfo = other630.metaInfo; + startedTime = other630.startedTime; + lastHeartbeatTime = other630.lastHeartbeatTime; + __isset = other630.__isset; return *this; } void TxnInfo::printTo(std::ostream& out) const { @@ -15650,14 +15756,14 @@ uint32_t GetOpenTxnsInfoResponse::read(::apache::thrift::protocol::TProtocol* ip if (ftype == ::apache::thrift::protocol::T_LIST) { { this->open_txns.clear(); - uint32_t _size629; - ::apache::thrift::protocol::TType _etype632; - xfer += iprot->readListBegin(_etype632, _size629); - this->open_txns.resize(_size629); - uint32_t _i633; - for (_i633 = 0; _i633 < _size629; ++_i633) + uint32_t _size631; + ::apache::thrift::protocol::TType _etype634; + xfer += iprot->readListBegin(_etype634, _size631); + this->open_txns.resize(_size631); + uint32_t _i635; + for (_i635 = 0; _i635 < _size631; ++_i635) { - xfer += this->open_txns[_i633].read(iprot); + xfer += this->open_txns[_i635].read(iprot); } xfer += iprot->readListEnd(); } @@ -15694,10 +15800,10 @@ uint32_t GetOpenTxnsInfoResponse::write(::apache::thrift::protocol::TProtocol* o xfer += oprot->writeFieldBegin("open_txns", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->open_txns.size())); - std::vector ::const_iterator _iter634; - for (_iter634 = this->open_txns.begin(); _iter634 != this->open_txns.end(); ++_iter634) + std::vector ::const_iterator _iter636; + for (_iter636 = this->open_txns.begin(); _iter636 != this->open_txns.end(); ++_iter636) { - xfer += (*_iter634).write(oprot); + xfer += (*_iter636).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15714,13 +15820,13 @@ void swap(GetOpenTxnsInfoResponse &a, GetOpenTxnsInfoResponse &b) { swap(a.open_txns, b.open_txns); } -GetOpenTxnsInfoResponse::GetOpenTxnsInfoResponse(const GetOpenTxnsInfoResponse& other635) { - txn_high_water_mark = other635.txn_high_water_mark; - open_txns = other635.open_txns; +GetOpenTxnsInfoResponse::GetOpenTxnsInfoResponse(const GetOpenTxnsInfoResponse& other637) { + txn_high_water_mark = other637.txn_high_water_mark; + open_txns = other637.open_txns; } -GetOpenTxnsInfoResponse& GetOpenTxnsInfoResponse::operator=(const GetOpenTxnsInfoResponse& other636) { - txn_high_water_mark = other636.txn_high_water_mark; - open_txns = other636.open_txns; +GetOpenTxnsInfoResponse& GetOpenTxnsInfoResponse::operator=(const GetOpenTxnsInfoResponse& other638) { + txn_high_water_mark = other638.txn_high_water_mark; + open_txns = other638.open_txns; return *this; } void GetOpenTxnsInfoResponse::printTo(std::ostream& out) const { @@ -15789,14 +15895,14 @@ uint32_t GetOpenTxnsResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->open_txns.clear(); - uint32_t _size637; - ::apache::thrift::protocol::TType _etype640; - xfer += iprot->readListBegin(_etype640, _size637); - this->open_txns.resize(_size637); - uint32_t _i641; - for (_i641 = 0; _i641 < _size637; ++_i641) + uint32_t _size639; + ::apache::thrift::protocol::TType _etype642; + xfer += iprot->readListBegin(_etype642, _size639); + this->open_txns.resize(_size639); + uint32_t _i643; + for (_i643 = 0; _i643 < _size639; ++_i643) { - xfer += iprot->readI64(this->open_txns[_i641]); + xfer += iprot->readI64(this->open_txns[_i643]); } xfer += iprot->readListEnd(); } @@ -15851,10 +15957,10 @@ uint32_t GetOpenTxnsResponse::write(::apache::thrift::protocol::TProtocol* oprot xfer += oprot->writeFieldBegin("open_txns", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->open_txns.size())); - std::vector ::const_iterator _iter642; - for (_iter642 = this->open_txns.begin(); _iter642 != this->open_txns.end(); ++_iter642) + std::vector ::const_iterator _iter644; + for (_iter644 = this->open_txns.begin(); _iter644 != this->open_txns.end(); ++_iter644) { - xfer += oprot->writeI64((*_iter642)); + xfer += oprot->writeI64((*_iter644)); } xfer += oprot->writeListEnd(); } @@ -15883,19 +15989,19 @@ void swap(GetOpenTxnsResponse &a, GetOpenTxnsResponse &b) { swap(a.__isset, b.__isset); } -GetOpenTxnsResponse::GetOpenTxnsResponse(const GetOpenTxnsResponse& other643) { - txn_high_water_mark = other643.txn_high_water_mark; - open_txns = other643.open_txns; - min_open_txn = other643.min_open_txn; - abortedBits = other643.abortedBits; - __isset = other643.__isset; +GetOpenTxnsResponse::GetOpenTxnsResponse(const GetOpenTxnsResponse& other645) { + txn_high_water_mark = other645.txn_high_water_mark; + open_txns = other645.open_txns; + min_open_txn = other645.min_open_txn; + abortedBits = other645.abortedBits; + __isset = other645.__isset; } -GetOpenTxnsResponse& GetOpenTxnsResponse::operator=(const GetOpenTxnsResponse& other644) { - txn_high_water_mark = other644.txn_high_water_mark; - open_txns = other644.open_txns; - min_open_txn = other644.min_open_txn; - abortedBits = other644.abortedBits; - __isset = other644.__isset; +GetOpenTxnsResponse& GetOpenTxnsResponse::operator=(const GetOpenTxnsResponse& other646) { + txn_high_water_mark = other646.txn_high_water_mark; + open_txns = other646.open_txns; + min_open_txn = other646.min_open_txn; + abortedBits = other646.abortedBits; + __isset = other646.__isset; return *this; } void GetOpenTxnsResponse::printTo(std::ostream& out) const { @@ -16008,14 +16114,14 @@ uint32_t OpenTxnRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->replSrcTxnIds.clear(); - uint32_t _size645; - ::apache::thrift::protocol::TType _etype648; - xfer += iprot->readListBegin(_etype648, _size645); - this->replSrcTxnIds.resize(_size645); - uint32_t _i649; - for (_i649 = 0; _i649 < _size645; ++_i649) + uint32_t _size647; + ::apache::thrift::protocol::TType _etype650; + xfer += iprot->readListBegin(_etype650, _size647); + this->replSrcTxnIds.resize(_size647); + uint32_t _i651; + for (_i651 = 0; _i651 < _size647; ++_i651) { - xfer += iprot->readI64(this->replSrcTxnIds[_i649]); + xfer += iprot->readI64(this->replSrcTxnIds[_i651]); } xfer += iprot->readListEnd(); } @@ -16073,10 +16179,10 @@ uint32_t OpenTxnRequest::write(::apache::thrift::protocol::TProtocol* oprot) con xfer += oprot->writeFieldBegin("replSrcTxnIds", ::apache::thrift::protocol::T_LIST, 6); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->replSrcTxnIds.size())); - std::vector ::const_iterator _iter650; - for (_iter650 = this->replSrcTxnIds.begin(); _iter650 != this->replSrcTxnIds.end(); ++_iter650) + std::vector ::const_iterator _iter652; + for (_iter652 = this->replSrcTxnIds.begin(); _iter652 != this->replSrcTxnIds.end(); ++_iter652) { - xfer += oprot->writeI64((*_iter650)); + xfer += oprot->writeI64((*_iter652)); } xfer += oprot->writeListEnd(); } @@ -16098,23 +16204,23 @@ void swap(OpenTxnRequest &a, OpenTxnRequest &b) { swap(a.__isset, b.__isset); } -OpenTxnRequest::OpenTxnRequest(const OpenTxnRequest& other651) { - num_txns = other651.num_txns; - user = other651.user; - hostname = other651.hostname; - agentInfo = other651.agentInfo; - replPolicy = other651.replPolicy; - replSrcTxnIds = other651.replSrcTxnIds; - __isset = other651.__isset; -} -OpenTxnRequest& OpenTxnRequest::operator=(const OpenTxnRequest& other652) { - num_txns = other652.num_txns; - user = other652.user; - hostname = other652.hostname; - agentInfo = other652.agentInfo; - replPolicy = other652.replPolicy; - replSrcTxnIds = other652.replSrcTxnIds; - __isset = other652.__isset; +OpenTxnRequest::OpenTxnRequest(const OpenTxnRequest& other653) { + num_txns = other653.num_txns; + user = other653.user; + hostname = other653.hostname; + agentInfo = other653.agentInfo; + replPolicy = other653.replPolicy; + replSrcTxnIds = other653.replSrcTxnIds; + __isset = other653.__isset; +} +OpenTxnRequest& OpenTxnRequest::operator=(const OpenTxnRequest& other654) { + num_txns = other654.num_txns; + user = other654.user; + hostname = other654.hostname; + agentInfo = other654.agentInfo; + replPolicy = other654.replPolicy; + replSrcTxnIds = other654.replSrcTxnIds; + __isset = other654.__isset; return *this; } void OpenTxnRequest::printTo(std::ostream& out) const { @@ -16164,14 +16270,14 @@ uint32_t OpenTxnsResponse::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->txn_ids.clear(); - uint32_t _size653; - ::apache::thrift::protocol::TType _etype656; - xfer += iprot->readListBegin(_etype656, _size653); - this->txn_ids.resize(_size653); - uint32_t _i657; - for (_i657 = 0; _i657 < _size653; ++_i657) + uint32_t _size655; + ::apache::thrift::protocol::TType _etype658; + xfer += iprot->readListBegin(_etype658, _size655); + this->txn_ids.resize(_size655); + uint32_t _i659; + for (_i659 = 0; _i659 < _size655; ++_i659) { - xfer += iprot->readI64(this->txn_ids[_i657]); + xfer += iprot->readI64(this->txn_ids[_i659]); } xfer += iprot->readListEnd(); } @@ -16202,10 +16308,10 @@ uint32_t OpenTxnsResponse::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("txn_ids", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->txn_ids.size())); - std::vector ::const_iterator _iter658; - for (_iter658 = this->txn_ids.begin(); _iter658 != this->txn_ids.end(); ++_iter658) + std::vector ::const_iterator _iter660; + for (_iter660 = this->txn_ids.begin(); _iter660 != this->txn_ids.end(); ++_iter660) { - xfer += oprot->writeI64((*_iter658)); + xfer += oprot->writeI64((*_iter660)); } xfer += oprot->writeListEnd(); } @@ -16221,11 +16327,11 @@ void swap(OpenTxnsResponse &a, OpenTxnsResponse &b) { swap(a.txn_ids, b.txn_ids); } -OpenTxnsResponse::OpenTxnsResponse(const OpenTxnsResponse& other659) { - txn_ids = other659.txn_ids; +OpenTxnsResponse::OpenTxnsResponse(const OpenTxnsResponse& other661) { + txn_ids = other661.txn_ids; } -OpenTxnsResponse& OpenTxnsResponse::operator=(const OpenTxnsResponse& other660) { - txn_ids = other660.txn_ids; +OpenTxnsResponse& OpenTxnsResponse::operator=(const OpenTxnsResponse& other662) { + txn_ids = other662.txn_ids; return *this; } void OpenTxnsResponse::printTo(std::ostream& out) const { @@ -16327,15 +16433,15 @@ void swap(AbortTxnRequest &a, AbortTxnRequest &b) { swap(a.__isset, b.__isset); } -AbortTxnRequest::AbortTxnRequest(const AbortTxnRequest& other661) { - txnid = other661.txnid; - replPolicy = other661.replPolicy; - __isset = other661.__isset; +AbortTxnRequest::AbortTxnRequest(const AbortTxnRequest& other663) { + txnid = other663.txnid; + replPolicy = other663.replPolicy; + __isset = other663.__isset; } -AbortTxnRequest& AbortTxnRequest::operator=(const AbortTxnRequest& other662) { - txnid = other662.txnid; - replPolicy = other662.replPolicy; - __isset = other662.__isset; +AbortTxnRequest& AbortTxnRequest::operator=(const AbortTxnRequest& other664) { + txnid = other664.txnid; + replPolicy = other664.replPolicy; + __isset = other664.__isset; return *this; } void AbortTxnRequest::printTo(std::ostream& out) const { @@ -16381,14 +16487,14 @@ uint32_t AbortTxnsRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->txn_ids.clear(); - uint32_t _size663; - ::apache::thrift::protocol::TType _etype666; - xfer += iprot->readListBegin(_etype666, _size663); - this->txn_ids.resize(_size663); - uint32_t _i667; - for (_i667 = 0; _i667 < _size663; ++_i667) + uint32_t _size665; + ::apache::thrift::protocol::TType _etype668; + xfer += iprot->readListBegin(_etype668, _size665); + this->txn_ids.resize(_size665); + uint32_t _i669; + for (_i669 = 0; _i669 < _size665; ++_i669) { - xfer += iprot->readI64(this->txn_ids[_i667]); + xfer += iprot->readI64(this->txn_ids[_i669]); } xfer += iprot->readListEnd(); } @@ -16419,10 +16525,10 @@ uint32_t AbortTxnsRequest::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("txn_ids", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->txn_ids.size())); - std::vector ::const_iterator _iter668; - for (_iter668 = this->txn_ids.begin(); _iter668 != this->txn_ids.end(); ++_iter668) + std::vector ::const_iterator _iter670; + for (_iter670 = this->txn_ids.begin(); _iter670 != this->txn_ids.end(); ++_iter670) { - xfer += oprot->writeI64((*_iter668)); + xfer += oprot->writeI64((*_iter670)); } xfer += oprot->writeListEnd(); } @@ -16438,11 +16544,11 @@ void swap(AbortTxnsRequest &a, AbortTxnsRequest &b) { swap(a.txn_ids, b.txn_ids); } -AbortTxnsRequest::AbortTxnsRequest(const AbortTxnsRequest& other669) { - txn_ids = other669.txn_ids; +AbortTxnsRequest::AbortTxnsRequest(const AbortTxnsRequest& other671) { + txn_ids = other671.txn_ids; } -AbortTxnsRequest& AbortTxnsRequest::operator=(const AbortTxnsRequest& other670) { - txn_ids = other670.txn_ids; +AbortTxnsRequest& AbortTxnsRequest::operator=(const AbortTxnsRequest& other672) { + txn_ids = other672.txn_ids; return *this; } void AbortTxnsRequest::printTo(std::ostream& out) const { @@ -16544,15 +16650,15 @@ void swap(CommitTxnRequest &a, CommitTxnRequest &b) { swap(a.__isset, b.__isset); } -CommitTxnRequest::CommitTxnRequest(const CommitTxnRequest& other671) { - txnid = other671.txnid; - replPolicy = other671.replPolicy; - __isset = other671.__isset; +CommitTxnRequest::CommitTxnRequest(const CommitTxnRequest& other673) { + txnid = other673.txnid; + replPolicy = other673.replPolicy; + __isset = other673.__isset; } -CommitTxnRequest& CommitTxnRequest::operator=(const CommitTxnRequest& other672) { - txnid = other672.txnid; - replPolicy = other672.replPolicy; - __isset = other672.__isset; +CommitTxnRequest& CommitTxnRequest::operator=(const CommitTxnRequest& other674) { + txnid = other674.txnid; + replPolicy = other674.replPolicy; + __isset = other674.__isset; return *this; } void CommitTxnRequest::printTo(std::ostream& out) const { @@ -16663,14 +16769,14 @@ uint32_t ReplTblWriteIdStateRequest::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partNames.clear(); - uint32_t _size673; - ::apache::thrift::protocol::TType _etype676; - xfer += iprot->readListBegin(_etype676, _size673); - this->partNames.resize(_size673); - uint32_t _i677; - for (_i677 = 0; _i677 < _size673; ++_i677) + uint32_t _size675; + ::apache::thrift::protocol::TType _etype678; + xfer += iprot->readListBegin(_etype678, _size675); + this->partNames.resize(_size675); + uint32_t _i679; + for (_i679 = 0; _i679 < _size675; ++_i679) { - xfer += iprot->readString(this->partNames[_i677]); + xfer += iprot->readString(this->partNames[_i679]); } xfer += iprot->readListEnd(); } @@ -16730,10 +16836,10 @@ uint32_t ReplTblWriteIdStateRequest::write(::apache::thrift::protocol::TProtocol xfer += oprot->writeFieldBegin("partNames", ::apache::thrift::protocol::T_LIST, 6); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partNames.size())); - std::vector ::const_iterator _iter678; - for (_iter678 = this->partNames.begin(); _iter678 != this->partNames.end(); ++_iter678) + std::vector ::const_iterator _iter680; + for (_iter680 = this->partNames.begin(); _iter680 != this->partNames.end(); ++_iter680) { - xfer += oprot->writeString((*_iter678)); + xfer += oprot->writeString((*_iter680)); } xfer += oprot->writeListEnd(); } @@ -16755,23 +16861,23 @@ void swap(ReplTblWriteIdStateRequest &a, ReplTblWriteIdStateRequest &b) { swap(a.__isset, b.__isset); } -ReplTblWriteIdStateRequest::ReplTblWriteIdStateRequest(const ReplTblWriteIdStateRequest& other679) { - validWriteIdlist = other679.validWriteIdlist; - user = other679.user; - hostName = other679.hostName; - dbName = other679.dbName; - tableName = other679.tableName; - partNames = other679.partNames; - __isset = other679.__isset; -} -ReplTblWriteIdStateRequest& ReplTblWriteIdStateRequest::operator=(const ReplTblWriteIdStateRequest& other680) { - validWriteIdlist = other680.validWriteIdlist; - user = other680.user; - hostName = other680.hostName; - dbName = other680.dbName; - tableName = other680.tableName; - partNames = other680.partNames; - __isset = other680.__isset; +ReplTblWriteIdStateRequest::ReplTblWriteIdStateRequest(const ReplTblWriteIdStateRequest& other681) { + validWriteIdlist = other681.validWriteIdlist; + user = other681.user; + hostName = other681.hostName; + dbName = other681.dbName; + tableName = other681.tableName; + partNames = other681.partNames; + __isset = other681.__isset; +} +ReplTblWriteIdStateRequest& ReplTblWriteIdStateRequest::operator=(const ReplTblWriteIdStateRequest& other682) { + validWriteIdlist = other682.validWriteIdlist; + user = other682.user; + hostName = other682.hostName; + dbName = other682.dbName; + tableName = other682.tableName; + partNames = other682.partNames; + __isset = other682.__isset; return *this; } void ReplTblWriteIdStateRequest::printTo(std::ostream& out) const { @@ -16826,14 +16932,14 @@ uint32_t GetValidWriteIdsRequest::read(::apache::thrift::protocol::TProtocol* ip if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fullTableNames.clear(); - uint32_t _size681; - ::apache::thrift::protocol::TType _etype684; - xfer += iprot->readListBegin(_etype684, _size681); - this->fullTableNames.resize(_size681); - uint32_t _i685; - for (_i685 = 0; _i685 < _size681; ++_i685) + uint32_t _size683; + ::apache::thrift::protocol::TType _etype686; + xfer += iprot->readListBegin(_etype686, _size683); + this->fullTableNames.resize(_size683); + uint32_t _i687; + for (_i687 = 0; _i687 < _size683; ++_i687) { - xfer += iprot->readString(this->fullTableNames[_i685]); + xfer += iprot->readString(this->fullTableNames[_i687]); } xfer += iprot->readListEnd(); } @@ -16874,10 +16980,10 @@ uint32_t GetValidWriteIdsRequest::write(::apache::thrift::protocol::TProtocol* o xfer += oprot->writeFieldBegin("fullTableNames", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->fullTableNames.size())); - std::vector ::const_iterator _iter686; - for (_iter686 = this->fullTableNames.begin(); _iter686 != this->fullTableNames.end(); ++_iter686) + std::vector ::const_iterator _iter688; + for (_iter688 = this->fullTableNames.begin(); _iter688 != this->fullTableNames.end(); ++_iter688) { - xfer += oprot->writeString((*_iter686)); + xfer += oprot->writeString((*_iter688)); } xfer += oprot->writeListEnd(); } @@ -16898,13 +17004,13 @@ void swap(GetValidWriteIdsRequest &a, GetValidWriteIdsRequest &b) { swap(a.validTxnList, b.validTxnList); } -GetValidWriteIdsRequest::GetValidWriteIdsRequest(const GetValidWriteIdsRequest& other687) { - fullTableNames = other687.fullTableNames; - validTxnList = other687.validTxnList; +GetValidWriteIdsRequest::GetValidWriteIdsRequest(const GetValidWriteIdsRequest& other689) { + fullTableNames = other689.fullTableNames; + validTxnList = other689.validTxnList; } -GetValidWriteIdsRequest& GetValidWriteIdsRequest::operator=(const GetValidWriteIdsRequest& other688) { - fullTableNames = other688.fullTableNames; - validTxnList = other688.validTxnList; +GetValidWriteIdsRequest& GetValidWriteIdsRequest::operator=(const GetValidWriteIdsRequest& other690) { + fullTableNames = other690.fullTableNames; + validTxnList = other690.validTxnList; return *this; } void GetValidWriteIdsRequest::printTo(std::ostream& out) const { @@ -16986,14 +17092,14 @@ uint32_t TableValidWriteIds::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->invalidWriteIds.clear(); - uint32_t _size689; - ::apache::thrift::protocol::TType _etype692; - xfer += iprot->readListBegin(_etype692, _size689); - this->invalidWriteIds.resize(_size689); - uint32_t _i693; - for (_i693 = 0; _i693 < _size689; ++_i693) + uint32_t _size691; + ::apache::thrift::protocol::TType _etype694; + xfer += iprot->readListBegin(_etype694, _size691); + this->invalidWriteIds.resize(_size691); + uint32_t _i695; + for (_i695 = 0; _i695 < _size691; ++_i695) { - xfer += iprot->readI64(this->invalidWriteIds[_i693]); + xfer += iprot->readI64(this->invalidWriteIds[_i695]); } xfer += iprot->readListEnd(); } @@ -17054,10 +17160,10 @@ uint32_t TableValidWriteIds::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("invalidWriteIds", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->invalidWriteIds.size())); - std::vector ::const_iterator _iter694; - for (_iter694 = this->invalidWriteIds.begin(); _iter694 != this->invalidWriteIds.end(); ++_iter694) + std::vector ::const_iterator _iter696; + for (_iter696 = this->invalidWriteIds.begin(); _iter696 != this->invalidWriteIds.end(); ++_iter696) { - xfer += oprot->writeI64((*_iter694)); + xfer += oprot->writeI64((*_iter696)); } xfer += oprot->writeListEnd(); } @@ -17087,21 +17193,21 @@ void swap(TableValidWriteIds &a, TableValidWriteIds &b) { swap(a.__isset, b.__isset); } -TableValidWriteIds::TableValidWriteIds(const TableValidWriteIds& other695) { - fullTableName = other695.fullTableName; - writeIdHighWaterMark = other695.writeIdHighWaterMark; - invalidWriteIds = other695.invalidWriteIds; - minOpenWriteId = other695.minOpenWriteId; - abortedBits = other695.abortedBits; - __isset = other695.__isset; -} -TableValidWriteIds& TableValidWriteIds::operator=(const TableValidWriteIds& other696) { - fullTableName = other696.fullTableName; - writeIdHighWaterMark = other696.writeIdHighWaterMark; - invalidWriteIds = other696.invalidWriteIds; - minOpenWriteId = other696.minOpenWriteId; - abortedBits = other696.abortedBits; - __isset = other696.__isset; +TableValidWriteIds::TableValidWriteIds(const TableValidWriteIds& other697) { + fullTableName = other697.fullTableName; + writeIdHighWaterMark = other697.writeIdHighWaterMark; + invalidWriteIds = other697.invalidWriteIds; + minOpenWriteId = other697.minOpenWriteId; + abortedBits = other697.abortedBits; + __isset = other697.__isset; +} +TableValidWriteIds& TableValidWriteIds::operator=(const TableValidWriteIds& other698) { + fullTableName = other698.fullTableName; + writeIdHighWaterMark = other698.writeIdHighWaterMark; + invalidWriteIds = other698.invalidWriteIds; + minOpenWriteId = other698.minOpenWriteId; + abortedBits = other698.abortedBits; + __isset = other698.__isset; return *this; } void TableValidWriteIds::printTo(std::ostream& out) const { @@ -17150,14 +17256,14 @@ uint32_t GetValidWriteIdsResponse::read(::apache::thrift::protocol::TProtocol* i if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tblValidWriteIds.clear(); - uint32_t _size697; - ::apache::thrift::protocol::TType _etype700; - xfer += iprot->readListBegin(_etype700, _size697); - this->tblValidWriteIds.resize(_size697); - uint32_t _i701; - for (_i701 = 0; _i701 < _size697; ++_i701) + uint32_t _size699; + ::apache::thrift::protocol::TType _etype702; + xfer += iprot->readListBegin(_etype702, _size699); + this->tblValidWriteIds.resize(_size699); + uint32_t _i703; + for (_i703 = 0; _i703 < _size699; ++_i703) { - xfer += this->tblValidWriteIds[_i701].read(iprot); + xfer += this->tblValidWriteIds[_i703].read(iprot); } xfer += iprot->readListEnd(); } @@ -17188,10 +17294,10 @@ uint32_t GetValidWriteIdsResponse::write(::apache::thrift::protocol::TProtocol* xfer += oprot->writeFieldBegin("tblValidWriteIds", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->tblValidWriteIds.size())); - std::vector ::const_iterator _iter702; - for (_iter702 = this->tblValidWriteIds.begin(); _iter702 != this->tblValidWriteIds.end(); ++_iter702) + std::vector ::const_iterator _iter704; + for (_iter704 = this->tblValidWriteIds.begin(); _iter704 != this->tblValidWriteIds.end(); ++_iter704) { - xfer += (*_iter702).write(oprot); + xfer += (*_iter704).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17207,11 +17313,11 @@ void swap(GetValidWriteIdsResponse &a, GetValidWriteIdsResponse &b) { swap(a.tblValidWriteIds, b.tblValidWriteIds); } -GetValidWriteIdsResponse::GetValidWriteIdsResponse(const GetValidWriteIdsResponse& other703) { - tblValidWriteIds = other703.tblValidWriteIds; +GetValidWriteIdsResponse::GetValidWriteIdsResponse(const GetValidWriteIdsResponse& other705) { + tblValidWriteIds = other705.tblValidWriteIds; } -GetValidWriteIdsResponse& GetValidWriteIdsResponse::operator=(const GetValidWriteIdsResponse& other704) { - tblValidWriteIds = other704.tblValidWriteIds; +GetValidWriteIdsResponse& GetValidWriteIdsResponse::operator=(const GetValidWriteIdsResponse& other706) { + tblValidWriteIds = other706.tblValidWriteIds; return *this; } void GetValidWriteIdsResponse::printTo(std::ostream& out) const { @@ -17292,14 +17398,14 @@ uint32_t AllocateTableWriteIdsRequest::read(::apache::thrift::protocol::TProtoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->txnIds.clear(); - uint32_t _size705; - ::apache::thrift::protocol::TType _etype708; - xfer += iprot->readListBegin(_etype708, _size705); - this->txnIds.resize(_size705); - uint32_t _i709; - for (_i709 = 0; _i709 < _size705; ++_i709) + uint32_t _size707; + ::apache::thrift::protocol::TType _etype710; + xfer += iprot->readListBegin(_etype710, _size707); + this->txnIds.resize(_size707); + uint32_t _i711; + for (_i711 = 0; _i711 < _size707; ++_i711) { - xfer += iprot->readI64(this->txnIds[_i709]); + xfer += iprot->readI64(this->txnIds[_i711]); } xfer += iprot->readListEnd(); } @@ -17320,14 +17426,14 @@ uint32_t AllocateTableWriteIdsRequest::read(::apache::thrift::protocol::TProtoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->srcTxnToWriteIdList.clear(); - uint32_t _size710; - ::apache::thrift::protocol::TType _etype713; - xfer += iprot->readListBegin(_etype713, _size710); - this->srcTxnToWriteIdList.resize(_size710); - uint32_t _i714; - for (_i714 = 0; _i714 < _size710; ++_i714) + uint32_t _size712; + ::apache::thrift::protocol::TType _etype715; + xfer += iprot->readListBegin(_etype715, _size712); + this->srcTxnToWriteIdList.resize(_size712); + uint32_t _i716; + for (_i716 = 0; _i716 < _size712; ++_i716) { - xfer += this->srcTxnToWriteIdList[_i714].read(iprot); + xfer += this->srcTxnToWriteIdList[_i716].read(iprot); } xfer += iprot->readListEnd(); } @@ -17369,10 +17475,10 @@ uint32_t AllocateTableWriteIdsRequest::write(::apache::thrift::protocol::TProtoc xfer += oprot->writeFieldBegin("txnIds", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->txnIds.size())); - std::vector ::const_iterator _iter715; - for (_iter715 = this->txnIds.begin(); _iter715 != this->txnIds.end(); ++_iter715) + std::vector ::const_iterator _iter717; + for (_iter717 = this->txnIds.begin(); _iter717 != this->txnIds.end(); ++_iter717) { - xfer += oprot->writeI64((*_iter715)); + xfer += oprot->writeI64((*_iter717)); } xfer += oprot->writeListEnd(); } @@ -17387,10 +17493,10 @@ uint32_t AllocateTableWriteIdsRequest::write(::apache::thrift::protocol::TProtoc xfer += oprot->writeFieldBegin("srcTxnToWriteIdList", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->srcTxnToWriteIdList.size())); - std::vector ::const_iterator _iter716; - for (_iter716 = this->srcTxnToWriteIdList.begin(); _iter716 != this->srcTxnToWriteIdList.end(); ++_iter716) + std::vector ::const_iterator _iter718; + for (_iter718 = this->srcTxnToWriteIdList.begin(); _iter718 != this->srcTxnToWriteIdList.end(); ++_iter718) { - xfer += (*_iter716).write(oprot); + xfer += (*_iter718).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17411,21 +17517,21 @@ void swap(AllocateTableWriteIdsRequest &a, AllocateTableWriteIdsRequest &b) { swap(a.__isset, b.__isset); } -AllocateTableWriteIdsRequest::AllocateTableWriteIdsRequest(const AllocateTableWriteIdsRequest& other717) { - dbName = other717.dbName; - tableName = other717.tableName; - txnIds = other717.txnIds; - replPolicy = other717.replPolicy; - srcTxnToWriteIdList = other717.srcTxnToWriteIdList; - __isset = other717.__isset; -} -AllocateTableWriteIdsRequest& AllocateTableWriteIdsRequest::operator=(const AllocateTableWriteIdsRequest& other718) { - dbName = other718.dbName; - tableName = other718.tableName; - txnIds = other718.txnIds; - replPolicy = other718.replPolicy; - srcTxnToWriteIdList = other718.srcTxnToWriteIdList; - __isset = other718.__isset; +AllocateTableWriteIdsRequest::AllocateTableWriteIdsRequest(const AllocateTableWriteIdsRequest& other719) { + dbName = other719.dbName; + tableName = other719.tableName; + txnIds = other719.txnIds; + replPolicy = other719.replPolicy; + srcTxnToWriteIdList = other719.srcTxnToWriteIdList; + __isset = other719.__isset; +} +AllocateTableWriteIdsRequest& AllocateTableWriteIdsRequest::operator=(const AllocateTableWriteIdsRequest& other720) { + dbName = other720.dbName; + tableName = other720.tableName; + txnIds = other720.txnIds; + replPolicy = other720.replPolicy; + srcTxnToWriteIdList = other720.srcTxnToWriteIdList; + __isset = other720.__isset; return *this; } void AllocateTableWriteIdsRequest::printTo(std::ostream& out) const { @@ -17531,13 +17637,13 @@ void swap(TxnToWriteId &a, TxnToWriteId &b) { swap(a.writeId, b.writeId); } -TxnToWriteId::TxnToWriteId(const TxnToWriteId& other719) { - txnId = other719.txnId; - writeId = other719.writeId; +TxnToWriteId::TxnToWriteId(const TxnToWriteId& other721) { + txnId = other721.txnId; + writeId = other721.writeId; } -TxnToWriteId& TxnToWriteId::operator=(const TxnToWriteId& other720) { - txnId = other720.txnId; - writeId = other720.writeId; +TxnToWriteId& TxnToWriteId::operator=(const TxnToWriteId& other722) { + txnId = other722.txnId; + writeId = other722.writeId; return *this; } void TxnToWriteId::printTo(std::ostream& out) const { @@ -17583,14 +17689,14 @@ uint32_t AllocateTableWriteIdsResponse::read(::apache::thrift::protocol::TProtoc if (ftype == ::apache::thrift::protocol::T_LIST) { { this->txnToWriteIds.clear(); - uint32_t _size721; - ::apache::thrift::protocol::TType _etype724; - xfer += iprot->readListBegin(_etype724, _size721); - this->txnToWriteIds.resize(_size721); - uint32_t _i725; - for (_i725 = 0; _i725 < _size721; ++_i725) + uint32_t _size723; + ::apache::thrift::protocol::TType _etype726; + xfer += iprot->readListBegin(_etype726, _size723); + this->txnToWriteIds.resize(_size723); + uint32_t _i727; + for (_i727 = 0; _i727 < _size723; ++_i727) { - xfer += this->txnToWriteIds[_i725].read(iprot); + xfer += this->txnToWriteIds[_i727].read(iprot); } xfer += iprot->readListEnd(); } @@ -17621,10 +17727,10 @@ uint32_t AllocateTableWriteIdsResponse::write(::apache::thrift::protocol::TProto xfer += oprot->writeFieldBegin("txnToWriteIds", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->txnToWriteIds.size())); - std::vector ::const_iterator _iter726; - for (_iter726 = this->txnToWriteIds.begin(); _iter726 != this->txnToWriteIds.end(); ++_iter726) + std::vector ::const_iterator _iter728; + for (_iter728 = this->txnToWriteIds.begin(); _iter728 != this->txnToWriteIds.end(); ++_iter728) { - xfer += (*_iter726).write(oprot); + xfer += (*_iter728).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17640,11 +17746,11 @@ void swap(AllocateTableWriteIdsResponse &a, AllocateTableWriteIdsResponse &b) { swap(a.txnToWriteIds, b.txnToWriteIds); } -AllocateTableWriteIdsResponse::AllocateTableWriteIdsResponse(const AllocateTableWriteIdsResponse& other727) { - txnToWriteIds = other727.txnToWriteIds; +AllocateTableWriteIdsResponse::AllocateTableWriteIdsResponse(const AllocateTableWriteIdsResponse& other729) { + txnToWriteIds = other729.txnToWriteIds; } -AllocateTableWriteIdsResponse& AllocateTableWriteIdsResponse::operator=(const AllocateTableWriteIdsResponse& other728) { - txnToWriteIds = other728.txnToWriteIds; +AllocateTableWriteIdsResponse& AllocateTableWriteIdsResponse::operator=(const AllocateTableWriteIdsResponse& other730) { + txnToWriteIds = other730.txnToWriteIds; return *this; } void AllocateTableWriteIdsResponse::printTo(std::ostream& out) const { @@ -17722,9 +17828,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) { { case 1: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast729; - xfer += iprot->readI32(ecast729); - this->type = (LockType::type)ecast729; + int32_t ecast731; + xfer += iprot->readI32(ecast731); + this->type = (LockType::type)ecast731; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -17732,9 +17838,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast730; - xfer += iprot->readI32(ecast730); - this->level = (LockLevel::type)ecast730; + int32_t ecast732; + xfer += iprot->readI32(ecast732); + this->level = (LockLevel::type)ecast732; isset_level = true; } else { xfer += iprot->skip(ftype); @@ -17766,9 +17872,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 6: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast731; - xfer += iprot->readI32(ecast731); - this->operationType = (DataOperationType::type)ecast731; + int32_t ecast733; + xfer += iprot->readI32(ecast733); + this->operationType = (DataOperationType::type)ecast733; this->__isset.operationType = true; } else { xfer += iprot->skip(ftype); @@ -17868,27 +17974,27 @@ void swap(LockComponent &a, LockComponent &b) { swap(a.__isset, b.__isset); } -LockComponent::LockComponent(const LockComponent& other732) { - type = other732.type; - level = other732.level; - dbname = other732.dbname; - tablename = other732.tablename; - partitionname = other732.partitionname; - operationType = other732.operationType; - isTransactional = other732.isTransactional; - isDynamicPartitionWrite = other732.isDynamicPartitionWrite; - __isset = other732.__isset; -} -LockComponent& LockComponent::operator=(const LockComponent& other733) { - type = other733.type; - level = other733.level; - dbname = other733.dbname; - tablename = other733.tablename; - partitionname = other733.partitionname; - operationType = other733.operationType; - isTransactional = other733.isTransactional; - isDynamicPartitionWrite = other733.isDynamicPartitionWrite; - __isset = other733.__isset; +LockComponent::LockComponent(const LockComponent& other734) { + type = other734.type; + level = other734.level; + dbname = other734.dbname; + tablename = other734.tablename; + partitionname = other734.partitionname; + operationType = other734.operationType; + isTransactional = other734.isTransactional; + isDynamicPartitionWrite = other734.isDynamicPartitionWrite; + __isset = other734.__isset; +} +LockComponent& LockComponent::operator=(const LockComponent& other735) { + type = other735.type; + level = other735.level; + dbname = other735.dbname; + tablename = other735.tablename; + partitionname = other735.partitionname; + operationType = other735.operationType; + isTransactional = other735.isTransactional; + isDynamicPartitionWrite = other735.isDynamicPartitionWrite; + __isset = other735.__isset; return *this; } void LockComponent::printTo(std::ostream& out) const { @@ -17960,14 +18066,14 @@ uint32_t LockRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->component.clear(); - uint32_t _size734; - ::apache::thrift::protocol::TType _etype737; - xfer += iprot->readListBegin(_etype737, _size734); - this->component.resize(_size734); - uint32_t _i738; - for (_i738 = 0; _i738 < _size734; ++_i738) + uint32_t _size736; + ::apache::thrift::protocol::TType _etype739; + xfer += iprot->readListBegin(_etype739, _size736); + this->component.resize(_size736); + uint32_t _i740; + for (_i740 = 0; _i740 < _size736; ++_i740) { - xfer += this->component[_i738].read(iprot); + xfer += this->component[_i740].read(iprot); } xfer += iprot->readListEnd(); } @@ -18034,10 +18140,10 @@ uint32_t LockRequest::write(::apache::thrift::protocol::TProtocol* oprot) const xfer += oprot->writeFieldBegin("component", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->component.size())); - std::vector ::const_iterator _iter739; - for (_iter739 = this->component.begin(); _iter739 != this->component.end(); ++_iter739) + std::vector ::const_iterator _iter741; + for (_iter741 = this->component.begin(); _iter741 != this->component.end(); ++_iter741) { - xfer += (*_iter739).write(oprot); + xfer += (*_iter741).write(oprot); } xfer += oprot->writeListEnd(); } @@ -18076,21 +18182,21 @@ void swap(LockRequest &a, LockRequest &b) { swap(a.__isset, b.__isset); } -LockRequest::LockRequest(const LockRequest& other740) { - component = other740.component; - txnid = other740.txnid; - user = other740.user; - hostname = other740.hostname; - agentInfo = other740.agentInfo; - __isset = other740.__isset; -} -LockRequest& LockRequest::operator=(const LockRequest& other741) { - component = other741.component; - txnid = other741.txnid; - user = other741.user; - hostname = other741.hostname; - agentInfo = other741.agentInfo; - __isset = other741.__isset; +LockRequest::LockRequest(const LockRequest& other742) { + component = other742.component; + txnid = other742.txnid; + user = other742.user; + hostname = other742.hostname; + agentInfo = other742.agentInfo; + __isset = other742.__isset; +} +LockRequest& LockRequest::operator=(const LockRequest& other743) { + component = other743.component; + txnid = other743.txnid; + user = other743.user; + hostname = other743.hostname; + agentInfo = other743.agentInfo; + __isset = other743.__isset; return *this; } void LockRequest::printTo(std::ostream& out) const { @@ -18150,9 +18256,9 @@ uint32_t LockResponse::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast742; - xfer += iprot->readI32(ecast742); - this->state = (LockState::type)ecast742; + int32_t ecast744; + xfer += iprot->readI32(ecast744); + this->state = (LockState::type)ecast744; isset_state = true; } else { xfer += iprot->skip(ftype); @@ -18198,13 +18304,13 @@ void swap(LockResponse &a, LockResponse &b) { swap(a.state, b.state); } -LockResponse::LockResponse(const LockResponse& other743) { - lockid = other743.lockid; - state = other743.state; +LockResponse::LockResponse(const LockResponse& other745) { + lockid = other745.lockid; + state = other745.state; } -LockResponse& LockResponse::operator=(const LockResponse& other744) { - lockid = other744.lockid; - state = other744.state; +LockResponse& LockResponse::operator=(const LockResponse& other746) { + lockid = other746.lockid; + state = other746.state; return *this; } void LockResponse::printTo(std::ostream& out) const { @@ -18326,17 +18432,17 @@ void swap(CheckLockRequest &a, CheckLockRequest &b) { swap(a.__isset, b.__isset); } -CheckLockRequest::CheckLockRequest(const CheckLockRequest& other745) { - lockid = other745.lockid; - txnid = other745.txnid; - elapsed_ms = other745.elapsed_ms; - __isset = other745.__isset; +CheckLockRequest::CheckLockRequest(const CheckLockRequest& other747) { + lockid = other747.lockid; + txnid = other747.txnid; + elapsed_ms = other747.elapsed_ms; + __isset = other747.__isset; } -CheckLockRequest& CheckLockRequest::operator=(const CheckLockRequest& other746) { - lockid = other746.lockid; - txnid = other746.txnid; - elapsed_ms = other746.elapsed_ms; - __isset = other746.__isset; +CheckLockRequest& CheckLockRequest::operator=(const CheckLockRequest& other748) { + lockid = other748.lockid; + txnid = other748.txnid; + elapsed_ms = other748.elapsed_ms; + __isset = other748.__isset; return *this; } void CheckLockRequest::printTo(std::ostream& out) const { @@ -18420,11 +18526,11 @@ void swap(UnlockRequest &a, UnlockRequest &b) { swap(a.lockid, b.lockid); } -UnlockRequest::UnlockRequest(const UnlockRequest& other747) { - lockid = other747.lockid; +UnlockRequest::UnlockRequest(const UnlockRequest& other749) { + lockid = other749.lockid; } -UnlockRequest& UnlockRequest::operator=(const UnlockRequest& other748) { - lockid = other748.lockid; +UnlockRequest& UnlockRequest::operator=(const UnlockRequest& other750) { + lockid = other750.lockid; return *this; } void UnlockRequest::printTo(std::ostream& out) const { @@ -18563,19 +18669,19 @@ void swap(ShowLocksRequest &a, ShowLocksRequest &b) { swap(a.__isset, b.__isset); } -ShowLocksRequest::ShowLocksRequest(const ShowLocksRequest& other749) { - dbname = other749.dbname; - tablename = other749.tablename; - partname = other749.partname; - isExtended = other749.isExtended; - __isset = other749.__isset; +ShowLocksRequest::ShowLocksRequest(const ShowLocksRequest& other751) { + dbname = other751.dbname; + tablename = other751.tablename; + partname = other751.partname; + isExtended = other751.isExtended; + __isset = other751.__isset; } -ShowLocksRequest& ShowLocksRequest::operator=(const ShowLocksRequest& other750) { - dbname = other750.dbname; - tablename = other750.tablename; - partname = other750.partname; - isExtended = other750.isExtended; - __isset = other750.__isset; +ShowLocksRequest& ShowLocksRequest::operator=(const ShowLocksRequest& other752) { + dbname = other752.dbname; + tablename = other752.tablename; + partname = other752.partname; + isExtended = other752.isExtended; + __isset = other752.__isset; return *this; } void ShowLocksRequest::printTo(std::ostream& out) const { @@ -18728,9 +18834,9 @@ uint32_t ShowLocksResponseElement::read(::apache::thrift::protocol::TProtocol* i break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast751; - xfer += iprot->readI32(ecast751); - this->state = (LockState::type)ecast751; + int32_t ecast753; + xfer += iprot->readI32(ecast753); + this->state = (LockState::type)ecast753; isset_state = true; } else { xfer += iprot->skip(ftype); @@ -18738,9 +18844,9 @@ uint32_t ShowLocksResponseElement::read(::apache::thrift::protocol::TProtocol* i break; case 6: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast752; - xfer += iprot->readI32(ecast752); - this->type = (LockType::type)ecast752; + int32_t ecast754; + xfer += iprot->readI32(ecast754); + this->type = (LockType::type)ecast754; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -18956,43 +19062,43 @@ void swap(ShowLocksResponseElement &a, ShowLocksResponseElement &b) { swap(a.__isset, b.__isset); } -ShowLocksResponseElement::ShowLocksResponseElement(const ShowLocksResponseElement& other753) { - lockid = other753.lockid; - dbname = other753.dbname; - tablename = other753.tablename; - partname = other753.partname; - state = other753.state; - type = other753.type; - txnid = other753.txnid; - lastheartbeat = other753.lastheartbeat; - acquiredat = other753.acquiredat; - user = other753.user; - hostname = other753.hostname; - heartbeatCount = other753.heartbeatCount; - agentInfo = other753.agentInfo; - blockedByExtId = other753.blockedByExtId; - blockedByIntId = other753.blockedByIntId; - lockIdInternal = other753.lockIdInternal; - __isset = other753.__isset; -} -ShowLocksResponseElement& ShowLocksResponseElement::operator=(const ShowLocksResponseElement& other754) { - lockid = other754.lockid; - dbname = other754.dbname; - tablename = other754.tablename; - partname = other754.partname; - state = other754.state; - type = other754.type; - txnid = other754.txnid; - lastheartbeat = other754.lastheartbeat; - acquiredat = other754.acquiredat; - user = other754.user; - hostname = other754.hostname; - heartbeatCount = other754.heartbeatCount; - agentInfo = other754.agentInfo; - blockedByExtId = other754.blockedByExtId; - blockedByIntId = other754.blockedByIntId; - lockIdInternal = other754.lockIdInternal; - __isset = other754.__isset; +ShowLocksResponseElement::ShowLocksResponseElement(const ShowLocksResponseElement& other755) { + lockid = other755.lockid; + dbname = other755.dbname; + tablename = other755.tablename; + partname = other755.partname; + state = other755.state; + type = other755.type; + txnid = other755.txnid; + lastheartbeat = other755.lastheartbeat; + acquiredat = other755.acquiredat; + user = other755.user; + hostname = other755.hostname; + heartbeatCount = other755.heartbeatCount; + agentInfo = other755.agentInfo; + blockedByExtId = other755.blockedByExtId; + blockedByIntId = other755.blockedByIntId; + lockIdInternal = other755.lockIdInternal; + __isset = other755.__isset; +} +ShowLocksResponseElement& ShowLocksResponseElement::operator=(const ShowLocksResponseElement& other756) { + lockid = other756.lockid; + dbname = other756.dbname; + tablename = other756.tablename; + partname = other756.partname; + state = other756.state; + type = other756.type; + txnid = other756.txnid; + lastheartbeat = other756.lastheartbeat; + acquiredat = other756.acquiredat; + user = other756.user; + hostname = other756.hostname; + heartbeatCount = other756.heartbeatCount; + agentInfo = other756.agentInfo; + blockedByExtId = other756.blockedByExtId; + blockedByIntId = other756.blockedByIntId; + lockIdInternal = other756.lockIdInternal; + __isset = other756.__isset; return *this; } void ShowLocksResponseElement::printTo(std::ostream& out) const { @@ -19051,14 +19157,14 @@ uint32_t ShowLocksResponse::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->locks.clear(); - uint32_t _size755; - ::apache::thrift::protocol::TType _etype758; - xfer += iprot->readListBegin(_etype758, _size755); - this->locks.resize(_size755); - uint32_t _i759; - for (_i759 = 0; _i759 < _size755; ++_i759) + uint32_t _size757; + ::apache::thrift::protocol::TType _etype760; + xfer += iprot->readListBegin(_etype760, _size757); + this->locks.resize(_size757); + uint32_t _i761; + for (_i761 = 0; _i761 < _size757; ++_i761) { - xfer += this->locks[_i759].read(iprot); + xfer += this->locks[_i761].read(iprot); } xfer += iprot->readListEnd(); } @@ -19087,10 +19193,10 @@ uint32_t ShowLocksResponse::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("locks", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->locks.size())); - std::vector ::const_iterator _iter760; - for (_iter760 = this->locks.begin(); _iter760 != this->locks.end(); ++_iter760) + std::vector ::const_iterator _iter762; + for (_iter762 = this->locks.begin(); _iter762 != this->locks.end(); ++_iter762) { - xfer += (*_iter760).write(oprot); + xfer += (*_iter762).write(oprot); } xfer += oprot->writeListEnd(); } @@ -19107,13 +19213,13 @@ void swap(ShowLocksResponse &a, ShowLocksResponse &b) { swap(a.__isset, b.__isset); } -ShowLocksResponse::ShowLocksResponse(const ShowLocksResponse& other761) { - locks = other761.locks; - __isset = other761.__isset; +ShowLocksResponse::ShowLocksResponse(const ShowLocksResponse& other763) { + locks = other763.locks; + __isset = other763.__isset; } -ShowLocksResponse& ShowLocksResponse::operator=(const ShowLocksResponse& other762) { - locks = other762.locks; - __isset = other762.__isset; +ShowLocksResponse& ShowLocksResponse::operator=(const ShowLocksResponse& other764) { + locks = other764.locks; + __isset = other764.__isset; return *this; } void ShowLocksResponse::printTo(std::ostream& out) const { @@ -19214,15 +19320,15 @@ void swap(HeartbeatRequest &a, HeartbeatRequest &b) { swap(a.__isset, b.__isset); } -HeartbeatRequest::HeartbeatRequest(const HeartbeatRequest& other763) { - lockid = other763.lockid; - txnid = other763.txnid; - __isset = other763.__isset; +HeartbeatRequest::HeartbeatRequest(const HeartbeatRequest& other765) { + lockid = other765.lockid; + txnid = other765.txnid; + __isset = other765.__isset; } -HeartbeatRequest& HeartbeatRequest::operator=(const HeartbeatRequest& other764) { - lockid = other764.lockid; - txnid = other764.txnid; - __isset = other764.__isset; +HeartbeatRequest& HeartbeatRequest::operator=(const HeartbeatRequest& other766) { + lockid = other766.lockid; + txnid = other766.txnid; + __isset = other766.__isset; return *this; } void HeartbeatRequest::printTo(std::ostream& out) const { @@ -19325,13 +19431,13 @@ void swap(HeartbeatTxnRangeRequest &a, HeartbeatTxnRangeRequest &b) { swap(a.max, b.max); } -HeartbeatTxnRangeRequest::HeartbeatTxnRangeRequest(const HeartbeatTxnRangeRequest& other765) { - min = other765.min; - max = other765.max; +HeartbeatTxnRangeRequest::HeartbeatTxnRangeRequest(const HeartbeatTxnRangeRequest& other767) { + min = other767.min; + max = other767.max; } -HeartbeatTxnRangeRequest& HeartbeatTxnRangeRequest::operator=(const HeartbeatTxnRangeRequest& other766) { - min = other766.min; - max = other766.max; +HeartbeatTxnRangeRequest& HeartbeatTxnRangeRequest::operator=(const HeartbeatTxnRangeRequest& other768) { + min = other768.min; + max = other768.max; return *this; } void HeartbeatTxnRangeRequest::printTo(std::ostream& out) const { @@ -19382,15 +19488,15 @@ uint32_t HeartbeatTxnRangeResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_SET) { { this->aborted.clear(); - uint32_t _size767; - ::apache::thrift::protocol::TType _etype770; - xfer += iprot->readSetBegin(_etype770, _size767); - uint32_t _i771; - for (_i771 = 0; _i771 < _size767; ++_i771) + uint32_t _size769; + ::apache::thrift::protocol::TType _etype772; + xfer += iprot->readSetBegin(_etype772, _size769); + uint32_t _i773; + for (_i773 = 0; _i773 < _size769; ++_i773) { - int64_t _elem772; - xfer += iprot->readI64(_elem772); - this->aborted.insert(_elem772); + int64_t _elem774; + xfer += iprot->readI64(_elem774); + this->aborted.insert(_elem774); } xfer += iprot->readSetEnd(); } @@ -19403,15 +19509,15 @@ uint32_t HeartbeatTxnRangeResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_SET) { { this->nosuch.clear(); - uint32_t _size773; - ::apache::thrift::protocol::TType _etype776; - xfer += iprot->readSetBegin(_etype776, _size773); - uint32_t _i777; - for (_i777 = 0; _i777 < _size773; ++_i777) + uint32_t _size775; + ::apache::thrift::protocol::TType _etype778; + xfer += iprot->readSetBegin(_etype778, _size775); + uint32_t _i779; + for (_i779 = 0; _i779 < _size775; ++_i779) { - int64_t _elem778; - xfer += iprot->readI64(_elem778); - this->nosuch.insert(_elem778); + int64_t _elem780; + xfer += iprot->readI64(_elem780); + this->nosuch.insert(_elem780); } xfer += iprot->readSetEnd(); } @@ -19444,10 +19550,10 @@ uint32_t HeartbeatTxnRangeResponse::write(::apache::thrift::protocol::TProtocol* xfer += oprot->writeFieldBegin("aborted", ::apache::thrift::protocol::T_SET, 1); { xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_I64, static_cast(this->aborted.size())); - std::set ::const_iterator _iter779; - for (_iter779 = this->aborted.begin(); _iter779 != this->aborted.end(); ++_iter779) + std::set ::const_iterator _iter781; + for (_iter781 = this->aborted.begin(); _iter781 != this->aborted.end(); ++_iter781) { - xfer += oprot->writeI64((*_iter779)); + xfer += oprot->writeI64((*_iter781)); } xfer += oprot->writeSetEnd(); } @@ -19456,10 +19562,10 @@ uint32_t HeartbeatTxnRangeResponse::write(::apache::thrift::protocol::TProtocol* xfer += oprot->writeFieldBegin("nosuch", ::apache::thrift::protocol::T_SET, 2); { xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_I64, static_cast(this->nosuch.size())); - std::set ::const_iterator _iter780; - for (_iter780 = this->nosuch.begin(); _iter780 != this->nosuch.end(); ++_iter780) + std::set ::const_iterator _iter782; + for (_iter782 = this->nosuch.begin(); _iter782 != this->nosuch.end(); ++_iter782) { - xfer += oprot->writeI64((*_iter780)); + xfer += oprot->writeI64((*_iter782)); } xfer += oprot->writeSetEnd(); } @@ -19476,13 +19582,13 @@ void swap(HeartbeatTxnRangeResponse &a, HeartbeatTxnRangeResponse &b) { swap(a.nosuch, b.nosuch); } -HeartbeatTxnRangeResponse::HeartbeatTxnRangeResponse(const HeartbeatTxnRangeResponse& other781) { - aborted = other781.aborted; - nosuch = other781.nosuch; +HeartbeatTxnRangeResponse::HeartbeatTxnRangeResponse(const HeartbeatTxnRangeResponse& other783) { + aborted = other783.aborted; + nosuch = other783.nosuch; } -HeartbeatTxnRangeResponse& HeartbeatTxnRangeResponse::operator=(const HeartbeatTxnRangeResponse& other782) { - aborted = other782.aborted; - nosuch = other782.nosuch; +HeartbeatTxnRangeResponse& HeartbeatTxnRangeResponse::operator=(const HeartbeatTxnRangeResponse& other784) { + aborted = other784.aborted; + nosuch = other784.nosuch; return *this; } void HeartbeatTxnRangeResponse::printTo(std::ostream& out) const { @@ -19575,9 +19681,9 @@ uint32_t CompactionRequest::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast783; - xfer += iprot->readI32(ecast783); - this->type = (CompactionType::type)ecast783; + int32_t ecast785; + xfer += iprot->readI32(ecast785); + this->type = (CompactionType::type)ecast785; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -19595,17 +19701,17 @@ uint32_t CompactionRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->properties.clear(); - uint32_t _size784; - ::apache::thrift::protocol::TType _ktype785; - ::apache::thrift::protocol::TType _vtype786; - xfer += iprot->readMapBegin(_ktype785, _vtype786, _size784); - uint32_t _i788; - for (_i788 = 0; _i788 < _size784; ++_i788) + uint32_t _size786; + ::apache::thrift::protocol::TType _ktype787; + ::apache::thrift::protocol::TType _vtype788; + xfer += iprot->readMapBegin(_ktype787, _vtype788, _size786); + uint32_t _i790; + for (_i790 = 0; _i790 < _size786; ++_i790) { - std::string _key789; - xfer += iprot->readString(_key789); - std::string& _val790 = this->properties[_key789]; - xfer += iprot->readString(_val790); + std::string _key791; + xfer += iprot->readString(_key791); + std::string& _val792 = this->properties[_key791]; + xfer += iprot->readString(_val792); } xfer += iprot->readMapEnd(); } @@ -19663,11 +19769,11 @@ uint32_t CompactionRequest::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("properties", ::apache::thrift::protocol::T_MAP, 6); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->properties.size())); - std::map ::const_iterator _iter791; - for (_iter791 = this->properties.begin(); _iter791 != this->properties.end(); ++_iter791) + std::map ::const_iterator _iter793; + for (_iter793 = this->properties.begin(); _iter793 != this->properties.end(); ++_iter793) { - xfer += oprot->writeString(_iter791->first); - xfer += oprot->writeString(_iter791->second); + xfer += oprot->writeString(_iter793->first); + xfer += oprot->writeString(_iter793->second); } xfer += oprot->writeMapEnd(); } @@ -19689,23 +19795,23 @@ void swap(CompactionRequest &a, CompactionRequest &b) { swap(a.__isset, b.__isset); } -CompactionRequest::CompactionRequest(const CompactionRequest& other792) { - dbname = other792.dbname; - tablename = other792.tablename; - partitionname = other792.partitionname; - type = other792.type; - runas = other792.runas; - properties = other792.properties; - __isset = other792.__isset; -} -CompactionRequest& CompactionRequest::operator=(const CompactionRequest& other793) { - dbname = other793.dbname; - tablename = other793.tablename; - partitionname = other793.partitionname; - type = other793.type; - runas = other793.runas; - properties = other793.properties; - __isset = other793.__isset; +CompactionRequest::CompactionRequest(const CompactionRequest& other794) { + dbname = other794.dbname; + tablename = other794.tablename; + partitionname = other794.partitionname; + type = other794.type; + runas = other794.runas; + properties = other794.properties; + __isset = other794.__isset; +} +CompactionRequest& CompactionRequest::operator=(const CompactionRequest& other795) { + dbname = other795.dbname; + tablename = other795.tablename; + partitionname = other795.partitionname; + type = other795.type; + runas = other795.runas; + properties = other795.properties; + __isset = other795.__isset; return *this; } void CompactionRequest::printTo(std::ostream& out) const { @@ -19832,15 +19938,15 @@ void swap(CompactionResponse &a, CompactionResponse &b) { swap(a.accepted, b.accepted); } -CompactionResponse::CompactionResponse(const CompactionResponse& other794) { - id = other794.id; - state = other794.state; - accepted = other794.accepted; +CompactionResponse::CompactionResponse(const CompactionResponse& other796) { + id = other796.id; + state = other796.state; + accepted = other796.accepted; } -CompactionResponse& CompactionResponse::operator=(const CompactionResponse& other795) { - id = other795.id; - state = other795.state; - accepted = other795.accepted; +CompactionResponse& CompactionResponse::operator=(const CompactionResponse& other797) { + id = other797.id; + state = other797.state; + accepted = other797.accepted; return *this; } void CompactionResponse::printTo(std::ostream& out) const { @@ -19901,11 +20007,11 @@ void swap(ShowCompactRequest &a, ShowCompactRequest &b) { (void) b; } -ShowCompactRequest::ShowCompactRequest(const ShowCompactRequest& other796) { - (void) other796; +ShowCompactRequest::ShowCompactRequest(const ShowCompactRequest& other798) { + (void) other798; } -ShowCompactRequest& ShowCompactRequest::operator=(const ShowCompactRequest& other797) { - (void) other797; +ShowCompactRequest& ShowCompactRequest::operator=(const ShowCompactRequest& other799) { + (void) other799; return *this; } void ShowCompactRequest::printTo(std::ostream& out) const { @@ -20031,9 +20137,9 @@ uint32_t ShowCompactResponseElement::read(::apache::thrift::protocol::TProtocol* break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast798; - xfer += iprot->readI32(ecast798); - this->type = (CompactionType::type)ecast798; + int32_t ecast800; + xfer += iprot->readI32(ecast800); + this->type = (CompactionType::type)ecast800; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -20220,37 +20326,37 @@ void swap(ShowCompactResponseElement &a, ShowCompactResponseElement &b) { swap(a.__isset, b.__isset); } -ShowCompactResponseElement::ShowCompactResponseElement(const ShowCompactResponseElement& other799) { - dbname = other799.dbname; - tablename = other799.tablename; - partitionname = other799.partitionname; - type = other799.type; - state = other799.state; - workerid = other799.workerid; - start = other799.start; - runAs = other799.runAs; - hightestTxnId = other799.hightestTxnId; - metaInfo = other799.metaInfo; - endTime = other799.endTime; - hadoopJobId = other799.hadoopJobId; - id = other799.id; - __isset = other799.__isset; -} -ShowCompactResponseElement& ShowCompactResponseElement::operator=(const ShowCompactResponseElement& other800) { - dbname = other800.dbname; - tablename = other800.tablename; - partitionname = other800.partitionname; - type = other800.type; - state = other800.state; - workerid = other800.workerid; - start = other800.start; - runAs = other800.runAs; - hightestTxnId = other800.hightestTxnId; - metaInfo = other800.metaInfo; - endTime = other800.endTime; - hadoopJobId = other800.hadoopJobId; - id = other800.id; - __isset = other800.__isset; +ShowCompactResponseElement::ShowCompactResponseElement(const ShowCompactResponseElement& other801) { + dbname = other801.dbname; + tablename = other801.tablename; + partitionname = other801.partitionname; + type = other801.type; + state = other801.state; + workerid = other801.workerid; + start = other801.start; + runAs = other801.runAs; + hightestTxnId = other801.hightestTxnId; + metaInfo = other801.metaInfo; + endTime = other801.endTime; + hadoopJobId = other801.hadoopJobId; + id = other801.id; + __isset = other801.__isset; +} +ShowCompactResponseElement& ShowCompactResponseElement::operator=(const ShowCompactResponseElement& other802) { + dbname = other802.dbname; + tablename = other802.tablename; + partitionname = other802.partitionname; + type = other802.type; + state = other802.state; + workerid = other802.workerid; + start = other802.start; + runAs = other802.runAs; + hightestTxnId = other802.hightestTxnId; + metaInfo = other802.metaInfo; + endTime = other802.endTime; + hadoopJobId = other802.hadoopJobId; + id = other802.id; + __isset = other802.__isset; return *this; } void ShowCompactResponseElement::printTo(std::ostream& out) const { @@ -20307,14 +20413,14 @@ uint32_t ShowCompactResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->compacts.clear(); - uint32_t _size801; - ::apache::thrift::protocol::TType _etype804; - xfer += iprot->readListBegin(_etype804, _size801); - this->compacts.resize(_size801); - uint32_t _i805; - for (_i805 = 0; _i805 < _size801; ++_i805) + uint32_t _size803; + ::apache::thrift::protocol::TType _etype806; + xfer += iprot->readListBegin(_etype806, _size803); + this->compacts.resize(_size803); + uint32_t _i807; + for (_i807 = 0; _i807 < _size803; ++_i807) { - xfer += this->compacts[_i805].read(iprot); + xfer += this->compacts[_i807].read(iprot); } xfer += iprot->readListEnd(); } @@ -20345,10 +20451,10 @@ uint32_t ShowCompactResponse::write(::apache::thrift::protocol::TProtocol* oprot xfer += oprot->writeFieldBegin("compacts", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->compacts.size())); - std::vector ::const_iterator _iter806; - for (_iter806 = this->compacts.begin(); _iter806 != this->compacts.end(); ++_iter806) + std::vector ::const_iterator _iter808; + for (_iter808 = this->compacts.begin(); _iter808 != this->compacts.end(); ++_iter808) { - xfer += (*_iter806).write(oprot); + xfer += (*_iter808).write(oprot); } xfer += oprot->writeListEnd(); } @@ -20364,11 +20470,11 @@ void swap(ShowCompactResponse &a, ShowCompactResponse &b) { swap(a.compacts, b.compacts); } -ShowCompactResponse::ShowCompactResponse(const ShowCompactResponse& other807) { - compacts = other807.compacts; +ShowCompactResponse::ShowCompactResponse(const ShowCompactResponse& other809) { + compacts = other809.compacts; } -ShowCompactResponse& ShowCompactResponse::operator=(const ShowCompactResponse& other808) { - compacts = other808.compacts; +ShowCompactResponse& ShowCompactResponse::operator=(const ShowCompactResponse& other810) { + compacts = other810.compacts; return *this; } void ShowCompactResponse::printTo(std::ostream& out) const { @@ -20470,14 +20576,14 @@ uint32_t AddDynamicPartitions::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionnames.clear(); - uint32_t _size809; - ::apache::thrift::protocol::TType _etype812; - xfer += iprot->readListBegin(_etype812, _size809); - this->partitionnames.resize(_size809); - uint32_t _i813; - for (_i813 = 0; _i813 < _size809; ++_i813) + uint32_t _size811; + ::apache::thrift::protocol::TType _etype814; + xfer += iprot->readListBegin(_etype814, _size811); + this->partitionnames.resize(_size811); + uint32_t _i815; + for (_i815 = 0; _i815 < _size811; ++_i815) { - xfer += iprot->readString(this->partitionnames[_i813]); + xfer += iprot->readString(this->partitionnames[_i815]); } xfer += iprot->readListEnd(); } @@ -20488,9 +20594,9 @@ uint32_t AddDynamicPartitions::read(::apache::thrift::protocol::TProtocol* iprot break; case 6: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast814; - xfer += iprot->readI32(ecast814); - this->operationType = (DataOperationType::type)ecast814; + int32_t ecast816; + xfer += iprot->readI32(ecast816); + this->operationType = (DataOperationType::type)ecast816; this->__isset.operationType = true; } else { xfer += iprot->skip(ftype); @@ -20542,10 +20648,10 @@ uint32_t AddDynamicPartitions::write(::apache::thrift::protocol::TProtocol* opro xfer += oprot->writeFieldBegin("partitionnames", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partitionnames.size())); - std::vector ::const_iterator _iter815; - for (_iter815 = this->partitionnames.begin(); _iter815 != this->partitionnames.end(); ++_iter815) + std::vector ::const_iterator _iter817; + for (_iter817 = this->partitionnames.begin(); _iter817 != this->partitionnames.end(); ++_iter817) { - xfer += oprot->writeString((*_iter815)); + xfer += oprot->writeString((*_iter817)); } xfer += oprot->writeListEnd(); } @@ -20572,23 +20678,23 @@ void swap(AddDynamicPartitions &a, AddDynamicPartitions &b) { swap(a.__isset, b.__isset); } -AddDynamicPartitions::AddDynamicPartitions(const AddDynamicPartitions& other816) { - txnid = other816.txnid; - writeid = other816.writeid; - dbname = other816.dbname; - tablename = other816.tablename; - partitionnames = other816.partitionnames; - operationType = other816.operationType; - __isset = other816.__isset; -} -AddDynamicPartitions& AddDynamicPartitions::operator=(const AddDynamicPartitions& other817) { - txnid = other817.txnid; - writeid = other817.writeid; - dbname = other817.dbname; - tablename = other817.tablename; - partitionnames = other817.partitionnames; - operationType = other817.operationType; - __isset = other817.__isset; +AddDynamicPartitions::AddDynamicPartitions(const AddDynamicPartitions& other818) { + txnid = other818.txnid; + writeid = other818.writeid; + dbname = other818.dbname; + tablename = other818.tablename; + partitionnames = other818.partitionnames; + operationType = other818.operationType; + __isset = other818.__isset; +} +AddDynamicPartitions& AddDynamicPartitions::operator=(const AddDynamicPartitions& other819) { + txnid = other819.txnid; + writeid = other819.writeid; + dbname = other819.dbname; + tablename = other819.tablename; + partitionnames = other819.partitionnames; + operationType = other819.operationType; + __isset = other819.__isset; return *this; } void AddDynamicPartitions::printTo(std::ostream& out) const { @@ -20771,23 +20877,23 @@ void swap(BasicTxnInfo &a, BasicTxnInfo &b) { swap(a.__isset, b.__isset); } -BasicTxnInfo::BasicTxnInfo(const BasicTxnInfo& other818) { - isnull = other818.isnull; - time = other818.time; - txnid = other818.txnid; - dbname = other818.dbname; - tablename = other818.tablename; - partitionname = other818.partitionname; - __isset = other818.__isset; -} -BasicTxnInfo& BasicTxnInfo::operator=(const BasicTxnInfo& other819) { - isnull = other819.isnull; - time = other819.time; - txnid = other819.txnid; - dbname = other819.dbname; - tablename = other819.tablename; - partitionname = other819.partitionname; - __isset = other819.__isset; +BasicTxnInfo::BasicTxnInfo(const BasicTxnInfo& other820) { + isnull = other820.isnull; + time = other820.time; + txnid = other820.txnid; + dbname = other820.dbname; + tablename = other820.tablename; + partitionname = other820.partitionname; + __isset = other820.__isset; +} +BasicTxnInfo& BasicTxnInfo::operator=(const BasicTxnInfo& other821) { + isnull = other821.isnull; + time = other821.time; + txnid = other821.txnid; + dbname = other821.dbname; + tablename = other821.tablename; + partitionname = other821.partitionname; + __isset = other821.__isset; return *this; } void BasicTxnInfo::printTo(std::ostream& out) const { @@ -20881,15 +20987,15 @@ uint32_t CreationMetadata::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_SET) { { this->tablesUsed.clear(); - uint32_t _size820; - ::apache::thrift::protocol::TType _etype823; - xfer += iprot->readSetBegin(_etype823, _size820); - uint32_t _i824; - for (_i824 = 0; _i824 < _size820; ++_i824) + uint32_t _size822; + ::apache::thrift::protocol::TType _etype825; + xfer += iprot->readSetBegin(_etype825, _size822); + uint32_t _i826; + for (_i826 = 0; _i826 < _size822; ++_i826) { - std::string _elem825; - xfer += iprot->readString(_elem825); - this->tablesUsed.insert(_elem825); + std::string _elem827; + xfer += iprot->readString(_elem827); + this->tablesUsed.insert(_elem827); } xfer += iprot->readSetEnd(); } @@ -20946,10 +21052,10 @@ uint32_t CreationMetadata::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("tablesUsed", ::apache::thrift::protocol::T_SET, 4); { xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast(this->tablesUsed.size())); - std::set ::const_iterator _iter826; - for (_iter826 = this->tablesUsed.begin(); _iter826 != this->tablesUsed.end(); ++_iter826) + std::set ::const_iterator _iter828; + for (_iter828 = this->tablesUsed.begin(); _iter828 != this->tablesUsed.end(); ++_iter828) { - xfer += oprot->writeString((*_iter826)); + xfer += oprot->writeString((*_iter828)); } xfer += oprot->writeSetEnd(); } @@ -20975,21 +21081,21 @@ void swap(CreationMetadata &a, CreationMetadata &b) { swap(a.__isset, b.__isset); } -CreationMetadata::CreationMetadata(const CreationMetadata& other827) { - catName = other827.catName; - dbName = other827.dbName; - tblName = other827.tblName; - tablesUsed = other827.tablesUsed; - validTxnList = other827.validTxnList; - __isset = other827.__isset; -} -CreationMetadata& CreationMetadata::operator=(const CreationMetadata& other828) { - catName = other828.catName; - dbName = other828.dbName; - tblName = other828.tblName; - tablesUsed = other828.tablesUsed; - validTxnList = other828.validTxnList; - __isset = other828.__isset; +CreationMetadata::CreationMetadata(const CreationMetadata& other829) { + catName = other829.catName; + dbName = other829.dbName; + tblName = other829.tblName; + tablesUsed = other829.tablesUsed; + validTxnList = other829.validTxnList; + __isset = other829.__isset; +} +CreationMetadata& CreationMetadata::operator=(const CreationMetadata& other830) { + catName = other830.catName; + dbName = other830.dbName; + tblName = other830.tblName; + tablesUsed = other830.tablesUsed; + validTxnList = other830.validTxnList; + __isset = other830.__isset; return *this; } void CreationMetadata::printTo(std::ostream& out) const { @@ -21095,15 +21201,15 @@ void swap(NotificationEventRequest &a, NotificationEventRequest &b) { swap(a.__isset, b.__isset); } -NotificationEventRequest::NotificationEventRequest(const NotificationEventRequest& other829) { - lastEvent = other829.lastEvent; - maxEvents = other829.maxEvents; - __isset = other829.__isset; +NotificationEventRequest::NotificationEventRequest(const NotificationEventRequest& other831) { + lastEvent = other831.lastEvent; + maxEvents = other831.maxEvents; + __isset = other831.__isset; } -NotificationEventRequest& NotificationEventRequest::operator=(const NotificationEventRequest& other830) { - lastEvent = other830.lastEvent; - maxEvents = other830.maxEvents; - __isset = other830.__isset; +NotificationEventRequest& NotificationEventRequest::operator=(const NotificationEventRequest& other832) { + lastEvent = other832.lastEvent; + maxEvents = other832.maxEvents; + __isset = other832.__isset; return *this; } void NotificationEventRequest::printTo(std::ostream& out) const { @@ -21323,27 +21429,27 @@ void swap(NotificationEvent &a, NotificationEvent &b) { swap(a.__isset, b.__isset); } -NotificationEvent::NotificationEvent(const NotificationEvent& other831) { - eventId = other831.eventId; - eventTime = other831.eventTime; - eventType = other831.eventType; - dbName = other831.dbName; - tableName = other831.tableName; - message = other831.message; - messageFormat = other831.messageFormat; - catName = other831.catName; - __isset = other831.__isset; -} -NotificationEvent& NotificationEvent::operator=(const NotificationEvent& other832) { - eventId = other832.eventId; - eventTime = other832.eventTime; - eventType = other832.eventType; - dbName = other832.dbName; - tableName = other832.tableName; - message = other832.message; - messageFormat = other832.messageFormat; - catName = other832.catName; - __isset = other832.__isset; +NotificationEvent::NotificationEvent(const NotificationEvent& other833) { + eventId = other833.eventId; + eventTime = other833.eventTime; + eventType = other833.eventType; + dbName = other833.dbName; + tableName = other833.tableName; + message = other833.message; + messageFormat = other833.messageFormat; + catName = other833.catName; + __isset = other833.__isset; +} +NotificationEvent& NotificationEvent::operator=(const NotificationEvent& other834) { + eventId = other834.eventId; + eventTime = other834.eventTime; + eventType = other834.eventType; + dbName = other834.dbName; + tableName = other834.tableName; + message = other834.message; + messageFormat = other834.messageFormat; + catName = other834.catName; + __isset = other834.__isset; return *this; } void NotificationEvent::printTo(std::ostream& out) const { @@ -21395,14 +21501,14 @@ uint32_t NotificationEventResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->events.clear(); - uint32_t _size833; - ::apache::thrift::protocol::TType _etype836; - xfer += iprot->readListBegin(_etype836, _size833); - this->events.resize(_size833); - uint32_t _i837; - for (_i837 = 0; _i837 < _size833; ++_i837) + uint32_t _size835; + ::apache::thrift::protocol::TType _etype838; + xfer += iprot->readListBegin(_etype838, _size835); + this->events.resize(_size835); + uint32_t _i839; + for (_i839 = 0; _i839 < _size835; ++_i839) { - xfer += this->events[_i837].read(iprot); + xfer += this->events[_i839].read(iprot); } xfer += iprot->readListEnd(); } @@ -21433,10 +21539,10 @@ uint32_t NotificationEventResponse::write(::apache::thrift::protocol::TProtocol* xfer += oprot->writeFieldBegin("events", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->events.size())); - std::vector ::const_iterator _iter838; - for (_iter838 = this->events.begin(); _iter838 != this->events.end(); ++_iter838) + std::vector ::const_iterator _iter840; + for (_iter840 = this->events.begin(); _iter840 != this->events.end(); ++_iter840) { - xfer += (*_iter838).write(oprot); + xfer += (*_iter840).write(oprot); } xfer += oprot->writeListEnd(); } @@ -21452,11 +21558,11 @@ void swap(NotificationEventResponse &a, NotificationEventResponse &b) { swap(a.events, b.events); } -NotificationEventResponse::NotificationEventResponse(const NotificationEventResponse& other839) { - events = other839.events; +NotificationEventResponse::NotificationEventResponse(const NotificationEventResponse& other841) { + events = other841.events; } -NotificationEventResponse& NotificationEventResponse::operator=(const NotificationEventResponse& other840) { - events = other840.events; +NotificationEventResponse& NotificationEventResponse::operator=(const NotificationEventResponse& other842) { + events = other842.events; return *this; } void NotificationEventResponse::printTo(std::ostream& out) const { @@ -21538,11 +21644,11 @@ void swap(CurrentNotificationEventId &a, CurrentNotificationEventId &b) { swap(a.eventId, b.eventId); } -CurrentNotificationEventId::CurrentNotificationEventId(const CurrentNotificationEventId& other841) { - eventId = other841.eventId; +CurrentNotificationEventId::CurrentNotificationEventId(const CurrentNotificationEventId& other843) { + eventId = other843.eventId; } -CurrentNotificationEventId& CurrentNotificationEventId::operator=(const CurrentNotificationEventId& other842) { - eventId = other842.eventId; +CurrentNotificationEventId& CurrentNotificationEventId::operator=(const CurrentNotificationEventId& other844) { + eventId = other844.eventId; return *this; } void CurrentNotificationEventId::printTo(std::ostream& out) const { @@ -21664,17 +21770,17 @@ void swap(NotificationEventsCountRequest &a, NotificationEventsCountRequest &b) swap(a.__isset, b.__isset); } -NotificationEventsCountRequest::NotificationEventsCountRequest(const NotificationEventsCountRequest& other843) { - fromEventId = other843.fromEventId; - dbName = other843.dbName; - catName = other843.catName; - __isset = other843.__isset; +NotificationEventsCountRequest::NotificationEventsCountRequest(const NotificationEventsCountRequest& other845) { + fromEventId = other845.fromEventId; + dbName = other845.dbName; + catName = other845.catName; + __isset = other845.__isset; } -NotificationEventsCountRequest& NotificationEventsCountRequest::operator=(const NotificationEventsCountRequest& other844) { - fromEventId = other844.fromEventId; - dbName = other844.dbName; - catName = other844.catName; - __isset = other844.__isset; +NotificationEventsCountRequest& NotificationEventsCountRequest::operator=(const NotificationEventsCountRequest& other846) { + fromEventId = other846.fromEventId; + dbName = other846.dbName; + catName = other846.catName; + __isset = other846.__isset; return *this; } void NotificationEventsCountRequest::printTo(std::ostream& out) const { @@ -21758,11 +21864,11 @@ void swap(NotificationEventsCountResponse &a, NotificationEventsCountResponse &b swap(a.eventsCount, b.eventsCount); } -NotificationEventsCountResponse::NotificationEventsCountResponse(const NotificationEventsCountResponse& other845) { - eventsCount = other845.eventsCount; +NotificationEventsCountResponse::NotificationEventsCountResponse(const NotificationEventsCountResponse& other847) { + eventsCount = other847.eventsCount; } -NotificationEventsCountResponse& NotificationEventsCountResponse::operator=(const NotificationEventsCountResponse& other846) { - eventsCount = other846.eventsCount; +NotificationEventsCountResponse& NotificationEventsCountResponse::operator=(const NotificationEventsCountResponse& other848) { + eventsCount = other848.eventsCount; return *this; } void NotificationEventsCountResponse::printTo(std::ostream& out) const { @@ -21825,14 +21931,14 @@ uint32_t InsertEventRequestData::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->filesAdded.clear(); - uint32_t _size847; - ::apache::thrift::protocol::TType _etype850; - xfer += iprot->readListBegin(_etype850, _size847); - this->filesAdded.resize(_size847); - uint32_t _i851; - for (_i851 = 0; _i851 < _size847; ++_i851) + uint32_t _size849; + ::apache::thrift::protocol::TType _etype852; + xfer += iprot->readListBegin(_etype852, _size849); + this->filesAdded.resize(_size849); + uint32_t _i853; + for (_i853 = 0; _i853 < _size849; ++_i853) { - xfer += iprot->readString(this->filesAdded[_i851]); + xfer += iprot->readString(this->filesAdded[_i853]); } xfer += iprot->readListEnd(); } @@ -21845,14 +21951,14 @@ uint32_t InsertEventRequestData::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->filesAddedChecksum.clear(); - uint32_t _size852; - ::apache::thrift::protocol::TType _etype855; - xfer += iprot->readListBegin(_etype855, _size852); - this->filesAddedChecksum.resize(_size852); - uint32_t _i856; - for (_i856 = 0; _i856 < _size852; ++_i856) + uint32_t _size854; + ::apache::thrift::protocol::TType _etype857; + xfer += iprot->readListBegin(_etype857, _size854); + this->filesAddedChecksum.resize(_size854); + uint32_t _i858; + for (_i858 = 0; _i858 < _size854; ++_i858) { - xfer += iprot->readString(this->filesAddedChecksum[_i856]); + xfer += iprot->readString(this->filesAddedChecksum[_i858]); } xfer += iprot->readListEnd(); } @@ -21888,10 +21994,10 @@ uint32_t InsertEventRequestData::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("filesAdded", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->filesAdded.size())); - std::vector ::const_iterator _iter857; - for (_iter857 = this->filesAdded.begin(); _iter857 != this->filesAdded.end(); ++_iter857) + std::vector ::const_iterator _iter859; + for (_iter859 = this->filesAdded.begin(); _iter859 != this->filesAdded.end(); ++_iter859) { - xfer += oprot->writeString((*_iter857)); + xfer += oprot->writeString((*_iter859)); } xfer += oprot->writeListEnd(); } @@ -21901,10 +22007,10 @@ uint32_t InsertEventRequestData::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("filesAddedChecksum", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->filesAddedChecksum.size())); - std::vector ::const_iterator _iter858; - for (_iter858 = this->filesAddedChecksum.begin(); _iter858 != this->filesAddedChecksum.end(); ++_iter858) + std::vector ::const_iterator _iter860; + for (_iter860 = this->filesAddedChecksum.begin(); _iter860 != this->filesAddedChecksum.end(); ++_iter860) { - xfer += oprot->writeString((*_iter858)); + xfer += oprot->writeString((*_iter860)); } xfer += oprot->writeListEnd(); } @@ -21923,17 +22029,17 @@ void swap(InsertEventRequestData &a, InsertEventRequestData &b) { swap(a.__isset, b.__isset); } -InsertEventRequestData::InsertEventRequestData(const InsertEventRequestData& other859) { - replace = other859.replace; - filesAdded = other859.filesAdded; - filesAddedChecksum = other859.filesAddedChecksum; - __isset = other859.__isset; +InsertEventRequestData::InsertEventRequestData(const InsertEventRequestData& other861) { + replace = other861.replace; + filesAdded = other861.filesAdded; + filesAddedChecksum = other861.filesAddedChecksum; + __isset = other861.__isset; } -InsertEventRequestData& InsertEventRequestData::operator=(const InsertEventRequestData& other860) { - replace = other860.replace; - filesAdded = other860.filesAdded; - filesAddedChecksum = other860.filesAddedChecksum; - __isset = other860.__isset; +InsertEventRequestData& InsertEventRequestData::operator=(const InsertEventRequestData& other862) { + replace = other862.replace; + filesAdded = other862.filesAdded; + filesAddedChecksum = other862.filesAddedChecksum; + __isset = other862.__isset; return *this; } void InsertEventRequestData::printTo(std::ostream& out) const { @@ -22015,13 +22121,13 @@ void swap(FireEventRequestData &a, FireEventRequestData &b) { swap(a.__isset, b.__isset); } -FireEventRequestData::FireEventRequestData(const FireEventRequestData& other861) { - insertData = other861.insertData; - __isset = other861.__isset; +FireEventRequestData::FireEventRequestData(const FireEventRequestData& other863) { + insertData = other863.insertData; + __isset = other863.__isset; } -FireEventRequestData& FireEventRequestData::operator=(const FireEventRequestData& other862) { - insertData = other862.insertData; - __isset = other862.__isset; +FireEventRequestData& FireEventRequestData::operator=(const FireEventRequestData& other864) { + insertData = other864.insertData; + __isset = other864.__isset; return *this; } void FireEventRequestData::printTo(std::ostream& out) const { @@ -22123,14 +22229,14 @@ uint32_t FireEventRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionVals.clear(); - uint32_t _size863; - ::apache::thrift::protocol::TType _etype866; - xfer += iprot->readListBegin(_etype866, _size863); - this->partitionVals.resize(_size863); - uint32_t _i867; - for (_i867 = 0; _i867 < _size863; ++_i867) + uint32_t _size865; + ::apache::thrift::protocol::TType _etype868; + xfer += iprot->readListBegin(_etype868, _size865); + this->partitionVals.resize(_size865); + uint32_t _i869; + for (_i869 = 0; _i869 < _size865; ++_i869) { - xfer += iprot->readString(this->partitionVals[_i867]); + xfer += iprot->readString(this->partitionVals[_i869]); } xfer += iprot->readListEnd(); } @@ -22190,10 +22296,10 @@ uint32_t FireEventRequest::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("partitionVals", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partitionVals.size())); - std::vector ::const_iterator _iter868; - for (_iter868 = this->partitionVals.begin(); _iter868 != this->partitionVals.end(); ++_iter868) + std::vector ::const_iterator _iter870; + for (_iter870 = this->partitionVals.begin(); _iter870 != this->partitionVals.end(); ++_iter870) { - xfer += oprot->writeString((*_iter868)); + xfer += oprot->writeString((*_iter870)); } xfer += oprot->writeListEnd(); } @@ -22220,23 +22326,23 @@ void swap(FireEventRequest &a, FireEventRequest &b) { swap(a.__isset, b.__isset); } -FireEventRequest::FireEventRequest(const FireEventRequest& other869) { - successful = other869.successful; - data = other869.data; - dbName = other869.dbName; - tableName = other869.tableName; - partitionVals = other869.partitionVals; - catName = other869.catName; - __isset = other869.__isset; -} -FireEventRequest& FireEventRequest::operator=(const FireEventRequest& other870) { - successful = other870.successful; - data = other870.data; - dbName = other870.dbName; - tableName = other870.tableName; - partitionVals = other870.partitionVals; - catName = other870.catName; - __isset = other870.__isset; +FireEventRequest::FireEventRequest(const FireEventRequest& other871) { + successful = other871.successful; + data = other871.data; + dbName = other871.dbName; + tableName = other871.tableName; + partitionVals = other871.partitionVals; + catName = other871.catName; + __isset = other871.__isset; +} +FireEventRequest& FireEventRequest::operator=(const FireEventRequest& other872) { + successful = other872.successful; + data = other872.data; + dbName = other872.dbName; + tableName = other872.tableName; + partitionVals = other872.partitionVals; + catName = other872.catName; + __isset = other872.__isset; return *this; } void FireEventRequest::printTo(std::ostream& out) const { @@ -22300,11 +22406,11 @@ void swap(FireEventResponse &a, FireEventResponse &b) { (void) b; } -FireEventResponse::FireEventResponse(const FireEventResponse& other871) { - (void) other871; +FireEventResponse::FireEventResponse(const FireEventResponse& other873) { + (void) other873; } -FireEventResponse& FireEventResponse::operator=(const FireEventResponse& other872) { - (void) other872; +FireEventResponse& FireEventResponse::operator=(const FireEventResponse& other874) { + (void) other874; return *this; } void FireEventResponse::printTo(std::ostream& out) const { @@ -22404,15 +22510,15 @@ void swap(MetadataPpdResult &a, MetadataPpdResult &b) { swap(a.__isset, b.__isset); } -MetadataPpdResult::MetadataPpdResult(const MetadataPpdResult& other873) { - metadata = other873.metadata; - includeBitset = other873.includeBitset; - __isset = other873.__isset; +MetadataPpdResult::MetadataPpdResult(const MetadataPpdResult& other875) { + metadata = other875.metadata; + includeBitset = other875.includeBitset; + __isset = other875.__isset; } -MetadataPpdResult& MetadataPpdResult::operator=(const MetadataPpdResult& other874) { - metadata = other874.metadata; - includeBitset = other874.includeBitset; - __isset = other874.__isset; +MetadataPpdResult& MetadataPpdResult::operator=(const MetadataPpdResult& other876) { + metadata = other876.metadata; + includeBitset = other876.includeBitset; + __isset = other876.__isset; return *this; } void MetadataPpdResult::printTo(std::ostream& out) const { @@ -22463,17 +22569,17 @@ uint32_t GetFileMetadataByExprResult::read(::apache::thrift::protocol::TProtocol if (ftype == ::apache::thrift::protocol::T_MAP) { { this->metadata.clear(); - uint32_t _size875; - ::apache::thrift::protocol::TType _ktype876; - ::apache::thrift::protocol::TType _vtype877; - xfer += iprot->readMapBegin(_ktype876, _vtype877, _size875); - uint32_t _i879; - for (_i879 = 0; _i879 < _size875; ++_i879) + uint32_t _size877; + ::apache::thrift::protocol::TType _ktype878; + ::apache::thrift::protocol::TType _vtype879; + xfer += iprot->readMapBegin(_ktype878, _vtype879, _size877); + uint32_t _i881; + for (_i881 = 0; _i881 < _size877; ++_i881) { - int64_t _key880; - xfer += iprot->readI64(_key880); - MetadataPpdResult& _val881 = this->metadata[_key880]; - xfer += _val881.read(iprot); + int64_t _key882; + xfer += iprot->readI64(_key882); + MetadataPpdResult& _val883 = this->metadata[_key882]; + xfer += _val883.read(iprot); } xfer += iprot->readMapEnd(); } @@ -22514,11 +22620,11 @@ uint32_t GetFileMetadataByExprResult::write(::apache::thrift::protocol::TProtoco xfer += oprot->writeFieldBegin("metadata", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_I64, ::apache::thrift::protocol::T_STRUCT, static_cast(this->metadata.size())); - std::map ::const_iterator _iter882; - for (_iter882 = this->metadata.begin(); _iter882 != this->metadata.end(); ++_iter882) + std::map ::const_iterator _iter884; + for (_iter884 = this->metadata.begin(); _iter884 != this->metadata.end(); ++_iter884) { - xfer += oprot->writeI64(_iter882->first); - xfer += _iter882->second.write(oprot); + xfer += oprot->writeI64(_iter884->first); + xfer += _iter884->second.write(oprot); } xfer += oprot->writeMapEnd(); } @@ -22539,13 +22645,13 @@ void swap(GetFileMetadataByExprResult &a, GetFileMetadataByExprResult &b) { swap(a.isSupported, b.isSupported); } -GetFileMetadataByExprResult::GetFileMetadataByExprResult(const GetFileMetadataByExprResult& other883) { - metadata = other883.metadata; - isSupported = other883.isSupported; +GetFileMetadataByExprResult::GetFileMetadataByExprResult(const GetFileMetadataByExprResult& other885) { + metadata = other885.metadata; + isSupported = other885.isSupported; } -GetFileMetadataByExprResult& GetFileMetadataByExprResult::operator=(const GetFileMetadataByExprResult& other884) { - metadata = other884.metadata; - isSupported = other884.isSupported; +GetFileMetadataByExprResult& GetFileMetadataByExprResult::operator=(const GetFileMetadataByExprResult& other886) { + metadata = other886.metadata; + isSupported = other886.isSupported; return *this; } void GetFileMetadataByExprResult::printTo(std::ostream& out) const { @@ -22606,14 +22712,14 @@ uint32_t GetFileMetadataByExprRequest::read(::apache::thrift::protocol::TProtoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size885; - ::apache::thrift::protocol::TType _etype888; - xfer += iprot->readListBegin(_etype888, _size885); - this->fileIds.resize(_size885); - uint32_t _i889; - for (_i889 = 0; _i889 < _size885; ++_i889) + uint32_t _size887; + ::apache::thrift::protocol::TType _etype890; + xfer += iprot->readListBegin(_etype890, _size887); + this->fileIds.resize(_size887); + uint32_t _i891; + for (_i891 = 0; _i891 < _size887; ++_i891) { - xfer += iprot->readI64(this->fileIds[_i889]); + xfer += iprot->readI64(this->fileIds[_i891]); } xfer += iprot->readListEnd(); } @@ -22640,9 +22746,9 @@ uint32_t GetFileMetadataByExprRequest::read(::apache::thrift::protocol::TProtoco break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast890; - xfer += iprot->readI32(ecast890); - this->type = (FileMetadataExprType::type)ecast890; + int32_t ecast892; + xfer += iprot->readI32(ecast892); + this->type = (FileMetadataExprType::type)ecast892; this->__isset.type = true; } else { xfer += iprot->skip(ftype); @@ -22672,10 +22778,10 @@ uint32_t GetFileMetadataByExprRequest::write(::apache::thrift::protocol::TProtoc xfer += oprot->writeFieldBegin("fileIds", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->fileIds.size())); - std::vector ::const_iterator _iter891; - for (_iter891 = this->fileIds.begin(); _iter891 != this->fileIds.end(); ++_iter891) + std::vector ::const_iterator _iter893; + for (_iter893 = this->fileIds.begin(); _iter893 != this->fileIds.end(); ++_iter893) { - xfer += oprot->writeI64((*_iter891)); + xfer += oprot->writeI64((*_iter893)); } xfer += oprot->writeListEnd(); } @@ -22709,19 +22815,19 @@ void swap(GetFileMetadataByExprRequest &a, GetFileMetadataByExprRequest &b) { swap(a.__isset, b.__isset); } -GetFileMetadataByExprRequest::GetFileMetadataByExprRequest(const GetFileMetadataByExprRequest& other892) { - fileIds = other892.fileIds; - expr = other892.expr; - doGetFooters = other892.doGetFooters; - type = other892.type; - __isset = other892.__isset; +GetFileMetadataByExprRequest::GetFileMetadataByExprRequest(const GetFileMetadataByExprRequest& other894) { + fileIds = other894.fileIds; + expr = other894.expr; + doGetFooters = other894.doGetFooters; + type = other894.type; + __isset = other894.__isset; } -GetFileMetadataByExprRequest& GetFileMetadataByExprRequest::operator=(const GetFileMetadataByExprRequest& other893) { - fileIds = other893.fileIds; - expr = other893.expr; - doGetFooters = other893.doGetFooters; - type = other893.type; - __isset = other893.__isset; +GetFileMetadataByExprRequest& GetFileMetadataByExprRequest::operator=(const GetFileMetadataByExprRequest& other895) { + fileIds = other895.fileIds; + expr = other895.expr; + doGetFooters = other895.doGetFooters; + type = other895.type; + __isset = other895.__isset; return *this; } void GetFileMetadataByExprRequest::printTo(std::ostream& out) const { @@ -22774,17 +22880,17 @@ uint32_t GetFileMetadataResult::read(::apache::thrift::protocol::TProtocol* ipro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->metadata.clear(); - uint32_t _size894; - ::apache::thrift::protocol::TType _ktype895; - ::apache::thrift::protocol::TType _vtype896; - xfer += iprot->readMapBegin(_ktype895, _vtype896, _size894); - uint32_t _i898; - for (_i898 = 0; _i898 < _size894; ++_i898) + uint32_t _size896; + ::apache::thrift::protocol::TType _ktype897; + ::apache::thrift::protocol::TType _vtype898; + xfer += iprot->readMapBegin(_ktype897, _vtype898, _size896); + uint32_t _i900; + for (_i900 = 0; _i900 < _size896; ++_i900) { - int64_t _key899; - xfer += iprot->readI64(_key899); - std::string& _val900 = this->metadata[_key899]; - xfer += iprot->readBinary(_val900); + int64_t _key901; + xfer += iprot->readI64(_key901); + std::string& _val902 = this->metadata[_key901]; + xfer += iprot->readBinary(_val902); } xfer += iprot->readMapEnd(); } @@ -22825,11 +22931,11 @@ uint32_t GetFileMetadataResult::write(::apache::thrift::protocol::TProtocol* opr xfer += oprot->writeFieldBegin("metadata", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_I64, ::apache::thrift::protocol::T_STRING, static_cast(this->metadata.size())); - std::map ::const_iterator _iter901; - for (_iter901 = this->metadata.begin(); _iter901 != this->metadata.end(); ++_iter901) + std::map ::const_iterator _iter903; + for (_iter903 = this->metadata.begin(); _iter903 != this->metadata.end(); ++_iter903) { - xfer += oprot->writeI64(_iter901->first); - xfer += oprot->writeBinary(_iter901->second); + xfer += oprot->writeI64(_iter903->first); + xfer += oprot->writeBinary(_iter903->second); } xfer += oprot->writeMapEnd(); } @@ -22850,13 +22956,13 @@ void swap(GetFileMetadataResult &a, GetFileMetadataResult &b) { swap(a.isSupported, b.isSupported); } -GetFileMetadataResult::GetFileMetadataResult(const GetFileMetadataResult& other902) { - metadata = other902.metadata; - isSupported = other902.isSupported; +GetFileMetadataResult::GetFileMetadataResult(const GetFileMetadataResult& other904) { + metadata = other904.metadata; + isSupported = other904.isSupported; } -GetFileMetadataResult& GetFileMetadataResult::operator=(const GetFileMetadataResult& other903) { - metadata = other903.metadata; - isSupported = other903.isSupported; +GetFileMetadataResult& GetFileMetadataResult::operator=(const GetFileMetadataResult& other905) { + metadata = other905.metadata; + isSupported = other905.isSupported; return *this; } void GetFileMetadataResult::printTo(std::ostream& out) const { @@ -22902,14 +23008,14 @@ uint32_t GetFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size904; - ::apache::thrift::protocol::TType _etype907; - xfer += iprot->readListBegin(_etype907, _size904); - this->fileIds.resize(_size904); - uint32_t _i908; - for (_i908 = 0; _i908 < _size904; ++_i908) + uint32_t _size906; + ::apache::thrift::protocol::TType _etype909; + xfer += iprot->readListBegin(_etype909, _size906); + this->fileIds.resize(_size906); + uint32_t _i910; + for (_i910 = 0; _i910 < _size906; ++_i910) { - xfer += iprot->readI64(this->fileIds[_i908]); + xfer += iprot->readI64(this->fileIds[_i910]); } xfer += iprot->readListEnd(); } @@ -22940,10 +23046,10 @@ uint32_t GetFileMetadataRequest::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("fileIds", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->fileIds.size())); - std::vector ::const_iterator _iter909; - for (_iter909 = this->fileIds.begin(); _iter909 != this->fileIds.end(); ++_iter909) + std::vector ::const_iterator _iter911; + for (_iter911 = this->fileIds.begin(); _iter911 != this->fileIds.end(); ++_iter911) { - xfer += oprot->writeI64((*_iter909)); + xfer += oprot->writeI64((*_iter911)); } xfer += oprot->writeListEnd(); } @@ -22959,11 +23065,11 @@ void swap(GetFileMetadataRequest &a, GetFileMetadataRequest &b) { swap(a.fileIds, b.fileIds); } -GetFileMetadataRequest::GetFileMetadataRequest(const GetFileMetadataRequest& other910) { - fileIds = other910.fileIds; +GetFileMetadataRequest::GetFileMetadataRequest(const GetFileMetadataRequest& other912) { + fileIds = other912.fileIds; } -GetFileMetadataRequest& GetFileMetadataRequest::operator=(const GetFileMetadataRequest& other911) { - fileIds = other911.fileIds; +GetFileMetadataRequest& GetFileMetadataRequest::operator=(const GetFileMetadataRequest& other913) { + fileIds = other913.fileIds; return *this; } void GetFileMetadataRequest::printTo(std::ostream& out) const { @@ -23022,11 +23128,11 @@ void swap(PutFileMetadataResult &a, PutFileMetadataResult &b) { (void) b; } -PutFileMetadataResult::PutFileMetadataResult(const PutFileMetadataResult& other912) { - (void) other912; +PutFileMetadataResult::PutFileMetadataResult(const PutFileMetadataResult& other914) { + (void) other914; } -PutFileMetadataResult& PutFileMetadataResult::operator=(const PutFileMetadataResult& other913) { - (void) other913; +PutFileMetadataResult& PutFileMetadataResult::operator=(const PutFileMetadataResult& other915) { + (void) other915; return *this; } void PutFileMetadataResult::printTo(std::ostream& out) const { @@ -23080,14 +23186,14 @@ uint32_t PutFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size914; - ::apache::thrift::protocol::TType _etype917; - xfer += iprot->readListBegin(_etype917, _size914); - this->fileIds.resize(_size914); - uint32_t _i918; - for (_i918 = 0; _i918 < _size914; ++_i918) + uint32_t _size916; + ::apache::thrift::protocol::TType _etype919; + xfer += iprot->readListBegin(_etype919, _size916); + this->fileIds.resize(_size916); + uint32_t _i920; + for (_i920 = 0; _i920 < _size916; ++_i920) { - xfer += iprot->readI64(this->fileIds[_i918]); + xfer += iprot->readI64(this->fileIds[_i920]); } xfer += iprot->readListEnd(); } @@ -23100,14 +23206,14 @@ uint32_t PutFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->metadata.clear(); - uint32_t _size919; - ::apache::thrift::protocol::TType _etype922; - xfer += iprot->readListBegin(_etype922, _size919); - this->metadata.resize(_size919); - uint32_t _i923; - for (_i923 = 0; _i923 < _size919; ++_i923) + uint32_t _size921; + ::apache::thrift::protocol::TType _etype924; + xfer += iprot->readListBegin(_etype924, _size921); + this->metadata.resize(_size921); + uint32_t _i925; + for (_i925 = 0; _i925 < _size921; ++_i925) { - xfer += iprot->readBinary(this->metadata[_i923]); + xfer += iprot->readBinary(this->metadata[_i925]); } xfer += iprot->readListEnd(); } @@ -23118,9 +23224,9 @@ uint32_t PutFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast924; - xfer += iprot->readI32(ecast924); - this->type = (FileMetadataExprType::type)ecast924; + int32_t ecast926; + xfer += iprot->readI32(ecast926); + this->type = (FileMetadataExprType::type)ecast926; this->__isset.type = true; } else { xfer += iprot->skip(ftype); @@ -23150,10 +23256,10 @@ uint32_t PutFileMetadataRequest::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("fileIds", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->fileIds.size())); - std::vector ::const_iterator _iter925; - for (_iter925 = this->fileIds.begin(); _iter925 != this->fileIds.end(); ++_iter925) + std::vector ::const_iterator _iter927; + for (_iter927 = this->fileIds.begin(); _iter927 != this->fileIds.end(); ++_iter927) { - xfer += oprot->writeI64((*_iter925)); + xfer += oprot->writeI64((*_iter927)); } xfer += oprot->writeListEnd(); } @@ -23162,10 +23268,10 @@ uint32_t PutFileMetadataRequest::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("metadata", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->metadata.size())); - std::vector ::const_iterator _iter926; - for (_iter926 = this->metadata.begin(); _iter926 != this->metadata.end(); ++_iter926) + std::vector ::const_iterator _iter928; + for (_iter928 = this->metadata.begin(); _iter928 != this->metadata.end(); ++_iter928) { - xfer += oprot->writeBinary((*_iter926)); + xfer += oprot->writeBinary((*_iter928)); } xfer += oprot->writeListEnd(); } @@ -23189,17 +23295,17 @@ void swap(PutFileMetadataRequest &a, PutFileMetadataRequest &b) { swap(a.__isset, b.__isset); } -PutFileMetadataRequest::PutFileMetadataRequest(const PutFileMetadataRequest& other927) { - fileIds = other927.fileIds; - metadata = other927.metadata; - type = other927.type; - __isset = other927.__isset; +PutFileMetadataRequest::PutFileMetadataRequest(const PutFileMetadataRequest& other929) { + fileIds = other929.fileIds; + metadata = other929.metadata; + type = other929.type; + __isset = other929.__isset; } -PutFileMetadataRequest& PutFileMetadataRequest::operator=(const PutFileMetadataRequest& other928) { - fileIds = other928.fileIds; - metadata = other928.metadata; - type = other928.type; - __isset = other928.__isset; +PutFileMetadataRequest& PutFileMetadataRequest::operator=(const PutFileMetadataRequest& other930) { + fileIds = other930.fileIds; + metadata = other930.metadata; + type = other930.type; + __isset = other930.__isset; return *this; } void PutFileMetadataRequest::printTo(std::ostream& out) const { @@ -23260,11 +23366,11 @@ void swap(ClearFileMetadataResult &a, ClearFileMetadataResult &b) { (void) b; } -ClearFileMetadataResult::ClearFileMetadataResult(const ClearFileMetadataResult& other929) { - (void) other929; +ClearFileMetadataResult::ClearFileMetadataResult(const ClearFileMetadataResult& other931) { + (void) other931; } -ClearFileMetadataResult& ClearFileMetadataResult::operator=(const ClearFileMetadataResult& other930) { - (void) other930; +ClearFileMetadataResult& ClearFileMetadataResult::operator=(const ClearFileMetadataResult& other932) { + (void) other932; return *this; } void ClearFileMetadataResult::printTo(std::ostream& out) const { @@ -23308,14 +23414,14 @@ uint32_t ClearFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* i if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size931; - ::apache::thrift::protocol::TType _etype934; - xfer += iprot->readListBegin(_etype934, _size931); - this->fileIds.resize(_size931); - uint32_t _i935; - for (_i935 = 0; _i935 < _size931; ++_i935) + uint32_t _size933; + ::apache::thrift::protocol::TType _etype936; + xfer += iprot->readListBegin(_etype936, _size933); + this->fileIds.resize(_size933); + uint32_t _i937; + for (_i937 = 0; _i937 < _size933; ++_i937) { - xfer += iprot->readI64(this->fileIds[_i935]); + xfer += iprot->readI64(this->fileIds[_i937]); } xfer += iprot->readListEnd(); } @@ -23346,10 +23452,10 @@ uint32_t ClearFileMetadataRequest::write(::apache::thrift::protocol::TProtocol* xfer += oprot->writeFieldBegin("fileIds", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->fileIds.size())); - std::vector ::const_iterator _iter936; - for (_iter936 = this->fileIds.begin(); _iter936 != this->fileIds.end(); ++_iter936) + std::vector ::const_iterator _iter938; + for (_iter938 = this->fileIds.begin(); _iter938 != this->fileIds.end(); ++_iter938) { - xfer += oprot->writeI64((*_iter936)); + xfer += oprot->writeI64((*_iter938)); } xfer += oprot->writeListEnd(); } @@ -23365,11 +23471,11 @@ void swap(ClearFileMetadataRequest &a, ClearFileMetadataRequest &b) { swap(a.fileIds, b.fileIds); } -ClearFileMetadataRequest::ClearFileMetadataRequest(const ClearFileMetadataRequest& other937) { - fileIds = other937.fileIds; +ClearFileMetadataRequest::ClearFileMetadataRequest(const ClearFileMetadataRequest& other939) { + fileIds = other939.fileIds; } -ClearFileMetadataRequest& ClearFileMetadataRequest::operator=(const ClearFileMetadataRequest& other938) { - fileIds = other938.fileIds; +ClearFileMetadataRequest& ClearFileMetadataRequest::operator=(const ClearFileMetadataRequest& other940) { + fileIds = other940.fileIds; return *this; } void ClearFileMetadataRequest::printTo(std::ostream& out) const { @@ -23451,11 +23557,11 @@ void swap(CacheFileMetadataResult &a, CacheFileMetadataResult &b) { swap(a.isSupported, b.isSupported); } -CacheFileMetadataResult::CacheFileMetadataResult(const CacheFileMetadataResult& other939) { - isSupported = other939.isSupported; +CacheFileMetadataResult::CacheFileMetadataResult(const CacheFileMetadataResult& other941) { + isSupported = other941.isSupported; } -CacheFileMetadataResult& CacheFileMetadataResult::operator=(const CacheFileMetadataResult& other940) { - isSupported = other940.isSupported; +CacheFileMetadataResult& CacheFileMetadataResult::operator=(const CacheFileMetadataResult& other942) { + isSupported = other942.isSupported; return *this; } void CacheFileMetadataResult::printTo(std::ostream& out) const { @@ -23596,19 +23702,19 @@ void swap(CacheFileMetadataRequest &a, CacheFileMetadataRequest &b) { swap(a.__isset, b.__isset); } -CacheFileMetadataRequest::CacheFileMetadataRequest(const CacheFileMetadataRequest& other941) { - dbName = other941.dbName; - tblName = other941.tblName; - partName = other941.partName; - isAllParts = other941.isAllParts; - __isset = other941.__isset; +CacheFileMetadataRequest::CacheFileMetadataRequest(const CacheFileMetadataRequest& other943) { + dbName = other943.dbName; + tblName = other943.tblName; + partName = other943.partName; + isAllParts = other943.isAllParts; + __isset = other943.__isset; } -CacheFileMetadataRequest& CacheFileMetadataRequest::operator=(const CacheFileMetadataRequest& other942) { - dbName = other942.dbName; - tblName = other942.tblName; - partName = other942.partName; - isAllParts = other942.isAllParts; - __isset = other942.__isset; +CacheFileMetadataRequest& CacheFileMetadataRequest::operator=(const CacheFileMetadataRequest& other944) { + dbName = other944.dbName; + tblName = other944.tblName; + partName = other944.partName; + isAllParts = other944.isAllParts; + __isset = other944.__isset; return *this; } void CacheFileMetadataRequest::printTo(std::ostream& out) const { @@ -23656,14 +23762,14 @@ uint32_t GetAllFunctionsResponse::read(::apache::thrift::protocol::TProtocol* ip if (ftype == ::apache::thrift::protocol::T_LIST) { { this->functions.clear(); - uint32_t _size943; - ::apache::thrift::protocol::TType _etype946; - xfer += iprot->readListBegin(_etype946, _size943); - this->functions.resize(_size943); - uint32_t _i947; - for (_i947 = 0; _i947 < _size943; ++_i947) + uint32_t _size945; + ::apache::thrift::protocol::TType _etype948; + xfer += iprot->readListBegin(_etype948, _size945); + this->functions.resize(_size945); + uint32_t _i949; + for (_i949 = 0; _i949 < _size945; ++_i949) { - xfer += this->functions[_i947].read(iprot); + xfer += this->functions[_i949].read(iprot); } xfer += iprot->readListEnd(); } @@ -23693,10 +23799,10 @@ uint32_t GetAllFunctionsResponse::write(::apache::thrift::protocol::TProtocol* o xfer += oprot->writeFieldBegin("functions", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->functions.size())); - std::vector ::const_iterator _iter948; - for (_iter948 = this->functions.begin(); _iter948 != this->functions.end(); ++_iter948) + std::vector ::const_iterator _iter950; + for (_iter950 = this->functions.begin(); _iter950 != this->functions.end(); ++_iter950) { - xfer += (*_iter948).write(oprot); + xfer += (*_iter950).write(oprot); } xfer += oprot->writeListEnd(); } @@ -23713,13 +23819,13 @@ void swap(GetAllFunctionsResponse &a, GetAllFunctionsResponse &b) { swap(a.__isset, b.__isset); } -GetAllFunctionsResponse::GetAllFunctionsResponse(const GetAllFunctionsResponse& other949) { - functions = other949.functions; - __isset = other949.__isset; +GetAllFunctionsResponse::GetAllFunctionsResponse(const GetAllFunctionsResponse& other951) { + functions = other951.functions; + __isset = other951.__isset; } -GetAllFunctionsResponse& GetAllFunctionsResponse::operator=(const GetAllFunctionsResponse& other950) { - functions = other950.functions; - __isset = other950.__isset; +GetAllFunctionsResponse& GetAllFunctionsResponse::operator=(const GetAllFunctionsResponse& other952) { + functions = other952.functions; + __isset = other952.__isset; return *this; } void GetAllFunctionsResponse::printTo(std::ostream& out) const { @@ -23764,16 +23870,16 @@ uint32_t ClientCapabilities::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->values.clear(); - uint32_t _size951; - ::apache::thrift::protocol::TType _etype954; - xfer += iprot->readListBegin(_etype954, _size951); - this->values.resize(_size951); - uint32_t _i955; - for (_i955 = 0; _i955 < _size951; ++_i955) + uint32_t _size953; + ::apache::thrift::protocol::TType _etype956; + xfer += iprot->readListBegin(_etype956, _size953); + this->values.resize(_size953); + uint32_t _i957; + for (_i957 = 0; _i957 < _size953; ++_i957) { - int32_t ecast956; - xfer += iprot->readI32(ecast956); - this->values[_i955] = (ClientCapability::type)ecast956; + int32_t ecast958; + xfer += iprot->readI32(ecast958); + this->values[_i957] = (ClientCapability::type)ecast958; } xfer += iprot->readListEnd(); } @@ -23804,10 +23910,10 @@ uint32_t ClientCapabilities::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I32, static_cast(this->values.size())); - std::vector ::const_iterator _iter957; - for (_iter957 = this->values.begin(); _iter957 != this->values.end(); ++_iter957) + std::vector ::const_iterator _iter959; + for (_iter959 = this->values.begin(); _iter959 != this->values.end(); ++_iter959) { - xfer += oprot->writeI32((int32_t)(*_iter957)); + xfer += oprot->writeI32((int32_t)(*_iter959)); } xfer += oprot->writeListEnd(); } @@ -23823,11 +23929,11 @@ void swap(ClientCapabilities &a, ClientCapabilities &b) { swap(a.values, b.values); } -ClientCapabilities::ClientCapabilities(const ClientCapabilities& other958) { - values = other958.values; +ClientCapabilities::ClientCapabilities(const ClientCapabilities& other960) { + values = other960.values; } -ClientCapabilities& ClientCapabilities::operator=(const ClientCapabilities& other959) { - values = other959.values; +ClientCapabilities& ClientCapabilities::operator=(const ClientCapabilities& other961) { + values = other961.values; return *this; } void ClientCapabilities::printTo(std::ostream& out) const { @@ -23968,19 +24074,19 @@ void swap(GetTableRequest &a, GetTableRequest &b) { swap(a.__isset, b.__isset); } -GetTableRequest::GetTableRequest(const GetTableRequest& other960) { - dbName = other960.dbName; - tblName = other960.tblName; - capabilities = other960.capabilities; - catName = other960.catName; - __isset = other960.__isset; +GetTableRequest::GetTableRequest(const GetTableRequest& other962) { + dbName = other962.dbName; + tblName = other962.tblName; + capabilities = other962.capabilities; + catName = other962.catName; + __isset = other962.__isset; } -GetTableRequest& GetTableRequest::operator=(const GetTableRequest& other961) { - dbName = other961.dbName; - tblName = other961.tblName; - capabilities = other961.capabilities; - catName = other961.catName; - __isset = other961.__isset; +GetTableRequest& GetTableRequest::operator=(const GetTableRequest& other963) { + dbName = other963.dbName; + tblName = other963.tblName; + capabilities = other963.capabilities; + catName = other963.catName; + __isset = other963.__isset; return *this; } void GetTableRequest::printTo(std::ostream& out) const { @@ -24065,11 +24171,11 @@ void swap(GetTableResult &a, GetTableResult &b) { swap(a.table, b.table); } -GetTableResult::GetTableResult(const GetTableResult& other962) { - table = other962.table; +GetTableResult::GetTableResult(const GetTableResult& other964) { + table = other964.table; } -GetTableResult& GetTableResult::operator=(const GetTableResult& other963) { - table = other963.table; +GetTableResult& GetTableResult::operator=(const GetTableResult& other965) { + table = other965.table; return *this; } void GetTableResult::printTo(std::ostream& out) const { @@ -24137,14 +24243,14 @@ uint32_t GetTablesRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tblNames.clear(); - uint32_t _size964; - ::apache::thrift::protocol::TType _etype967; - xfer += iprot->readListBegin(_etype967, _size964); - this->tblNames.resize(_size964); - uint32_t _i968; - for (_i968 = 0; _i968 < _size964; ++_i968) + uint32_t _size966; + ::apache::thrift::protocol::TType _etype969; + xfer += iprot->readListBegin(_etype969, _size966); + this->tblNames.resize(_size966); + uint32_t _i970; + for (_i970 = 0; _i970 < _size966; ++_i970) { - xfer += iprot->readString(this->tblNames[_i968]); + xfer += iprot->readString(this->tblNames[_i970]); } xfer += iprot->readListEnd(); } @@ -24196,10 +24302,10 @@ uint32_t GetTablesRequest::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("tblNames", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->tblNames.size())); - std::vector ::const_iterator _iter969; - for (_iter969 = this->tblNames.begin(); _iter969 != this->tblNames.end(); ++_iter969) + std::vector ::const_iterator _iter971; + for (_iter971 = this->tblNames.begin(); _iter971 != this->tblNames.end(); ++_iter971) { - xfer += oprot->writeString((*_iter969)); + xfer += oprot->writeString((*_iter971)); } xfer += oprot->writeListEnd(); } @@ -24229,19 +24335,19 @@ void swap(GetTablesRequest &a, GetTablesRequest &b) { swap(a.__isset, b.__isset); } -GetTablesRequest::GetTablesRequest(const GetTablesRequest& other970) { - dbName = other970.dbName; - tblNames = other970.tblNames; - capabilities = other970.capabilities; - catName = other970.catName; - __isset = other970.__isset; +GetTablesRequest::GetTablesRequest(const GetTablesRequest& other972) { + dbName = other972.dbName; + tblNames = other972.tblNames; + capabilities = other972.capabilities; + catName = other972.catName; + __isset = other972.__isset; } -GetTablesRequest& GetTablesRequest::operator=(const GetTablesRequest& other971) { - dbName = other971.dbName; - tblNames = other971.tblNames; - capabilities = other971.capabilities; - catName = other971.catName; - __isset = other971.__isset; +GetTablesRequest& GetTablesRequest::operator=(const GetTablesRequest& other973) { + dbName = other973.dbName; + tblNames = other973.tblNames; + capabilities = other973.capabilities; + catName = other973.catName; + __isset = other973.__isset; return *this; } void GetTablesRequest::printTo(std::ostream& out) const { @@ -24289,14 +24395,14 @@ uint32_t GetTablesResult::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tables.clear(); - uint32_t _size972; - ::apache::thrift::protocol::TType _etype975; - xfer += iprot->readListBegin(_etype975, _size972); - this->tables.resize(_size972); - uint32_t _i976; - for (_i976 = 0; _i976 < _size972; ++_i976) + uint32_t _size974; + ::apache::thrift::protocol::TType _etype977; + xfer += iprot->readListBegin(_etype977, _size974); + this->tables.resize(_size974); + uint32_t _i978; + for (_i978 = 0; _i978 < _size974; ++_i978) { - xfer += this->tables[_i976].read(iprot); + xfer += this->tables[_i978].read(iprot); } xfer += iprot->readListEnd(); } @@ -24327,10 +24433,10 @@ uint32_t GetTablesResult::write(::apache::thrift::protocol::TProtocol* oprot) co xfer += oprot->writeFieldBegin("tables", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->tables.size())); - std::vector
::const_iterator _iter977; - for (_iter977 = this->tables.begin(); _iter977 != this->tables.end(); ++_iter977) + std::vector
::const_iterator _iter979; + for (_iter979 = this->tables.begin(); _iter979 != this->tables.end(); ++_iter979) { - xfer += (*_iter977).write(oprot); + xfer += (*_iter979).write(oprot); } xfer += oprot->writeListEnd(); } @@ -24346,11 +24452,11 @@ void swap(GetTablesResult &a, GetTablesResult &b) { swap(a.tables, b.tables); } -GetTablesResult::GetTablesResult(const GetTablesResult& other978) { - tables = other978.tables; +GetTablesResult::GetTablesResult(const GetTablesResult& other980) { + tables = other980.tables; } -GetTablesResult& GetTablesResult::operator=(const GetTablesResult& other979) { - tables = other979.tables; +GetTablesResult& GetTablesResult::operator=(const GetTablesResult& other981) { + tables = other981.tables; return *this; } void GetTablesResult::printTo(std::ostream& out) const { @@ -24452,13 +24558,13 @@ void swap(CmRecycleRequest &a, CmRecycleRequest &b) { swap(a.purge, b.purge); } -CmRecycleRequest::CmRecycleRequest(const CmRecycleRequest& other980) { - dataPath = other980.dataPath; - purge = other980.purge; +CmRecycleRequest::CmRecycleRequest(const CmRecycleRequest& other982) { + dataPath = other982.dataPath; + purge = other982.purge; } -CmRecycleRequest& CmRecycleRequest::operator=(const CmRecycleRequest& other981) { - dataPath = other981.dataPath; - purge = other981.purge; +CmRecycleRequest& CmRecycleRequest::operator=(const CmRecycleRequest& other983) { + dataPath = other983.dataPath; + purge = other983.purge; return *this; } void CmRecycleRequest::printTo(std::ostream& out) const { @@ -24518,11 +24624,11 @@ void swap(CmRecycleResponse &a, CmRecycleResponse &b) { (void) b; } -CmRecycleResponse::CmRecycleResponse(const CmRecycleResponse& other982) { - (void) other982; +CmRecycleResponse::CmRecycleResponse(const CmRecycleResponse& other984) { + (void) other984; } -CmRecycleResponse& CmRecycleResponse::operator=(const CmRecycleResponse& other983) { - (void) other983; +CmRecycleResponse& CmRecycleResponse::operator=(const CmRecycleResponse& other985) { + (void) other985; return *this; } void CmRecycleResponse::printTo(std::ostream& out) const { @@ -24682,21 +24788,21 @@ void swap(TableMeta &a, TableMeta &b) { swap(a.__isset, b.__isset); } -TableMeta::TableMeta(const TableMeta& other984) { - dbName = other984.dbName; - tableName = other984.tableName; - tableType = other984.tableType; - comments = other984.comments; - catName = other984.catName; - __isset = other984.__isset; -} -TableMeta& TableMeta::operator=(const TableMeta& other985) { - dbName = other985.dbName; - tableName = other985.tableName; - tableType = other985.tableType; - comments = other985.comments; - catName = other985.catName; - __isset = other985.__isset; +TableMeta::TableMeta(const TableMeta& other986) { + dbName = other986.dbName; + tableName = other986.tableName; + tableType = other986.tableType; + comments = other986.comments; + catName = other986.catName; + __isset = other986.__isset; +} +TableMeta& TableMeta::operator=(const TableMeta& other987) { + dbName = other987.dbName; + tableName = other987.tableName; + tableType = other987.tableType; + comments = other987.comments; + catName = other987.catName; + __isset = other987.__isset; return *this; } void TableMeta::printTo(std::ostream& out) const { @@ -24760,15 +24866,15 @@ uint32_t Materialization::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_SET) { { this->tablesUsed.clear(); - uint32_t _size986; - ::apache::thrift::protocol::TType _etype989; - xfer += iprot->readSetBegin(_etype989, _size986); - uint32_t _i990; - for (_i990 = 0; _i990 < _size986; ++_i990) + uint32_t _size988; + ::apache::thrift::protocol::TType _etype991; + xfer += iprot->readSetBegin(_etype991, _size988); + uint32_t _i992; + for (_i992 = 0; _i992 < _size988; ++_i992) { - std::string _elem991; - xfer += iprot->readString(_elem991); - this->tablesUsed.insert(_elem991); + std::string _elem993; + xfer += iprot->readString(_elem993); + this->tablesUsed.insert(_elem993); } xfer += iprot->readSetEnd(); } @@ -24823,10 +24929,10 @@ uint32_t Materialization::write(::apache::thrift::protocol::TProtocol* oprot) co xfer += oprot->writeFieldBegin("tablesUsed", ::apache::thrift::protocol::T_SET, 1); { xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast(this->tablesUsed.size())); - std::set ::const_iterator _iter992; - for (_iter992 = this->tablesUsed.begin(); _iter992 != this->tablesUsed.end(); ++_iter992) + std::set ::const_iterator _iter994; + for (_iter994 = this->tablesUsed.begin(); _iter994 != this->tablesUsed.end(); ++_iter994) { - xfer += oprot->writeString((*_iter992)); + xfer += oprot->writeString((*_iter994)); } xfer += oprot->writeSetEnd(); } @@ -24861,19 +24967,19 @@ void swap(Materialization &a, Materialization &b) { swap(a.__isset, b.__isset); } -Materialization::Materialization(const Materialization& other993) { - tablesUsed = other993.tablesUsed; - validTxnList = other993.validTxnList; - invalidationTime = other993.invalidationTime; - sourceTablesUpdateDeleteModified = other993.sourceTablesUpdateDeleteModified; - __isset = other993.__isset; +Materialization::Materialization(const Materialization& other995) { + tablesUsed = other995.tablesUsed; + validTxnList = other995.validTxnList; + invalidationTime = other995.invalidationTime; + sourceTablesUpdateDeleteModified = other995.sourceTablesUpdateDeleteModified; + __isset = other995.__isset; } -Materialization& Materialization::operator=(const Materialization& other994) { - tablesUsed = other994.tablesUsed; - validTxnList = other994.validTxnList; - invalidationTime = other994.invalidationTime; - sourceTablesUpdateDeleteModified = other994.sourceTablesUpdateDeleteModified; - __isset = other994.__isset; +Materialization& Materialization::operator=(const Materialization& other996) { + tablesUsed = other996.tablesUsed; + validTxnList = other996.validTxnList; + invalidationTime = other996.invalidationTime; + sourceTablesUpdateDeleteModified = other996.sourceTablesUpdateDeleteModified; + __isset = other996.__isset; return *this; } void Materialization::printTo(std::ostream& out) const { @@ -24942,9 +25048,9 @@ uint32_t WMResourcePlan::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast995; - xfer += iprot->readI32(ecast995); - this->status = (WMResourcePlanStatus::type)ecast995; + int32_t ecast997; + xfer += iprot->readI32(ecast997); + this->status = (WMResourcePlanStatus::type)ecast997; this->__isset.status = true; } else { xfer += iprot->skip(ftype); @@ -25018,19 +25124,19 @@ void swap(WMResourcePlan &a, WMResourcePlan &b) { swap(a.__isset, b.__isset); } -WMResourcePlan::WMResourcePlan(const WMResourcePlan& other996) { - name = other996.name; - status = other996.status; - queryParallelism = other996.queryParallelism; - defaultPoolPath = other996.defaultPoolPath; - __isset = other996.__isset; +WMResourcePlan::WMResourcePlan(const WMResourcePlan& other998) { + name = other998.name; + status = other998.status; + queryParallelism = other998.queryParallelism; + defaultPoolPath = other998.defaultPoolPath; + __isset = other998.__isset; } -WMResourcePlan& WMResourcePlan::operator=(const WMResourcePlan& other997) { - name = other997.name; - status = other997.status; - queryParallelism = other997.queryParallelism; - defaultPoolPath = other997.defaultPoolPath; - __isset = other997.__isset; +WMResourcePlan& WMResourcePlan::operator=(const WMResourcePlan& other999) { + name = other999.name; + status = other999.status; + queryParallelism = other999.queryParallelism; + defaultPoolPath = other999.defaultPoolPath; + __isset = other999.__isset; return *this; } void WMResourcePlan::printTo(std::ostream& out) const { @@ -25109,9 +25215,9 @@ uint32_t WMNullableResourcePlan::read(::apache::thrift::protocol::TProtocol* ipr break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast998; - xfer += iprot->readI32(ecast998); - this->status = (WMResourcePlanStatus::type)ecast998; + int32_t ecast1000; + xfer += iprot->readI32(ecast1000); + this->status = (WMResourcePlanStatus::type)ecast1000; this->__isset.status = true; } else { xfer += iprot->skip(ftype); @@ -25212,23 +25318,23 @@ void swap(WMNullableResourcePlan &a, WMNullableResourcePlan &b) { swap(a.__isset, b.__isset); } -WMNullableResourcePlan::WMNullableResourcePlan(const WMNullableResourcePlan& other999) { - name = other999.name; - status = other999.status; - queryParallelism = other999.queryParallelism; - isSetQueryParallelism = other999.isSetQueryParallelism; - defaultPoolPath = other999.defaultPoolPath; - isSetDefaultPoolPath = other999.isSetDefaultPoolPath; - __isset = other999.__isset; +WMNullableResourcePlan::WMNullableResourcePlan(const WMNullableResourcePlan& other1001) { + name = other1001.name; + status = other1001.status; + queryParallelism = other1001.queryParallelism; + isSetQueryParallelism = other1001.isSetQueryParallelism; + defaultPoolPath = other1001.defaultPoolPath; + isSetDefaultPoolPath = other1001.isSetDefaultPoolPath; + __isset = other1001.__isset; } -WMNullableResourcePlan& WMNullableResourcePlan::operator=(const WMNullableResourcePlan& other1000) { - name = other1000.name; - status = other1000.status; - queryParallelism = other1000.queryParallelism; - isSetQueryParallelism = other1000.isSetQueryParallelism; - defaultPoolPath = other1000.defaultPoolPath; - isSetDefaultPoolPath = other1000.isSetDefaultPoolPath; - __isset = other1000.__isset; +WMNullableResourcePlan& WMNullableResourcePlan::operator=(const WMNullableResourcePlan& other1002) { + name = other1002.name; + status = other1002.status; + queryParallelism = other1002.queryParallelism; + isSetQueryParallelism = other1002.isSetQueryParallelism; + defaultPoolPath = other1002.defaultPoolPath; + isSetDefaultPoolPath = other1002.isSetDefaultPoolPath; + __isset = other1002.__isset; return *this; } void WMNullableResourcePlan::printTo(std::ostream& out) const { @@ -25393,21 +25499,21 @@ void swap(WMPool &a, WMPool &b) { swap(a.__isset, b.__isset); } -WMPool::WMPool(const WMPool& other1001) { - resourcePlanName = other1001.resourcePlanName; - poolPath = other1001.poolPath; - allocFraction = other1001.allocFraction; - queryParallelism = other1001.queryParallelism; - schedulingPolicy = other1001.schedulingPolicy; - __isset = other1001.__isset; +WMPool::WMPool(const WMPool& other1003) { + resourcePlanName = other1003.resourcePlanName; + poolPath = other1003.poolPath; + allocFraction = other1003.allocFraction; + queryParallelism = other1003.queryParallelism; + schedulingPolicy = other1003.schedulingPolicy; + __isset = other1003.__isset; } -WMPool& WMPool::operator=(const WMPool& other1002) { - resourcePlanName = other1002.resourcePlanName; - poolPath = other1002.poolPath; - allocFraction = other1002.allocFraction; - queryParallelism = other1002.queryParallelism; - schedulingPolicy = other1002.schedulingPolicy; - __isset = other1002.__isset; +WMPool& WMPool::operator=(const WMPool& other1004) { + resourcePlanName = other1004.resourcePlanName; + poolPath = other1004.poolPath; + allocFraction = other1004.allocFraction; + queryParallelism = other1004.queryParallelism; + schedulingPolicy = other1004.schedulingPolicy; + __isset = other1004.__isset; return *this; } void WMPool::printTo(std::ostream& out) const { @@ -25590,23 +25696,23 @@ void swap(WMNullablePool &a, WMNullablePool &b) { swap(a.__isset, b.__isset); } -WMNullablePool::WMNullablePool(const WMNullablePool& other1003) { - resourcePlanName = other1003.resourcePlanName; - poolPath = other1003.poolPath; - allocFraction = other1003.allocFraction; - queryParallelism = other1003.queryParallelism; - schedulingPolicy = other1003.schedulingPolicy; - isSetSchedulingPolicy = other1003.isSetSchedulingPolicy; - __isset = other1003.__isset; +WMNullablePool::WMNullablePool(const WMNullablePool& other1005) { + resourcePlanName = other1005.resourcePlanName; + poolPath = other1005.poolPath; + allocFraction = other1005.allocFraction; + queryParallelism = other1005.queryParallelism; + schedulingPolicy = other1005.schedulingPolicy; + isSetSchedulingPolicy = other1005.isSetSchedulingPolicy; + __isset = other1005.__isset; } -WMNullablePool& WMNullablePool::operator=(const WMNullablePool& other1004) { - resourcePlanName = other1004.resourcePlanName; - poolPath = other1004.poolPath; - allocFraction = other1004.allocFraction; - queryParallelism = other1004.queryParallelism; - schedulingPolicy = other1004.schedulingPolicy; - isSetSchedulingPolicy = other1004.isSetSchedulingPolicy; - __isset = other1004.__isset; +WMNullablePool& WMNullablePool::operator=(const WMNullablePool& other1006) { + resourcePlanName = other1006.resourcePlanName; + poolPath = other1006.poolPath; + allocFraction = other1006.allocFraction; + queryParallelism = other1006.queryParallelism; + schedulingPolicy = other1006.schedulingPolicy; + isSetSchedulingPolicy = other1006.isSetSchedulingPolicy; + __isset = other1006.__isset; return *this; } void WMNullablePool::printTo(std::ostream& out) const { @@ -25771,21 +25877,21 @@ void swap(WMTrigger &a, WMTrigger &b) { swap(a.__isset, b.__isset); } -WMTrigger::WMTrigger(const WMTrigger& other1005) { - resourcePlanName = other1005.resourcePlanName; - triggerName = other1005.triggerName; - triggerExpression = other1005.triggerExpression; - actionExpression = other1005.actionExpression; - isInUnmanaged = other1005.isInUnmanaged; - __isset = other1005.__isset; +WMTrigger::WMTrigger(const WMTrigger& other1007) { + resourcePlanName = other1007.resourcePlanName; + triggerName = other1007.triggerName; + triggerExpression = other1007.triggerExpression; + actionExpression = other1007.actionExpression; + isInUnmanaged = other1007.isInUnmanaged; + __isset = other1007.__isset; } -WMTrigger& WMTrigger::operator=(const WMTrigger& other1006) { - resourcePlanName = other1006.resourcePlanName; - triggerName = other1006.triggerName; - triggerExpression = other1006.triggerExpression; - actionExpression = other1006.actionExpression; - isInUnmanaged = other1006.isInUnmanaged; - __isset = other1006.__isset; +WMTrigger& WMTrigger::operator=(const WMTrigger& other1008) { + resourcePlanName = other1008.resourcePlanName; + triggerName = other1008.triggerName; + triggerExpression = other1008.triggerExpression; + actionExpression = other1008.actionExpression; + isInUnmanaged = other1008.isInUnmanaged; + __isset = other1008.__isset; return *this; } void WMTrigger::printTo(std::ostream& out) const { @@ -25950,21 +26056,21 @@ void swap(WMMapping &a, WMMapping &b) { swap(a.__isset, b.__isset); } -WMMapping::WMMapping(const WMMapping& other1007) { - resourcePlanName = other1007.resourcePlanName; - entityType = other1007.entityType; - entityName = other1007.entityName; - poolPath = other1007.poolPath; - ordering = other1007.ordering; - __isset = other1007.__isset; -} -WMMapping& WMMapping::operator=(const WMMapping& other1008) { - resourcePlanName = other1008.resourcePlanName; - entityType = other1008.entityType; - entityName = other1008.entityName; - poolPath = other1008.poolPath; - ordering = other1008.ordering; - __isset = other1008.__isset; +WMMapping::WMMapping(const WMMapping& other1009) { + resourcePlanName = other1009.resourcePlanName; + entityType = other1009.entityType; + entityName = other1009.entityName; + poolPath = other1009.poolPath; + ordering = other1009.ordering; + __isset = other1009.__isset; +} +WMMapping& WMMapping::operator=(const WMMapping& other1010) { + resourcePlanName = other1010.resourcePlanName; + entityType = other1010.entityType; + entityName = other1010.entityName; + poolPath = other1010.poolPath; + ordering = other1010.ordering; + __isset = other1010.__isset; return *this; } void WMMapping::printTo(std::ostream& out) const { @@ -26070,13 +26176,13 @@ void swap(WMPoolTrigger &a, WMPoolTrigger &b) { swap(a.trigger, b.trigger); } -WMPoolTrigger::WMPoolTrigger(const WMPoolTrigger& other1009) { - pool = other1009.pool; - trigger = other1009.trigger; +WMPoolTrigger::WMPoolTrigger(const WMPoolTrigger& other1011) { + pool = other1011.pool; + trigger = other1011.trigger; } -WMPoolTrigger& WMPoolTrigger::operator=(const WMPoolTrigger& other1010) { - pool = other1010.pool; - trigger = other1010.trigger; +WMPoolTrigger& WMPoolTrigger::operator=(const WMPoolTrigger& other1012) { + pool = other1012.pool; + trigger = other1012.trigger; return *this; } void WMPoolTrigger::printTo(std::ostream& out) const { @@ -26150,14 +26256,14 @@ uint32_t WMFullResourcePlan::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->pools.clear(); - uint32_t _size1011; - ::apache::thrift::protocol::TType _etype1014; - xfer += iprot->readListBegin(_etype1014, _size1011); - this->pools.resize(_size1011); - uint32_t _i1015; - for (_i1015 = 0; _i1015 < _size1011; ++_i1015) + uint32_t _size1013; + ::apache::thrift::protocol::TType _etype1016; + xfer += iprot->readListBegin(_etype1016, _size1013); + this->pools.resize(_size1013); + uint32_t _i1017; + for (_i1017 = 0; _i1017 < _size1013; ++_i1017) { - xfer += this->pools[_i1015].read(iprot); + xfer += this->pools[_i1017].read(iprot); } xfer += iprot->readListEnd(); } @@ -26170,14 +26276,14 @@ uint32_t WMFullResourcePlan::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->mappings.clear(); - uint32_t _size1016; - ::apache::thrift::protocol::TType _etype1019; - xfer += iprot->readListBegin(_etype1019, _size1016); - this->mappings.resize(_size1016); - uint32_t _i1020; - for (_i1020 = 0; _i1020 < _size1016; ++_i1020) + uint32_t _size1018; + ::apache::thrift::protocol::TType _etype1021; + xfer += iprot->readListBegin(_etype1021, _size1018); + this->mappings.resize(_size1018); + uint32_t _i1022; + for (_i1022 = 0; _i1022 < _size1018; ++_i1022) { - xfer += this->mappings[_i1020].read(iprot); + xfer += this->mappings[_i1022].read(iprot); } xfer += iprot->readListEnd(); } @@ -26190,14 +26296,14 @@ uint32_t WMFullResourcePlan::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->triggers.clear(); - uint32_t _size1021; - ::apache::thrift::protocol::TType _etype1024; - xfer += iprot->readListBegin(_etype1024, _size1021); - this->triggers.resize(_size1021); - uint32_t _i1025; - for (_i1025 = 0; _i1025 < _size1021; ++_i1025) + uint32_t _size1023; + ::apache::thrift::protocol::TType _etype1026; + xfer += iprot->readListBegin(_etype1026, _size1023); + this->triggers.resize(_size1023); + uint32_t _i1027; + for (_i1027 = 0; _i1027 < _size1023; ++_i1027) { - xfer += this->triggers[_i1025].read(iprot); + xfer += this->triggers[_i1027].read(iprot); } xfer += iprot->readListEnd(); } @@ -26210,14 +26316,14 @@ uint32_t WMFullResourcePlan::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->poolTriggers.clear(); - uint32_t _size1026; - ::apache::thrift::protocol::TType _etype1029; - xfer += iprot->readListBegin(_etype1029, _size1026); - this->poolTriggers.resize(_size1026); - uint32_t _i1030; - for (_i1030 = 0; _i1030 < _size1026; ++_i1030) + uint32_t _size1028; + ::apache::thrift::protocol::TType _etype1031; + xfer += iprot->readListBegin(_etype1031, _size1028); + this->poolTriggers.resize(_size1028); + uint32_t _i1032; + for (_i1032 = 0; _i1032 < _size1028; ++_i1032) { - xfer += this->poolTriggers[_i1030].read(iprot); + xfer += this->poolTriggers[_i1032].read(iprot); } xfer += iprot->readListEnd(); } @@ -26254,10 +26360,10 @@ uint32_t WMFullResourcePlan::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("pools", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->pools.size())); - std::vector ::const_iterator _iter1031; - for (_iter1031 = this->pools.begin(); _iter1031 != this->pools.end(); ++_iter1031) + std::vector ::const_iterator _iter1033; + for (_iter1033 = this->pools.begin(); _iter1033 != this->pools.end(); ++_iter1033) { - xfer += (*_iter1031).write(oprot); + xfer += (*_iter1033).write(oprot); } xfer += oprot->writeListEnd(); } @@ -26267,10 +26373,10 @@ uint32_t WMFullResourcePlan::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("mappings", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->mappings.size())); - std::vector ::const_iterator _iter1032; - for (_iter1032 = this->mappings.begin(); _iter1032 != this->mappings.end(); ++_iter1032) + std::vector ::const_iterator _iter1034; + for (_iter1034 = this->mappings.begin(); _iter1034 != this->mappings.end(); ++_iter1034) { - xfer += (*_iter1032).write(oprot); + xfer += (*_iter1034).write(oprot); } xfer += oprot->writeListEnd(); } @@ -26280,10 +26386,10 @@ uint32_t WMFullResourcePlan::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("triggers", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->triggers.size())); - std::vector ::const_iterator _iter1033; - for (_iter1033 = this->triggers.begin(); _iter1033 != this->triggers.end(); ++_iter1033) + std::vector ::const_iterator _iter1035; + for (_iter1035 = this->triggers.begin(); _iter1035 != this->triggers.end(); ++_iter1035) { - xfer += (*_iter1033).write(oprot); + xfer += (*_iter1035).write(oprot); } xfer += oprot->writeListEnd(); } @@ -26293,10 +26399,10 @@ uint32_t WMFullResourcePlan::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("poolTriggers", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->poolTriggers.size())); - std::vector ::const_iterator _iter1034; - for (_iter1034 = this->poolTriggers.begin(); _iter1034 != this->poolTriggers.end(); ++_iter1034) + std::vector ::const_iterator _iter1036; + for (_iter1036 = this->poolTriggers.begin(); _iter1036 != this->poolTriggers.end(); ++_iter1036) { - xfer += (*_iter1034).write(oprot); + xfer += (*_iter1036).write(oprot); } xfer += oprot->writeListEnd(); } @@ -26317,21 +26423,21 @@ void swap(WMFullResourcePlan &a, WMFullResourcePlan &b) { swap(a.__isset, b.__isset); } -WMFullResourcePlan::WMFullResourcePlan(const WMFullResourcePlan& other1035) { - plan = other1035.plan; - pools = other1035.pools; - mappings = other1035.mappings; - triggers = other1035.triggers; - poolTriggers = other1035.poolTriggers; - __isset = other1035.__isset; -} -WMFullResourcePlan& WMFullResourcePlan::operator=(const WMFullResourcePlan& other1036) { - plan = other1036.plan; - pools = other1036.pools; - mappings = other1036.mappings; - triggers = other1036.triggers; - poolTriggers = other1036.poolTriggers; - __isset = other1036.__isset; +WMFullResourcePlan::WMFullResourcePlan(const WMFullResourcePlan& other1037) { + plan = other1037.plan; + pools = other1037.pools; + mappings = other1037.mappings; + triggers = other1037.triggers; + poolTriggers = other1037.poolTriggers; + __isset = other1037.__isset; +} +WMFullResourcePlan& WMFullResourcePlan::operator=(const WMFullResourcePlan& other1038) { + plan = other1038.plan; + pools = other1038.pools; + mappings = other1038.mappings; + triggers = other1038.triggers; + poolTriggers = other1038.poolTriggers; + __isset = other1038.__isset; return *this; } void WMFullResourcePlan::printTo(std::ostream& out) const { @@ -26436,15 +26542,15 @@ void swap(WMCreateResourcePlanRequest &a, WMCreateResourcePlanRequest &b) { swap(a.__isset, b.__isset); } -WMCreateResourcePlanRequest::WMCreateResourcePlanRequest(const WMCreateResourcePlanRequest& other1037) { - resourcePlan = other1037.resourcePlan; - copyFrom = other1037.copyFrom; - __isset = other1037.__isset; +WMCreateResourcePlanRequest::WMCreateResourcePlanRequest(const WMCreateResourcePlanRequest& other1039) { + resourcePlan = other1039.resourcePlan; + copyFrom = other1039.copyFrom; + __isset = other1039.__isset; } -WMCreateResourcePlanRequest& WMCreateResourcePlanRequest::operator=(const WMCreateResourcePlanRequest& other1038) { - resourcePlan = other1038.resourcePlan; - copyFrom = other1038.copyFrom; - __isset = other1038.__isset; +WMCreateResourcePlanRequest& WMCreateResourcePlanRequest::operator=(const WMCreateResourcePlanRequest& other1040) { + resourcePlan = other1040.resourcePlan; + copyFrom = other1040.copyFrom; + __isset = other1040.__isset; return *this; } void WMCreateResourcePlanRequest::printTo(std::ostream& out) const { @@ -26504,11 +26610,11 @@ void swap(WMCreateResourcePlanResponse &a, WMCreateResourcePlanResponse &b) { (void) b; } -WMCreateResourcePlanResponse::WMCreateResourcePlanResponse(const WMCreateResourcePlanResponse& other1039) { - (void) other1039; +WMCreateResourcePlanResponse::WMCreateResourcePlanResponse(const WMCreateResourcePlanResponse& other1041) { + (void) other1041; } -WMCreateResourcePlanResponse& WMCreateResourcePlanResponse::operator=(const WMCreateResourcePlanResponse& other1040) { - (void) other1040; +WMCreateResourcePlanResponse& WMCreateResourcePlanResponse::operator=(const WMCreateResourcePlanResponse& other1042) { + (void) other1042; return *this; } void WMCreateResourcePlanResponse::printTo(std::ostream& out) const { @@ -26566,11 +26672,11 @@ void swap(WMGetActiveResourcePlanRequest &a, WMGetActiveResourcePlanRequest &b) (void) b; } -WMGetActiveResourcePlanRequest::WMGetActiveResourcePlanRequest(const WMGetActiveResourcePlanRequest& other1041) { - (void) other1041; +WMGetActiveResourcePlanRequest::WMGetActiveResourcePlanRequest(const WMGetActiveResourcePlanRequest& other1043) { + (void) other1043; } -WMGetActiveResourcePlanRequest& WMGetActiveResourcePlanRequest::operator=(const WMGetActiveResourcePlanRequest& other1042) { - (void) other1042; +WMGetActiveResourcePlanRequest& WMGetActiveResourcePlanRequest::operator=(const WMGetActiveResourcePlanRequest& other1044) { + (void) other1044; return *this; } void WMGetActiveResourcePlanRequest::printTo(std::ostream& out) const { @@ -26651,13 +26757,13 @@ void swap(WMGetActiveResourcePlanResponse &a, WMGetActiveResourcePlanResponse &b swap(a.__isset, b.__isset); } -WMGetActiveResourcePlanResponse::WMGetActiveResourcePlanResponse(const WMGetActiveResourcePlanResponse& other1043) { - resourcePlan = other1043.resourcePlan; - __isset = other1043.__isset; +WMGetActiveResourcePlanResponse::WMGetActiveResourcePlanResponse(const WMGetActiveResourcePlanResponse& other1045) { + resourcePlan = other1045.resourcePlan; + __isset = other1045.__isset; } -WMGetActiveResourcePlanResponse& WMGetActiveResourcePlanResponse::operator=(const WMGetActiveResourcePlanResponse& other1044) { - resourcePlan = other1044.resourcePlan; - __isset = other1044.__isset; +WMGetActiveResourcePlanResponse& WMGetActiveResourcePlanResponse::operator=(const WMGetActiveResourcePlanResponse& other1046) { + resourcePlan = other1046.resourcePlan; + __isset = other1046.__isset; return *this; } void WMGetActiveResourcePlanResponse::printTo(std::ostream& out) const { @@ -26739,13 +26845,13 @@ void swap(WMGetResourcePlanRequest &a, WMGetResourcePlanRequest &b) { swap(a.__isset, b.__isset); } -WMGetResourcePlanRequest::WMGetResourcePlanRequest(const WMGetResourcePlanRequest& other1045) { - resourcePlanName = other1045.resourcePlanName; - __isset = other1045.__isset; +WMGetResourcePlanRequest::WMGetResourcePlanRequest(const WMGetResourcePlanRequest& other1047) { + resourcePlanName = other1047.resourcePlanName; + __isset = other1047.__isset; } -WMGetResourcePlanRequest& WMGetResourcePlanRequest::operator=(const WMGetResourcePlanRequest& other1046) { - resourcePlanName = other1046.resourcePlanName; - __isset = other1046.__isset; +WMGetResourcePlanRequest& WMGetResourcePlanRequest::operator=(const WMGetResourcePlanRequest& other1048) { + resourcePlanName = other1048.resourcePlanName; + __isset = other1048.__isset; return *this; } void WMGetResourcePlanRequest::printTo(std::ostream& out) const { @@ -26827,13 +26933,13 @@ void swap(WMGetResourcePlanResponse &a, WMGetResourcePlanResponse &b) { swap(a.__isset, b.__isset); } -WMGetResourcePlanResponse::WMGetResourcePlanResponse(const WMGetResourcePlanResponse& other1047) { - resourcePlan = other1047.resourcePlan; - __isset = other1047.__isset; +WMGetResourcePlanResponse::WMGetResourcePlanResponse(const WMGetResourcePlanResponse& other1049) { + resourcePlan = other1049.resourcePlan; + __isset = other1049.__isset; } -WMGetResourcePlanResponse& WMGetResourcePlanResponse::operator=(const WMGetResourcePlanResponse& other1048) { - resourcePlan = other1048.resourcePlan; - __isset = other1048.__isset; +WMGetResourcePlanResponse& WMGetResourcePlanResponse::operator=(const WMGetResourcePlanResponse& other1050) { + resourcePlan = other1050.resourcePlan; + __isset = other1050.__isset; return *this; } void WMGetResourcePlanResponse::printTo(std::ostream& out) const { @@ -26892,11 +26998,11 @@ void swap(WMGetAllResourcePlanRequest &a, WMGetAllResourcePlanRequest &b) { (void) b; } -WMGetAllResourcePlanRequest::WMGetAllResourcePlanRequest(const WMGetAllResourcePlanRequest& other1049) { - (void) other1049; +WMGetAllResourcePlanRequest::WMGetAllResourcePlanRequest(const WMGetAllResourcePlanRequest& other1051) { + (void) other1051; } -WMGetAllResourcePlanRequest& WMGetAllResourcePlanRequest::operator=(const WMGetAllResourcePlanRequest& other1050) { - (void) other1050; +WMGetAllResourcePlanRequest& WMGetAllResourcePlanRequest::operator=(const WMGetAllResourcePlanRequest& other1052) { + (void) other1052; return *this; } void WMGetAllResourcePlanRequest::printTo(std::ostream& out) const { @@ -26940,14 +27046,14 @@ uint32_t WMGetAllResourcePlanResponse::read(::apache::thrift::protocol::TProtoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->resourcePlans.clear(); - uint32_t _size1051; - ::apache::thrift::protocol::TType _etype1054; - xfer += iprot->readListBegin(_etype1054, _size1051); - this->resourcePlans.resize(_size1051); - uint32_t _i1055; - for (_i1055 = 0; _i1055 < _size1051; ++_i1055) + uint32_t _size1053; + ::apache::thrift::protocol::TType _etype1056; + xfer += iprot->readListBegin(_etype1056, _size1053); + this->resourcePlans.resize(_size1053); + uint32_t _i1057; + for (_i1057 = 0; _i1057 < _size1053; ++_i1057) { - xfer += this->resourcePlans[_i1055].read(iprot); + xfer += this->resourcePlans[_i1057].read(iprot); } xfer += iprot->readListEnd(); } @@ -26977,10 +27083,10 @@ uint32_t WMGetAllResourcePlanResponse::write(::apache::thrift::protocol::TProtoc xfer += oprot->writeFieldBegin("resourcePlans", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->resourcePlans.size())); - std::vector ::const_iterator _iter1056; - for (_iter1056 = this->resourcePlans.begin(); _iter1056 != this->resourcePlans.end(); ++_iter1056) + std::vector ::const_iterator _iter1058; + for (_iter1058 = this->resourcePlans.begin(); _iter1058 != this->resourcePlans.end(); ++_iter1058) { - xfer += (*_iter1056).write(oprot); + xfer += (*_iter1058).write(oprot); } xfer += oprot->writeListEnd(); } @@ -26997,13 +27103,13 @@ void swap(WMGetAllResourcePlanResponse &a, WMGetAllResourcePlanResponse &b) { swap(a.__isset, b.__isset); } -WMGetAllResourcePlanResponse::WMGetAllResourcePlanResponse(const WMGetAllResourcePlanResponse& other1057) { - resourcePlans = other1057.resourcePlans; - __isset = other1057.__isset; +WMGetAllResourcePlanResponse::WMGetAllResourcePlanResponse(const WMGetAllResourcePlanResponse& other1059) { + resourcePlans = other1059.resourcePlans; + __isset = other1059.__isset; } -WMGetAllResourcePlanResponse& WMGetAllResourcePlanResponse::operator=(const WMGetAllResourcePlanResponse& other1058) { - resourcePlans = other1058.resourcePlans; - __isset = other1058.__isset; +WMGetAllResourcePlanResponse& WMGetAllResourcePlanResponse::operator=(const WMGetAllResourcePlanResponse& other1060) { + resourcePlans = other1060.resourcePlans; + __isset = other1060.__isset; return *this; } void WMGetAllResourcePlanResponse::printTo(std::ostream& out) const { @@ -27161,21 +27267,21 @@ void swap(WMAlterResourcePlanRequest &a, WMAlterResourcePlanRequest &b) { swap(a.__isset, b.__isset); } -WMAlterResourcePlanRequest::WMAlterResourcePlanRequest(const WMAlterResourcePlanRequest& other1059) { - resourcePlanName = other1059.resourcePlanName; - resourcePlan = other1059.resourcePlan; - isEnableAndActivate = other1059.isEnableAndActivate; - isForceDeactivate = other1059.isForceDeactivate; - isReplace = other1059.isReplace; - __isset = other1059.__isset; +WMAlterResourcePlanRequest::WMAlterResourcePlanRequest(const WMAlterResourcePlanRequest& other1061) { + resourcePlanName = other1061.resourcePlanName; + resourcePlan = other1061.resourcePlan; + isEnableAndActivate = other1061.isEnableAndActivate; + isForceDeactivate = other1061.isForceDeactivate; + isReplace = other1061.isReplace; + __isset = other1061.__isset; } -WMAlterResourcePlanRequest& WMAlterResourcePlanRequest::operator=(const WMAlterResourcePlanRequest& other1060) { - resourcePlanName = other1060.resourcePlanName; - resourcePlan = other1060.resourcePlan; - isEnableAndActivate = other1060.isEnableAndActivate; - isForceDeactivate = other1060.isForceDeactivate; - isReplace = other1060.isReplace; - __isset = other1060.__isset; +WMAlterResourcePlanRequest& WMAlterResourcePlanRequest::operator=(const WMAlterResourcePlanRequest& other1062) { + resourcePlanName = other1062.resourcePlanName; + resourcePlan = other1062.resourcePlan; + isEnableAndActivate = other1062.isEnableAndActivate; + isForceDeactivate = other1062.isForceDeactivate; + isReplace = other1062.isReplace; + __isset = other1062.__isset; return *this; } void WMAlterResourcePlanRequest::printTo(std::ostream& out) const { @@ -27261,13 +27367,13 @@ void swap(WMAlterResourcePlanResponse &a, WMAlterResourcePlanResponse &b) { swap(a.__isset, b.__isset); } -WMAlterResourcePlanResponse::WMAlterResourcePlanResponse(const WMAlterResourcePlanResponse& other1061) { - fullResourcePlan = other1061.fullResourcePlan; - __isset = other1061.__isset; +WMAlterResourcePlanResponse::WMAlterResourcePlanResponse(const WMAlterResourcePlanResponse& other1063) { + fullResourcePlan = other1063.fullResourcePlan; + __isset = other1063.__isset; } -WMAlterResourcePlanResponse& WMAlterResourcePlanResponse::operator=(const WMAlterResourcePlanResponse& other1062) { - fullResourcePlan = other1062.fullResourcePlan; - __isset = other1062.__isset; +WMAlterResourcePlanResponse& WMAlterResourcePlanResponse::operator=(const WMAlterResourcePlanResponse& other1064) { + fullResourcePlan = other1064.fullResourcePlan; + __isset = other1064.__isset; return *this; } void WMAlterResourcePlanResponse::printTo(std::ostream& out) const { @@ -27349,13 +27455,13 @@ void swap(WMValidateResourcePlanRequest &a, WMValidateResourcePlanRequest &b) { swap(a.__isset, b.__isset); } -WMValidateResourcePlanRequest::WMValidateResourcePlanRequest(const WMValidateResourcePlanRequest& other1063) { - resourcePlanName = other1063.resourcePlanName; - __isset = other1063.__isset; +WMValidateResourcePlanRequest::WMValidateResourcePlanRequest(const WMValidateResourcePlanRequest& other1065) { + resourcePlanName = other1065.resourcePlanName; + __isset = other1065.__isset; } -WMValidateResourcePlanRequest& WMValidateResourcePlanRequest::operator=(const WMValidateResourcePlanRequest& other1064) { - resourcePlanName = other1064.resourcePlanName; - __isset = other1064.__isset; +WMValidateResourcePlanRequest& WMValidateResourcePlanRequest::operator=(const WMValidateResourcePlanRequest& other1066) { + resourcePlanName = other1066.resourcePlanName; + __isset = other1066.__isset; return *this; } void WMValidateResourcePlanRequest::printTo(std::ostream& out) const { @@ -27405,14 +27511,14 @@ uint32_t WMValidateResourcePlanResponse::read(::apache::thrift::protocol::TProto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->errors.clear(); - uint32_t _size1065; - ::apache::thrift::protocol::TType _etype1068; - xfer += iprot->readListBegin(_etype1068, _size1065); - this->errors.resize(_size1065); - uint32_t _i1069; - for (_i1069 = 0; _i1069 < _size1065; ++_i1069) + uint32_t _size1067; + ::apache::thrift::protocol::TType _etype1070; + xfer += iprot->readListBegin(_etype1070, _size1067); + this->errors.resize(_size1067); + uint32_t _i1071; + for (_i1071 = 0; _i1071 < _size1067; ++_i1071) { - xfer += iprot->readString(this->errors[_i1069]); + xfer += iprot->readString(this->errors[_i1071]); } xfer += iprot->readListEnd(); } @@ -27425,14 +27531,14 @@ uint32_t WMValidateResourcePlanResponse::read(::apache::thrift::protocol::TProto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->warnings.clear(); - uint32_t _size1070; - ::apache::thrift::protocol::TType _etype1073; - xfer += iprot->readListBegin(_etype1073, _size1070); - this->warnings.resize(_size1070); - uint32_t _i1074; - for (_i1074 = 0; _i1074 < _size1070; ++_i1074) + uint32_t _size1072; + ::apache::thrift::protocol::TType _etype1075; + xfer += iprot->readListBegin(_etype1075, _size1072); + this->warnings.resize(_size1072); + uint32_t _i1076; + for (_i1076 = 0; _i1076 < _size1072; ++_i1076) { - xfer += iprot->readString(this->warnings[_i1074]); + xfer += iprot->readString(this->warnings[_i1076]); } xfer += iprot->readListEnd(); } @@ -27462,10 +27568,10 @@ uint32_t WMValidateResourcePlanResponse::write(::apache::thrift::protocol::TProt xfer += oprot->writeFieldBegin("errors", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->errors.size())); - std::vector ::const_iterator _iter1075; - for (_iter1075 = this->errors.begin(); _iter1075 != this->errors.end(); ++_iter1075) + std::vector ::const_iterator _iter1077; + for (_iter1077 = this->errors.begin(); _iter1077 != this->errors.end(); ++_iter1077) { - xfer += oprot->writeString((*_iter1075)); + xfer += oprot->writeString((*_iter1077)); } xfer += oprot->writeListEnd(); } @@ -27475,10 +27581,10 @@ uint32_t WMValidateResourcePlanResponse::write(::apache::thrift::protocol::TProt xfer += oprot->writeFieldBegin("warnings", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->warnings.size())); - std::vector ::const_iterator _iter1076; - for (_iter1076 = this->warnings.begin(); _iter1076 != this->warnings.end(); ++_iter1076) + std::vector ::const_iterator _iter1078; + for (_iter1078 = this->warnings.begin(); _iter1078 != this->warnings.end(); ++_iter1078) { - xfer += oprot->writeString((*_iter1076)); + xfer += oprot->writeString((*_iter1078)); } xfer += oprot->writeListEnd(); } @@ -27496,15 +27602,15 @@ void swap(WMValidateResourcePlanResponse &a, WMValidateResourcePlanResponse &b) swap(a.__isset, b.__isset); } -WMValidateResourcePlanResponse::WMValidateResourcePlanResponse(const WMValidateResourcePlanResponse& other1077) { - errors = other1077.errors; - warnings = other1077.warnings; - __isset = other1077.__isset; +WMValidateResourcePlanResponse::WMValidateResourcePlanResponse(const WMValidateResourcePlanResponse& other1079) { + errors = other1079.errors; + warnings = other1079.warnings; + __isset = other1079.__isset; } -WMValidateResourcePlanResponse& WMValidateResourcePlanResponse::operator=(const WMValidateResourcePlanResponse& other1078) { - errors = other1078.errors; - warnings = other1078.warnings; - __isset = other1078.__isset; +WMValidateResourcePlanResponse& WMValidateResourcePlanResponse::operator=(const WMValidateResourcePlanResponse& other1080) { + errors = other1080.errors; + warnings = other1080.warnings; + __isset = other1080.__isset; return *this; } void WMValidateResourcePlanResponse::printTo(std::ostream& out) const { @@ -27587,13 +27693,13 @@ void swap(WMDropResourcePlanRequest &a, WMDropResourcePlanRequest &b) { swap(a.__isset, b.__isset); } -WMDropResourcePlanRequest::WMDropResourcePlanRequest(const WMDropResourcePlanRequest& other1079) { - resourcePlanName = other1079.resourcePlanName; - __isset = other1079.__isset; +WMDropResourcePlanRequest::WMDropResourcePlanRequest(const WMDropResourcePlanRequest& other1081) { + resourcePlanName = other1081.resourcePlanName; + __isset = other1081.__isset; } -WMDropResourcePlanRequest& WMDropResourcePlanRequest::operator=(const WMDropResourcePlanRequest& other1080) { - resourcePlanName = other1080.resourcePlanName; - __isset = other1080.__isset; +WMDropResourcePlanRequest& WMDropResourcePlanRequest::operator=(const WMDropResourcePlanRequest& other1082) { + resourcePlanName = other1082.resourcePlanName; + __isset = other1082.__isset; return *this; } void WMDropResourcePlanRequest::printTo(std::ostream& out) const { @@ -27652,11 +27758,11 @@ void swap(WMDropResourcePlanResponse &a, WMDropResourcePlanResponse &b) { (void) b; } -WMDropResourcePlanResponse::WMDropResourcePlanResponse(const WMDropResourcePlanResponse& other1081) { - (void) other1081; +WMDropResourcePlanResponse::WMDropResourcePlanResponse(const WMDropResourcePlanResponse& other1083) { + (void) other1083; } -WMDropResourcePlanResponse& WMDropResourcePlanResponse::operator=(const WMDropResourcePlanResponse& other1082) { - (void) other1082; +WMDropResourcePlanResponse& WMDropResourcePlanResponse::operator=(const WMDropResourcePlanResponse& other1084) { + (void) other1084; return *this; } void WMDropResourcePlanResponse::printTo(std::ostream& out) const { @@ -27737,13 +27843,13 @@ void swap(WMCreateTriggerRequest &a, WMCreateTriggerRequest &b) { swap(a.__isset, b.__isset); } -WMCreateTriggerRequest::WMCreateTriggerRequest(const WMCreateTriggerRequest& other1083) { - trigger = other1083.trigger; - __isset = other1083.__isset; +WMCreateTriggerRequest::WMCreateTriggerRequest(const WMCreateTriggerRequest& other1085) { + trigger = other1085.trigger; + __isset = other1085.__isset; } -WMCreateTriggerRequest& WMCreateTriggerRequest::operator=(const WMCreateTriggerRequest& other1084) { - trigger = other1084.trigger; - __isset = other1084.__isset; +WMCreateTriggerRequest& WMCreateTriggerRequest::operator=(const WMCreateTriggerRequest& other1086) { + trigger = other1086.trigger; + __isset = other1086.__isset; return *this; } void WMCreateTriggerRequest::printTo(std::ostream& out) const { @@ -27802,11 +27908,11 @@ void swap(WMCreateTriggerResponse &a, WMCreateTriggerResponse &b) { (void) b; } -WMCreateTriggerResponse::WMCreateTriggerResponse(const WMCreateTriggerResponse& other1085) { - (void) other1085; +WMCreateTriggerResponse::WMCreateTriggerResponse(const WMCreateTriggerResponse& other1087) { + (void) other1087; } -WMCreateTriggerResponse& WMCreateTriggerResponse::operator=(const WMCreateTriggerResponse& other1086) { - (void) other1086; +WMCreateTriggerResponse& WMCreateTriggerResponse::operator=(const WMCreateTriggerResponse& other1088) { + (void) other1088; return *this; } void WMCreateTriggerResponse::printTo(std::ostream& out) const { @@ -27887,13 +27993,13 @@ void swap(WMAlterTriggerRequest &a, WMAlterTriggerRequest &b) { swap(a.__isset, b.__isset); } -WMAlterTriggerRequest::WMAlterTriggerRequest(const WMAlterTriggerRequest& other1087) { - trigger = other1087.trigger; - __isset = other1087.__isset; +WMAlterTriggerRequest::WMAlterTriggerRequest(const WMAlterTriggerRequest& other1089) { + trigger = other1089.trigger; + __isset = other1089.__isset; } -WMAlterTriggerRequest& WMAlterTriggerRequest::operator=(const WMAlterTriggerRequest& other1088) { - trigger = other1088.trigger; - __isset = other1088.__isset; +WMAlterTriggerRequest& WMAlterTriggerRequest::operator=(const WMAlterTriggerRequest& other1090) { + trigger = other1090.trigger; + __isset = other1090.__isset; return *this; } void WMAlterTriggerRequest::printTo(std::ostream& out) const { @@ -27952,11 +28058,11 @@ void swap(WMAlterTriggerResponse &a, WMAlterTriggerResponse &b) { (void) b; } -WMAlterTriggerResponse::WMAlterTriggerResponse(const WMAlterTriggerResponse& other1089) { - (void) other1089; +WMAlterTriggerResponse::WMAlterTriggerResponse(const WMAlterTriggerResponse& other1091) { + (void) other1091; } -WMAlterTriggerResponse& WMAlterTriggerResponse::operator=(const WMAlterTriggerResponse& other1090) { - (void) other1090; +WMAlterTriggerResponse& WMAlterTriggerResponse::operator=(const WMAlterTriggerResponse& other1092) { + (void) other1092; return *this; } void WMAlterTriggerResponse::printTo(std::ostream& out) const { @@ -28056,15 +28162,15 @@ void swap(WMDropTriggerRequest &a, WMDropTriggerRequest &b) { swap(a.__isset, b.__isset); } -WMDropTriggerRequest::WMDropTriggerRequest(const WMDropTriggerRequest& other1091) { - resourcePlanName = other1091.resourcePlanName; - triggerName = other1091.triggerName; - __isset = other1091.__isset; +WMDropTriggerRequest::WMDropTriggerRequest(const WMDropTriggerRequest& other1093) { + resourcePlanName = other1093.resourcePlanName; + triggerName = other1093.triggerName; + __isset = other1093.__isset; } -WMDropTriggerRequest& WMDropTriggerRequest::operator=(const WMDropTriggerRequest& other1092) { - resourcePlanName = other1092.resourcePlanName; - triggerName = other1092.triggerName; - __isset = other1092.__isset; +WMDropTriggerRequest& WMDropTriggerRequest::operator=(const WMDropTriggerRequest& other1094) { + resourcePlanName = other1094.resourcePlanName; + triggerName = other1094.triggerName; + __isset = other1094.__isset; return *this; } void WMDropTriggerRequest::printTo(std::ostream& out) const { @@ -28124,11 +28230,11 @@ void swap(WMDropTriggerResponse &a, WMDropTriggerResponse &b) { (void) b; } -WMDropTriggerResponse::WMDropTriggerResponse(const WMDropTriggerResponse& other1093) { - (void) other1093; +WMDropTriggerResponse::WMDropTriggerResponse(const WMDropTriggerResponse& other1095) { + (void) other1095; } -WMDropTriggerResponse& WMDropTriggerResponse::operator=(const WMDropTriggerResponse& other1094) { - (void) other1094; +WMDropTriggerResponse& WMDropTriggerResponse::operator=(const WMDropTriggerResponse& other1096) { + (void) other1096; return *this; } void WMDropTriggerResponse::printTo(std::ostream& out) const { @@ -28209,13 +28315,13 @@ void swap(WMGetTriggersForResourePlanRequest &a, WMGetTriggersForResourePlanRequ swap(a.__isset, b.__isset); } -WMGetTriggersForResourePlanRequest::WMGetTriggersForResourePlanRequest(const WMGetTriggersForResourePlanRequest& other1095) { - resourcePlanName = other1095.resourcePlanName; - __isset = other1095.__isset; +WMGetTriggersForResourePlanRequest::WMGetTriggersForResourePlanRequest(const WMGetTriggersForResourePlanRequest& other1097) { + resourcePlanName = other1097.resourcePlanName; + __isset = other1097.__isset; } -WMGetTriggersForResourePlanRequest& WMGetTriggersForResourePlanRequest::operator=(const WMGetTriggersForResourePlanRequest& other1096) { - resourcePlanName = other1096.resourcePlanName; - __isset = other1096.__isset; +WMGetTriggersForResourePlanRequest& WMGetTriggersForResourePlanRequest::operator=(const WMGetTriggersForResourePlanRequest& other1098) { + resourcePlanName = other1098.resourcePlanName; + __isset = other1098.__isset; return *this; } void WMGetTriggersForResourePlanRequest::printTo(std::ostream& out) const { @@ -28260,14 +28366,14 @@ uint32_t WMGetTriggersForResourePlanResponse::read(::apache::thrift::protocol::T if (ftype == ::apache::thrift::protocol::T_LIST) { { this->triggers.clear(); - uint32_t _size1097; - ::apache::thrift::protocol::TType _etype1100; - xfer += iprot->readListBegin(_etype1100, _size1097); - this->triggers.resize(_size1097); - uint32_t _i1101; - for (_i1101 = 0; _i1101 < _size1097; ++_i1101) + uint32_t _size1099; + ::apache::thrift::protocol::TType _etype1102; + xfer += iprot->readListBegin(_etype1102, _size1099); + this->triggers.resize(_size1099); + uint32_t _i1103; + for (_i1103 = 0; _i1103 < _size1099; ++_i1103) { - xfer += this->triggers[_i1101].read(iprot); + xfer += this->triggers[_i1103].read(iprot); } xfer += iprot->readListEnd(); } @@ -28297,10 +28403,10 @@ uint32_t WMGetTriggersForResourePlanResponse::write(::apache::thrift::protocol:: xfer += oprot->writeFieldBegin("triggers", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->triggers.size())); - std::vector ::const_iterator _iter1102; - for (_iter1102 = this->triggers.begin(); _iter1102 != this->triggers.end(); ++_iter1102) + std::vector ::const_iterator _iter1104; + for (_iter1104 = this->triggers.begin(); _iter1104 != this->triggers.end(); ++_iter1104) { - xfer += (*_iter1102).write(oprot); + xfer += (*_iter1104).write(oprot); } xfer += oprot->writeListEnd(); } @@ -28317,13 +28423,13 @@ void swap(WMGetTriggersForResourePlanResponse &a, WMGetTriggersForResourePlanRes swap(a.__isset, b.__isset); } -WMGetTriggersForResourePlanResponse::WMGetTriggersForResourePlanResponse(const WMGetTriggersForResourePlanResponse& other1103) { - triggers = other1103.triggers; - __isset = other1103.__isset; +WMGetTriggersForResourePlanResponse::WMGetTriggersForResourePlanResponse(const WMGetTriggersForResourePlanResponse& other1105) { + triggers = other1105.triggers; + __isset = other1105.__isset; } -WMGetTriggersForResourePlanResponse& WMGetTriggersForResourePlanResponse::operator=(const WMGetTriggersForResourePlanResponse& other1104) { - triggers = other1104.triggers; - __isset = other1104.__isset; +WMGetTriggersForResourePlanResponse& WMGetTriggersForResourePlanResponse::operator=(const WMGetTriggersForResourePlanResponse& other1106) { + triggers = other1106.triggers; + __isset = other1106.__isset; return *this; } void WMGetTriggersForResourePlanResponse::printTo(std::ostream& out) const { @@ -28405,13 +28511,13 @@ void swap(WMCreatePoolRequest &a, WMCreatePoolRequest &b) { swap(a.__isset, b.__isset); } -WMCreatePoolRequest::WMCreatePoolRequest(const WMCreatePoolRequest& other1105) { - pool = other1105.pool; - __isset = other1105.__isset; +WMCreatePoolRequest::WMCreatePoolRequest(const WMCreatePoolRequest& other1107) { + pool = other1107.pool; + __isset = other1107.__isset; } -WMCreatePoolRequest& WMCreatePoolRequest::operator=(const WMCreatePoolRequest& other1106) { - pool = other1106.pool; - __isset = other1106.__isset; +WMCreatePoolRequest& WMCreatePoolRequest::operator=(const WMCreatePoolRequest& other1108) { + pool = other1108.pool; + __isset = other1108.__isset; return *this; } void WMCreatePoolRequest::printTo(std::ostream& out) const { @@ -28470,11 +28576,11 @@ void swap(WMCreatePoolResponse &a, WMCreatePoolResponse &b) { (void) b; } -WMCreatePoolResponse::WMCreatePoolResponse(const WMCreatePoolResponse& other1107) { - (void) other1107; +WMCreatePoolResponse::WMCreatePoolResponse(const WMCreatePoolResponse& other1109) { + (void) other1109; } -WMCreatePoolResponse& WMCreatePoolResponse::operator=(const WMCreatePoolResponse& other1108) { - (void) other1108; +WMCreatePoolResponse& WMCreatePoolResponse::operator=(const WMCreatePoolResponse& other1110) { + (void) other1110; return *this; } void WMCreatePoolResponse::printTo(std::ostream& out) const { @@ -28574,15 +28680,15 @@ void swap(WMAlterPoolRequest &a, WMAlterPoolRequest &b) { swap(a.__isset, b.__isset); } -WMAlterPoolRequest::WMAlterPoolRequest(const WMAlterPoolRequest& other1109) { - pool = other1109.pool; - poolPath = other1109.poolPath; - __isset = other1109.__isset; +WMAlterPoolRequest::WMAlterPoolRequest(const WMAlterPoolRequest& other1111) { + pool = other1111.pool; + poolPath = other1111.poolPath; + __isset = other1111.__isset; } -WMAlterPoolRequest& WMAlterPoolRequest::operator=(const WMAlterPoolRequest& other1110) { - pool = other1110.pool; - poolPath = other1110.poolPath; - __isset = other1110.__isset; +WMAlterPoolRequest& WMAlterPoolRequest::operator=(const WMAlterPoolRequest& other1112) { + pool = other1112.pool; + poolPath = other1112.poolPath; + __isset = other1112.__isset; return *this; } void WMAlterPoolRequest::printTo(std::ostream& out) const { @@ -28642,11 +28748,11 @@ void swap(WMAlterPoolResponse &a, WMAlterPoolResponse &b) { (void) b; } -WMAlterPoolResponse::WMAlterPoolResponse(const WMAlterPoolResponse& other1111) { - (void) other1111; +WMAlterPoolResponse::WMAlterPoolResponse(const WMAlterPoolResponse& other1113) { + (void) other1113; } -WMAlterPoolResponse& WMAlterPoolResponse::operator=(const WMAlterPoolResponse& other1112) { - (void) other1112; +WMAlterPoolResponse& WMAlterPoolResponse::operator=(const WMAlterPoolResponse& other1114) { + (void) other1114; return *this; } void WMAlterPoolResponse::printTo(std::ostream& out) const { @@ -28746,15 +28852,15 @@ void swap(WMDropPoolRequest &a, WMDropPoolRequest &b) { swap(a.__isset, b.__isset); } -WMDropPoolRequest::WMDropPoolRequest(const WMDropPoolRequest& other1113) { - resourcePlanName = other1113.resourcePlanName; - poolPath = other1113.poolPath; - __isset = other1113.__isset; +WMDropPoolRequest::WMDropPoolRequest(const WMDropPoolRequest& other1115) { + resourcePlanName = other1115.resourcePlanName; + poolPath = other1115.poolPath; + __isset = other1115.__isset; } -WMDropPoolRequest& WMDropPoolRequest::operator=(const WMDropPoolRequest& other1114) { - resourcePlanName = other1114.resourcePlanName; - poolPath = other1114.poolPath; - __isset = other1114.__isset; +WMDropPoolRequest& WMDropPoolRequest::operator=(const WMDropPoolRequest& other1116) { + resourcePlanName = other1116.resourcePlanName; + poolPath = other1116.poolPath; + __isset = other1116.__isset; return *this; } void WMDropPoolRequest::printTo(std::ostream& out) const { @@ -28814,11 +28920,11 @@ void swap(WMDropPoolResponse &a, WMDropPoolResponse &b) { (void) b; } -WMDropPoolResponse::WMDropPoolResponse(const WMDropPoolResponse& other1115) { - (void) other1115; +WMDropPoolResponse::WMDropPoolResponse(const WMDropPoolResponse& other1117) { + (void) other1117; } -WMDropPoolResponse& WMDropPoolResponse::operator=(const WMDropPoolResponse& other1116) { - (void) other1116; +WMDropPoolResponse& WMDropPoolResponse::operator=(const WMDropPoolResponse& other1118) { + (void) other1118; return *this; } void WMDropPoolResponse::printTo(std::ostream& out) const { @@ -28918,15 +29024,15 @@ void swap(WMCreateOrUpdateMappingRequest &a, WMCreateOrUpdateMappingRequest &b) swap(a.__isset, b.__isset); } -WMCreateOrUpdateMappingRequest::WMCreateOrUpdateMappingRequest(const WMCreateOrUpdateMappingRequest& other1117) { - mapping = other1117.mapping; - update = other1117.update; - __isset = other1117.__isset; +WMCreateOrUpdateMappingRequest::WMCreateOrUpdateMappingRequest(const WMCreateOrUpdateMappingRequest& other1119) { + mapping = other1119.mapping; + update = other1119.update; + __isset = other1119.__isset; } -WMCreateOrUpdateMappingRequest& WMCreateOrUpdateMappingRequest::operator=(const WMCreateOrUpdateMappingRequest& other1118) { - mapping = other1118.mapping; - update = other1118.update; - __isset = other1118.__isset; +WMCreateOrUpdateMappingRequest& WMCreateOrUpdateMappingRequest::operator=(const WMCreateOrUpdateMappingRequest& other1120) { + mapping = other1120.mapping; + update = other1120.update; + __isset = other1120.__isset; return *this; } void WMCreateOrUpdateMappingRequest::printTo(std::ostream& out) const { @@ -28986,11 +29092,11 @@ void swap(WMCreateOrUpdateMappingResponse &a, WMCreateOrUpdateMappingResponse &b (void) b; } -WMCreateOrUpdateMappingResponse::WMCreateOrUpdateMappingResponse(const WMCreateOrUpdateMappingResponse& other1119) { - (void) other1119; +WMCreateOrUpdateMappingResponse::WMCreateOrUpdateMappingResponse(const WMCreateOrUpdateMappingResponse& other1121) { + (void) other1121; } -WMCreateOrUpdateMappingResponse& WMCreateOrUpdateMappingResponse::operator=(const WMCreateOrUpdateMappingResponse& other1120) { - (void) other1120; +WMCreateOrUpdateMappingResponse& WMCreateOrUpdateMappingResponse::operator=(const WMCreateOrUpdateMappingResponse& other1122) { + (void) other1122; return *this; } void WMCreateOrUpdateMappingResponse::printTo(std::ostream& out) const { @@ -29071,13 +29177,13 @@ void swap(WMDropMappingRequest &a, WMDropMappingRequest &b) { swap(a.__isset, b.__isset); } -WMDropMappingRequest::WMDropMappingRequest(const WMDropMappingRequest& other1121) { - mapping = other1121.mapping; - __isset = other1121.__isset; +WMDropMappingRequest::WMDropMappingRequest(const WMDropMappingRequest& other1123) { + mapping = other1123.mapping; + __isset = other1123.__isset; } -WMDropMappingRequest& WMDropMappingRequest::operator=(const WMDropMappingRequest& other1122) { - mapping = other1122.mapping; - __isset = other1122.__isset; +WMDropMappingRequest& WMDropMappingRequest::operator=(const WMDropMappingRequest& other1124) { + mapping = other1124.mapping; + __isset = other1124.__isset; return *this; } void WMDropMappingRequest::printTo(std::ostream& out) const { @@ -29136,11 +29242,11 @@ void swap(WMDropMappingResponse &a, WMDropMappingResponse &b) { (void) b; } -WMDropMappingResponse::WMDropMappingResponse(const WMDropMappingResponse& other1123) { - (void) other1123; +WMDropMappingResponse::WMDropMappingResponse(const WMDropMappingResponse& other1125) { + (void) other1125; } -WMDropMappingResponse& WMDropMappingResponse::operator=(const WMDropMappingResponse& other1124) { - (void) other1124; +WMDropMappingResponse& WMDropMappingResponse::operator=(const WMDropMappingResponse& other1126) { + (void) other1126; return *this; } void WMDropMappingResponse::printTo(std::ostream& out) const { @@ -29278,19 +29384,19 @@ void swap(WMCreateOrDropTriggerToPoolMappingRequest &a, WMCreateOrDropTriggerToP swap(a.__isset, b.__isset); } -WMCreateOrDropTriggerToPoolMappingRequest::WMCreateOrDropTriggerToPoolMappingRequest(const WMCreateOrDropTriggerToPoolMappingRequest& other1125) { - resourcePlanName = other1125.resourcePlanName; - triggerName = other1125.triggerName; - poolPath = other1125.poolPath; - drop = other1125.drop; - __isset = other1125.__isset; +WMCreateOrDropTriggerToPoolMappingRequest::WMCreateOrDropTriggerToPoolMappingRequest(const WMCreateOrDropTriggerToPoolMappingRequest& other1127) { + resourcePlanName = other1127.resourcePlanName; + triggerName = other1127.triggerName; + poolPath = other1127.poolPath; + drop = other1127.drop; + __isset = other1127.__isset; } -WMCreateOrDropTriggerToPoolMappingRequest& WMCreateOrDropTriggerToPoolMappingRequest::operator=(const WMCreateOrDropTriggerToPoolMappingRequest& other1126) { - resourcePlanName = other1126.resourcePlanName; - triggerName = other1126.triggerName; - poolPath = other1126.poolPath; - drop = other1126.drop; - __isset = other1126.__isset; +WMCreateOrDropTriggerToPoolMappingRequest& WMCreateOrDropTriggerToPoolMappingRequest::operator=(const WMCreateOrDropTriggerToPoolMappingRequest& other1128) { + resourcePlanName = other1128.resourcePlanName; + triggerName = other1128.triggerName; + poolPath = other1128.poolPath; + drop = other1128.drop; + __isset = other1128.__isset; return *this; } void WMCreateOrDropTriggerToPoolMappingRequest::printTo(std::ostream& out) const { @@ -29352,11 +29458,11 @@ void swap(WMCreateOrDropTriggerToPoolMappingResponse &a, WMCreateOrDropTriggerTo (void) b; } -WMCreateOrDropTriggerToPoolMappingResponse::WMCreateOrDropTriggerToPoolMappingResponse(const WMCreateOrDropTriggerToPoolMappingResponse& other1127) { - (void) other1127; +WMCreateOrDropTriggerToPoolMappingResponse::WMCreateOrDropTriggerToPoolMappingResponse(const WMCreateOrDropTriggerToPoolMappingResponse& other1129) { + (void) other1129; } -WMCreateOrDropTriggerToPoolMappingResponse& WMCreateOrDropTriggerToPoolMappingResponse::operator=(const WMCreateOrDropTriggerToPoolMappingResponse& other1128) { - (void) other1128; +WMCreateOrDropTriggerToPoolMappingResponse& WMCreateOrDropTriggerToPoolMappingResponse::operator=(const WMCreateOrDropTriggerToPoolMappingResponse& other1130) { + (void) other1130; return *this; } void WMCreateOrDropTriggerToPoolMappingResponse::printTo(std::ostream& out) const { @@ -29431,9 +29537,9 @@ uint32_t ISchema::read(::apache::thrift::protocol::TProtocol* iprot) { { case 1: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1129; - xfer += iprot->readI32(ecast1129); - this->schemaType = (SchemaType::type)ecast1129; + int32_t ecast1131; + xfer += iprot->readI32(ecast1131); + this->schemaType = (SchemaType::type)ecast1131; this->__isset.schemaType = true; } else { xfer += iprot->skip(ftype); @@ -29465,9 +29571,9 @@ uint32_t ISchema::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1130; - xfer += iprot->readI32(ecast1130); - this->compatibility = (SchemaCompatibility::type)ecast1130; + int32_t ecast1132; + xfer += iprot->readI32(ecast1132); + this->compatibility = (SchemaCompatibility::type)ecast1132; this->__isset.compatibility = true; } else { xfer += iprot->skip(ftype); @@ -29475,9 +29581,9 @@ uint32_t ISchema::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 6: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1131; - xfer += iprot->readI32(ecast1131); - this->validationLevel = (SchemaValidation::type)ecast1131; + int32_t ecast1133; + xfer += iprot->readI32(ecast1133); + this->validationLevel = (SchemaValidation::type)ecast1133; this->__isset.validationLevel = true; } else { xfer += iprot->skip(ftype); @@ -29581,29 +29687,29 @@ void swap(ISchema &a, ISchema &b) { swap(a.__isset, b.__isset); } -ISchema::ISchema(const ISchema& other1132) { - schemaType = other1132.schemaType; - name = other1132.name; - catName = other1132.catName; - dbName = other1132.dbName; - compatibility = other1132.compatibility; - validationLevel = other1132.validationLevel; - canEvolve = other1132.canEvolve; - schemaGroup = other1132.schemaGroup; - description = other1132.description; - __isset = other1132.__isset; -} -ISchema& ISchema::operator=(const ISchema& other1133) { - schemaType = other1133.schemaType; - name = other1133.name; - catName = other1133.catName; - dbName = other1133.dbName; - compatibility = other1133.compatibility; - validationLevel = other1133.validationLevel; - canEvolve = other1133.canEvolve; - schemaGroup = other1133.schemaGroup; - description = other1133.description; - __isset = other1133.__isset; +ISchema::ISchema(const ISchema& other1134) { + schemaType = other1134.schemaType; + name = other1134.name; + catName = other1134.catName; + dbName = other1134.dbName; + compatibility = other1134.compatibility; + validationLevel = other1134.validationLevel; + canEvolve = other1134.canEvolve; + schemaGroup = other1134.schemaGroup; + description = other1134.description; + __isset = other1134.__isset; +} +ISchema& ISchema::operator=(const ISchema& other1135) { + schemaType = other1135.schemaType; + name = other1135.name; + catName = other1135.catName; + dbName = other1135.dbName; + compatibility = other1135.compatibility; + validationLevel = other1135.validationLevel; + canEvolve = other1135.canEvolve; + schemaGroup = other1135.schemaGroup; + description = other1135.description; + __isset = other1135.__isset; return *this; } void ISchema::printTo(std::ostream& out) const { @@ -29725,17 +29831,17 @@ void swap(ISchemaName &a, ISchemaName &b) { swap(a.__isset, b.__isset); } -ISchemaName::ISchemaName(const ISchemaName& other1134) { - catName = other1134.catName; - dbName = other1134.dbName; - schemaName = other1134.schemaName; - __isset = other1134.__isset; +ISchemaName::ISchemaName(const ISchemaName& other1136) { + catName = other1136.catName; + dbName = other1136.dbName; + schemaName = other1136.schemaName; + __isset = other1136.__isset; } -ISchemaName& ISchemaName::operator=(const ISchemaName& other1135) { - catName = other1135.catName; - dbName = other1135.dbName; - schemaName = other1135.schemaName; - __isset = other1135.__isset; +ISchemaName& ISchemaName::operator=(const ISchemaName& other1137) { + catName = other1137.catName; + dbName = other1137.dbName; + schemaName = other1137.schemaName; + __isset = other1137.__isset; return *this; } void ISchemaName::printTo(std::ostream& out) const { @@ -29834,15 +29940,15 @@ void swap(AlterISchemaRequest &a, AlterISchemaRequest &b) { swap(a.__isset, b.__isset); } -AlterISchemaRequest::AlterISchemaRequest(const AlterISchemaRequest& other1136) { - name = other1136.name; - newSchema = other1136.newSchema; - __isset = other1136.__isset; +AlterISchemaRequest::AlterISchemaRequest(const AlterISchemaRequest& other1138) { + name = other1138.name; + newSchema = other1138.newSchema; + __isset = other1138.__isset; } -AlterISchemaRequest& AlterISchemaRequest::operator=(const AlterISchemaRequest& other1137) { - name = other1137.name; - newSchema = other1137.newSchema; - __isset = other1137.__isset; +AlterISchemaRequest& AlterISchemaRequest::operator=(const AlterISchemaRequest& other1139) { + name = other1139.name; + newSchema = other1139.newSchema; + __isset = other1139.__isset; return *this; } void AlterISchemaRequest::printTo(std::ostream& out) const { @@ -29953,14 +30059,14 @@ uint32_t SchemaVersion::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->cols.clear(); - uint32_t _size1138; - ::apache::thrift::protocol::TType _etype1141; - xfer += iprot->readListBegin(_etype1141, _size1138); - this->cols.resize(_size1138); - uint32_t _i1142; - for (_i1142 = 0; _i1142 < _size1138; ++_i1142) + uint32_t _size1140; + ::apache::thrift::protocol::TType _etype1143; + xfer += iprot->readListBegin(_etype1143, _size1140); + this->cols.resize(_size1140); + uint32_t _i1144; + for (_i1144 = 0; _i1144 < _size1140; ++_i1144) { - xfer += this->cols[_i1142].read(iprot); + xfer += this->cols[_i1144].read(iprot); } xfer += iprot->readListEnd(); } @@ -29971,9 +30077,9 @@ uint32_t SchemaVersion::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1143; - xfer += iprot->readI32(ecast1143); - this->state = (SchemaVersionState::type)ecast1143; + int32_t ecast1145; + xfer += iprot->readI32(ecast1145); + this->state = (SchemaVersionState::type)ecast1145; this->__isset.state = true; } else { xfer += iprot->skip(ftype); @@ -30051,10 +30157,10 @@ uint32_t SchemaVersion::write(::apache::thrift::protocol::TProtocol* oprot) cons xfer += oprot->writeFieldBegin("cols", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->cols.size())); - std::vector ::const_iterator _iter1144; - for (_iter1144 = this->cols.begin(); _iter1144 != this->cols.end(); ++_iter1144) + std::vector ::const_iterator _iter1146; + for (_iter1146 = this->cols.begin(); _iter1146 != this->cols.end(); ++_iter1146) { - xfer += (*_iter1144).write(oprot); + xfer += (*_iter1146).write(oprot); } xfer += oprot->writeListEnd(); } @@ -30110,31 +30216,31 @@ void swap(SchemaVersion &a, SchemaVersion &b) { swap(a.__isset, b.__isset); } -SchemaVersion::SchemaVersion(const SchemaVersion& other1145) { - schema = other1145.schema; - version = other1145.version; - createdAt = other1145.createdAt; - cols = other1145.cols; - state = other1145.state; - description = other1145.description; - schemaText = other1145.schemaText; - fingerprint = other1145.fingerprint; - name = other1145.name; - serDe = other1145.serDe; - __isset = other1145.__isset; -} -SchemaVersion& SchemaVersion::operator=(const SchemaVersion& other1146) { - schema = other1146.schema; - version = other1146.version; - createdAt = other1146.createdAt; - cols = other1146.cols; - state = other1146.state; - description = other1146.description; - schemaText = other1146.schemaText; - fingerprint = other1146.fingerprint; - name = other1146.name; - serDe = other1146.serDe; - __isset = other1146.__isset; +SchemaVersion::SchemaVersion(const SchemaVersion& other1147) { + schema = other1147.schema; + version = other1147.version; + createdAt = other1147.createdAt; + cols = other1147.cols; + state = other1147.state; + description = other1147.description; + schemaText = other1147.schemaText; + fingerprint = other1147.fingerprint; + name = other1147.name; + serDe = other1147.serDe; + __isset = other1147.__isset; +} +SchemaVersion& SchemaVersion::operator=(const SchemaVersion& other1148) { + schema = other1148.schema; + version = other1148.version; + createdAt = other1148.createdAt; + cols = other1148.cols; + state = other1148.state; + description = other1148.description; + schemaText = other1148.schemaText; + fingerprint = other1148.fingerprint; + name = other1148.name; + serDe = other1148.serDe; + __isset = other1148.__isset; return *this; } void SchemaVersion::printTo(std::ostream& out) const { @@ -30240,15 +30346,15 @@ void swap(SchemaVersionDescriptor &a, SchemaVersionDescriptor &b) { swap(a.__isset, b.__isset); } -SchemaVersionDescriptor::SchemaVersionDescriptor(const SchemaVersionDescriptor& other1147) { - schema = other1147.schema; - version = other1147.version; - __isset = other1147.__isset; +SchemaVersionDescriptor::SchemaVersionDescriptor(const SchemaVersionDescriptor& other1149) { + schema = other1149.schema; + version = other1149.version; + __isset = other1149.__isset; } -SchemaVersionDescriptor& SchemaVersionDescriptor::operator=(const SchemaVersionDescriptor& other1148) { - schema = other1148.schema; - version = other1148.version; - __isset = other1148.__isset; +SchemaVersionDescriptor& SchemaVersionDescriptor::operator=(const SchemaVersionDescriptor& other1150) { + schema = other1150.schema; + version = other1150.version; + __isset = other1150.__isset; return *this; } void SchemaVersionDescriptor::printTo(std::ostream& out) const { @@ -30369,17 +30475,17 @@ void swap(FindSchemasByColsRqst &a, FindSchemasByColsRqst &b) { swap(a.__isset, b.__isset); } -FindSchemasByColsRqst::FindSchemasByColsRqst(const FindSchemasByColsRqst& other1149) { - colName = other1149.colName; - colNamespace = other1149.colNamespace; - type = other1149.type; - __isset = other1149.__isset; +FindSchemasByColsRqst::FindSchemasByColsRqst(const FindSchemasByColsRqst& other1151) { + colName = other1151.colName; + colNamespace = other1151.colNamespace; + type = other1151.type; + __isset = other1151.__isset; } -FindSchemasByColsRqst& FindSchemasByColsRqst::operator=(const FindSchemasByColsRqst& other1150) { - colName = other1150.colName; - colNamespace = other1150.colNamespace; - type = other1150.type; - __isset = other1150.__isset; +FindSchemasByColsRqst& FindSchemasByColsRqst::operator=(const FindSchemasByColsRqst& other1152) { + colName = other1152.colName; + colNamespace = other1152.colNamespace; + type = other1152.type; + __isset = other1152.__isset; return *this; } void FindSchemasByColsRqst::printTo(std::ostream& out) const { @@ -30425,14 +30531,14 @@ uint32_t FindSchemasByColsResp::read(::apache::thrift::protocol::TProtocol* ipro if (ftype == ::apache::thrift::protocol::T_LIST) { { this->schemaVersions.clear(); - uint32_t _size1151; - ::apache::thrift::protocol::TType _etype1154; - xfer += iprot->readListBegin(_etype1154, _size1151); - this->schemaVersions.resize(_size1151); - uint32_t _i1155; - for (_i1155 = 0; _i1155 < _size1151; ++_i1155) + uint32_t _size1153; + ::apache::thrift::protocol::TType _etype1156; + xfer += iprot->readListBegin(_etype1156, _size1153); + this->schemaVersions.resize(_size1153); + uint32_t _i1157; + for (_i1157 = 0; _i1157 < _size1153; ++_i1157) { - xfer += this->schemaVersions[_i1155].read(iprot); + xfer += this->schemaVersions[_i1157].read(iprot); } xfer += iprot->readListEnd(); } @@ -30461,10 +30567,10 @@ uint32_t FindSchemasByColsResp::write(::apache::thrift::protocol::TProtocol* opr xfer += oprot->writeFieldBegin("schemaVersions", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->schemaVersions.size())); - std::vector ::const_iterator _iter1156; - for (_iter1156 = this->schemaVersions.begin(); _iter1156 != this->schemaVersions.end(); ++_iter1156) + std::vector ::const_iterator _iter1158; + for (_iter1158 = this->schemaVersions.begin(); _iter1158 != this->schemaVersions.end(); ++_iter1158) { - xfer += (*_iter1156).write(oprot); + xfer += (*_iter1158).write(oprot); } xfer += oprot->writeListEnd(); } @@ -30481,13 +30587,13 @@ void swap(FindSchemasByColsResp &a, FindSchemasByColsResp &b) { swap(a.__isset, b.__isset); } -FindSchemasByColsResp::FindSchemasByColsResp(const FindSchemasByColsResp& other1157) { - schemaVersions = other1157.schemaVersions; - __isset = other1157.__isset; +FindSchemasByColsResp::FindSchemasByColsResp(const FindSchemasByColsResp& other1159) { + schemaVersions = other1159.schemaVersions; + __isset = other1159.__isset; } -FindSchemasByColsResp& FindSchemasByColsResp::operator=(const FindSchemasByColsResp& other1158) { - schemaVersions = other1158.schemaVersions; - __isset = other1158.__isset; +FindSchemasByColsResp& FindSchemasByColsResp::operator=(const FindSchemasByColsResp& other1160) { + schemaVersions = other1160.schemaVersions; + __isset = other1160.__isset; return *this; } void FindSchemasByColsResp::printTo(std::ostream& out) const { @@ -30584,15 +30690,15 @@ void swap(MapSchemaVersionToSerdeRequest &a, MapSchemaVersionToSerdeRequest &b) swap(a.__isset, b.__isset); } -MapSchemaVersionToSerdeRequest::MapSchemaVersionToSerdeRequest(const MapSchemaVersionToSerdeRequest& other1159) { - schemaVersion = other1159.schemaVersion; - serdeName = other1159.serdeName; - __isset = other1159.__isset; +MapSchemaVersionToSerdeRequest::MapSchemaVersionToSerdeRequest(const MapSchemaVersionToSerdeRequest& other1161) { + schemaVersion = other1161.schemaVersion; + serdeName = other1161.serdeName; + __isset = other1161.__isset; } -MapSchemaVersionToSerdeRequest& MapSchemaVersionToSerdeRequest::operator=(const MapSchemaVersionToSerdeRequest& other1160) { - schemaVersion = other1160.schemaVersion; - serdeName = other1160.serdeName; - __isset = other1160.__isset; +MapSchemaVersionToSerdeRequest& MapSchemaVersionToSerdeRequest::operator=(const MapSchemaVersionToSerdeRequest& other1162) { + schemaVersion = other1162.schemaVersion; + serdeName = other1162.serdeName; + __isset = other1162.__isset; return *this; } void MapSchemaVersionToSerdeRequest::printTo(std::ostream& out) const { @@ -30647,9 +30753,9 @@ uint32_t SetSchemaVersionStateRequest::read(::apache::thrift::protocol::TProtoco break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1161; - xfer += iprot->readI32(ecast1161); - this->state = (SchemaVersionState::type)ecast1161; + int32_t ecast1163; + xfer += iprot->readI32(ecast1163); + this->state = (SchemaVersionState::type)ecast1163; this->__isset.state = true; } else { xfer += iprot->skip(ftype); @@ -30692,15 +30798,15 @@ void swap(SetSchemaVersionStateRequest &a, SetSchemaVersionStateRequest &b) { swap(a.__isset, b.__isset); } -SetSchemaVersionStateRequest::SetSchemaVersionStateRequest(const SetSchemaVersionStateRequest& other1162) { - schemaVersion = other1162.schemaVersion; - state = other1162.state; - __isset = other1162.__isset; +SetSchemaVersionStateRequest::SetSchemaVersionStateRequest(const SetSchemaVersionStateRequest& other1164) { + schemaVersion = other1164.schemaVersion; + state = other1164.state; + __isset = other1164.__isset; } -SetSchemaVersionStateRequest& SetSchemaVersionStateRequest::operator=(const SetSchemaVersionStateRequest& other1163) { - schemaVersion = other1163.schemaVersion; - state = other1163.state; - __isset = other1163.__isset; +SetSchemaVersionStateRequest& SetSchemaVersionStateRequest::operator=(const SetSchemaVersionStateRequest& other1165) { + schemaVersion = other1165.schemaVersion; + state = other1165.state; + __isset = other1165.__isset; return *this; } void SetSchemaVersionStateRequest::printTo(std::ostream& out) const { @@ -30781,13 +30887,13 @@ void swap(GetSerdeRequest &a, GetSerdeRequest &b) { swap(a.__isset, b.__isset); } -GetSerdeRequest::GetSerdeRequest(const GetSerdeRequest& other1164) { - serdeName = other1164.serdeName; - __isset = other1164.__isset; +GetSerdeRequest::GetSerdeRequest(const GetSerdeRequest& other1166) { + serdeName = other1166.serdeName; + __isset = other1166.__isset; } -GetSerdeRequest& GetSerdeRequest::operator=(const GetSerdeRequest& other1165) { - serdeName = other1165.serdeName; - __isset = other1165.__isset; +GetSerdeRequest& GetSerdeRequest::operator=(const GetSerdeRequest& other1167) { + serdeName = other1167.serdeName; + __isset = other1167.__isset; return *this; } void GetSerdeRequest::printTo(std::ostream& out) const { @@ -30909,17 +31015,17 @@ void swap(RuntimeStat &a, RuntimeStat &b) { swap(a.__isset, b.__isset); } -RuntimeStat::RuntimeStat(const RuntimeStat& other1166) { - createTime = other1166.createTime; - weight = other1166.weight; - payload = other1166.payload; - __isset = other1166.__isset; +RuntimeStat::RuntimeStat(const RuntimeStat& other1168) { + createTime = other1168.createTime; + weight = other1168.weight; + payload = other1168.payload; + __isset = other1168.__isset; } -RuntimeStat& RuntimeStat::operator=(const RuntimeStat& other1167) { - createTime = other1167.createTime; - weight = other1167.weight; - payload = other1167.payload; - __isset = other1167.__isset; +RuntimeStat& RuntimeStat::operator=(const RuntimeStat& other1169) { + createTime = other1169.createTime; + weight = other1169.weight; + payload = other1169.payload; + __isset = other1169.__isset; return *this; } void RuntimeStat::printTo(std::ostream& out) const { @@ -31023,13 +31129,13 @@ void swap(GetRuntimeStatsRequest &a, GetRuntimeStatsRequest &b) { swap(a.maxCreateTime, b.maxCreateTime); } -GetRuntimeStatsRequest::GetRuntimeStatsRequest(const GetRuntimeStatsRequest& other1168) { - maxWeight = other1168.maxWeight; - maxCreateTime = other1168.maxCreateTime; +GetRuntimeStatsRequest::GetRuntimeStatsRequest(const GetRuntimeStatsRequest& other1170) { + maxWeight = other1170.maxWeight; + maxCreateTime = other1170.maxCreateTime; } -GetRuntimeStatsRequest& GetRuntimeStatsRequest::operator=(const GetRuntimeStatsRequest& other1169) { - maxWeight = other1169.maxWeight; - maxCreateTime = other1169.maxCreateTime; +GetRuntimeStatsRequest& GetRuntimeStatsRequest::operator=(const GetRuntimeStatsRequest& other1171) { + maxWeight = other1171.maxWeight; + maxCreateTime = other1171.maxCreateTime; return *this; } void GetRuntimeStatsRequest::printTo(std::ostream& out) const { @@ -31110,13 +31216,13 @@ void swap(MetaException &a, MetaException &b) { swap(a.__isset, b.__isset); } -MetaException::MetaException(const MetaException& other1170) : TException() { - message = other1170.message; - __isset = other1170.__isset; +MetaException::MetaException(const MetaException& other1172) : TException() { + message = other1172.message; + __isset = other1172.__isset; } -MetaException& MetaException::operator=(const MetaException& other1171) { - message = other1171.message; - __isset = other1171.__isset; +MetaException& MetaException::operator=(const MetaException& other1173) { + message = other1173.message; + __isset = other1173.__isset; return *this; } void MetaException::printTo(std::ostream& out) const { @@ -31207,13 +31313,13 @@ void swap(UnknownTableException &a, UnknownTableException &b) { swap(a.__isset, b.__isset); } -UnknownTableException::UnknownTableException(const UnknownTableException& other1172) : TException() { - message = other1172.message; - __isset = other1172.__isset; +UnknownTableException::UnknownTableException(const UnknownTableException& other1174) : TException() { + message = other1174.message; + __isset = other1174.__isset; } -UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other1173) { - message = other1173.message; - __isset = other1173.__isset; +UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other1175) { + message = other1175.message; + __isset = other1175.__isset; return *this; } void UnknownTableException::printTo(std::ostream& out) const { @@ -31304,13 +31410,13 @@ void swap(UnknownDBException &a, UnknownDBException &b) { swap(a.__isset, b.__isset); } -UnknownDBException::UnknownDBException(const UnknownDBException& other1174) : TException() { - message = other1174.message; - __isset = other1174.__isset; +UnknownDBException::UnknownDBException(const UnknownDBException& other1176) : TException() { + message = other1176.message; + __isset = other1176.__isset; } -UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other1175) { - message = other1175.message; - __isset = other1175.__isset; +UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other1177) { + message = other1177.message; + __isset = other1177.__isset; return *this; } void UnknownDBException::printTo(std::ostream& out) const { @@ -31401,13 +31507,13 @@ void swap(AlreadyExistsException &a, AlreadyExistsException &b) { swap(a.__isset, b.__isset); } -AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other1176) : TException() { - message = other1176.message; - __isset = other1176.__isset; +AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other1178) : TException() { + message = other1178.message; + __isset = other1178.__isset; } -AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other1177) { - message = other1177.message; - __isset = other1177.__isset; +AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other1179) { + message = other1179.message; + __isset = other1179.__isset; return *this; } void AlreadyExistsException::printTo(std::ostream& out) const { @@ -31498,13 +31604,13 @@ void swap(InvalidPartitionException &a, InvalidPartitionException &b) { swap(a.__isset, b.__isset); } -InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other1178) : TException() { - message = other1178.message; - __isset = other1178.__isset; +InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other1180) : TException() { + message = other1180.message; + __isset = other1180.__isset; } -InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other1179) { - message = other1179.message; - __isset = other1179.__isset; +InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other1181) { + message = other1181.message; + __isset = other1181.__isset; return *this; } void InvalidPartitionException::printTo(std::ostream& out) const { @@ -31595,13 +31701,13 @@ void swap(UnknownPartitionException &a, UnknownPartitionException &b) { swap(a.__isset, b.__isset); } -UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other1180) : TException() { - message = other1180.message; - __isset = other1180.__isset; +UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other1182) : TException() { + message = other1182.message; + __isset = other1182.__isset; } -UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other1181) { - message = other1181.message; - __isset = other1181.__isset; +UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other1183) { + message = other1183.message; + __isset = other1183.__isset; return *this; } void UnknownPartitionException::printTo(std::ostream& out) const { @@ -31692,13 +31798,13 @@ void swap(InvalidObjectException &a, InvalidObjectException &b) { swap(a.__isset, b.__isset); } -InvalidObjectException::InvalidObjectException(const InvalidObjectException& other1182) : TException() { - message = other1182.message; - __isset = other1182.__isset; +InvalidObjectException::InvalidObjectException(const InvalidObjectException& other1184) : TException() { + message = other1184.message; + __isset = other1184.__isset; } -InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other1183) { - message = other1183.message; - __isset = other1183.__isset; +InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other1185) { + message = other1185.message; + __isset = other1185.__isset; return *this; } void InvalidObjectException::printTo(std::ostream& out) const { @@ -31789,13 +31895,13 @@ void swap(NoSuchObjectException &a, NoSuchObjectException &b) { swap(a.__isset, b.__isset); } -NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other1184) : TException() { - message = other1184.message; - __isset = other1184.__isset; +NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other1186) : TException() { + message = other1186.message; + __isset = other1186.__isset; } -NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other1185) { - message = other1185.message; - __isset = other1185.__isset; +NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other1187) { + message = other1187.message; + __isset = other1187.__isset; return *this; } void NoSuchObjectException::printTo(std::ostream& out) const { @@ -31886,13 +31992,13 @@ void swap(InvalidOperationException &a, InvalidOperationException &b) { swap(a.__isset, b.__isset); } -InvalidOperationException::InvalidOperationException(const InvalidOperationException& other1186) : TException() { - message = other1186.message; - __isset = other1186.__isset; +InvalidOperationException::InvalidOperationException(const InvalidOperationException& other1188) : TException() { + message = other1188.message; + __isset = other1188.__isset; } -InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other1187) { - message = other1187.message; - __isset = other1187.__isset; +InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other1189) { + message = other1189.message; + __isset = other1189.__isset; return *this; } void InvalidOperationException::printTo(std::ostream& out) const { @@ -31983,13 +32089,13 @@ void swap(ConfigValSecurityException &a, ConfigValSecurityException &b) { swap(a.__isset, b.__isset); } -ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other1188) : TException() { - message = other1188.message; - __isset = other1188.__isset; +ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other1190) : TException() { + message = other1190.message; + __isset = other1190.__isset; } -ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other1189) { - message = other1189.message; - __isset = other1189.__isset; +ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other1191) { + message = other1191.message; + __isset = other1191.__isset; return *this; } void ConfigValSecurityException::printTo(std::ostream& out) const { @@ -32080,13 +32186,13 @@ void swap(InvalidInputException &a, InvalidInputException &b) { swap(a.__isset, b.__isset); } -InvalidInputException::InvalidInputException(const InvalidInputException& other1190) : TException() { - message = other1190.message; - __isset = other1190.__isset; +InvalidInputException::InvalidInputException(const InvalidInputException& other1192) : TException() { + message = other1192.message; + __isset = other1192.__isset; } -InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other1191) { - message = other1191.message; - __isset = other1191.__isset; +InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other1193) { + message = other1193.message; + __isset = other1193.__isset; return *this; } void InvalidInputException::printTo(std::ostream& out) const { @@ -32177,13 +32283,13 @@ void swap(NoSuchTxnException &a, NoSuchTxnException &b) { swap(a.__isset, b.__isset); } -NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other1192) : TException() { - message = other1192.message; - __isset = other1192.__isset; +NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other1194) : TException() { + message = other1194.message; + __isset = other1194.__isset; } -NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other1193) { - message = other1193.message; - __isset = other1193.__isset; +NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other1195) { + message = other1195.message; + __isset = other1195.__isset; return *this; } void NoSuchTxnException::printTo(std::ostream& out) const { @@ -32274,13 +32380,13 @@ void swap(TxnAbortedException &a, TxnAbortedException &b) { swap(a.__isset, b.__isset); } -TxnAbortedException::TxnAbortedException(const TxnAbortedException& other1194) : TException() { - message = other1194.message; - __isset = other1194.__isset; +TxnAbortedException::TxnAbortedException(const TxnAbortedException& other1196) : TException() { + message = other1196.message; + __isset = other1196.__isset; } -TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other1195) { - message = other1195.message; - __isset = other1195.__isset; +TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other1197) { + message = other1197.message; + __isset = other1197.__isset; return *this; } void TxnAbortedException::printTo(std::ostream& out) const { @@ -32371,13 +32477,13 @@ void swap(TxnOpenException &a, TxnOpenException &b) { swap(a.__isset, b.__isset); } -TxnOpenException::TxnOpenException(const TxnOpenException& other1196) : TException() { - message = other1196.message; - __isset = other1196.__isset; +TxnOpenException::TxnOpenException(const TxnOpenException& other1198) : TException() { + message = other1198.message; + __isset = other1198.__isset; } -TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other1197) { - message = other1197.message; - __isset = other1197.__isset; +TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other1199) { + message = other1199.message; + __isset = other1199.__isset; return *this; } void TxnOpenException::printTo(std::ostream& out) const { @@ -32468,13 +32574,13 @@ void swap(NoSuchLockException &a, NoSuchLockException &b) { swap(a.__isset, b.__isset); } -NoSuchLockException::NoSuchLockException(const NoSuchLockException& other1198) : TException() { - message = other1198.message; - __isset = other1198.__isset; +NoSuchLockException::NoSuchLockException(const NoSuchLockException& other1200) : TException() { + message = other1200.message; + __isset = other1200.__isset; } -NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other1199) { - message = other1199.message; - __isset = other1199.__isset; +NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other1201) { + message = other1201.message; + __isset = other1201.__isset; return *this; } void NoSuchLockException::printTo(std::ostream& out) const { diff --git standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h index 7b42182d60..86dec2b33a 100644 --- standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h +++ standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h @@ -291,6 +291,8 @@ class Catalog; class CreateCatalogRequest; +class AlterCatalogRequest; + class GetCatalogRequest; class GetCatalogResponse; @@ -2444,6 +2446,58 @@ inline std::ostream& operator<<(std::ostream& out, const CreateCatalogRequest& o return out; } +typedef struct _AlterCatalogRequest__isset { + _AlterCatalogRequest__isset() : name(false), newCat(false) {} + bool name :1; + bool newCat :1; +} _AlterCatalogRequest__isset; + +class AlterCatalogRequest { + public: + + AlterCatalogRequest(const AlterCatalogRequest&); + AlterCatalogRequest& operator=(const AlterCatalogRequest&); + AlterCatalogRequest() : name() { + } + + virtual ~AlterCatalogRequest() throw(); + std::string name; + Catalog newCat; + + _AlterCatalogRequest__isset __isset; + + void __set_name(const std::string& val); + + void __set_newCat(const Catalog& val); + + bool operator == (const AlterCatalogRequest & rhs) const + { + if (!(name == rhs.name)) + return false; + if (!(newCat == rhs.newCat)) + return false; + return true; + } + bool operator != (const AlterCatalogRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AlterCatalogRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(AlterCatalogRequest &a, AlterCatalogRequest &b); + +inline std::ostream& operator<<(std::ostream& out, const AlterCatalogRequest& obj) +{ + obj.printTo(out); + return out; +} + typedef struct _GetCatalogRequest__isset { _GetCatalogRequest__isset() : name(false) {} bool name :1; diff --git standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AlterCatalogRequest.java standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AlterCatalogRequest.java new file mode 100644 index 0000000000..b9b51174bd --- /dev/null +++ standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AlterCatalogRequest.java @@ -0,0 +1,504 @@ +/** + * Autogenerated by Thrift Compiler (0.9.3) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +package org.apache.hadoop.hive.metastore.api; + +import org.apache.thrift.scheme.IScheme; +import org.apache.thrift.scheme.SchemeFactory; +import org.apache.thrift.scheme.StandardScheme; + +import org.apache.thrift.scheme.TupleScheme; +import org.apache.thrift.protocol.TTupleProtocol; +import org.apache.thrift.protocol.TProtocolException; +import org.apache.thrift.EncodingUtils; +import org.apache.thrift.TException; +import org.apache.thrift.async.AsyncMethodCallback; +import org.apache.thrift.server.AbstractNonblockingServer.*; +import java.util.List; +import java.util.ArrayList; +import java.util.Map; +import java.util.HashMap; +import java.util.EnumMap; +import java.util.Set; +import java.util.HashSet; +import java.util.EnumSet; +import java.util.Collections; +import java.util.BitSet; +import java.nio.ByteBuffer; +import java.util.Arrays; +import javax.annotation.Generated; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) +@Generated(value = "Autogenerated by Thrift Compiler (0.9.3)") +@org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public class AlterCatalogRequest 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("AlterCatalogRequest"); + + private static final org.apache.thrift.protocol.TField NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("name", org.apache.thrift.protocol.TType.STRING, (short)1); + private static final org.apache.thrift.protocol.TField NEW_CAT_FIELD_DESC = new org.apache.thrift.protocol.TField("newCat", org.apache.thrift.protocol.TType.STRUCT, (short)2); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new AlterCatalogRequestStandardSchemeFactory()); + schemes.put(TupleScheme.class, new AlterCatalogRequestTupleSchemeFactory()); + } + + private String name; // required + private Catalog newCat; // 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 { + NAME((short)1, "name"), + NEW_CAT((short)2, "newCat"); + + 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: // NAME + return NAME; + case 2: // NEW_CAT + return NEW_CAT; + 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.NAME, new org.apache.thrift.meta_data.FieldMetaData("name", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.NEW_CAT, new org.apache.thrift.meta_data.FieldMetaData("newCat", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, Catalog.class))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(AlterCatalogRequest.class, metaDataMap); + } + + public AlterCatalogRequest() { + } + + public AlterCatalogRequest( + String name, + Catalog newCat) + { + this(); + this.name = name; + this.newCat = newCat; + } + + /** + * Performs a deep copy on other. + */ + public AlterCatalogRequest(AlterCatalogRequest other) { + if (other.isSetName()) { + this.name = other.name; + } + if (other.isSetNewCat()) { + this.newCat = new Catalog(other.newCat); + } + } + + public AlterCatalogRequest deepCopy() { + return new AlterCatalogRequest(this); + } + + @Override + public void clear() { + this.name = null; + this.newCat = null; + } + + public String getName() { + return this.name; + } + + public void setName(String name) { + this.name = name; + } + + public void unsetName() { + this.name = null; + } + + /** Returns true if field name is set (has been assigned a value) and false otherwise */ + public boolean isSetName() { + return this.name != null; + } + + public void setNameIsSet(boolean value) { + if (!value) { + this.name = null; + } + } + + public Catalog getNewCat() { + return this.newCat; + } + + public void setNewCat(Catalog newCat) { + this.newCat = newCat; + } + + public void unsetNewCat() { + this.newCat = null; + } + + /** Returns true if field newCat is set (has been assigned a value) and false otherwise */ + public boolean isSetNewCat() { + return this.newCat != null; + } + + public void setNewCatIsSet(boolean value) { + if (!value) { + this.newCat = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case NAME: + if (value == null) { + unsetName(); + } else { + setName((String)value); + } + break; + + case NEW_CAT: + if (value == null) { + unsetNewCat(); + } else { + setNewCat((Catalog)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case NAME: + return getName(); + + case NEW_CAT: + return getNewCat(); + + } + 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 NAME: + return isSetName(); + case NEW_CAT: + return isSetNewCat(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof AlterCatalogRequest) + return this.equals((AlterCatalogRequest)that); + return false; + } + + public boolean equals(AlterCatalogRequest that) { + if (that == null) + return false; + + boolean this_present_name = true && this.isSetName(); + boolean that_present_name = true && that.isSetName(); + if (this_present_name || that_present_name) { + if (!(this_present_name && that_present_name)) + return false; + if (!this.name.equals(that.name)) + return false; + } + + boolean this_present_newCat = true && this.isSetNewCat(); + boolean that_present_newCat = true && that.isSetNewCat(); + if (this_present_newCat || that_present_newCat) { + if (!(this_present_newCat && that_present_newCat)) + return false; + if (!this.newCat.equals(that.newCat)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + boolean present_name = true && (isSetName()); + list.add(present_name); + if (present_name) + list.add(name); + + boolean present_newCat = true && (isSetNewCat()); + list.add(present_newCat); + if (present_newCat) + list.add(newCat); + + return list.hashCode(); + } + + @Override + public int compareTo(AlterCatalogRequest other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetName()).compareTo(other.isSetName()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetName()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.name, other.name); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetNewCat()).compareTo(other.isSetNewCat()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetNewCat()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.newCat, other.newCat); + 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("AlterCatalogRequest("); + boolean first = true; + + sb.append("name:"); + if (this.name == null) { + sb.append("null"); + } else { + sb.append(this.name); + } + first = false; + if (!first) sb.append(", "); + sb.append("newCat:"); + if (this.newCat == null) { + sb.append("null"); + } else { + sb.append(this.newCat); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + if (newCat != null) { + newCat.validate(); + } + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class AlterCatalogRequestStandardSchemeFactory implements SchemeFactory { + public AlterCatalogRequestStandardScheme getScheme() { + return new AlterCatalogRequestStandardScheme(); + } + } + + private static class AlterCatalogRequestStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, AlterCatalogRequest 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: // NAME + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.name = iprot.readString(); + struct.setNameIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // NEW_CAT + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.newCat = new Catalog(); + struct.newCat.read(iprot); + struct.setNewCatIsSet(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, AlterCatalogRequest struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.name != null) { + oprot.writeFieldBegin(NAME_FIELD_DESC); + oprot.writeString(struct.name); + oprot.writeFieldEnd(); + } + if (struct.newCat != null) { + oprot.writeFieldBegin(NEW_CAT_FIELD_DESC); + struct.newCat.write(oprot); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class AlterCatalogRequestTupleSchemeFactory implements SchemeFactory { + public AlterCatalogRequestTupleScheme getScheme() { + return new AlterCatalogRequestTupleScheme(); + } + } + + private static class AlterCatalogRequestTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, AlterCatalogRequest struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetName()) { + optionals.set(0); + } + if (struct.isSetNewCat()) { + optionals.set(1); + } + oprot.writeBitSet(optionals, 2); + if (struct.isSetName()) { + oprot.writeString(struct.name); + } + if (struct.isSetNewCat()) { + struct.newCat.write(oprot); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, AlterCatalogRequest struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(2); + if (incoming.get(0)) { + struct.name = iprot.readString(); + struct.setNameIsSet(true); + } + if (incoming.get(1)) { + struct.newCat = new Catalog(); + struct.newCat.read(iprot); + struct.setNewCatIsSet(true); + } + } + } + +} + diff --git standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java index 3139058bee..9e15bb9d74 100644 --- standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java +++ standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java @@ -48,6 +48,8 @@ public void create_catalog(CreateCatalogRequest catalog) throws AlreadyExistsException, InvalidObjectException, MetaException, org.apache.thrift.TException; + public void alter_catalog(AlterCatalogRequest rqst) throws NoSuchObjectException, InvalidOperationException, MetaException, org.apache.thrift.TException; + public GetCatalogResponse get_catalog(GetCatalogRequest catName) throws NoSuchObjectException, MetaException, org.apache.thrift.TException; public GetCatalogsResponse get_catalogs() throws MetaException, org.apache.thrift.TException; @@ -464,6 +466,8 @@ public void create_catalog(CreateCatalogRequest catalog, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void alter_catalog(AlterCatalogRequest rqst, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void get_catalog(GetCatalogRequest catName, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; public void get_catalogs(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; @@ -971,6 +975,35 @@ public void recv_create_catalog() throws AlreadyExistsException, InvalidObjectEx return; } + public void alter_catalog(AlterCatalogRequest rqst) throws NoSuchObjectException, InvalidOperationException, MetaException, org.apache.thrift.TException + { + send_alter_catalog(rqst); + recv_alter_catalog(); + } + + public void send_alter_catalog(AlterCatalogRequest rqst) throws org.apache.thrift.TException + { + alter_catalog_args args = new alter_catalog_args(); + args.setRqst(rqst); + sendBase("alter_catalog", args); + } + + public void recv_alter_catalog() throws NoSuchObjectException, InvalidOperationException, MetaException, org.apache.thrift.TException + { + alter_catalog_result result = new alter_catalog_result(); + receiveBase(result, "alter_catalog"); + if (result.o1 != null) { + throw result.o1; + } + if (result.o2 != null) { + throw result.o2; + } + if (result.o3 != null) { + throw result.o3; + } + return; + } + public GetCatalogResponse get_catalog(GetCatalogRequest catName) throws NoSuchObjectException, MetaException, org.apache.thrift.TException { send_get_catalog(catName); @@ -6921,6 +6954,38 @@ public void getResult() throws AlreadyExistsException, InvalidObjectException, M } } + public void alter_catalog(AlterCatalogRequest rqst, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + alter_catalog_call method_call = new alter_catalog_call(rqst, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class alter_catalog_call extends org.apache.thrift.async.TAsyncMethodCall { + private AlterCatalogRequest rqst; + public alter_catalog_call(AlterCatalogRequest rqst, 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.rqst = rqst; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("alter_catalog", org.apache.thrift.protocol.TMessageType.CALL, 0)); + alter_catalog_args args = new alter_catalog_args(); + args.setRqst(rqst); + args.write(prot); + prot.writeMessageEnd(); + } + + public void getResult() throws NoSuchObjectException, InvalidOperationException, 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_alter_catalog(); + } + } + public void get_catalog(GetCatalogRequest catName, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { checkReady(); get_catalog_call method_call = new get_catalog_call(catName, resultHandler, this, ___protocolFactory, ___transport); @@ -13919,6 +13984,7 @@ protected Processor(I iface, Map extends org.apache.thrift.ProcessFunction { + public alter_catalog() { + super("alter_catalog"); + } + + public alter_catalog_args getEmptyArgsInstance() { + return new alter_catalog_args(); + } + + protected boolean isOneway() { + return false; + } + + public alter_catalog_result getResult(I iface, alter_catalog_args args) throws org.apache.thrift.TException { + alter_catalog_result result = new alter_catalog_result(); + try { + iface.alter_catalog(args.rqst); + } catch (NoSuchObjectException o1) { + result.o1 = o1; + } catch (InvalidOperationException o2) { + result.o2 = o2; + } catch (MetaException o3) { + result.o3 = o3; + } + return result; + } + } + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class get_catalog extends org.apache.thrift.ProcessFunction { public get_catalog() { super("get_catalog"); @@ -19423,6 +19517,7 @@ protected AsyncProcessor(I iface, Map extends org.apache.thrift.AsyncProcessFunction { - public get_catalog() { - super("get_catalog"); - } - - public get_catalog_args getEmptyArgsInstance() { - return new get_catalog_args(); - } - - public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { - final org.apache.thrift.AsyncProcessFunction fcall = this; - return new AsyncMethodCallback() { - public void onComplete(GetCatalogResponse o) { - get_catalog_result result = new get_catalog_result(); - result.success = o; - try { - fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); - return; - } catch (Exception e) { - LOGGER.error("Exception writing to internal frame buffer", e); - } - fb.close(); - } - public void onError(Exception e) { - byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; - org.apache.thrift.TBase msg; - get_catalog_result result = new get_catalog_result(); - if (e instanceof NoSuchObjectException) { - result.o1 = (NoSuchObjectException) e; - result.setO1IsSet(true); - msg = result; - } - else if (e instanceof MetaException) { - result.o2 = (MetaException) e; - result.setO2IsSet(true); - msg = result; - } - else - { - msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; - msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); - } - try { - fcall.sendResponse(fb,msg,msgType,seqid); - return; - } catch (Exception ex) { - LOGGER.error("Exception writing to internal frame buffer", ex); - } - fb.close(); - } - }; - } - - protected boolean isOneway() { - return false; - } - - public void start(I iface, get_catalog_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { - iface.get_catalog(args.catName,resultHandler); - } - } - - @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class get_catalogs extends org.apache.thrift.AsyncProcessFunction { - public get_catalogs() { - super("get_catalogs"); + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class alter_catalog extends org.apache.thrift.AsyncProcessFunction { + public alter_catalog() { + super("alter_catalog"); } - public get_catalogs_args getEmptyArgsInstance() { - return new get_catalogs_args(); - } - - public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { - final org.apache.thrift.AsyncProcessFunction fcall = this; - return new AsyncMethodCallback() { - public void onComplete(GetCatalogsResponse o) { - get_catalogs_result result = new get_catalogs_result(); - result.success = o; - try { - fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); - return; - } catch (Exception e) { - LOGGER.error("Exception writing to internal frame buffer", e); - } - fb.close(); - } - public void onError(Exception e) { - byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; - org.apache.thrift.TBase msg; - get_catalogs_result result = new get_catalogs_result(); - if (e instanceof MetaException) { - result.o1 = (MetaException) e; - result.setO1IsSet(true); - msg = result; - } - else - { - msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; - msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); - } - try { - fcall.sendResponse(fb,msg,msgType,seqid); - return; - } catch (Exception ex) { - LOGGER.error("Exception writing to internal frame buffer", ex); - } - fb.close(); - } - }; - } - - protected boolean isOneway() { - return false; - } - - public void start(I iface, get_catalogs_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { - iface.get_catalogs(resultHandler); - } - } - - @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class drop_catalog extends org.apache.thrift.AsyncProcessFunction { - public drop_catalog() { - super("drop_catalog"); - } - - public drop_catalog_args getEmptyArgsInstance() { - return new drop_catalog_args(); + public alter_catalog_args getEmptyArgsInstance() { + return new alter_catalog_args(); } public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { final org.apache.thrift.AsyncProcessFunction fcall = this; return new AsyncMethodCallback() { public void onComplete(Void o) { - drop_catalog_result result = new drop_catalog_result(); + alter_catalog_result result = new alter_catalog_result(); try { fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); return; @@ -19952,7 +19928,7 @@ public void onComplete(Void o) { public void onError(Exception e) { byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; org.apache.thrift.TBase msg; - drop_catalog_result result = new drop_catalog_result(); + alter_catalog_result result = new alter_catalog_result(); if (e instanceof NoSuchObjectException) { result.o1 = (NoSuchObjectException) e; result.setO1IsSet(true); @@ -19988,25 +19964,26 @@ protected boolean isOneway() { return false; } - public void start(I iface, drop_catalog_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { - iface.drop_catalog(args.catName,resultHandler); + public void start(I iface, alter_catalog_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.alter_catalog(args.rqst,resultHandler); } } - @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class create_database extends org.apache.thrift.AsyncProcessFunction { - public create_database() { - super("create_database"); + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class get_catalog extends org.apache.thrift.AsyncProcessFunction { + public get_catalog() { + super("get_catalog"); } - public create_database_args getEmptyArgsInstance() { - return new create_database_args(); + public get_catalog_args getEmptyArgsInstance() { + return new get_catalog_args(); } - public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { final org.apache.thrift.AsyncProcessFunction fcall = this; - return new AsyncMethodCallback() { - public void onComplete(Void o) { - create_database_result result = new create_database_result(); + return new AsyncMethodCallback() { + public void onComplete(GetCatalogResponse o) { + get_catalog_result result = new get_catalog_result(); + result.success = o; try { fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); return; @@ -20018,20 +19995,15 @@ public void onComplete(Void o) { public void onError(Exception e) { byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; org.apache.thrift.TBase msg; - create_database_result result = new create_database_result(); - if (e instanceof AlreadyExistsException) { - result.o1 = (AlreadyExistsException) e; + get_catalog_result result = new get_catalog_result(); + if (e instanceof NoSuchObjectException) { + result.o1 = (NoSuchObjectException) e; result.setO1IsSet(true); msg = result; } - else if (e instanceof InvalidObjectException) { - result.o2 = (InvalidObjectException) e; - result.setO2IsSet(true); - msg = result; - } else if (e instanceof MetaException) { - result.o3 = (MetaException) e; - result.setO3IsSet(true); + result.o2 = (MetaException) e; + result.setO2IsSet(true); msg = result; } else @@ -20054,25 +20026,25 @@ protected boolean isOneway() { return false; } - public void start(I iface, create_database_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { - iface.create_database(args.database,resultHandler); + public void start(I iface, get_catalog_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.get_catalog(args.catName,resultHandler); } } - @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class get_database extends org.apache.thrift.AsyncProcessFunction { - public get_database() { - super("get_database"); + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class get_catalogs extends org.apache.thrift.AsyncProcessFunction { + public get_catalogs() { + super("get_catalogs"); } - public get_database_args getEmptyArgsInstance() { - return new get_database_args(); + public get_catalogs_args getEmptyArgsInstance() { + return new get_catalogs_args(); } - public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { final org.apache.thrift.AsyncProcessFunction fcall = this; - return new AsyncMethodCallback() { - public void onComplete(Database o) { - get_database_result result = new get_database_result(); + return new AsyncMethodCallback() { + public void onComplete(GetCatalogsResponse o) { + get_catalogs_result result = new get_catalogs_result(); result.success = o; try { fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); @@ -20085,17 +20057,12 @@ public void onComplete(Database o) { public void onError(Exception e) { byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; org.apache.thrift.TBase msg; - get_database_result result = new get_database_result(); - if (e instanceof NoSuchObjectException) { - result.o1 = (NoSuchObjectException) e; + get_catalogs_result result = new get_catalogs_result(); + if (e instanceof MetaException) { + result.o1 = (MetaException) e; result.setO1IsSet(true); msg = result; } - else if (e instanceof MetaException) { - result.o2 = (MetaException) e; - result.setO2IsSet(true); - msg = result; - } else { msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; @@ -20116,25 +20083,25 @@ protected boolean isOneway() { return false; } - public void start(I iface, get_database_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { - iface.get_database(args.name,resultHandler); + public void start(I iface, get_catalogs_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.get_catalogs(resultHandler); } } - @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class drop_database extends org.apache.thrift.AsyncProcessFunction { - public drop_database() { - super("drop_database"); + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class drop_catalog extends org.apache.thrift.AsyncProcessFunction { + public drop_catalog() { + super("drop_catalog"); } - public drop_database_args getEmptyArgsInstance() { - return new drop_database_args(); + public drop_catalog_args getEmptyArgsInstance() { + return new drop_catalog_args(); } public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { final org.apache.thrift.AsyncProcessFunction fcall = this; return new AsyncMethodCallback() { public void onComplete(Void o) { - drop_database_result result = new drop_database_result(); + drop_catalog_result result = new drop_catalog_result(); try { fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); return; @@ -20146,7 +20113,201 @@ public void onComplete(Void o) { public void onError(Exception e) { byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; org.apache.thrift.TBase msg; - drop_database_result result = new drop_database_result(); + drop_catalog_result result = new drop_catalog_result(); + if (e instanceof NoSuchObjectException) { + result.o1 = (NoSuchObjectException) e; + result.setO1IsSet(true); + msg = result; + } + else if (e instanceof InvalidOperationException) { + result.o2 = (InvalidOperationException) e; + result.setO2IsSet(true); + msg = result; + } + else if (e instanceof MetaException) { + result.o3 = (MetaException) e; + result.setO3IsSet(true); + msg = result; + } + else + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb,msg,msgType,seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, drop_catalog_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.drop_catalog(args.catName,resultHandler); + } + } + + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class create_database extends org.apache.thrift.AsyncProcessFunction { + public create_database() { + super("create_database"); + } + + public create_database_args getEmptyArgsInstance() { + return new create_database_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) { + create_database_result result = new create_database_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; + create_database_result result = new create_database_result(); + if (e instanceof AlreadyExistsException) { + result.o1 = (AlreadyExistsException) e; + result.setO1IsSet(true); + msg = result; + } + else if (e instanceof InvalidObjectException) { + result.o2 = (InvalidObjectException) e; + result.setO2IsSet(true); + msg = result; + } + else if (e instanceof MetaException) { + result.o3 = (MetaException) e; + result.setO3IsSet(true); + msg = result; + } + else + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb,msg,msgType,seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, create_database_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.create_database(args.database,resultHandler); + } + } + + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class get_database extends org.apache.thrift.AsyncProcessFunction { + public get_database() { + super("get_database"); + } + + public get_database_args getEmptyArgsInstance() { + return new get_database_args(); + } + + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback() { + public void onComplete(Database o) { + get_database_result result = new get_database_result(); + result.success = o; + try { + fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + get_database_result result = new get_database_result(); + if (e instanceof NoSuchObjectException) { + result.o1 = (NoSuchObjectException) e; + result.setO1IsSet(true); + msg = result; + } + else if (e instanceof MetaException) { + result.o2 = (MetaException) e; + result.setO2IsSet(true); + msg = result; + } + else + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb,msg,msgType,seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, get_database_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.get_database(args.name,resultHandler); + } + } + + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class drop_database extends org.apache.thrift.AsyncProcessFunction { + public drop_database() { + super("drop_database"); + } + + public drop_database_args getEmptyArgsInstance() { + return new drop_database_args(); + } + + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback() { + public void onComplete(Void o) { + drop_database_result result = new drop_database_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; + drop_database_result result = new drop_database_result(); if (e instanceof NoSuchObjectException) { result.o1 = (NoSuchObjectException) e; result.setO1IsSet(true); @@ -33794,15 +33955,900 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class setMetaConf_resultStandardSchemeFactory implements SchemeFactory { - public setMetaConf_resultStandardScheme getScheme() { - return new setMetaConf_resultStandardScheme(); + private static class setMetaConf_resultStandardSchemeFactory implements SchemeFactory { + public setMetaConf_resultStandardScheme getScheme() { + return new setMetaConf_resultStandardScheme(); + } + } + + private static class setMetaConf_resultStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, setMetaConf_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 MetaException(); + struct.o1.read(iprot); + struct.setO1IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + struct.validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot, setMetaConf_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(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class setMetaConf_resultTupleSchemeFactory implements SchemeFactory { + public setMetaConf_resultTupleScheme getScheme() { + return new setMetaConf_resultTupleScheme(); + } + } + + private static class setMetaConf_resultTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, setMetaConf_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetO1()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetO1()) { + struct.o1.write(oprot); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, setMetaConf_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.o1 = new MetaException(); + struct.o1.read(iprot); + struct.setO1IsSet(true); + } + } + } + + } + + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class create_catalog_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("create_catalog_args"); + + private static final org.apache.thrift.protocol.TField CATALOG_FIELD_DESC = new org.apache.thrift.protocol.TField("catalog", org.apache.thrift.protocol.TType.STRUCT, (short)1); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new create_catalog_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new create_catalog_argsTupleSchemeFactory()); + } + + private CreateCatalogRequest catalog; // 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 { + CATALOG((short)1, "catalog"); + + 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: // CATALOG + return CATALOG; + 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.CATALOG, new org.apache.thrift.meta_data.FieldMetaData("catalog", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, CreateCatalogRequest.class))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(create_catalog_args.class, metaDataMap); + } + + public create_catalog_args() { + } + + public create_catalog_args( + CreateCatalogRequest catalog) + { + this(); + this.catalog = catalog; + } + + /** + * Performs a deep copy on other. + */ + public create_catalog_args(create_catalog_args other) { + if (other.isSetCatalog()) { + this.catalog = new CreateCatalogRequest(other.catalog); + } + } + + public create_catalog_args deepCopy() { + return new create_catalog_args(this); + } + + @Override + public void clear() { + this.catalog = null; + } + + public CreateCatalogRequest getCatalog() { + return this.catalog; + } + + public void setCatalog(CreateCatalogRequest catalog) { + this.catalog = catalog; + } + + public void unsetCatalog() { + this.catalog = null; + } + + /** Returns true if field catalog is set (has been assigned a value) and false otherwise */ + public boolean isSetCatalog() { + return this.catalog != null; + } + + public void setCatalogIsSet(boolean value) { + if (!value) { + this.catalog = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case CATALOG: + if (value == null) { + unsetCatalog(); + } else { + setCatalog((CreateCatalogRequest)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case CATALOG: + return getCatalog(); + + } + 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 CATALOG: + return isSetCatalog(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof create_catalog_args) + return this.equals((create_catalog_args)that); + return false; + } + + public boolean equals(create_catalog_args that) { + if (that == null) + return false; + + boolean this_present_catalog = true && this.isSetCatalog(); + boolean that_present_catalog = true && that.isSetCatalog(); + if (this_present_catalog || that_present_catalog) { + if (!(this_present_catalog && that_present_catalog)) + return false; + if (!this.catalog.equals(that.catalog)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + boolean present_catalog = true && (isSetCatalog()); + list.add(present_catalog); + if (present_catalog) + list.add(catalog); + + return list.hashCode(); + } + + @Override + public int compareTo(create_catalog_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetCatalog()).compareTo(other.isSetCatalog()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetCatalog()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.catalog, other.catalog); + 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("create_catalog_args("); + boolean first = true; + + sb.append("catalog:"); + if (this.catalog == null) { + sb.append("null"); + } else { + sb.append(this.catalog); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + if (catalog != null) { + catalog.validate(); + } + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class create_catalog_argsStandardSchemeFactory implements SchemeFactory { + public create_catalog_argsStandardScheme getScheme() { + return new create_catalog_argsStandardScheme(); + } + } + + private static class create_catalog_argsStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, create_catalog_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: // CATALOG + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.catalog = new CreateCatalogRequest(); + struct.catalog.read(iprot); + struct.setCatalogIsSet(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, create_catalog_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.catalog != null) { + oprot.writeFieldBegin(CATALOG_FIELD_DESC); + struct.catalog.write(oprot); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class create_catalog_argsTupleSchemeFactory implements SchemeFactory { + public create_catalog_argsTupleScheme getScheme() { + return new create_catalog_argsTupleScheme(); + } + } + + private static class create_catalog_argsTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, create_catalog_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetCatalog()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetCatalog()) { + struct.catalog.write(oprot); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, create_catalog_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.catalog = new CreateCatalogRequest(); + struct.catalog.read(iprot); + struct.setCatalogIsSet(true); + } + } + } + + } + + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class create_catalog_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("create_catalog_result"); + + private static final org.apache.thrift.protocol.TField O1_FIELD_DESC = new org.apache.thrift.protocol.TField("o1", org.apache.thrift.protocol.TType.STRUCT, (short)1); + private static final org.apache.thrift.protocol.TField O2_FIELD_DESC = new org.apache.thrift.protocol.TField("o2", org.apache.thrift.protocol.TType.STRUCT, (short)2); + private static final org.apache.thrift.protocol.TField O3_FIELD_DESC = new org.apache.thrift.protocol.TField("o3", org.apache.thrift.protocol.TType.STRUCT, (short)3); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new create_catalog_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new create_catalog_resultTupleSchemeFactory()); + } + + private AlreadyExistsException o1; // required + private InvalidObjectException o2; // required + private MetaException o3; // required + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + O1((short)1, "o1"), + O2((short)2, "o2"), + O3((short)3, "o3"); + + private static final Map byName = new HashMap(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 1: // O1 + return O1; + case 2: // O2 + return O2; + case 3: // O3 + return O3; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.O1, new org.apache.thrift.meta_data.FieldMetaData("o1", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + tmpMap.put(_Fields.O2, new org.apache.thrift.meta_data.FieldMetaData("o2", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + tmpMap.put(_Fields.O3, new org.apache.thrift.meta_data.FieldMetaData("o3", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(create_catalog_result.class, metaDataMap); + } + + public create_catalog_result() { + } + + public create_catalog_result( + AlreadyExistsException o1, + InvalidObjectException o2, + MetaException o3) + { + this(); + this.o1 = o1; + this.o2 = o2; + this.o3 = o3; + } + + /** + * Performs a deep copy on other. + */ + public create_catalog_result(create_catalog_result other) { + if (other.isSetO1()) { + this.o1 = new AlreadyExistsException(other.o1); + } + if (other.isSetO2()) { + this.o2 = new InvalidObjectException(other.o2); + } + if (other.isSetO3()) { + this.o3 = new MetaException(other.o3); + } + } + + public create_catalog_result deepCopy() { + return new create_catalog_result(this); + } + + @Override + public void clear() { + this.o1 = null; + this.o2 = null; + this.o3 = null; + } + + public AlreadyExistsException getO1() { + return this.o1; + } + + public void setO1(AlreadyExistsException 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 InvalidObjectException getO2() { + return this.o2; + } + + public void setO2(InvalidObjectException o2) { + this.o2 = o2; + } + + public void unsetO2() { + this.o2 = null; + } + + /** Returns true if field o2 is set (has been assigned a value) and false otherwise */ + public boolean isSetO2() { + return this.o2 != null; + } + + public void setO2IsSet(boolean value) { + if (!value) { + this.o2 = null; + } + } + + public MetaException getO3() { + return this.o3; + } + + public void setO3(MetaException o3) { + this.o3 = o3; + } + + public void unsetO3() { + this.o3 = null; + } + + /** Returns true if field o3 is set (has been assigned a value) and false otherwise */ + public boolean isSetO3() { + return this.o3 != null; + } + + public void setO3IsSet(boolean value) { + if (!value) { + this.o3 = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case O1: + if (value == null) { + unsetO1(); + } else { + setO1((AlreadyExistsException)value); + } + break; + + case O2: + if (value == null) { + unsetO2(); + } else { + setO2((InvalidObjectException)value); + } + break; + + case O3: + if (value == null) { + unsetO3(); + } else { + setO3((MetaException)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case O1: + return getO1(); + + case O2: + return getO2(); + + case O3: + return getO3(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case O1: + return isSetO1(); + case O2: + return isSetO2(); + case O3: + return isSetO3(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof create_catalog_result) + return this.equals((create_catalog_result)that); + return false; + } + + public boolean equals(create_catalog_result that) { + if (that == null) + return false; + + boolean this_present_o1 = true && this.isSetO1(); + boolean that_present_o1 = true && that.isSetO1(); + if (this_present_o1 || that_present_o1) { + if (!(this_present_o1 && that_present_o1)) + return false; + if (!this.o1.equals(that.o1)) + return false; + } + + boolean this_present_o2 = true && this.isSetO2(); + boolean that_present_o2 = true && that.isSetO2(); + if (this_present_o2 || that_present_o2) { + if (!(this_present_o2 && that_present_o2)) + return false; + if (!this.o2.equals(that.o2)) + return false; + } + + boolean this_present_o3 = true && this.isSetO3(); + boolean that_present_o3 = true && that.isSetO3(); + if (this_present_o3 || that_present_o3) { + if (!(this_present_o3 && that_present_o3)) + return false; + if (!this.o3.equals(that.o3)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + boolean present_o1 = true && (isSetO1()); + list.add(present_o1); + if (present_o1) + list.add(o1); + + boolean present_o2 = true && (isSetO2()); + list.add(present_o2); + if (present_o2) + list.add(o2); + + boolean present_o3 = true && (isSetO3()); + list.add(present_o3); + if (present_o3) + list.add(o3); + + return list.hashCode(); + } + + @Override + public int compareTo(create_catalog_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetO1()).compareTo(other.isSetO1()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetO1()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.o1, other.o1); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetO2()).compareTo(other.isSetO2()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetO2()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.o2, other.o2); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetO3()).compareTo(other.isSetO3()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetO3()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.o3, other.o3); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("create_catalog_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("o2:"); + if (this.o2 == null) { + sb.append("null"); + } else { + sb.append(this.o2); + } + 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 create_catalog_resultStandardSchemeFactory implements SchemeFactory { + public create_catalog_resultStandardScheme getScheme() { + return new create_catalog_resultStandardScheme(); } } - private static class setMetaConf_resultStandardScheme extends StandardScheme { + private static class create_catalog_resultStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, setMetaConf_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, create_catalog_result struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -33814,13 +34860,31 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, setMetaConf_result switch (schemeField.id) { case 1: // O1 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.o1 = new MetaException(); + struct.o1 = new AlreadyExistsException(); struct.o1.read(iprot); struct.setO1IsSet(true); } else { org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } break; + case 2: // O2 + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.o2 = new InvalidObjectException(); + struct.o2.read(iprot); + struct.setO2IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 3: // 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); } @@ -33830,7 +34894,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, setMetaConf_result struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, setMetaConf_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, create_catalog_result struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -33839,63 +34903,95 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, setMetaConf_result struct.o1.write(oprot); oprot.writeFieldEnd(); } + if (struct.o2 != null) { + oprot.writeFieldBegin(O2_FIELD_DESC); + struct.o2.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 setMetaConf_resultTupleSchemeFactory implements SchemeFactory { - public setMetaConf_resultTupleScheme getScheme() { - return new setMetaConf_resultTupleScheme(); + private static class create_catalog_resultTupleSchemeFactory implements SchemeFactory { + public create_catalog_resultTupleScheme getScheme() { + return new create_catalog_resultTupleScheme(); } } - private static class setMetaConf_resultTupleScheme extends TupleScheme { + private static class create_catalog_resultTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, setMetaConf_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, create_catalog_result struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetO1()) { optionals.set(0); } - oprot.writeBitSet(optionals, 1); + if (struct.isSetO2()) { + optionals.set(1); + } + if (struct.isSetO3()) { + optionals.set(2); + } + oprot.writeBitSet(optionals, 3); if (struct.isSetO1()) { struct.o1.write(oprot); } + if (struct.isSetO2()) { + struct.o2.write(oprot); + } + if (struct.isSetO3()) { + struct.o3.write(oprot); + } } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, setMetaConf_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, create_catalog_result struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); + BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { - struct.o1 = new MetaException(); + struct.o1 = new AlreadyExistsException(); struct.o1.read(iprot); struct.setO1IsSet(true); } + if (incoming.get(1)) { + struct.o2 = new InvalidObjectException(); + struct.o2.read(iprot); + struct.setO2IsSet(true); + } + if (incoming.get(2)) { + struct.o3 = new MetaException(); + struct.o3.read(iprot); + struct.setO3IsSet(true); + } } } } - @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class create_catalog_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("create_catalog_args"); + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class alter_catalog_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("alter_catalog_args"); - private static final org.apache.thrift.protocol.TField CATALOG_FIELD_DESC = new org.apache.thrift.protocol.TField("catalog", org.apache.thrift.protocol.TType.STRUCT, (short)1); + private static final org.apache.thrift.protocol.TField RQST_FIELD_DESC = new org.apache.thrift.protocol.TField("rqst", org.apache.thrift.protocol.TType.STRUCT, (short)1); private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { - schemes.put(StandardScheme.class, new create_catalog_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new create_catalog_argsTupleSchemeFactory()); + schemes.put(StandardScheme.class, new alter_catalog_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new alter_catalog_argsTupleSchemeFactory()); } - private CreateCatalogRequest catalog; // required + private AlterCatalogRequest rqst; // 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 { - CATALOG((short)1, "catalog"); + RQST((short)1, "rqst"); private static final Map byName = new HashMap(); @@ -33910,8 +35006,8 @@ public void read(org.apache.thrift.protocol.TProtocol prot, setMetaConf_result s */ public static _Fields findByThriftId(int fieldId) { switch(fieldId) { - case 1: // CATALOG - return CATALOG; + case 1: // RQST + return RQST; default: return null; } @@ -33955,70 +35051,70 @@ public String getFieldName() { 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.CATALOG, new org.apache.thrift.meta_data.FieldMetaData("catalog", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, CreateCatalogRequest.class))); + tmpMap.put(_Fields.RQST, new org.apache.thrift.meta_data.FieldMetaData("rqst", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, AlterCatalogRequest.class))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(create_catalog_args.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(alter_catalog_args.class, metaDataMap); } - public create_catalog_args() { + public alter_catalog_args() { } - public create_catalog_args( - CreateCatalogRequest catalog) + public alter_catalog_args( + AlterCatalogRequest rqst) { this(); - this.catalog = catalog; + this.rqst = rqst; } /** * Performs a deep copy on other. */ - public create_catalog_args(create_catalog_args other) { - if (other.isSetCatalog()) { - this.catalog = new CreateCatalogRequest(other.catalog); + public alter_catalog_args(alter_catalog_args other) { + if (other.isSetRqst()) { + this.rqst = new AlterCatalogRequest(other.rqst); } } - public create_catalog_args deepCopy() { - return new create_catalog_args(this); + public alter_catalog_args deepCopy() { + return new alter_catalog_args(this); } @Override public void clear() { - this.catalog = null; + this.rqst = null; } - public CreateCatalogRequest getCatalog() { - return this.catalog; + public AlterCatalogRequest getRqst() { + return this.rqst; } - public void setCatalog(CreateCatalogRequest catalog) { - this.catalog = catalog; + public void setRqst(AlterCatalogRequest rqst) { + this.rqst = rqst; } - public void unsetCatalog() { - this.catalog = null; + public void unsetRqst() { + this.rqst = null; } - /** Returns true if field catalog is set (has been assigned a value) and false otherwise */ - public boolean isSetCatalog() { - return this.catalog != null; + /** Returns true if field rqst is set (has been assigned a value) and false otherwise */ + public boolean isSetRqst() { + return this.rqst != null; } - public void setCatalogIsSet(boolean value) { + public void setRqstIsSet(boolean value) { if (!value) { - this.catalog = null; + this.rqst = null; } } public void setFieldValue(_Fields field, Object value) { switch (field) { - case CATALOG: + case RQST: if (value == null) { - unsetCatalog(); + unsetRqst(); } else { - setCatalog((CreateCatalogRequest)value); + setRqst((AlterCatalogRequest)value); } break; @@ -34027,8 +35123,8 @@ public void setFieldValue(_Fields field, Object value) { public Object getFieldValue(_Fields field) { switch (field) { - case CATALOG: - return getCatalog(); + case RQST: + return getRqst(); } throw new IllegalStateException(); @@ -34041,8 +35137,8 @@ public boolean isSet(_Fields field) { } switch (field) { - case CATALOG: - return isSetCatalog(); + case RQST: + return isSetRqst(); } throw new IllegalStateException(); } @@ -34051,21 +35147,21 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof create_catalog_args) - return this.equals((create_catalog_args)that); + if (that instanceof alter_catalog_args) + return this.equals((alter_catalog_args)that); return false; } - public boolean equals(create_catalog_args that) { + public boolean equals(alter_catalog_args that) { if (that == null) return false; - boolean this_present_catalog = true && this.isSetCatalog(); - boolean that_present_catalog = true && that.isSetCatalog(); - if (this_present_catalog || that_present_catalog) { - if (!(this_present_catalog && that_present_catalog)) + boolean this_present_rqst = true && this.isSetRqst(); + boolean that_present_rqst = true && that.isSetRqst(); + if (this_present_rqst || that_present_rqst) { + if (!(this_present_rqst && that_present_rqst)) return false; - if (!this.catalog.equals(that.catalog)) + if (!this.rqst.equals(that.rqst)) return false; } @@ -34076,28 +35172,28 @@ public boolean equals(create_catalog_args that) { public int hashCode() { List list = new ArrayList(); - boolean present_catalog = true && (isSetCatalog()); - list.add(present_catalog); - if (present_catalog) - list.add(catalog); + boolean present_rqst = true && (isSetRqst()); + list.add(present_rqst); + if (present_rqst) + list.add(rqst); return list.hashCode(); } @Override - public int compareTo(create_catalog_args other) { + public int compareTo(alter_catalog_args other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } int lastComparison = 0; - lastComparison = Boolean.valueOf(isSetCatalog()).compareTo(other.isSetCatalog()); + lastComparison = Boolean.valueOf(isSetRqst()).compareTo(other.isSetRqst()); if (lastComparison != 0) { return lastComparison; } - if (isSetCatalog()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.catalog, other.catalog); + if (isSetRqst()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.rqst, other.rqst); if (lastComparison != 0) { return lastComparison; } @@ -34119,14 +35215,14 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("create_catalog_args("); + StringBuilder sb = new StringBuilder("alter_catalog_args("); boolean first = true; - sb.append("catalog:"); - if (this.catalog == null) { + sb.append("rqst:"); + if (this.rqst == null) { sb.append("null"); } else { - sb.append(this.catalog); + sb.append(this.rqst); } first = false; sb.append(")"); @@ -34136,8 +35232,8 @@ public String toString() { public void validate() throws org.apache.thrift.TException { // check for required fields // check for sub-struct validity - if (catalog != null) { - catalog.validate(); + if (rqst != null) { + rqst.validate(); } } @@ -34157,15 +35253,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class create_catalog_argsStandardSchemeFactory implements SchemeFactory { - public create_catalog_argsStandardScheme getScheme() { - return new create_catalog_argsStandardScheme(); + private static class alter_catalog_argsStandardSchemeFactory implements SchemeFactory { + public alter_catalog_argsStandardScheme getScheme() { + return new alter_catalog_argsStandardScheme(); } } - private static class create_catalog_argsStandardScheme extends StandardScheme { + private static class alter_catalog_argsStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, create_catalog_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, alter_catalog_args struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -34175,11 +35271,11 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, create_catalog_args break; } switch (schemeField.id) { - case 1: // CATALOG + case 1: // RQST if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.catalog = new CreateCatalogRequest(); - struct.catalog.read(iprot); - struct.setCatalogIsSet(true); + struct.rqst = new AlterCatalogRequest(); + struct.rqst.read(iprot); + struct.setRqstIsSet(true); } else { org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } @@ -34193,13 +35289,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, create_catalog_args struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, create_catalog_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, alter_catalog_args struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); - if (struct.catalog != null) { - oprot.writeFieldBegin(CATALOG_FIELD_DESC); - struct.catalog.write(oprot); + if (struct.rqst != null) { + oprot.writeFieldBegin(RQST_FIELD_DESC); + struct.rqst.write(oprot); oprot.writeFieldEnd(); } oprot.writeFieldStop(); @@ -34208,43 +35304,43 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, create_catalog_arg } - private static class create_catalog_argsTupleSchemeFactory implements SchemeFactory { - public create_catalog_argsTupleScheme getScheme() { - return new create_catalog_argsTupleScheme(); + private static class alter_catalog_argsTupleSchemeFactory implements SchemeFactory { + public alter_catalog_argsTupleScheme getScheme() { + return new alter_catalog_argsTupleScheme(); } } - private static class create_catalog_argsTupleScheme extends TupleScheme { + private static class alter_catalog_argsTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, create_catalog_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, alter_catalog_args struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); - if (struct.isSetCatalog()) { + if (struct.isSetRqst()) { optionals.set(0); } oprot.writeBitSet(optionals, 1); - if (struct.isSetCatalog()) { - struct.catalog.write(oprot); + if (struct.isSetRqst()) { + struct.rqst.write(oprot); } } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, create_catalog_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, alter_catalog_args struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { - struct.catalog = new CreateCatalogRequest(); - struct.catalog.read(iprot); - struct.setCatalogIsSet(true); + struct.rqst = new AlterCatalogRequest(); + struct.rqst.read(iprot); + struct.setRqstIsSet(true); } } } } - @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class create_catalog_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("create_catalog_result"); + @org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public static class alter_catalog_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("alter_catalog_result"); private static final org.apache.thrift.protocol.TField O1_FIELD_DESC = new org.apache.thrift.protocol.TField("o1", org.apache.thrift.protocol.TType.STRUCT, (short)1); private static final org.apache.thrift.protocol.TField O2_FIELD_DESC = new org.apache.thrift.protocol.TField("o2", org.apache.thrift.protocol.TType.STRUCT, (short)2); @@ -34252,12 +35348,12 @@ public void read(org.apache.thrift.protocol.TProtocol prot, create_catalog_args private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { - schemes.put(StandardScheme.class, new create_catalog_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new create_catalog_resultTupleSchemeFactory()); + schemes.put(StandardScheme.class, new alter_catalog_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new alter_catalog_resultTupleSchemeFactory()); } - private AlreadyExistsException o1; // required - private InvalidObjectException o2; // required + private NoSuchObjectException o1; // required + private InvalidOperationException o2; // required private MetaException o3; // required /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ @@ -34335,15 +35431,15 @@ public String getFieldName() { tmpMap.put(_Fields.O3, new org.apache.thrift.meta_data.FieldMetaData("o3", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(create_catalog_result.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(alter_catalog_result.class, metaDataMap); } - public create_catalog_result() { + public alter_catalog_result() { } - public create_catalog_result( - AlreadyExistsException o1, - InvalidObjectException o2, + public alter_catalog_result( + NoSuchObjectException o1, + InvalidOperationException o2, MetaException o3) { this(); @@ -34355,20 +35451,20 @@ public create_catalog_result( /** * Performs a deep copy on other. */ - public create_catalog_result(create_catalog_result other) { + public alter_catalog_result(alter_catalog_result other) { if (other.isSetO1()) { - this.o1 = new AlreadyExistsException(other.o1); + this.o1 = new NoSuchObjectException(other.o1); } if (other.isSetO2()) { - this.o2 = new InvalidObjectException(other.o2); + this.o2 = new InvalidOperationException(other.o2); } if (other.isSetO3()) { this.o3 = new MetaException(other.o3); } } - public create_catalog_result deepCopy() { - return new create_catalog_result(this); + public alter_catalog_result deepCopy() { + return new alter_catalog_result(this); } @Override @@ -34378,11 +35474,11 @@ public void clear() { this.o3 = null; } - public AlreadyExistsException getO1() { + public NoSuchObjectException getO1() { return this.o1; } - public void setO1(AlreadyExistsException o1) { + public void setO1(NoSuchObjectException o1) { this.o1 = o1; } @@ -34401,11 +35497,11 @@ public void setO1IsSet(boolean value) { } } - public InvalidObjectException getO2() { + public InvalidOperationException getO2() { return this.o2; } - public void setO2(InvalidObjectException o2) { + public void setO2(InvalidOperationException o2) { this.o2 = o2; } @@ -34453,7 +35549,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetO1(); } else { - setO1((AlreadyExistsException)value); + setO1((NoSuchObjectException)value); } break; @@ -34461,7 +35557,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetO2(); } else { - setO2((InvalidObjectException)value); + setO2((InvalidOperationException)value); } break; @@ -34512,12 +35608,12 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof create_catalog_result) - return this.equals((create_catalog_result)that); + if (that instanceof alter_catalog_result) + return this.equals((alter_catalog_result)that); return false; } - public boolean equals(create_catalog_result that) { + public boolean equals(alter_catalog_result that) { if (that == null) return false; @@ -34574,7 +35670,7 @@ public int hashCode() { } @Override - public int compareTo(create_catalog_result other) { + public int compareTo(alter_catalog_result other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -34628,7 +35724,7 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("create_catalog_result("); + StringBuilder sb = new StringBuilder("alter_catalog_result("); boolean first = true; sb.append("o1:"); @@ -34679,15 +35775,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class create_catalog_resultStandardSchemeFactory implements SchemeFactory { - public create_catalog_resultStandardScheme getScheme() { - return new create_catalog_resultStandardScheme(); + private static class alter_catalog_resultStandardSchemeFactory implements SchemeFactory { + public alter_catalog_resultStandardScheme getScheme() { + return new alter_catalog_resultStandardScheme(); } } - private static class create_catalog_resultStandardScheme extends StandardScheme { + private static class alter_catalog_resultStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, create_catalog_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, alter_catalog_result struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -34699,7 +35795,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, create_catalog_resu switch (schemeField.id) { case 1: // O1 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.o1 = new AlreadyExistsException(); + struct.o1 = new NoSuchObjectException(); struct.o1.read(iprot); struct.setO1IsSet(true); } else { @@ -34708,7 +35804,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, create_catalog_resu break; case 2: // O2 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.o2 = new InvalidObjectException(); + struct.o2 = new InvalidOperationException(); struct.o2.read(iprot); struct.setO2IsSet(true); } else { @@ -34733,7 +35829,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, create_catalog_resu struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, create_catalog_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, alter_catalog_result struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -34758,16 +35854,16 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, create_catalog_res } - private static class create_catalog_resultTupleSchemeFactory implements SchemeFactory { - public create_catalog_resultTupleScheme getScheme() { - return new create_catalog_resultTupleScheme(); + private static class alter_catalog_resultTupleSchemeFactory implements SchemeFactory { + public alter_catalog_resultTupleScheme getScheme() { + return new alter_catalog_resultTupleScheme(); } } - private static class create_catalog_resultTupleScheme extends TupleScheme { + private static class alter_catalog_resultTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, create_catalog_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, alter_catalog_result struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetO1()) { @@ -34792,16 +35888,16 @@ public void write(org.apache.thrift.protocol.TProtocol prot, create_catalog_resu } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, create_catalog_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, alter_catalog_result struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { - struct.o1 = new AlreadyExistsException(); + struct.o1 = new NoSuchObjectException(); struct.o1.read(iprot); struct.setO1IsSet(true); } if (incoming.get(1)) { - struct.o2 = new InvalidObjectException(); + struct.o2 = new InvalidOperationException(); struct.o2.read(iprot); struct.setO2IsSet(true); } diff --git standalone-metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php standalone-metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php index 250d990b08..1ad9b644c8 100644 --- standalone-metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php +++ standalone-metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php @@ -40,6 +40,13 @@ interface ThriftHiveMetastoreIf extends \FacebookServiceIf { */ public function create_catalog(\metastore\CreateCatalogRequest $catalog); /** + * @param \metastore\AlterCatalogRequest $rqst + * @throws \metastore\NoSuchObjectException + * @throws \metastore\InvalidOperationException + * @throws \metastore\MetaException + */ + public function alter_catalog(\metastore\AlterCatalogRequest $rqst); + /** * @param \metastore\GetCatalogRequest $catName * @return \metastore\GetCatalogResponse * @throws \metastore\NoSuchObjectException @@ -1720,6 +1727,63 @@ class ThriftHiveMetastoreClient extends \FacebookServiceClient implements \metas return; } + public function alter_catalog(\metastore\AlterCatalogRequest $rqst) + { + $this->send_alter_catalog($rqst); + $this->recv_alter_catalog(); + } + + public function send_alter_catalog(\metastore\AlterCatalogRequest $rqst) + { + $args = new \metastore\ThriftHiveMetastore_alter_catalog_args(); + $args->rqst = $rqst; + $bin_accel = ($this->output_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_write_binary'); + if ($bin_accel) + { + thrift_protocol_write_binary($this->output_, 'alter_catalog', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite()); + } + else + { + $this->output_->writeMessageBegin('alter_catalog', TMessageType::CALL, $this->seqid_); + $args->write($this->output_); + $this->output_->writeMessageEnd(); + $this->output_->getTransport()->flush(); + } + } + + public function recv_alter_catalog() + { + $bin_accel = ($this->input_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_read_binary'); + if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\metastore\ThriftHiveMetastore_alter_catalog_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_alter_catalog_result(); + $result->read($this->input_); + $this->input_->readMessageEnd(); + } + if ($result->o1 !== null) { + throw $result->o1; + } + if ($result->o2 !== null) { + throw $result->o2; + } + if ($result->o3 !== null) { + throw $result->o3; + } + return; + } + public function get_catalog(\metastore\GetCatalogRequest $catName) { $this->send_get_catalog($catName); @@ -13798,6 +13862,213 @@ class ThriftHiveMetastore_create_catalog_result { } +class ThriftHiveMetastore_alter_catalog_args { + static $_TSPEC; + + /** + * @var \metastore\AlterCatalogRequest + */ + public $rqst = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'rqst', + 'type' => TType::STRUCT, + 'class' => '\metastore\AlterCatalogRequest', + ), + ); + } + if (is_array($vals)) { + if (isset($vals['rqst'])) { + $this->rqst = $vals['rqst']; + } + } + } + + public function getName() { + return 'ThriftHiveMetastore_alter_catalog_args'; + } + + public function read($input) + { + $xfer = 0; + $fname = null; + $ftype = 0; + $fid = 0; + $xfer += $input->readStructBegin($fname); + while (true) + { + $xfer += $input->readFieldBegin($fname, $ftype, $fid); + if ($ftype == TType::STOP) { + break; + } + switch ($fid) + { + case 1: + if ($ftype == TType::STRUCT) { + $this->rqst = new \metastore\AlterCatalogRequest(); + $xfer += $this->rqst->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_alter_catalog_args'); + if ($this->rqst !== null) { + if (!is_object($this->rqst)) { + throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); + } + $xfer += $output->writeFieldBegin('rqst', TType::STRUCT, 1); + $xfer += $this->rqst->write($output); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class ThriftHiveMetastore_alter_catalog_result { + static $_TSPEC; + + /** + * @var \metastore\NoSuchObjectException + */ + public $o1 = null; + /** + * @var \metastore\InvalidOperationException + */ + public $o2 = null; + /** + * @var \metastore\MetaException + */ + public $o3 = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'o1', + 'type' => TType::STRUCT, + 'class' => '\metastore\NoSuchObjectException', + ), + 2 => array( + 'var' => 'o2', + 'type' => TType::STRUCT, + 'class' => '\metastore\InvalidOperationException', + ), + 3 => array( + 'var' => 'o3', + 'type' => TType::STRUCT, + 'class' => '\metastore\MetaException', + ), + ); + } + if (is_array($vals)) { + if (isset($vals['o1'])) { + $this->o1 = $vals['o1']; + } + if (isset($vals['o2'])) { + $this->o2 = $vals['o2']; + } + if (isset($vals['o3'])) { + $this->o3 = $vals['o3']; + } + } + } + + public function getName() { + return 'ThriftHiveMetastore_alter_catalog_result'; + } + + public function read($input) + { + $xfer = 0; + $fname = null; + $ftype = 0; + $fid = 0; + $xfer += $input->readStructBegin($fname); + while (true) + { + $xfer += $input->readFieldBegin($fname, $ftype, $fid); + if ($ftype == TType::STOP) { + break; + } + switch ($fid) + { + case 1: + if ($ftype == TType::STRUCT) { + $this->o1 = new \metastore\NoSuchObjectException(); + $xfer += $this->o1->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + case 2: + if ($ftype == TType::STRUCT) { + $this->o2 = new \metastore\InvalidOperationException(); + $xfer += $this->o2->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + case 3: + if ($ftype == TType::STRUCT) { + $this->o3 = new \metastore\MetaException(); + $xfer += $this->o3->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + default: + $xfer += $input->skip($ftype); + break; + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; + } + + public function write($output) { + $xfer = 0; + $xfer += $output->writeStructBegin('ThriftHiveMetastore_alter_catalog_result'); + if ($this->o1 !== null) { + $xfer += $output->writeFieldBegin('o1', TType::STRUCT, 1); + $xfer += $this->o1->write($output); + $xfer += $output->writeFieldEnd(); + } + if ($this->o2 !== null) { + $xfer += $output->writeFieldBegin('o2', TType::STRUCT, 2); + $xfer += $this->o2->write($output); + $xfer += $output->writeFieldEnd(); + } + if ($this->o3 !== null) { + $xfer += $output->writeFieldBegin('o3', TType::STRUCT, 3); + $xfer += $this->o3->write($output); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + class ThriftHiveMetastore_get_catalog_args { static $_TSPEC; diff --git standalone-metastore/src/gen/thrift/gen-php/metastore/Types.php standalone-metastore/src/gen/thrift/gen-php/metastore/Types.php index 353c0deb91..b62bd74190 100644 --- standalone-metastore/src/gen/thrift/gen-php/metastore/Types.php +++ standalone-metastore/src/gen/thrift/gen-php/metastore/Types.php @@ -4658,6 +4658,109 @@ class CreateCatalogRequest { } +class AlterCatalogRequest { + static $_TSPEC; + + /** + * @var string + */ + public $name = null; + /** + * @var \metastore\Catalog + */ + public $newCat = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'name', + 'type' => TType::STRING, + ), + 2 => array( + 'var' => 'newCat', + 'type' => TType::STRUCT, + 'class' => '\metastore\Catalog', + ), + ); + } + if (is_array($vals)) { + if (isset($vals['name'])) { + $this->name = $vals['name']; + } + if (isset($vals['newCat'])) { + $this->newCat = $vals['newCat']; + } + } + } + + public function getName() { + return 'AlterCatalogRequest'; + } + + 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->name); + } else { + $xfer += $input->skip($ftype); + } + break; + case 2: + if ($ftype == TType::STRUCT) { + $this->newCat = new \metastore\Catalog(); + $xfer += $this->newCat->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('AlterCatalogRequest'); + if ($this->name !== null) { + $xfer += $output->writeFieldBegin('name', TType::STRING, 1); + $xfer += $output->writeString($this->name); + $xfer += $output->writeFieldEnd(); + } + if ($this->newCat !== null) { + if (!is_object($this->newCat)) { + throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); + } + $xfer += $output->writeFieldBegin('newCat', TType::STRUCT, 2); + $xfer += $this->newCat->write($output); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + class GetCatalogRequest { static $_TSPEC; diff --git standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote index 58afb24bed..01f91a78b7 100755 --- standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote +++ standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote @@ -27,6 +27,7 @@ if len(sys.argv) <= 1 or sys.argv[1] == '--help': print(' string getMetaConf(string key)') print(' void setMetaConf(string key, string value)') print(' void create_catalog(CreateCatalogRequest catalog)') + print(' void alter_catalog(AlterCatalogRequest rqst)') print(' GetCatalogResponse get_catalog(GetCatalogRequest catName)') print(' GetCatalogsResponse get_catalogs()') print(' void drop_catalog(DropCatalogRequest catName)') @@ -317,6 +318,12 @@ elif cmd == 'create_catalog': sys.exit(1) pp.pprint(client.create_catalog(eval(args[0]),)) +elif cmd == 'alter_catalog': + if len(args) != 1: + print('alter_catalog requires 1 args') + sys.exit(1) + pp.pprint(client.alter_catalog(eval(args[0]),)) + elif cmd == 'get_catalog': if len(args) != 1: print('get_catalog requires 1 args') diff --git standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py index 768c0e3110..c0e0f9b39d 100644 --- standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py +++ standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py @@ -45,6 +45,13 @@ def create_catalog(self, catalog): """ pass + def alter_catalog(self, rqst): + """ + Parameters: + - rqst + """ + pass + def get_catalog(self, catName): """ Parameters: @@ -1704,6 +1711,41 @@ def recv_create_catalog(self): raise result.o3 return + def alter_catalog(self, rqst): + """ + Parameters: + - rqst + """ + self.send_alter_catalog(rqst) + self.recv_alter_catalog() + + def send_alter_catalog(self, rqst): + self._oprot.writeMessageBegin('alter_catalog', TMessageType.CALL, self._seqid) + args = alter_catalog_args() + args.rqst = rqst + args.write(self._oprot) + self._oprot.writeMessageEnd() + self._oprot.trans.flush() + + def recv_alter_catalog(self): + iprot = self._iprot + (fname, mtype, rseqid) = iprot.readMessageBegin() + if mtype == TMessageType.EXCEPTION: + x = TApplicationException() + x.read(iprot) + iprot.readMessageEnd() + raise x + result = alter_catalog_result() + result.read(iprot) + iprot.readMessageEnd() + if result.o1 is not None: + raise result.o1 + if result.o2 is not None: + raise result.o2 + if result.o3 is not None: + raise result.o3 + return + def get_catalog(self, catName): """ Parameters: @@ -8963,6 +9005,7 @@ def __init__(self, handler): self._processMap["getMetaConf"] = Processor.process_getMetaConf self._processMap["setMetaConf"] = Processor.process_setMetaConf self._processMap["create_catalog"] = Processor.process_create_catalog + self._processMap["alter_catalog"] = Processor.process_alter_catalog self._processMap["get_catalog"] = Processor.process_get_catalog self._processMap["get_catalogs"] = Processor.process_get_catalogs self._processMap["drop_catalog"] = Processor.process_drop_catalog @@ -9254,6 +9297,34 @@ def process_create_catalog(self, seqid, iprot, oprot): oprot.writeMessageEnd() oprot.trans.flush() + def process_alter_catalog(self, seqid, iprot, oprot): + args = alter_catalog_args() + args.read(iprot) + iprot.readMessageEnd() + result = alter_catalog_result() + try: + self._handler.alter_catalog(args.rqst) + msg_type = TMessageType.REPLY + except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): + raise + except NoSuchObjectException as o1: + msg_type = TMessageType.REPLY + result.o1 = o1 + except InvalidOperationException as o2: + msg_type = TMessageType.REPLY + result.o2 = o2 + except MetaException as o3: + msg_type = TMessageType.REPLY + result.o3 = o3 + except Exception as ex: + msg_type = TMessageType.EXCEPTION + logging.exception(ex) + result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') + oprot.writeMessageBegin("alter_catalog", msg_type, seqid) + result.write(oprot) + oprot.writeMessageEnd() + oprot.trans.flush() + def process_get_catalog(self, seqid, iprot, oprot): args = get_catalog_args() args.read(iprot) @@ -14713,6 +14784,166 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) +class alter_catalog_args: + """ + Attributes: + - rqst + """ + + thrift_spec = ( + None, # 0 + (1, TType.STRUCT, 'rqst', (AlterCatalogRequest, AlterCatalogRequest.thrift_spec), None, ), # 1 + ) + + def __init__(self, rqst=None,): + self.rqst = rqst + + 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.rqst = AlterCatalogRequest() + self.rqst.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('alter_catalog_args') + if self.rqst is not None: + oprot.writeFieldBegin('rqst', TType.STRUCT, 1) + self.rqst.write(oprot) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.rqst) + 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 alter_catalog_result: + """ + Attributes: + - o1 + - o2 + - o3 + """ + + thrift_spec = ( + None, # 0 + (1, TType.STRUCT, 'o1', (NoSuchObjectException, NoSuchObjectException.thrift_spec), None, ), # 1 + (2, TType.STRUCT, 'o2', (InvalidOperationException, InvalidOperationException.thrift_spec), None, ), # 2 + (3, TType.STRUCT, 'o3', (MetaException, MetaException.thrift_spec), None, ), # 3 + ) + + def __init__(self, o1=None, o2=None, o3=None,): + self.o1 = o1 + self.o2 = o2 + self.o3 = o3 + + def read(self, iprot): + if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: + fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) + return + iprot.readStructBegin() + while True: + (fname, ftype, fid) = iprot.readFieldBegin() + if ftype == TType.STOP: + break + if fid == 1: + if ftype == TType.STRUCT: + self.o1 = NoSuchObjectException() + self.o1.read(iprot) + else: + iprot.skip(ftype) + elif fid == 2: + if ftype == TType.STRUCT: + self.o2 = InvalidOperationException() + self.o2.read(iprot) + else: + iprot.skip(ftype) + elif fid == 3: + if ftype == TType.STRUCT: + self.o3 = MetaException() + self.o3.read(iprot) + else: + iprot.skip(ftype) + else: + iprot.skip(ftype) + iprot.readFieldEnd() + iprot.readStructEnd() + + def write(self, oprot): + if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: + oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) + return + oprot.writeStructBegin('alter_catalog_result') + if self.o1 is not None: + oprot.writeFieldBegin('o1', TType.STRUCT, 1) + self.o1.write(oprot) + oprot.writeFieldEnd() + if self.o2 is not None: + oprot.writeFieldBegin('o2', TType.STRUCT, 2) + self.o2.write(oprot) + oprot.writeFieldEnd() + if self.o3 is not None: + oprot.writeFieldBegin('o3', TType.STRUCT, 3) + self.o3.write(oprot) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.o1) + value = (value * 31) ^ hash(self.o2) + value = (value * 31) ^ hash(self.o3) + return value + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + class get_catalog_args: """ Attributes: diff --git standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py index fdec32e10c..862797eb4f 100644 --- standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py +++ standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py @@ -3391,6 +3391,85 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) +class AlterCatalogRequest: + """ + Attributes: + - name + - newCat + """ + + thrift_spec = ( + None, # 0 + (1, TType.STRING, 'name', None, None, ), # 1 + (2, TType.STRUCT, 'newCat', (Catalog, Catalog.thrift_spec), None, ), # 2 + ) + + def __init__(self, name=None, newCat=None,): + self.name = name + self.newCat = newCat + + 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.name = iprot.readString() + else: + iprot.skip(ftype) + elif fid == 2: + if ftype == TType.STRUCT: + self.newCat = Catalog() + self.newCat.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('AlterCatalogRequest') + if self.name is not None: + oprot.writeFieldBegin('name', TType.STRING, 1) + oprot.writeString(self.name) + oprot.writeFieldEnd() + if self.newCat is not None: + oprot.writeFieldBegin('newCat', TType.STRUCT, 2) + self.newCat.write(oprot) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.name) + value = (value * 31) ^ hash(self.newCat) + 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 GetCatalogRequest: """ Attributes: diff --git standalone-metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb standalone-metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb index fb73b28f62..81d2ec6f58 100644 --- standalone-metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb +++ standalone-metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb @@ -818,6 +818,24 @@ class CreateCatalogRequest ::Thrift::Struct.generate_accessors self end +class AlterCatalogRequest + include ::Thrift::Struct, ::Thrift::Struct_Union + NAME = 1 + NEWCAT = 2 + + FIELDS = { + NAME => {:type => ::Thrift::Types::STRING, :name => 'name'}, + NEWCAT => {:type => ::Thrift::Types::STRUCT, :name => 'newCat', :class => ::Catalog} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self +end + class GetCatalogRequest include ::Thrift::Struct, ::Thrift::Struct_Union NAME = 1 diff --git standalone-metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb standalone-metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb index d394f72a54..d5fa75d7f2 100644 --- standalone-metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb +++ standalone-metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb @@ -60,6 +60,23 @@ module ThriftHiveMetastore return end + def alter_catalog(rqst) + send_alter_catalog(rqst) + recv_alter_catalog() + end + + def send_alter_catalog(rqst) + send_message('alter_catalog', Alter_catalog_args, :rqst => rqst) + end + + def recv_alter_catalog() + result = receive_message(Alter_catalog_result) + raise result.o1 unless result.o1.nil? + raise result.o2 unless result.o2.nil? + raise result.o3 unless result.o3.nil? + return + end + def get_catalog(catName) send_get_catalog(catName) return recv_get_catalog() @@ -3481,6 +3498,21 @@ module ThriftHiveMetastore write_result(result, oprot, 'create_catalog', seqid) end + def process_alter_catalog(seqid, iprot, oprot) + args = read_args(iprot, Alter_catalog_args) + result = Alter_catalog_result.new() + begin + @handler.alter_catalog(args.rqst) + rescue ::NoSuchObjectException => o1 + result.o1 = o1 + rescue ::InvalidOperationException => o2 + result.o2 = o2 + rescue ::MetaException => o3 + result.o3 = o3 + end + write_result(result, oprot, 'alter_catalog', seqid) + end + def process_get_catalog(seqid, iprot, oprot) args = read_args(iprot, Get_catalog_args) result = Get_catalog_result.new() @@ -6128,6 +6160,42 @@ module ThriftHiveMetastore ::Thrift::Struct.generate_accessors self end + class Alter_catalog_args + include ::Thrift::Struct, ::Thrift::Struct_Union + RQST = 1 + + FIELDS = { + RQST => {:type => ::Thrift::Types::STRUCT, :name => 'rqst', :class => ::AlterCatalogRequest} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Alter_catalog_result + include ::Thrift::Struct, ::Thrift::Struct_Union + O1 = 1 + O2 = 2 + O3 = 3 + + FIELDS = { + O1 => {:type => ::Thrift::Types::STRUCT, :name => 'o1', :class => ::NoSuchObjectException}, + O2 => {:type => ::Thrift::Types::STRUCT, :name => 'o2', :class => ::InvalidOperationException}, + O3 => {:type => ::Thrift::Types::STRUCT, :name => 'o3', :class => ::MetaException} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + class Get_catalog_args include ::Thrift::Struct, ::Thrift::Struct_Union CATNAME = 1 diff --git standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java index 92d2e3f368..44a1c00eea 100644 --- standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java +++ standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java @@ -87,6 +87,7 @@ import org.apache.hadoop.hive.metastore.events.AddPrimaryKeyEvent; import org.apache.hadoop.hive.metastore.events.AddUniqueConstraintEvent; import org.apache.hadoop.hive.metastore.events.AllocWriteIdEvent; +import org.apache.hadoop.hive.metastore.events.AlterCatalogEvent; import org.apache.hadoop.hive.metastore.events.AlterDatabaseEvent; import org.apache.hadoop.hive.metastore.events.AlterISchemaEvent; import org.apache.hadoop.hive.metastore.events.AlterPartitionEvent; @@ -112,6 +113,7 @@ import org.apache.hadoop.hive.metastore.events.LoadPartitionDoneEvent; import org.apache.hadoop.hive.metastore.events.OpenTxnEvent; import org.apache.hadoop.hive.metastore.events.PreAddPartitionEvent; +import org.apache.hadoop.hive.metastore.events.PreAlterCatalogEvent; import org.apache.hadoop.hive.metastore.events.PreAlterDatabaseEvent; import org.apache.hadoop.hive.metastore.events.PreAlterISchemaEvent; import org.apache.hadoop.hive.metastore.events.PreAlterPartitionEvent; @@ -1057,6 +1059,51 @@ public void create_catalog(CreateCatalogRequest rqst) } @Override + public void alter_catalog(AlterCatalogRequest rqst) throws TException { + startFunction("alter_catalog " + rqst.getName()); + boolean success = false; + Exception ex = null; + RawStore ms = getMS(); + Map transactionalListenersResponses = Collections.emptyMap(); + GetCatalogResponse oldCat = null; + + try { + oldCat = get_catalog(new GetCatalogRequest(rqst.getName())); + // Above should have thrown NoSuchObjectException if there is no such catalog + assert oldCat != null && oldCat.getCatalog() != null; + firePreEvent(new PreAlterCatalogEvent(oldCat.getCatalog(), rqst.getNewCat(), this)); + + ms.openTransaction(); + ms.alterCatalog(rqst.getName(), rqst.getNewCat()); + + if (!transactionalListeners.isEmpty()) { + transactionalListenersResponses = + MetaStoreListenerNotifier.notifyEvent(transactionalListeners, + EventType.ALTER_CATALOG, + new AlterCatalogEvent(oldCat.getCatalog(), rqst.getNewCat(), true, this)); + } + + success = ms.commitTransaction(); + } catch (MetaException|NoSuchObjectException e) { + ex = e; + throw e; + } finally { + if (!success) { + ms.rollbackTransaction(); + } + + if ((null != oldCat) && (!listeners.isEmpty())) { + MetaStoreListenerNotifier.notifyEvent(listeners, + EventType.ALTER_CATALOG, + new AlterCatalogEvent(oldCat.getCatalog(), rqst.getNewCat(), success, this), + null, transactionalListenersResponses, ms); + } + endFunction("alter_catalog", success, ex); + } + + } + + @Override public GetCatalogResponse get_catalog(GetCatalogRequest rqst) throws NoSuchObjectException, TException { String catName = rqst.getName(); diff --git standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java index 6af2aa5b3a..88f55b69a9 100644 --- standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java +++ standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java @@ -616,6 +616,11 @@ public void createCatalog(Catalog catalog) throws TException { } @Override + public void alterCatalog(String catalogName, Catalog newCatalog) throws TException { + client.alter_catalog(new AlterCatalogRequest(catalogName, newCatalog)); + } + + @Override public Catalog getCatalog(String catName) throws TException { GetCatalogResponse rsp = client.get_catalog(new GetCatalogRequest(catName)); return rsp == null ? null : filterHook.filterCatalog(rsp.getCatalog()); diff --git standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java index 09f9bb1cbc..c932c512a5 100644 --- standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java +++ standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java @@ -189,6 +189,21 @@ void createCatalog(Catalog catalog) throws AlreadyExistsException, InvalidObjectException, MetaException, TException; /** + * Alter an existing catalog. + * @param catalogName the name of the catalog to alter. + * @param newCatalog the new catalog object. All relevant details of the catalog should be + * set, don't rely on the system to figure out what you changed and only copy + * that in. + * @throws NoSuchObjectException no catalog of this name exists + * @throws InvalidObjectException an attempt was made to make an unsupported change (such as + * catalog name). + * @throws MetaException usually indicates a database error + * @throws TException general thrift exception + */ + void alterCatalog(String catalogName, Catalog newCatalog) + throws NoSuchObjectException, InvalidObjectException, MetaException, TException; + + /** * Get a catalog object. * @param catName Name of the catalog to fetch. * @return The catalog. diff --git standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/MetaStoreEventListener.java standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/MetaStoreEventListener.java index 92505af4f8..e0e65cf231 100644 --- standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/MetaStoreEventListener.java +++ standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/MetaStoreEventListener.java @@ -28,6 +28,7 @@ import org.apache.hadoop.hive.metastore.events.AddPrimaryKeyEvent; import org.apache.hadoop.hive.metastore.events.AddSchemaVersionEvent; import org.apache.hadoop.hive.metastore.events.AddUniqueConstraintEvent; +import org.apache.hadoop.hive.metastore.events.AlterCatalogEvent; import org.apache.hadoop.hive.metastore.events.AlterDatabaseEvent; import org.apache.hadoop.hive.metastore.events.AlterISchemaEvent; import org.apache.hadoop.hive.metastore.events.AddPartitionEvent; @@ -232,6 +233,9 @@ public void onDropSchemaVersion(DropSchemaVersionEvent dropSchemaVersionEvent) public void onCreateCatalog(CreateCatalogEvent createCatalogEvent) throws MetaException { } + public void onAlterCatalog(AlterCatalogEvent alterCatalogEvent) throws MetaException { + } + public void onDropCatalog(DropCatalogEvent dropCatalogEvent) throws MetaException { } diff --git standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/MetaStoreListenerNotifier.java standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/MetaStoreListenerNotifier.java index b2856e2520..3cf83149a8 100644 --- standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/MetaStoreListenerNotifier.java +++ standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/MetaStoreListenerNotifier.java @@ -30,6 +30,7 @@ import org.apache.hadoop.hive.metastore.events.AddPrimaryKeyEvent; import org.apache.hadoop.hive.metastore.events.AddSchemaVersionEvent; import org.apache.hadoop.hive.metastore.events.AddUniqueConstraintEvent; +import org.apache.hadoop.hive.metastore.events.AlterCatalogEvent; import org.apache.hadoop.hive.metastore.events.AlterDatabaseEvent; import org.apache.hadoop.hive.metastore.events.AlterISchemaEvent; import org.apache.hadoop.hive.metastore.events.AlterPartitionEvent; @@ -210,6 +211,8 @@ public void notify(MetaStoreEventListener listener, ListenerEvent event) throws (listener, event) -> listener.onCreateCatalog((CreateCatalogEvent)event)) .put(EventType.DROP_CATALOG, (listener, event) -> listener.onDropCatalog((DropCatalogEvent)event)) + .put(EventType.ALTER_CATALOG, + (listener, event) -> listener.onAlterCatalog((AlterCatalogEvent)event)) .put(EventType.OPEN_TXN, (listener, event) -> listener.onOpenTxn((OpenTxnEvent) event, null, null)) .put(EventType.COMMIT_TXN, diff --git standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/events/AlterCatalogEvent.java standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/events/AlterCatalogEvent.java new file mode 100644 index 0000000000..7a19fd09f1 --- /dev/null +++ standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/events/AlterCatalogEvent.java @@ -0,0 +1,44 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + *

+ * http://www.apache.org/licenses/LICENSE-2.0 + *

+ * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.hadoop.hive.metastore.events; + +import org.apache.hadoop.classification.InterfaceAudience; +import org.apache.hadoop.classification.InterfaceStability; +import org.apache.hadoop.hive.metastore.IHMSHandler; +import org.apache.hadoop.hive.metastore.api.Catalog; + +@InterfaceAudience.Public +@InterfaceStability.Stable +public class AlterCatalogEvent extends ListenerEvent { + + private final Catalog oldCat, newCat; + + public AlterCatalogEvent(Catalog oldCat, Catalog newCat, boolean status, IHMSHandler handler) { + super(status, handler); + this.oldCat = oldCat; + this.newCat = newCat; + } + + public Catalog getOldCatalog() { + return oldCat; + } + + public Catalog getNewCatalog() { + return newCat; + } +} diff --git standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/events/PreAlterCatalogEvent.java standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/events/PreAlterCatalogEvent.java new file mode 100644 index 0000000000..e6ffe8cc1b --- /dev/null +++ standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/events/PreAlterCatalogEvent.java @@ -0,0 +1,40 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + *

+ * http://www.apache.org/licenses/LICENSE-2.0 + *

+ * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.hadoop.hive.metastore.events; + +import org.apache.hadoop.hive.metastore.IHMSHandler; +import org.apache.hadoop.hive.metastore.api.Catalog; + +public class PreAlterCatalogEvent extends PreEventContext { + + private final Catalog oldCat, newCat; + + public PreAlterCatalogEvent(Catalog oldCat, Catalog newCat, IHMSHandler handler) { + super(PreEventType.ALTER_CATALOG, handler); + this.oldCat = oldCat; + this.newCat = newCat; + } + + public Catalog getOldCatalog() { + return oldCat; + } + + public Catalog getNewCatalog() { + return newCat; + } +} diff --git standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/events/PreEventContext.java standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/events/PreEventContext.java index b45a537755..b93675fd5d 100644 --- standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/events/PreEventContext.java +++ standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/events/PreEventContext.java @@ -53,7 +53,8 @@ READ_SCHEMA_VERSION, CREATE_CATALOG, DROP_CATALOG, - READ_CATALOG + READ_CATALOG, + ALTER_CATALOG } private final PreEventType eventType; diff --git standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/AlterCatalogMessage.java standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/AlterCatalogMessage.java new file mode 100644 index 0000000000..175d6efba6 --- /dev/null +++ standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/AlterCatalogMessage.java @@ -0,0 +1,29 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + *

+ * http://www.apache.org/licenses/LICENSE-2.0 + *

+ * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.hadoop.hive.metastore.messaging; + +import org.apache.hadoop.hive.metastore.api.Catalog; + +public abstract class AlterCatalogMessage extends EventMessage { + protected AlterCatalogMessage() { + super(EventType.ALTER_CATALOG); + } + + public abstract Catalog getCatObjBefore() throws Exception; + public abstract Catalog getCatObjAfter() throws Exception; +} diff --git standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/EventMessage.java standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/EventMessage.java index ffbce1d13b..969dd7bce5 100644 --- standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/EventMessage.java +++ standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/EventMessage.java @@ -59,7 +59,8 @@ OPEN_TXN(MessageFactory.OPEN_TXN_EVENT), COMMIT_TXN(MessageFactory.COMMIT_TXN_EVENT), ABORT_TXN(MessageFactory.ABORT_TXN_EVENT), - ALLOC_WRITE_ID(MessageFactory.ALLOC_WRITE_ID_EVENT); + ALLOC_WRITE_ID(MessageFactory.ALLOC_WRITE_ID_EVENT), + ALTER_CATALOG(MessageFactory.ALTER_CATALOG_EVENT); private String typeString; diff --git standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/MessageFactory.java standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/MessageFactory.java index 75ca6eceb5..e0629ea4ab 100644 --- standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/MessageFactory.java +++ standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/MessageFactory.java @@ -73,6 +73,7 @@ public static final String COMMIT_TXN_EVENT = "COMMIT_TXN"; public static final String ABORT_TXN_EVENT = "ABORT_TXN"; public static final String ALLOC_WRITE_ID_EVENT = "ALLOC_WRITE_ID_EVENT"; + public static final String ALTER_CATALOG_EVENT = "ALTER_CATALOG"; private static MessageFactory instance = null; @@ -323,4 +324,6 @@ public abstract DropConstraintMessage buildDropConstraintMessage(String dbName, public abstract CreateCatalogMessage buildCreateCatalogMessage(Catalog catalog); public abstract DropCatalogMessage buildDropCatalogMessage(Catalog catalog); + + public abstract AlterCatalogMessage buildAlterCatalogMessage(Catalog oldCat, Catalog newCat); } diff --git standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/json/JSONAlterCatalogMessage.java standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/json/JSONAlterCatalogMessage.java new file mode 100644 index 0000000000..779c0b0407 --- /dev/null +++ standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/json/JSONAlterCatalogMessage.java @@ -0,0 +1,90 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + *

+ * http://www.apache.org/licenses/LICENSE-2.0 + *

+ * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.hadoop.hive.metastore.messaging.json; + +import com.fasterxml.jackson.annotation.JsonProperty; +import org.apache.hadoop.hive.metastore.api.Catalog; +import org.apache.hadoop.hive.metastore.messaging.AlterCatalogMessage; +import org.apache.thrift.TException; + +public class JSONAlterCatalogMessage extends AlterCatalogMessage { + @JsonProperty + String server, servicePrincipal, catObjBeforeJson, catObjAfterJson; + + @JsonProperty + Long timestamp; + + /** + * Default constructor, needed for Jackson. + */ + public JSONAlterCatalogMessage() { + } + + public JSONAlterCatalogMessage(String server, String servicePrincipal, + Catalog catObjBefore, Catalog catObjAfter, Long timestamp) { + this.server = server; + this.servicePrincipal = servicePrincipal; + this.timestamp = timestamp; + try { + this.catObjBeforeJson = JSONMessageFactory.createCatalogObjJson(catObjBefore); + this.catObjAfterJson = JSONMessageFactory.createCatalogObjJson(catObjAfter); + } catch (TException e) { + throw new IllegalArgumentException("Could not serialize: ", e); + } + checkValid(); + } + + @Override + public String getDB() { + return null; + } + + @Override + public String getServer() { + return server; + } + + @Override + public String getServicePrincipal() { + return servicePrincipal; + } + + @Override + public Long getTimestamp() { + return timestamp; + } + + @Override + public Catalog getCatObjBefore() throws Exception { + return (Catalog) JSONMessageFactory.getTObj(catObjBeforeJson, Catalog.class); + } + + @Override + public Catalog getCatObjAfter() throws Exception { + return (Catalog) JSONMessageFactory.getTObj(catObjAfterJson, Catalog.class); + } + + @Override + public String toString() { + try { + return JSONMessageDeserializer.mapper.writeValueAsString(this); + } catch (Exception e) { + throw new IllegalArgumentException("Could not serialize: ", e); + } + } +} diff --git standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/json/JSONMessageFactory.java standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/json/JSONMessageFactory.java index f0c5f4f287..d64c3ffb80 100644 --- standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/json/JSONMessageFactory.java +++ standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/messaging/json/JSONMessageFactory.java @@ -44,6 +44,7 @@ import org.apache.hadoop.hive.metastore.messaging.AddPartitionMessage; import org.apache.hadoop.hive.metastore.messaging.AddPrimaryKeyMessage; import org.apache.hadoop.hive.metastore.messaging.AddUniqueConstraintMessage; +import org.apache.hadoop.hive.metastore.messaging.AlterCatalogMessage; import org.apache.hadoop.hive.metastore.messaging.AlterDatabaseMessage; import org.apache.hadoop.hive.metastore.messaging.AlterPartitionMessage; import org.apache.hadoop.hive.metastore.messaging.AlterTableMessage; @@ -204,6 +205,12 @@ public CreateCatalogMessage buildCreateCatalogMessage(Catalog catalog) { } @Override + public AlterCatalogMessage buildAlterCatalogMessage(Catalog beforeCat, Catalog afterCat) { + return new JSONAlterCatalogMessage(MS_SERVER_URL, MS_SERVICE_PRINCIPAL, + beforeCat, afterCat, now()); + } + + @Override public DropCatalogMessage buildDropCatalogMessage(Catalog catalog) { return new JSONDropCatalogMessage(MS_SERVER_URL, MS_SERVICE_PRINCIPAL, catalog.getName(), now()); } @@ -276,6 +283,11 @@ static String createDatabaseObjJson(Database dbObj) throws TException { return serializer.toString(dbObj, "UTF-8"); } + static String createCatalogObjJson(Catalog catObj) throws TException { + TSerializer serializer = new TSerializer(new TJSONProtocol.Factory()); + return serializer.toString(catObj, "UTF-8"); + } + static String createTableObjJson(Table tableObj) throws TException { TSerializer serializer = new TSerializer(new TJSONProtocol.Factory()); return serializer.toString(tableObj, "UTF-8"); diff --git standalone-metastore/src/main/thrift/hive_metastore.thrift standalone-metastore/src/main/thrift/hive_metastore.thrift index 19d4433078..7525306067 100644 --- standalone-metastore/src/main/thrift/hive_metastore.thrift +++ standalone-metastore/src/main/thrift/hive_metastore.thrift @@ -337,6 +337,11 @@ struct CreateCatalogRequest { 1: Catalog catalog } +struct AlterCatalogRequest { + 1: string name, + 2: Catalog newCat +} + struct GetCatalogRequest { 1: string name } @@ -1610,6 +1615,7 @@ service ThriftHiveMetastore extends fb303.FacebookService void setMetaConf(1:string key, 2:string value) throws(1:MetaException o1) void create_catalog(1: CreateCatalogRequest catalog) throws (1:AlreadyExistsException o1, 2:InvalidObjectException o2, 3: MetaException o3) + void alter_catalog(1: AlterCatalogRequest rqst) throws (1:NoSuchObjectException o1, 2:InvalidOperationException o2, 3:MetaException o3) GetCatalogResponse get_catalog(1: GetCatalogRequest catName) throws (1:NoSuchObjectException o1, 2:MetaException o2) GetCatalogsResponse get_catalogs() throws (1:MetaException o1) void drop_catalog(1: DropCatalogRequest catName) throws (1:NoSuchObjectException o1, 2:InvalidOperationException o2, 3:MetaException o3) diff --git standalone-metastore/src/test/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClientPreCatalog.java standalone-metastore/src/test/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClientPreCatalog.java index 7186addacd..d9fd8ac1cc 100644 --- standalone-metastore/src/test/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClientPreCatalog.java +++ standalone-metastore/src/test/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClientPreCatalog.java @@ -2903,6 +2903,12 @@ public Catalog getCatalog(String catName) throws TException { } @Override + public void alterCatalog(String catalogName, Catalog newCatalog) throws NoSuchObjectException, + InvalidObjectException, MetaException, TException { + throw new UnsupportedOperationException(); + } + + @Override public List getCatalogs() throws TException { throw new UnsupportedOperationException(); } diff --git standalone-metastore/src/test/java/org/apache/hadoop/hive/metastore/client/TestCatalogs.java standalone-metastore/src/test/java/org/apache/hadoop/hive/metastore/client/TestCatalogs.java index 02fb9eb0de..4ccbd099cd 100644 --- standalone-metastore/src/test/java/org/apache/hadoop/hive/metastore/client/TestCatalogs.java +++ standalone-metastore/src/test/java/org/apache/hadoop/hive/metastore/client/TestCatalogs.java @@ -144,6 +144,26 @@ public void catalogOperations() throws TException { catalogs.get(i).equalsIgnoreCase(expected.get(i))); } + + // Update catalogs + // Update location + Catalog newCat = new Catalog(client.getCatalog(catNames[0])); + String newLocation = MetaStoreTestUtils.getTestWarehouseDir("a_different_location"); + newCat.setLocationUri(newLocation); + client.alterCatalog(catNames[0], newCat); + Catalog fetchedNewCat = client.getCatalog(catNames[0]); + Assert.assertEquals(newLocation, fetchedNewCat.getLocationUri()); + Assert.assertEquals(description[0], fetchedNewCat.getDescription()); + + // Update description + newCat = new Catalog(client.getCatalog(catNames[1])); + String newDescription = "an even more descriptive description"; + newCat.setDescription(newDescription); + client.alterCatalog(catNames[1], newCat); + fetchedNewCat = client.getCatalog(catNames[1]); + Assert.assertEquals(location[1], fetchedNewCat.getLocationUri()); + Assert.assertEquals(newDescription, fetchedNewCat.getDescription()); + for (int i = 0; i < catNames.length; i++) { client.dropCatalog(catNames[i]); File dir = new File(location[i]); @@ -214,4 +234,31 @@ public void dropCatalogWithNonEmptyDefaultDb() throws TException { client.dropCatalog(catName); } + + @Test(expected = NoSuchObjectException.class) + public void alterNonExistentCatalog() throws TException { + String catName = "alter_no_such_catalog"; + Catalog cat = new CatalogBuilder() + .setName(catName) + .setLocation(MetaStoreTestUtils.getTestWarehouseDir(catName)) + .build(); + + client.alterCatalog(catName, cat); + } + + @Test(expected = InvalidOperationException.class) + public void alterChangeName() throws TException { + String catName = "alter_change_name"; + String location = MetaStoreTestUtils.getTestWarehouseDir(catName); + String description = "I have a bad feeling about this"; + new CatalogBuilder() + .setName(catName) + .setLocation(location) + .setDescription(description) + .create(client); + + Catalog newCat = client.getCatalog(catName); + newCat.setName("you_may_call_me_tim"); + client.alterCatalog(catName, newCat); + } }