Index: metastore/scripts/upgrade/derby/016-HIVE-6386.derby.sql =================================================================== --- metastore/scripts/upgrade/derby/016-HIVE-6386.derby.sql (revision 0) +++ metastore/scripts/upgrade/derby/016-HIVE-6386.derby.sql (revision 0) @@ -0,0 +1,2 @@ +ALTER TABLE "DBS" ADD "OWNER_NAME" CHAR(128); +ALTER TABLE "DBS" ADD "OWNER_TYPE" CHAR(10); Index: metastore/scripts/upgrade/mysql/016-HIVE-6386.mysql.sql =================================================================== --- metastore/scripts/upgrade/mysql/016-HIVE-6386.mysql.sql (revision 0) +++ metastore/scripts/upgrade/mysql/016-HIVE-6386.mysql.sql (revision 0) @@ -0,0 +1,5 @@ +SELECT '< HIVE-6386: Add owner filed to database >' AS ' '; + +ALTER TABLE `DBS` ADD `OWNER_NAME` varchar(128); +ALTER TABLE `DBS` ADD `OWNER_TYPE` varchar(10); + Index: metastore/scripts/upgrade/oracle/016-HIVE-6386.oracle.sql =================================================================== --- metastore/scripts/upgrade/oracle/016-HIVE-6386.oracle.sql (revision 0) +++ metastore/scripts/upgrade/oracle/016-HIVE-6386.oracle.sql (revision 0) @@ -0,0 +1,2 @@ +ALTER TABLE DBS ADD OWNER_NAME VARCHAR2(128); +ALTER TABLE DBS ADD OWNER_TYPE VARCHAR2(10); Index: metastore/scripts/upgrade/postgres/016-HIVE-6386.postgres.sql =================================================================== --- metastore/scripts/upgrade/postgres/016-HIVE-6386.postgres.sql (revision 0) +++ metastore/scripts/upgrade/postgres/016-HIVE-6386.postgres.sql (revision 0) @@ -0,0 +1,4 @@ +SELECT '< HIVE-6386 Database should have an owner >'; + +ALTER TABLE "DBS" ADD COLUMN "OWNER_NAME" character varying(128); +ALTER TABLE "DBS" ADD COLUMN "OWNER_TYPE" character varying(10); Index: metastore/src/model/package.jdo =================================================================== --- metastore/src/model/package.jdo (revision 1568537) +++ metastore/src/model/package.jdo (working copy) @@ -53,6 +53,12 @@ + + + + + + Index: metastore/src/model/org/apache/hadoop/hive/metastore/model/MDatabase.java =================================================================== --- metastore/src/model/org/apache/hadoop/hive/metastore/model/MDatabase.java (revision 1568537) +++ metastore/src/model/org/apache/hadoop/hive/metastore/model/MDatabase.java (working copy) @@ -32,6 +32,8 @@ private String locationUri; private String description; private Map parameters; + private String ownerName; + private String ownerType; /** * Default construction to keep jpox/jdo happy @@ -107,4 +109,20 @@ public void setParameters(Map parameters) { this.parameters = parameters; } + + public String getOwnerName() { + return ownerName; + } + + public void setOwnerName(String ownerName) { + this.ownerName = ownerName; + } + + public String getOwnerType() { + return ownerType; + } + + public void setOwnerType(String ownerType) { + this.ownerType = ownerType; + } } Index: metastore/src/java/org/apache/hadoop/hive/metastore/ObjectStore.java =================================================================== --- metastore/src/java/org/apache/hadoop/hive/metastore/ObjectStore.java (revision 1568537) +++ metastore/src/java/org/apache/hadoop/hive/metastore/ObjectStore.java (working copy) @@ -184,6 +184,7 @@ public ObjectStore() { } + @Override public Configuration getConf() { return hiveConf; } @@ -193,6 +194,7 @@ * on connection retries. In cases of connection retries, conf will usually * contain modified values. */ + @Override @SuppressWarnings("nls") public void setConf(Configuration conf) { // Although an instance of ObjectStore is accessed by one thread, there may @@ -267,7 +269,7 @@ @SuppressWarnings("unchecked") Class clazz = (Class)MetaStoreUtils.getClass(className); - return (PartitionExpressionProxy)MetaStoreUtils.newInstance( + return MetaStoreUtils.newInstance( clazz, new Class[0], new Object[0]); } catch (MetaException e) { LOG.error("Error loading PartitionExpressionProxy", e); @@ -340,6 +342,7 @@ return getPMF().getPersistenceManager(); } + @Override public void shutdown() { if (pm != null) { pm.close(); @@ -353,6 +356,7 @@ * @return an active transaction */ + @Override public boolean openTransaction() { openTrasactionCalls++; if (openTrasactionCalls == 1) { @@ -376,6 +380,7 @@ * * @return Always returns true */ + @Override @SuppressWarnings("nls") public boolean commitTransaction() { if (TXN_STATUS.ROLLBACK == transactionStatus) { @@ -421,6 +426,7 @@ /** * Rolls back the current transaction if it is active */ + @Override public void rollbackTransaction() { if (openTrasactionCalls < 1) { debugLog("rolling back transaction: no open transactions: " + openTrasactionCalls); @@ -440,6 +446,7 @@ } } + @Override public void createDatabase(Database db) throws InvalidObjectException, MetaException { boolean commited = false; MDatabase mdb = new MDatabase(); @@ -447,6 +454,9 @@ mdb.setLocationUri(db.getLocationUri()); mdb.setDescription(db.getDescription()); mdb.setParameters(db.getParameters()); + mdb.setOwnerName(db.getOwnerName()); + PrincipalType ownerType = db.getOwnerType(); + mdb.setOwnerType((null == ownerType ? PrincipalType.USER.name() : ownerType.name())); try { openTransaction(); pm.makePersistent(mdb); @@ -482,6 +492,7 @@ return mdb; } + @Override public Database getDatabase(String name) throws NoSuchObjectException { MDatabase mdb = null; boolean commited = false; @@ -499,6 +510,9 @@ db.setDescription(mdb.getDescription()); db.setLocationUri(mdb.getLocationUri()); db.setParameters(mdb.getParameters()); + db.setOwnerName(mdb.getOwnerName()); + String type = mdb.getOwnerType(); + db.setOwnerType((null == type || type.trim().isEmpty()) ? null : PrincipalType.valueOf(type)); return db; } @@ -510,6 +524,7 @@ * @throws MetaException * @throws NoSuchObjectException */ + @Override public boolean alterDatabase(String dbName, Database db) throws MetaException, NoSuchObjectException { @@ -531,6 +546,7 @@ return true; } + @Override public boolean dropDatabase(String dbname) throws NoSuchObjectException, MetaException { boolean success = false; LOG.info("Dropping database " + dbname + " along with all tables"); @@ -558,6 +574,7 @@ } + @Override public List getDatabases(String pattern) throws MetaException { boolean commited = false; List databases = null; @@ -595,6 +612,7 @@ return databases; } + @Override public List getAllDatabases() throws MetaException { return getDatabases(".*"); } @@ -626,6 +644,7 @@ return ret; } + @Override public boolean createType(Type type) { boolean success = false; MType mtype = getMType(type); @@ -643,6 +662,7 @@ return success; } + @Override public Type getType(String typeName) { Type type = null; boolean commited = false; @@ -665,6 +685,7 @@ return type; } + @Override public boolean dropType(String typeName) { boolean success = false; try { @@ -689,6 +710,7 @@ return success; } + @Override public void createTable(Table tbl) throws InvalidObjectException, MetaException { boolean commited = false; try { @@ -751,6 +773,7 @@ } } + @Override public boolean dropTable(String dbName, String tableName) throws MetaException, NoSuchObjectException, InvalidObjectException, InvalidInputException { boolean success = false; @@ -801,6 +824,7 @@ return success; } + @Override public Table getTable(String dbName, String tableName) throws MetaException { boolean commited = false; Table tbl = null; @@ -816,6 +840,7 @@ return tbl; } + @Override public List getTables(String dbName, String pattern) throws MetaException { boolean commited = false; @@ -858,6 +883,7 @@ return tbls; } + @Override public List getAllTables(String dbName) throws MetaException { return getTables(dbName, ".*"); } @@ -883,6 +909,7 @@ return mtbl; } + @Override public List getTableObjectsByName(String db, List tbl_names) throws MetaException, UnknownDBException { List
tables = new ArrayList
(); @@ -1296,6 +1323,7 @@ return success; } + @Override public Partition getPartition(String dbName, String tableName, List part_vals) throws NoSuchObjectException, MetaException { openTransaction(); @@ -1511,6 +1539,7 @@ return success; } + @Override public List getPartitions( String dbName, String tableName, int maxParts) throws MetaException, NoSuchObjectException { return getPartitionsInternal(dbName, tableName, maxParts, true, true); @@ -1520,10 +1549,12 @@ String dbName, String tblName, final int maxParts, boolean allowSql, boolean allowJdo) throws MetaException, NoSuchObjectException { return new GetListHelper(dbName, tblName, allowSql, allowJdo) { + @Override protected List getSqlResult(GetHelper> ctx) throws MetaException { Integer max = (maxParts < 0) ? null : maxParts; return directSql.getPartitions(dbName, tblName, max); } + @Override protected List getJdoResult( GetHelper> ctx) throws MetaException, NoSuchObjectException { return convertToParts(listMPartitions(dbName, tblName, maxParts)); @@ -1626,6 +1657,7 @@ } // TODO:pc implement max + @Override public List listPartitionNames(String dbName, String tableName, short max) throws MetaException { List pns = null; @@ -1824,9 +1856,11 @@ final List partNames, boolean allowSql, boolean allowJdo) throws MetaException, NoSuchObjectException { return new GetListHelper(dbName, tblName, allowSql, allowJdo) { + @Override protected List getSqlResult(GetHelper> ctx) throws MetaException { return directSql.getPartitionsViaSqlFilter(dbName, tblName, partNames, null); } + @Override protected List getJdoResult( GetHelper> ctx) throws MetaException, NoSuchObjectException { return getPartitionsViaOrmFilter(dbName, tblName, partNames); @@ -1865,6 +1899,7 @@ final AtomicBoolean hasUnknownPartitions = new AtomicBoolean(false); result.addAll(new GetListHelper(dbName, tblName, allowSql, allowJdo) { + @Override protected List getSqlResult(GetHelper> ctx) throws MetaException { // If we have some sort of expression tree, try SQL filter pushdown. List result = null; @@ -1880,6 +1915,7 @@ } return result; } + @Override protected List getJdoResult( GetHelper> ctx) throws MetaException, NoSuchObjectException { // If we have some sort of expression tree, try JDOQL filter pushdown. @@ -2271,6 +2307,7 @@ ? getFilterParser(filter).tree : ExpressionTree.EMPTY_TREE; return new GetListHelper(dbName, tblName, allowSql, allowJdo) { + @Override protected List getSqlResult(GetHelper> ctx) throws MetaException { List parts = directSql.getPartitionsViaSqlFilter( ctx.getTable(), tree, (maxParts < 0) ? null : (int)maxParts); @@ -2281,6 +2318,7 @@ } return parts; } + @Override protected List getJdoResult( GetHelper> ctx) throws MetaException, NoSuchObjectException { return getPartitionsViaOrmFilter(ctx.getTable(), tree, maxParts, true); @@ -2499,6 +2537,7 @@ return partNames; } + @Override public void alterTable(String dbname, String name, Table newTable) throws InvalidObjectException, MetaException { boolean success = false; @@ -2540,6 +2579,7 @@ } } + @Override public void alterIndex(String dbname, String baseTblName, String name, Index newIndex) throws InvalidObjectException, MetaException { boolean success = false; @@ -2593,6 +2633,7 @@ } } + @Override public void alterPartition(String dbname, String name, List part_vals, Partition newPart) throws InvalidObjectException, MetaException { boolean success = false; @@ -2617,6 +2658,7 @@ } } + @Override public void alterPartitions(String dbname, String name, List> part_vals, List newParts) throws InvalidObjectException, MetaException { boolean success = false; @@ -3187,6 +3229,7 @@ return mRoleMemebership; } + @Override public Role getRole(String roleName) throws NoSuchObjectException { MRole mRole = this.getMRole(roleName); if (mRole == null) { @@ -3216,6 +3259,7 @@ return mrole; } + @Override public List listRoleNames() { boolean success = false; try { @@ -4388,6 +4432,7 @@ return new ObjectPair(query, params); } + @Override @SuppressWarnings("unchecked") public List listAllTableGrants( String principalName, PrincipalType principalType, String dbName, @@ -4489,6 +4534,7 @@ return mSecurityColList; } + @Override @SuppressWarnings("unchecked") public List listPrincipalPartitionColumnGrants( String principalName, PrincipalType principalType, String dbName, @@ -5493,6 +5539,7 @@ } } + @Override public boolean updateTableColumnStatistics(ColumnStatistics colStats) throws NoSuchObjectException, MetaException, InvalidObjectException, InvalidInputException { boolean committed = false; @@ -5520,6 +5567,7 @@ } } + @Override public boolean updatePartitionColumnStatistics(ColumnStatistics colStats, List partVals) throws NoSuchObjectException, MetaException, InvalidObjectException, InvalidInputException { boolean committed = false; @@ -5611,6 +5659,7 @@ } } + @Override public ColumnStatistics getTableColumnStatistics(String dbName, String tableName, List colNames) throws MetaException, NoSuchObjectException { return getTableColumnStatisticsInternal(dbName, tableName, colNames, true, true); @@ -5620,9 +5669,11 @@ String dbName, String tableName, final List colNames, boolean allowSql, boolean allowJdo) throws MetaException, NoSuchObjectException { return new GetStatHelper(dbName.toLowerCase(), tableName.toLowerCase(), allowSql, allowJdo) { + @Override protected ColumnStatistics getSqlResult(GetHelper ctx) throws MetaException { return directSql.getTableStats(dbName, tblName, colNames); } + @Override protected ColumnStatistics getJdoResult( GetHelper ctx) throws MetaException, NoSuchObjectException { List mStats = getMTableColumnStatistics(getTable(), colNames); @@ -5642,6 +5693,7 @@ }.run(true); } + @Override public List getPartitionColumnStatistics(String dbName, String tableName, List partNames, List colNames) throws MetaException, NoSuchObjectException { return getPartitionColumnStatisticsInternal( @@ -5652,10 +5704,12 @@ String dbName, String tableName, final List partNames, final List colNames, boolean allowSql, boolean allowJdo) throws MetaException, NoSuchObjectException { return new GetListHelper(dbName, tableName, allowSql, allowJdo) { + @Override protected List getSqlResult( GetHelper> ctx) throws MetaException { return directSql.getPartitionStats(dbName, tblName, partNames, colNames); } + @Override protected List getJdoResult( GetHelper> ctx) throws MetaException, NoSuchObjectException { List mStats = @@ -5749,6 +5803,7 @@ queryWithParams.getFirst().deletePersistentAll(queryWithParams.getSecond()); } + @Override public boolean deletePartitionColumnStatistics(String dbName, String tableName, String partName, List partVals, String colName) throws NoSuchObjectException, MetaException, InvalidObjectException, InvalidInputException { @@ -5837,6 +5892,7 @@ return ret; } + @Override public boolean deleteTableColumnStatistics(String dbName, String tableName, String colName) throws NoSuchObjectException, MetaException, InvalidObjectException, InvalidInputException { Index: metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java =================================================================== --- metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java (revision 1568537) +++ metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java (working copy) @@ -453,9 +453,11 @@ try { ms.getDatabase(DEFAULT_DATABASE_NAME); } catch (NoSuchObjectException e) { - ms.createDatabase( - new Database(DEFAULT_DATABASE_NAME, DEFAULT_DATABASE_COMMENT, - wh.getDefaultDatabasePath(DEFAULT_DATABASE_NAME).toString(), null)); + Database db = new Database(DEFAULT_DATABASE_NAME, DEFAULT_DATABASE_COMMENT, + wh.getDefaultDatabasePath(DEFAULT_DATABASE_NAME).toString(), null); + db.setOwnerName(PUBLIC); + db.setOwnerType(PrincipalType.ROLE); + ms.createDatabase(db); } HMSHandler.createDefaultDB = true; } Index: metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py =================================================================== --- metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py (revision 1568537) +++ metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py (working copy) @@ -1015,6 +1015,8 @@ - locationUri - parameters - privileges + - ownerName + - ownerType """ thrift_spec = ( @@ -1024,14 +1026,18 @@ (3, TType.STRING, 'locationUri', None, None, ), # 3 (4, TType.MAP, 'parameters', (TType.STRING,None,TType.STRING,None), None, ), # 4 (5, TType.STRUCT, 'privileges', (PrincipalPrivilegeSet, PrincipalPrivilegeSet.thrift_spec), None, ), # 5 + (6, TType.STRING, 'ownerName', None, None, ), # 6 + (7, TType.I32, 'ownerType', None, None, ), # 7 ) - def __init__(self, name=None, description=None, locationUri=None, parameters=None, privileges=None,): + def __init__(self, name=None, description=None, locationUri=None, parameters=None, privileges=None, ownerName=None, ownerType=None,): self.name = name self.description = description self.locationUri = locationUri self.parameters = parameters self.privileges = privileges + self.ownerName = ownerName + self.ownerType = ownerType 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: @@ -1074,6 +1080,16 @@ self.privileges.read(iprot) else: iprot.skip(ftype) + elif fid == 6: + if ftype == TType.STRING: + self.ownerName = iprot.readString(); + else: + iprot.skip(ftype) + elif fid == 7: + if ftype == TType.I32: + self.ownerType = iprot.readI32(); + else: + iprot.skip(ftype) else: iprot.skip(ftype) iprot.readFieldEnd() @@ -1108,6 +1124,14 @@ oprot.writeFieldBegin('privileges', TType.STRUCT, 5) self.privileges.write(oprot) oprot.writeFieldEnd() + if self.ownerName is not None: + oprot.writeFieldBegin('ownerName', TType.STRING, 6) + oprot.writeString(self.ownerName) + oprot.writeFieldEnd() + if self.ownerType is not None: + oprot.writeFieldBegin('ownerType', TType.I32, 7) + oprot.writeI32(self.ownerType) + oprot.writeFieldEnd() oprot.writeFieldStop() oprot.writeStructEnd() Index: metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp =================================================================== --- metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp (revision 1568537) +++ metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp (working copy) @@ -736,14 +736,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size275; - ::apache::thrift::protocol::TType _etype278; - xfer += iprot->readListBegin(_etype278, _size275); - this->success.resize(_size275); - uint32_t _i279; - for (_i279 = 0; _i279 < _size275; ++_i279) + uint32_t _size276; + ::apache::thrift::protocol::TType _etype279; + xfer += iprot->readListBegin(_etype279, _size276); + this->success.resize(_size276); + uint32_t _i280; + for (_i280 = 0; _i280 < _size276; ++_i280) { - xfer += iprot->readString(this->success[_i279]); + xfer += iprot->readString(this->success[_i280]); } xfer += iprot->readListEnd(); } @@ -782,10 +782,10 @@ 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 _iter280; - for (_iter280 = this->success.begin(); _iter280 != this->success.end(); ++_iter280) + std::vector ::const_iterator _iter281; + for (_iter281 = this->success.begin(); _iter281 != this->success.end(); ++_iter281) { - xfer += oprot->writeString((*_iter280)); + xfer += oprot->writeString((*_iter281)); } xfer += oprot->writeListEnd(); } @@ -824,14 +824,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size281; - ::apache::thrift::protocol::TType _etype284; - xfer += iprot->readListBegin(_etype284, _size281); - (*(this->success)).resize(_size281); - uint32_t _i285; - for (_i285 = 0; _i285 < _size281; ++_i285) + uint32_t _size282; + ::apache::thrift::protocol::TType _etype285; + xfer += iprot->readListBegin(_etype285, _size282); + (*(this->success)).resize(_size282); + uint32_t _i286; + for (_i286 = 0; _i286 < _size282; ++_i286) { - xfer += iprot->readString((*(this->success))[_i285]); + xfer += iprot->readString((*(this->success))[_i286]); } xfer += iprot->readListEnd(); } @@ -929,14 +929,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size286; - ::apache::thrift::protocol::TType _etype289; - xfer += iprot->readListBegin(_etype289, _size286); - this->success.resize(_size286); - uint32_t _i290; - for (_i290 = 0; _i290 < _size286; ++_i290) + uint32_t _size287; + ::apache::thrift::protocol::TType _etype290; + xfer += iprot->readListBegin(_etype290, _size287); + this->success.resize(_size287); + uint32_t _i291; + for (_i291 = 0; _i291 < _size287; ++_i291) { - xfer += iprot->readString(this->success[_i290]); + xfer += iprot->readString(this->success[_i291]); } xfer += iprot->readListEnd(); } @@ -975,10 +975,10 @@ 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 _iter291; - for (_iter291 = this->success.begin(); _iter291 != this->success.end(); ++_iter291) + std::vector ::const_iterator _iter292; + for (_iter292 = this->success.begin(); _iter292 != this->success.end(); ++_iter292) { - xfer += oprot->writeString((*_iter291)); + xfer += oprot->writeString((*_iter292)); } xfer += oprot->writeListEnd(); } @@ -1017,14 +1017,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size292; - ::apache::thrift::protocol::TType _etype295; - xfer += iprot->readListBegin(_etype295, _size292); - (*(this->success)).resize(_size292); - uint32_t _i296; - for (_i296 = 0; _i296 < _size292; ++_i296) + uint32_t _size293; + ::apache::thrift::protocol::TType _etype296; + xfer += iprot->readListBegin(_etype296, _size293); + (*(this->success)).resize(_size293); + uint32_t _i297; + for (_i297 = 0; _i297 < _size293; ++_i297) { - xfer += iprot->readString((*(this->success))[_i296]); + xfer += iprot->readString((*(this->success))[_i297]); } xfer += iprot->readListEnd(); } @@ -1967,17 +1967,17 @@ if (ftype == ::apache::thrift::protocol::T_MAP) { { this->success.clear(); - uint32_t _size297; - ::apache::thrift::protocol::TType _ktype298; - ::apache::thrift::protocol::TType _vtype299; - xfer += iprot->readMapBegin(_ktype298, _vtype299, _size297); - uint32_t _i301; - for (_i301 = 0; _i301 < _size297; ++_i301) + uint32_t _size298; + ::apache::thrift::protocol::TType _ktype299; + ::apache::thrift::protocol::TType _vtype300; + xfer += iprot->readMapBegin(_ktype299, _vtype300, _size298); + uint32_t _i302; + for (_i302 = 0; _i302 < _size298; ++_i302) { - std::string _key302; - xfer += iprot->readString(_key302); - Type& _val303 = this->success[_key302]; - xfer += _val303.read(iprot); + std::string _key303; + xfer += iprot->readString(_key303); + Type& _val304 = this->success[_key303]; + xfer += _val304.read(iprot); } xfer += iprot->readMapEnd(); } @@ -2016,11 +2016,11 @@ 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 _iter304; - for (_iter304 = this->success.begin(); _iter304 != this->success.end(); ++_iter304) + std::map ::const_iterator _iter305; + for (_iter305 = this->success.begin(); _iter305 != this->success.end(); ++_iter305) { - xfer += oprot->writeString(_iter304->first); - xfer += _iter304->second.write(oprot); + xfer += oprot->writeString(_iter305->first); + xfer += _iter305->second.write(oprot); } xfer += oprot->writeMapEnd(); } @@ -2059,17 +2059,17 @@ if (ftype == ::apache::thrift::protocol::T_MAP) { { (*(this->success)).clear(); - uint32_t _size305; - ::apache::thrift::protocol::TType _ktype306; - ::apache::thrift::protocol::TType _vtype307; - xfer += iprot->readMapBegin(_ktype306, _vtype307, _size305); - uint32_t _i309; - for (_i309 = 0; _i309 < _size305; ++_i309) + uint32_t _size306; + ::apache::thrift::protocol::TType _ktype307; + ::apache::thrift::protocol::TType _vtype308; + xfer += iprot->readMapBegin(_ktype307, _vtype308, _size306); + uint32_t _i310; + for (_i310 = 0; _i310 < _size306; ++_i310) { - std::string _key310; - xfer += iprot->readString(_key310); - Type& _val311 = (*(this->success))[_key310]; - xfer += _val311.read(iprot); + std::string _key311; + xfer += iprot->readString(_key311); + Type& _val312 = (*(this->success))[_key311]; + xfer += _val312.read(iprot); } xfer += iprot->readMapEnd(); } @@ -2204,14 +2204,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size312; - ::apache::thrift::protocol::TType _etype315; - xfer += iprot->readListBegin(_etype315, _size312); - this->success.resize(_size312); - uint32_t _i316; - for (_i316 = 0; _i316 < _size312; ++_i316) + uint32_t _size313; + ::apache::thrift::protocol::TType _etype316; + xfer += iprot->readListBegin(_etype316, _size313); + this->success.resize(_size313); + uint32_t _i317; + for (_i317 = 0; _i317 < _size313; ++_i317) { - xfer += this->success[_i316].read(iprot); + xfer += this->success[_i317].read(iprot); } xfer += iprot->readListEnd(); } @@ -2266,10 +2266,10 @@ 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 _iter317; - for (_iter317 = this->success.begin(); _iter317 != this->success.end(); ++_iter317) + std::vector ::const_iterator _iter318; + for (_iter318 = this->success.begin(); _iter318 != this->success.end(); ++_iter318) { - xfer += (*_iter317).write(oprot); + xfer += (*_iter318).write(oprot); } xfer += oprot->writeListEnd(); } @@ -2316,14 +2316,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size318; - ::apache::thrift::protocol::TType _etype321; - xfer += iprot->readListBegin(_etype321, _size318); - (*(this->success)).resize(_size318); - uint32_t _i322; - for (_i322 = 0; _i322 < _size318; ++_i322) + uint32_t _size319; + ::apache::thrift::protocol::TType _etype322; + xfer += iprot->readListBegin(_etype322, _size319); + (*(this->success)).resize(_size319); + uint32_t _i323; + for (_i323 = 0; _i323 < _size319; ++_i323) { - xfer += (*(this->success))[_i322].read(iprot); + xfer += (*(this->success))[_i323].read(iprot); } xfer += iprot->readListEnd(); } @@ -2474,14 +2474,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size323; - ::apache::thrift::protocol::TType _etype326; - xfer += iprot->readListBegin(_etype326, _size323); - this->success.resize(_size323); - uint32_t _i327; - for (_i327 = 0; _i327 < _size323; ++_i327) + uint32_t _size324; + ::apache::thrift::protocol::TType _etype327; + xfer += iprot->readListBegin(_etype327, _size324); + this->success.resize(_size324); + uint32_t _i328; + for (_i328 = 0; _i328 < _size324; ++_i328) { - xfer += this->success[_i327].read(iprot); + xfer += this->success[_i328].read(iprot); } xfer += iprot->readListEnd(); } @@ -2536,10 +2536,10 @@ 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 _iter328; - for (_iter328 = this->success.begin(); _iter328 != this->success.end(); ++_iter328) + std::vector ::const_iterator _iter329; + for (_iter329 = this->success.begin(); _iter329 != this->success.end(); ++_iter329) { - xfer += (*_iter328).write(oprot); + xfer += (*_iter329).write(oprot); } xfer += oprot->writeListEnd(); } @@ -2586,14 +2586,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size329; - ::apache::thrift::protocol::TType _etype332; - xfer += iprot->readListBegin(_etype332, _size329); - (*(this->success)).resize(_size329); - uint32_t _i333; - for (_i333 = 0; _i333 < _size329; ++_i333) + uint32_t _size330; + ::apache::thrift::protocol::TType _etype333; + xfer += iprot->readListBegin(_etype333, _size330); + (*(this->success)).resize(_size330); + uint32_t _i334; + for (_i334 = 0; _i334 < _size330; ++_i334) { - xfer += (*(this->success))[_i333].read(iprot); + xfer += (*(this->success))[_i334].read(iprot); } xfer += iprot->readListEnd(); } @@ -3648,14 +3648,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size334; - ::apache::thrift::protocol::TType _etype337; - xfer += iprot->readListBegin(_etype337, _size334); - this->success.resize(_size334); - uint32_t _i338; - for (_i338 = 0; _i338 < _size334; ++_i338) + uint32_t _size335; + ::apache::thrift::protocol::TType _etype338; + xfer += iprot->readListBegin(_etype338, _size335); + this->success.resize(_size335); + uint32_t _i339; + for (_i339 = 0; _i339 < _size335; ++_i339) { - xfer += iprot->readString(this->success[_i338]); + xfer += iprot->readString(this->success[_i339]); } xfer += iprot->readListEnd(); } @@ -3694,10 +3694,10 @@ 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 _iter339; - for (_iter339 = this->success.begin(); _iter339 != this->success.end(); ++_iter339) + std::vector ::const_iterator _iter340; + for (_iter340 = this->success.begin(); _iter340 != this->success.end(); ++_iter340) { - xfer += oprot->writeString((*_iter339)); + xfer += oprot->writeString((*_iter340)); } xfer += oprot->writeListEnd(); } @@ -3736,14 +3736,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size340; - ::apache::thrift::protocol::TType _etype343; - xfer += iprot->readListBegin(_etype343, _size340); - (*(this->success)).resize(_size340); - uint32_t _i344; - for (_i344 = 0; _i344 < _size340; ++_i344) + uint32_t _size341; + ::apache::thrift::protocol::TType _etype344; + xfer += iprot->readListBegin(_etype344, _size341); + (*(this->success)).resize(_size341); + uint32_t _i345; + for (_i345 = 0; _i345 < _size341; ++_i345) { - xfer += iprot->readString((*(this->success))[_i344]); + xfer += iprot->readString((*(this->success))[_i345]); } xfer += iprot->readListEnd(); } @@ -3862,14 +3862,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size345; - ::apache::thrift::protocol::TType _etype348; - xfer += iprot->readListBegin(_etype348, _size345); - this->success.resize(_size345); - uint32_t _i349; - for (_i349 = 0; _i349 < _size345; ++_i349) + uint32_t _size346; + ::apache::thrift::protocol::TType _etype349; + xfer += iprot->readListBegin(_etype349, _size346); + this->success.resize(_size346); + uint32_t _i350; + for (_i350 = 0; _i350 < _size346; ++_i350) { - xfer += iprot->readString(this->success[_i349]); + xfer += iprot->readString(this->success[_i350]); } xfer += iprot->readListEnd(); } @@ -3908,10 +3908,10 @@ 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 _iter350; - for (_iter350 = this->success.begin(); _iter350 != this->success.end(); ++_iter350) + std::vector ::const_iterator _iter351; + for (_iter351 = this->success.begin(); _iter351 != this->success.end(); ++_iter351) { - xfer += oprot->writeString((*_iter350)); + xfer += oprot->writeString((*_iter351)); } xfer += oprot->writeListEnd(); } @@ -3950,14 +3950,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size351; - ::apache::thrift::protocol::TType _etype354; - xfer += iprot->readListBegin(_etype354, _size351); - (*(this->success)).resize(_size351); - uint32_t _i355; - for (_i355 = 0; _i355 < _size351; ++_i355) + uint32_t _size352; + ::apache::thrift::protocol::TType _etype355; + xfer += iprot->readListBegin(_etype355, _size352); + (*(this->success)).resize(_size352); + uint32_t _i356; + for (_i356 = 0; _i356 < _size352; ++_i356) { - xfer += iprot->readString((*(this->success))[_i355]); + xfer += iprot->readString((*(this->success))[_i356]); } xfer += iprot->readListEnd(); } @@ -4236,14 +4236,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tbl_names.clear(); - uint32_t _size356; - ::apache::thrift::protocol::TType _etype359; - xfer += iprot->readListBegin(_etype359, _size356); - this->tbl_names.resize(_size356); - uint32_t _i360; - for (_i360 = 0; _i360 < _size356; ++_i360) + uint32_t _size357; + ::apache::thrift::protocol::TType _etype360; + xfer += iprot->readListBegin(_etype360, _size357); + this->tbl_names.resize(_size357); + uint32_t _i361; + for (_i361 = 0; _i361 < _size357; ++_i361) { - xfer += iprot->readString(this->tbl_names[_i360]); + xfer += iprot->readString(this->tbl_names[_i361]); } xfer += iprot->readListEnd(); } @@ -4275,10 +4275,10 @@ 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 _iter361; - for (_iter361 = this->tbl_names.begin(); _iter361 != this->tbl_names.end(); ++_iter361) + std::vector ::const_iterator _iter362; + for (_iter362 = this->tbl_names.begin(); _iter362 != this->tbl_names.end(); ++_iter362) { - xfer += oprot->writeString((*_iter361)); + xfer += oprot->writeString((*_iter362)); } xfer += oprot->writeListEnd(); } @@ -4300,10 +4300,10 @@ 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 _iter362; - for (_iter362 = (*(this->tbl_names)).begin(); _iter362 != (*(this->tbl_names)).end(); ++_iter362) + std::vector ::const_iterator _iter363; + for (_iter363 = (*(this->tbl_names)).begin(); _iter363 != (*(this->tbl_names)).end(); ++_iter363) { - xfer += oprot->writeString((*_iter362)); + xfer += oprot->writeString((*_iter363)); } xfer += oprot->writeListEnd(); } @@ -4338,14 +4338,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size363; - ::apache::thrift::protocol::TType _etype366; - xfer += iprot->readListBegin(_etype366, _size363); - this->success.resize(_size363); - uint32_t _i367; - for (_i367 = 0; _i367 < _size363; ++_i367) + uint32_t _size364; + ::apache::thrift::protocol::TType _etype367; + xfer += iprot->readListBegin(_etype367, _size364); + this->success.resize(_size364); + uint32_t _i368; + for (_i368 = 0; _i368 < _size364; ++_i368) { - xfer += this->success[_i367].read(iprot); + xfer += this->success[_i368].read(iprot); } xfer += iprot->readListEnd(); } @@ -4400,10 +4400,10 @@ 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 _iter368; - for (_iter368 = this->success.begin(); _iter368 != this->success.end(); ++_iter368) + std::vector
::const_iterator _iter369; + for (_iter369 = this->success.begin(); _iter369 != this->success.end(); ++_iter369) { - xfer += (*_iter368).write(oprot); + xfer += (*_iter369).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4450,14 +4450,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size369; - ::apache::thrift::protocol::TType _etype372; - xfer += iprot->readListBegin(_etype372, _size369); - (*(this->success)).resize(_size369); - uint32_t _i373; - for (_i373 = 0; _i373 < _size369; ++_i373) + uint32_t _size370; + ::apache::thrift::protocol::TType _etype373; + xfer += iprot->readListBegin(_etype373, _size370); + (*(this->success)).resize(_size370); + uint32_t _i374; + for (_i374 = 0; _i374 < _size370; ++_i374) { - xfer += (*(this->success))[_i373].read(iprot); + xfer += (*(this->success))[_i374].read(iprot); } xfer += iprot->readListEnd(); } @@ -4624,14 +4624,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size374; - ::apache::thrift::protocol::TType _etype377; - xfer += iprot->readListBegin(_etype377, _size374); - this->success.resize(_size374); - uint32_t _i378; - for (_i378 = 0; _i378 < _size374; ++_i378) + uint32_t _size375; + ::apache::thrift::protocol::TType _etype378; + xfer += iprot->readListBegin(_etype378, _size375); + this->success.resize(_size375); + uint32_t _i379; + for (_i379 = 0; _i379 < _size375; ++_i379) { - xfer += iprot->readString(this->success[_i378]); + xfer += iprot->readString(this->success[_i379]); } xfer += iprot->readListEnd(); } @@ -4686,10 +4686,10 @@ 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 _iter379; - for (_iter379 = this->success.begin(); _iter379 != this->success.end(); ++_iter379) + std::vector ::const_iterator _iter380; + for (_iter380 = this->success.begin(); _iter380 != this->success.end(); ++_iter380) { - xfer += oprot->writeString((*_iter379)); + xfer += oprot->writeString((*_iter380)); } xfer += oprot->writeListEnd(); } @@ -4736,14 +4736,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size380; - ::apache::thrift::protocol::TType _etype383; - xfer += iprot->readListBegin(_etype383, _size380); - (*(this->success)).resize(_size380); - uint32_t _i384; - for (_i384 = 0; _i384 < _size380; ++_i384) + uint32_t _size381; + ::apache::thrift::protocol::TType _etype384; + xfer += iprot->readListBegin(_etype384, _size381); + (*(this->success)).resize(_size381); + uint32_t _i385; + for (_i385 = 0; _i385 < _size381; ++_i385) { - xfer += iprot->readString((*(this->success))[_i384]); + xfer += iprot->readString((*(this->success))[_i385]); } xfer += iprot->readListEnd(); } @@ -5716,14 +5716,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size385; - ::apache::thrift::protocol::TType _etype388; - xfer += iprot->readListBegin(_etype388, _size385); - this->new_parts.resize(_size385); - uint32_t _i389; - for (_i389 = 0; _i389 < _size385; ++_i389) + uint32_t _size386; + ::apache::thrift::protocol::TType _etype389; + xfer += iprot->readListBegin(_etype389, _size386); + this->new_parts.resize(_size386); + uint32_t _i390; + for (_i390 = 0; _i390 < _size386; ++_i390) { - xfer += this->new_parts[_i389].read(iprot); + xfer += this->new_parts[_i390].read(iprot); } xfer += iprot->readListEnd(); } @@ -5751,10 +5751,10 @@ 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 _iter390; - for (_iter390 = this->new_parts.begin(); _iter390 != this->new_parts.end(); ++_iter390) + std::vector ::const_iterator _iter391; + for (_iter391 = this->new_parts.begin(); _iter391 != this->new_parts.end(); ++_iter391) { - xfer += (*_iter390).write(oprot); + xfer += (*_iter391).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5772,10 +5772,10 @@ 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 _iter391; - for (_iter391 = (*(this->new_parts)).begin(); _iter391 != (*(this->new_parts)).end(); ++_iter391) + std::vector ::const_iterator _iter392; + for (_iter392 = (*(this->new_parts)).begin(); _iter392 != (*(this->new_parts)).end(); ++_iter392) { - xfer += (*_iter391).write(oprot); + xfer += (*_iter392).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5982,14 +5982,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size392; - ::apache::thrift::protocol::TType _etype395; - xfer += iprot->readListBegin(_etype395, _size392); - this->part_vals.resize(_size392); - uint32_t _i396; - for (_i396 = 0; _i396 < _size392; ++_i396) + uint32_t _size393; + ::apache::thrift::protocol::TType _etype396; + xfer += iprot->readListBegin(_etype396, _size393); + this->part_vals.resize(_size393); + uint32_t _i397; + for (_i397 = 0; _i397 < _size393; ++_i397) { - xfer += iprot->readString(this->part_vals[_i396]); + xfer += iprot->readString(this->part_vals[_i397]); } xfer += iprot->readListEnd(); } @@ -6025,10 +6025,10 @@ 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 _iter397; - for (_iter397 = this->part_vals.begin(); _iter397 != this->part_vals.end(); ++_iter397) + std::vector ::const_iterator _iter398; + for (_iter398 = this->part_vals.begin(); _iter398 != this->part_vals.end(); ++_iter398) { - xfer += oprot->writeString((*_iter397)); + xfer += oprot->writeString((*_iter398)); } xfer += oprot->writeListEnd(); } @@ -6054,10 +6054,10 @@ 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 _iter398; - for (_iter398 = (*(this->part_vals)).begin(); _iter398 != (*(this->part_vals)).end(); ++_iter398) + std::vector ::const_iterator _iter399; + for (_iter399 = (*(this->part_vals)).begin(); _iter399 != (*(this->part_vals)).end(); ++_iter399) { - xfer += oprot->writeString((*_iter398)); + xfer += oprot->writeString((*_iter399)); } xfer += oprot->writeListEnd(); } @@ -6486,14 +6486,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size399; - ::apache::thrift::protocol::TType _etype402; - xfer += iprot->readListBegin(_etype402, _size399); - this->part_vals.resize(_size399); - uint32_t _i403; - for (_i403 = 0; _i403 < _size399; ++_i403) + uint32_t _size400; + ::apache::thrift::protocol::TType _etype403; + xfer += iprot->readListBegin(_etype403, _size400); + this->part_vals.resize(_size400); + uint32_t _i404; + for (_i404 = 0; _i404 < _size400; ++_i404) { - xfer += iprot->readString(this->part_vals[_i403]); + xfer += iprot->readString(this->part_vals[_i404]); } xfer += iprot->readListEnd(); } @@ -6537,10 +6537,10 @@ 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 _iter404; - for (_iter404 = this->part_vals.begin(); _iter404 != this->part_vals.end(); ++_iter404) + std::vector ::const_iterator _iter405; + for (_iter405 = this->part_vals.begin(); _iter405 != this->part_vals.end(); ++_iter405) { - xfer += oprot->writeString((*_iter404)); + xfer += oprot->writeString((*_iter405)); } xfer += oprot->writeListEnd(); } @@ -6570,10 +6570,10 @@ 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 _iter405; - for (_iter405 = (*(this->part_vals)).begin(); _iter405 != (*(this->part_vals)).end(); ++_iter405) + std::vector ::const_iterator _iter406; + for (_iter406 = (*(this->part_vals)).begin(); _iter406 != (*(this->part_vals)).end(); ++_iter406) { - xfer += oprot->writeString((*_iter405)); + xfer += oprot->writeString((*_iter406)); } xfer += oprot->writeListEnd(); } @@ -7308,14 +7308,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size406; - ::apache::thrift::protocol::TType _etype409; - xfer += iprot->readListBegin(_etype409, _size406); - this->part_vals.resize(_size406); - uint32_t _i410; - for (_i410 = 0; _i410 < _size406; ++_i410) + uint32_t _size407; + ::apache::thrift::protocol::TType _etype410; + xfer += iprot->readListBegin(_etype410, _size407); + this->part_vals.resize(_size407); + uint32_t _i411; + for (_i411 = 0; _i411 < _size407; ++_i411) { - xfer += iprot->readString(this->part_vals[_i410]); + xfer += iprot->readString(this->part_vals[_i411]); } xfer += iprot->readListEnd(); } @@ -7359,10 +7359,10 @@ 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 _iter411; - for (_iter411 = this->part_vals.begin(); _iter411 != this->part_vals.end(); ++_iter411) + std::vector ::const_iterator _iter412; + for (_iter412 = this->part_vals.begin(); _iter412 != this->part_vals.end(); ++_iter412) { - xfer += oprot->writeString((*_iter411)); + xfer += oprot->writeString((*_iter412)); } xfer += oprot->writeListEnd(); } @@ -7392,10 +7392,10 @@ 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 _iter412; - for (_iter412 = (*(this->part_vals)).begin(); _iter412 != (*(this->part_vals)).end(); ++_iter412) + std::vector ::const_iterator _iter413; + for (_iter413 = (*(this->part_vals)).begin(); _iter413 != (*(this->part_vals)).end(); ++_iter413) { - xfer += oprot->writeString((*_iter412)); + xfer += oprot->writeString((*_iter413)); } xfer += oprot->writeListEnd(); } @@ -7586,14 +7586,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size413; - ::apache::thrift::protocol::TType _etype416; - xfer += iprot->readListBegin(_etype416, _size413); - this->part_vals.resize(_size413); - uint32_t _i417; - for (_i417 = 0; _i417 < _size413; ++_i417) + uint32_t _size414; + ::apache::thrift::protocol::TType _etype417; + xfer += iprot->readListBegin(_etype417, _size414); + this->part_vals.resize(_size414); + uint32_t _i418; + for (_i418 = 0; _i418 < _size414; ++_i418) { - xfer += iprot->readString(this->part_vals[_i417]); + xfer += iprot->readString(this->part_vals[_i418]); } xfer += iprot->readListEnd(); } @@ -7645,10 +7645,10 @@ 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 _iter418; - for (_iter418 = this->part_vals.begin(); _iter418 != this->part_vals.end(); ++_iter418) + std::vector ::const_iterator _iter419; + for (_iter419 = this->part_vals.begin(); _iter419 != this->part_vals.end(); ++_iter419) { - xfer += oprot->writeString((*_iter418)); + xfer += oprot->writeString((*_iter419)); } xfer += oprot->writeListEnd(); } @@ -7682,10 +7682,10 @@ 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 _iter419; - for (_iter419 = (*(this->part_vals)).begin(); _iter419 != (*(this->part_vals)).end(); ++_iter419) + std::vector ::const_iterator _iter420; + for (_iter420 = (*(this->part_vals)).begin(); _iter420 != (*(this->part_vals)).end(); ++_iter420) { - xfer += oprot->writeString((*_iter419)); + xfer += oprot->writeString((*_iter420)); } xfer += oprot->writeListEnd(); } @@ -8598,14 +8598,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size420; - ::apache::thrift::protocol::TType _etype423; - xfer += iprot->readListBegin(_etype423, _size420); - this->part_vals.resize(_size420); - uint32_t _i424; - for (_i424 = 0; _i424 < _size420; ++_i424) + uint32_t _size421; + ::apache::thrift::protocol::TType _etype424; + xfer += iprot->readListBegin(_etype424, _size421); + this->part_vals.resize(_size421); + uint32_t _i425; + for (_i425 = 0; _i425 < _size421; ++_i425) { - xfer += iprot->readString(this->part_vals[_i424]); + xfer += iprot->readString(this->part_vals[_i425]); } xfer += iprot->readListEnd(); } @@ -8641,10 +8641,10 @@ 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 _iter425; - for (_iter425 = this->part_vals.begin(); _iter425 != this->part_vals.end(); ++_iter425) + std::vector ::const_iterator _iter426; + for (_iter426 = this->part_vals.begin(); _iter426 != this->part_vals.end(); ++_iter426) { - xfer += oprot->writeString((*_iter425)); + xfer += oprot->writeString((*_iter426)); } xfer += oprot->writeListEnd(); } @@ -8670,10 +8670,10 @@ 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 _iter426; - for (_iter426 = (*(this->part_vals)).begin(); _iter426 != (*(this->part_vals)).end(); ++_iter426) + std::vector ::const_iterator _iter427; + for (_iter427 = (*(this->part_vals)).begin(); _iter427 != (*(this->part_vals)).end(); ++_iter427) { - xfer += oprot->writeString((*_iter426)); + xfer += oprot->writeString((*_iter427)); } xfer += oprot->writeListEnd(); } @@ -8844,17 +8844,17 @@ if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size427; - ::apache::thrift::protocol::TType _ktype428; - ::apache::thrift::protocol::TType _vtype429; - xfer += iprot->readMapBegin(_ktype428, _vtype429, _size427); - uint32_t _i431; - for (_i431 = 0; _i431 < _size427; ++_i431) + uint32_t _size428; + ::apache::thrift::protocol::TType _ktype429; + ::apache::thrift::protocol::TType _vtype430; + xfer += iprot->readMapBegin(_ktype429, _vtype430, _size428); + uint32_t _i432; + for (_i432 = 0; _i432 < _size428; ++_i432) { - std::string _key432; - xfer += iprot->readString(_key432); - std::string& _val433 = this->partitionSpecs[_key432]; - xfer += iprot->readString(_val433); + std::string _key433; + xfer += iprot->readString(_key433); + std::string& _val434 = this->partitionSpecs[_key433]; + xfer += iprot->readString(_val434); } xfer += iprot->readMapEnd(); } @@ -8914,11 +8914,11 @@ 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 _iter434; - for (_iter434 = this->partitionSpecs.begin(); _iter434 != this->partitionSpecs.end(); ++_iter434) + std::map ::const_iterator _iter435; + for (_iter435 = this->partitionSpecs.begin(); _iter435 != this->partitionSpecs.end(); ++_iter435) { - xfer += oprot->writeString(_iter434->first); - xfer += oprot->writeString(_iter434->second); + xfer += oprot->writeString(_iter435->first); + xfer += oprot->writeString(_iter435->second); } xfer += oprot->writeMapEnd(); } @@ -8952,11 +8952,11 @@ 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 _iter435; - for (_iter435 = (*(this->partitionSpecs)).begin(); _iter435 != (*(this->partitionSpecs)).end(); ++_iter435) + std::map ::const_iterator _iter436; + for (_iter436 = (*(this->partitionSpecs)).begin(); _iter436 != (*(this->partitionSpecs)).end(); ++_iter436) { - xfer += oprot->writeString(_iter435->first); - xfer += oprot->writeString(_iter435->second); + xfer += oprot->writeString(_iter436->first); + xfer += oprot->writeString(_iter436->second); } xfer += oprot->writeMapEnd(); } @@ -9199,14 +9199,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size436; - ::apache::thrift::protocol::TType _etype439; - xfer += iprot->readListBegin(_etype439, _size436); - this->part_vals.resize(_size436); - uint32_t _i440; - for (_i440 = 0; _i440 < _size436; ++_i440) + uint32_t _size437; + ::apache::thrift::protocol::TType _etype440; + xfer += iprot->readListBegin(_etype440, _size437); + this->part_vals.resize(_size437); + uint32_t _i441; + for (_i441 = 0; _i441 < _size437; ++_i441) { - xfer += iprot->readString(this->part_vals[_i440]); + xfer += iprot->readString(this->part_vals[_i441]); } xfer += iprot->readListEnd(); } @@ -9227,14 +9227,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size441; - ::apache::thrift::protocol::TType _etype444; - xfer += iprot->readListBegin(_etype444, _size441); - this->group_names.resize(_size441); - uint32_t _i445; - for (_i445 = 0; _i445 < _size441; ++_i445) + uint32_t _size442; + ::apache::thrift::protocol::TType _etype445; + xfer += iprot->readListBegin(_etype445, _size442); + this->group_names.resize(_size442); + uint32_t _i446; + for (_i446 = 0; _i446 < _size442; ++_i446) { - xfer += iprot->readString(this->group_names[_i445]); + xfer += iprot->readString(this->group_names[_i446]); } xfer += iprot->readListEnd(); } @@ -9270,10 +9270,10 @@ 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 _iter446; - for (_iter446 = this->part_vals.begin(); _iter446 != this->part_vals.end(); ++_iter446) + std::vector ::const_iterator _iter447; + for (_iter447 = this->part_vals.begin(); _iter447 != this->part_vals.end(); ++_iter447) { - xfer += oprot->writeString((*_iter446)); + xfer += oprot->writeString((*_iter447)); } xfer += oprot->writeListEnd(); } @@ -9286,10 +9286,10 @@ 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 _iter447; - for (_iter447 = this->group_names.begin(); _iter447 != this->group_names.end(); ++_iter447) + std::vector ::const_iterator _iter448; + for (_iter448 = this->group_names.begin(); _iter448 != this->group_names.end(); ++_iter448) { - xfer += oprot->writeString((*_iter447)); + xfer += oprot->writeString((*_iter448)); } xfer += oprot->writeListEnd(); } @@ -9315,10 +9315,10 @@ 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 _iter448; - for (_iter448 = (*(this->part_vals)).begin(); _iter448 != (*(this->part_vals)).end(); ++_iter448) + std::vector ::const_iterator _iter449; + for (_iter449 = (*(this->part_vals)).begin(); _iter449 != (*(this->part_vals)).end(); ++_iter449) { - xfer += oprot->writeString((*_iter448)); + xfer += oprot->writeString((*_iter449)); } xfer += oprot->writeListEnd(); } @@ -9331,10 +9331,10 @@ 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 _iter449; - for (_iter449 = (*(this->group_names)).begin(); _iter449 != (*(this->group_names)).end(); ++_iter449) + std::vector ::const_iterator _iter450; + for (_iter450 = (*(this->group_names)).begin(); _iter450 != (*(this->group_names)).end(); ++_iter450) { - xfer += oprot->writeString((*_iter449)); + xfer += oprot->writeString((*_iter450)); } xfer += oprot->writeListEnd(); } @@ -9837,14 +9837,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size450; - ::apache::thrift::protocol::TType _etype453; - xfer += iprot->readListBegin(_etype453, _size450); - this->success.resize(_size450); - uint32_t _i454; - for (_i454 = 0; _i454 < _size450; ++_i454) + uint32_t _size451; + ::apache::thrift::protocol::TType _etype454; + xfer += iprot->readListBegin(_etype454, _size451); + this->success.resize(_size451); + uint32_t _i455; + for (_i455 = 0; _i455 < _size451; ++_i455) { - xfer += this->success[_i454].read(iprot); + xfer += this->success[_i455].read(iprot); } xfer += iprot->readListEnd(); } @@ -9891,10 +9891,10 @@ 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 _iter455; - for (_iter455 = this->success.begin(); _iter455 != this->success.end(); ++_iter455) + std::vector ::const_iterator _iter456; + for (_iter456 = this->success.begin(); _iter456 != this->success.end(); ++_iter456) { - xfer += (*_iter455).write(oprot); + xfer += (*_iter456).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9937,14 +9937,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size456; - ::apache::thrift::protocol::TType _etype459; - xfer += iprot->readListBegin(_etype459, _size456); - (*(this->success)).resize(_size456); - uint32_t _i460; - for (_i460 = 0; _i460 < _size456; ++_i460) + uint32_t _size457; + ::apache::thrift::protocol::TType _etype460; + xfer += iprot->readListBegin(_etype460, _size457); + (*(this->success)).resize(_size457); + uint32_t _i461; + for (_i461 = 0; _i461 < _size457; ++_i461) { - xfer += (*(this->success))[_i460].read(iprot); + xfer += (*(this->success))[_i461].read(iprot); } xfer += iprot->readListEnd(); } @@ -10037,14 +10037,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size461; - ::apache::thrift::protocol::TType _etype464; - xfer += iprot->readListBegin(_etype464, _size461); - this->group_names.resize(_size461); - uint32_t _i465; - for (_i465 = 0; _i465 < _size461; ++_i465) + uint32_t _size462; + ::apache::thrift::protocol::TType _etype465; + xfer += iprot->readListBegin(_etype465, _size462); + this->group_names.resize(_size462); + uint32_t _i466; + for (_i466 = 0; _i466 < _size462; ++_i466) { - xfer += iprot->readString(this->group_names[_i465]); + xfer += iprot->readString(this->group_names[_i466]); } xfer += iprot->readListEnd(); } @@ -10088,10 +10088,10 @@ 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 _iter466; - for (_iter466 = this->group_names.begin(); _iter466 != this->group_names.end(); ++_iter466) + std::vector ::const_iterator _iter467; + for (_iter467 = this->group_names.begin(); _iter467 != this->group_names.end(); ++_iter467) { - xfer += oprot->writeString((*_iter466)); + xfer += oprot->writeString((*_iter467)); } xfer += oprot->writeListEnd(); } @@ -10125,10 +10125,10 @@ 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 _iter467; - for (_iter467 = (*(this->group_names)).begin(); _iter467 != (*(this->group_names)).end(); ++_iter467) + std::vector ::const_iterator _iter468; + for (_iter468 = (*(this->group_names)).begin(); _iter468 != (*(this->group_names)).end(); ++_iter468) { - xfer += oprot->writeString((*_iter467)); + xfer += oprot->writeString((*_iter468)); } xfer += oprot->writeListEnd(); } @@ -10163,14 +10163,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size468; - ::apache::thrift::protocol::TType _etype471; - xfer += iprot->readListBegin(_etype471, _size468); - this->success.resize(_size468); - uint32_t _i472; - for (_i472 = 0; _i472 < _size468; ++_i472) + uint32_t _size469; + ::apache::thrift::protocol::TType _etype472; + xfer += iprot->readListBegin(_etype472, _size469); + this->success.resize(_size469); + uint32_t _i473; + for (_i473 = 0; _i473 < _size469; ++_i473) { - xfer += this->success[_i472].read(iprot); + xfer += this->success[_i473].read(iprot); } xfer += iprot->readListEnd(); } @@ -10217,10 +10217,10 @@ 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 _iter473; - for (_iter473 = this->success.begin(); _iter473 != this->success.end(); ++_iter473) + std::vector ::const_iterator _iter474; + for (_iter474 = this->success.begin(); _iter474 != this->success.end(); ++_iter474) { - xfer += (*_iter473).write(oprot); + xfer += (*_iter474).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10263,14 +10263,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size474; - ::apache::thrift::protocol::TType _etype477; - xfer += iprot->readListBegin(_etype477, _size474); - (*(this->success)).resize(_size474); - uint32_t _i478; - for (_i478 = 0; _i478 < _size474; ++_i478) + uint32_t _size475; + ::apache::thrift::protocol::TType _etype478; + xfer += iprot->readListBegin(_etype478, _size475); + (*(this->success)).resize(_size475); + uint32_t _i479; + for (_i479 = 0; _i479 < _size475; ++_i479) { - xfer += (*(this->success))[_i478].read(iprot); + xfer += (*(this->success))[_i479].read(iprot); } xfer += iprot->readListEnd(); } @@ -10429,14 +10429,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size479; - ::apache::thrift::protocol::TType _etype482; - xfer += iprot->readListBegin(_etype482, _size479); - this->success.resize(_size479); - uint32_t _i483; - for (_i483 = 0; _i483 < _size479; ++_i483) + uint32_t _size480; + ::apache::thrift::protocol::TType _etype483; + xfer += iprot->readListBegin(_etype483, _size480); + this->success.resize(_size480); + uint32_t _i484; + for (_i484 = 0; _i484 < _size480; ++_i484) { - xfer += iprot->readString(this->success[_i483]); + xfer += iprot->readString(this->success[_i484]); } xfer += iprot->readListEnd(); } @@ -10475,10 +10475,10 @@ 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 _iter484; - for (_iter484 = this->success.begin(); _iter484 != this->success.end(); ++_iter484) + std::vector ::const_iterator _iter485; + for (_iter485 = this->success.begin(); _iter485 != this->success.end(); ++_iter485) { - xfer += oprot->writeString((*_iter484)); + xfer += oprot->writeString((*_iter485)); } xfer += oprot->writeListEnd(); } @@ -10517,14 +10517,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size485; - ::apache::thrift::protocol::TType _etype488; - xfer += iprot->readListBegin(_etype488, _size485); - (*(this->success)).resize(_size485); - uint32_t _i489; - for (_i489 = 0; _i489 < _size485; ++_i489) + uint32_t _size486; + ::apache::thrift::protocol::TType _etype489; + xfer += iprot->readListBegin(_etype489, _size486); + (*(this->success)).resize(_size486); + uint32_t _i490; + for (_i490 = 0; _i490 < _size486; ++_i490) { - xfer += iprot->readString((*(this->success))[_i489]); + xfer += iprot->readString((*(this->success))[_i490]); } xfer += iprot->readListEnd(); } @@ -10593,14 +10593,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size490; - ::apache::thrift::protocol::TType _etype493; - xfer += iprot->readListBegin(_etype493, _size490); - this->part_vals.resize(_size490); - uint32_t _i494; - for (_i494 = 0; _i494 < _size490; ++_i494) + uint32_t _size491; + ::apache::thrift::protocol::TType _etype494; + xfer += iprot->readListBegin(_etype494, _size491); + this->part_vals.resize(_size491); + uint32_t _i495; + for (_i495 = 0; _i495 < _size491; ++_i495) { - xfer += iprot->readString(this->part_vals[_i494]); + xfer += iprot->readString(this->part_vals[_i495]); } xfer += iprot->readListEnd(); } @@ -10644,10 +10644,10 @@ 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 _iter495; - for (_iter495 = this->part_vals.begin(); _iter495 != this->part_vals.end(); ++_iter495) + std::vector ::const_iterator _iter496; + for (_iter496 = this->part_vals.begin(); _iter496 != this->part_vals.end(); ++_iter496) { - xfer += oprot->writeString((*_iter495)); + xfer += oprot->writeString((*_iter496)); } xfer += oprot->writeListEnd(); } @@ -10677,10 +10677,10 @@ 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 _iter496; - for (_iter496 = (*(this->part_vals)).begin(); _iter496 != (*(this->part_vals)).end(); ++_iter496) + std::vector ::const_iterator _iter497; + for (_iter497 = (*(this->part_vals)).begin(); _iter497 != (*(this->part_vals)).end(); ++_iter497) { - xfer += oprot->writeString((*_iter496)); + xfer += oprot->writeString((*_iter497)); } xfer += oprot->writeListEnd(); } @@ -10719,14 +10719,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size497; - ::apache::thrift::protocol::TType _etype500; - xfer += iprot->readListBegin(_etype500, _size497); - this->success.resize(_size497); - uint32_t _i501; - for (_i501 = 0; _i501 < _size497; ++_i501) + uint32_t _size498; + ::apache::thrift::protocol::TType _etype501; + xfer += iprot->readListBegin(_etype501, _size498); + this->success.resize(_size498); + uint32_t _i502; + for (_i502 = 0; _i502 < _size498; ++_i502) { - xfer += this->success[_i501].read(iprot); + xfer += this->success[_i502].read(iprot); } xfer += iprot->readListEnd(); } @@ -10773,10 +10773,10 @@ 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 _iter502; - for (_iter502 = this->success.begin(); _iter502 != this->success.end(); ++_iter502) + std::vector ::const_iterator _iter503; + for (_iter503 = this->success.begin(); _iter503 != this->success.end(); ++_iter503) { - xfer += (*_iter502).write(oprot); + xfer += (*_iter503).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10819,14 +10819,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size503; - ::apache::thrift::protocol::TType _etype506; - xfer += iprot->readListBegin(_etype506, _size503); - (*(this->success)).resize(_size503); - uint32_t _i507; - for (_i507 = 0; _i507 < _size503; ++_i507) + uint32_t _size504; + ::apache::thrift::protocol::TType _etype507; + xfer += iprot->readListBegin(_etype507, _size504); + (*(this->success)).resize(_size504); + uint32_t _i508; + for (_i508 = 0; _i508 < _size504; ++_i508) { - xfer += (*(this->success))[_i507].read(iprot); + xfer += (*(this->success))[_i508].read(iprot); } xfer += iprot->readListEnd(); } @@ -10903,14 +10903,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size508; - ::apache::thrift::protocol::TType _etype511; - xfer += iprot->readListBegin(_etype511, _size508); - this->part_vals.resize(_size508); - uint32_t _i512; - for (_i512 = 0; _i512 < _size508; ++_i512) + uint32_t _size509; + ::apache::thrift::protocol::TType _etype512; + xfer += iprot->readListBegin(_etype512, _size509); + this->part_vals.resize(_size509); + uint32_t _i513; + for (_i513 = 0; _i513 < _size509; ++_i513) { - xfer += iprot->readString(this->part_vals[_i512]); + xfer += iprot->readString(this->part_vals[_i513]); } xfer += iprot->readListEnd(); } @@ -10939,14 +10939,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size513; - ::apache::thrift::protocol::TType _etype516; - xfer += iprot->readListBegin(_etype516, _size513); - this->group_names.resize(_size513); - uint32_t _i517; - for (_i517 = 0; _i517 < _size513; ++_i517) + uint32_t _size514; + ::apache::thrift::protocol::TType _etype517; + xfer += iprot->readListBegin(_etype517, _size514); + this->group_names.resize(_size514); + uint32_t _i518; + for (_i518 = 0; _i518 < _size514; ++_i518) { - xfer += iprot->readString(this->group_names[_i517]); + xfer += iprot->readString(this->group_names[_i518]); } xfer += iprot->readListEnd(); } @@ -10982,10 +10982,10 @@ 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 _iter518; - for (_iter518 = this->part_vals.begin(); _iter518 != this->part_vals.end(); ++_iter518) + std::vector ::const_iterator _iter519; + for (_iter519 = this->part_vals.begin(); _iter519 != this->part_vals.end(); ++_iter519) { - xfer += oprot->writeString((*_iter518)); + xfer += oprot->writeString((*_iter519)); } xfer += oprot->writeListEnd(); } @@ -11002,10 +11002,10 @@ 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 _iter519; - for (_iter519 = this->group_names.begin(); _iter519 != this->group_names.end(); ++_iter519) + std::vector ::const_iterator _iter520; + for (_iter520 = this->group_names.begin(); _iter520 != this->group_names.end(); ++_iter520) { - xfer += oprot->writeString((*_iter519)); + xfer += oprot->writeString((*_iter520)); } xfer += oprot->writeListEnd(); } @@ -11031,10 +11031,10 @@ 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 _iter520; - for (_iter520 = (*(this->part_vals)).begin(); _iter520 != (*(this->part_vals)).end(); ++_iter520) + std::vector ::const_iterator _iter521; + for (_iter521 = (*(this->part_vals)).begin(); _iter521 != (*(this->part_vals)).end(); ++_iter521) { - xfer += oprot->writeString((*_iter520)); + xfer += oprot->writeString((*_iter521)); } xfer += oprot->writeListEnd(); } @@ -11051,10 +11051,10 @@ 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 _iter521; - for (_iter521 = (*(this->group_names)).begin(); _iter521 != (*(this->group_names)).end(); ++_iter521) + std::vector ::const_iterator _iter522; + for (_iter522 = (*(this->group_names)).begin(); _iter522 != (*(this->group_names)).end(); ++_iter522) { - xfer += oprot->writeString((*_iter521)); + xfer += oprot->writeString((*_iter522)); } xfer += oprot->writeListEnd(); } @@ -11089,14 +11089,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size522; - ::apache::thrift::protocol::TType _etype525; - xfer += iprot->readListBegin(_etype525, _size522); - this->success.resize(_size522); - uint32_t _i526; - for (_i526 = 0; _i526 < _size522; ++_i526) + uint32_t _size523; + ::apache::thrift::protocol::TType _etype526; + xfer += iprot->readListBegin(_etype526, _size523); + this->success.resize(_size523); + uint32_t _i527; + for (_i527 = 0; _i527 < _size523; ++_i527) { - xfer += this->success[_i526].read(iprot); + xfer += this->success[_i527].read(iprot); } xfer += iprot->readListEnd(); } @@ -11143,10 +11143,10 @@ 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 _iter527; - for (_iter527 = this->success.begin(); _iter527 != this->success.end(); ++_iter527) + std::vector ::const_iterator _iter528; + for (_iter528 = this->success.begin(); _iter528 != this->success.end(); ++_iter528) { - xfer += (*_iter527).write(oprot); + xfer += (*_iter528).write(oprot); } xfer += oprot->writeListEnd(); } @@ -11189,14 +11189,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size528; - ::apache::thrift::protocol::TType _etype531; - xfer += iprot->readListBegin(_etype531, _size528); - (*(this->success)).resize(_size528); - uint32_t _i532; - for (_i532 = 0; _i532 < _size528; ++_i532) + uint32_t _size529; + ::apache::thrift::protocol::TType _etype532; + xfer += iprot->readListBegin(_etype532, _size529); + (*(this->success)).resize(_size529); + uint32_t _i533; + for (_i533 = 0; _i533 < _size529; ++_i533) { - xfer += (*(this->success))[_i532].read(iprot); + xfer += (*(this->success))[_i533].read(iprot); } xfer += iprot->readListEnd(); } @@ -11273,14 +11273,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size533; - ::apache::thrift::protocol::TType _etype536; - xfer += iprot->readListBegin(_etype536, _size533); - this->part_vals.resize(_size533); - uint32_t _i537; - for (_i537 = 0; _i537 < _size533; ++_i537) + uint32_t _size534; + ::apache::thrift::protocol::TType _etype537; + xfer += iprot->readListBegin(_etype537, _size534); + this->part_vals.resize(_size534); + uint32_t _i538; + for (_i538 = 0; _i538 < _size534; ++_i538) { - xfer += iprot->readString(this->part_vals[_i537]); + xfer += iprot->readString(this->part_vals[_i538]); } xfer += iprot->readListEnd(); } @@ -11324,10 +11324,10 @@ 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 _iter538; - for (_iter538 = this->part_vals.begin(); _iter538 != this->part_vals.end(); ++_iter538) + std::vector ::const_iterator _iter539; + for (_iter539 = this->part_vals.begin(); _iter539 != this->part_vals.end(); ++_iter539) { - xfer += oprot->writeString((*_iter538)); + xfer += oprot->writeString((*_iter539)); } xfer += oprot->writeListEnd(); } @@ -11357,10 +11357,10 @@ 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 _iter539; - for (_iter539 = (*(this->part_vals)).begin(); _iter539 != (*(this->part_vals)).end(); ++_iter539) + std::vector ::const_iterator _iter540; + for (_iter540 = (*(this->part_vals)).begin(); _iter540 != (*(this->part_vals)).end(); ++_iter540) { - xfer += oprot->writeString((*_iter539)); + xfer += oprot->writeString((*_iter540)); } xfer += oprot->writeListEnd(); } @@ -11399,14 +11399,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size540; - ::apache::thrift::protocol::TType _etype543; - xfer += iprot->readListBegin(_etype543, _size540); - this->success.resize(_size540); - uint32_t _i544; - for (_i544 = 0; _i544 < _size540; ++_i544) + uint32_t _size541; + ::apache::thrift::protocol::TType _etype544; + xfer += iprot->readListBegin(_etype544, _size541); + this->success.resize(_size541); + uint32_t _i545; + for (_i545 = 0; _i545 < _size541; ++_i545) { - xfer += iprot->readString(this->success[_i544]); + xfer += iprot->readString(this->success[_i545]); } xfer += iprot->readListEnd(); } @@ -11453,10 +11453,10 @@ 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 _iter545; - for (_iter545 = this->success.begin(); _iter545 != this->success.end(); ++_iter545) + std::vector ::const_iterator _iter546; + for (_iter546 = this->success.begin(); _iter546 != this->success.end(); ++_iter546) { - xfer += oprot->writeString((*_iter545)); + xfer += oprot->writeString((*_iter546)); } xfer += oprot->writeListEnd(); } @@ -11499,14 +11499,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size546; - ::apache::thrift::protocol::TType _etype549; - xfer += iprot->readListBegin(_etype549, _size546); - (*(this->success)).resize(_size546); - uint32_t _i550; - for (_i550 = 0; _i550 < _size546; ++_i550) + uint32_t _size547; + ::apache::thrift::protocol::TType _etype550; + xfer += iprot->readListBegin(_etype550, _size547); + (*(this->success)).resize(_size547); + uint32_t _i551; + for (_i551 = 0; _i551 < _size547; ++_i551) { - xfer += iprot->readString((*(this->success))[_i550]); + xfer += iprot->readString((*(this->success))[_i551]); } xfer += iprot->readListEnd(); } @@ -11681,14 +11681,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size551; - ::apache::thrift::protocol::TType _etype554; - xfer += iprot->readListBegin(_etype554, _size551); - this->success.resize(_size551); - uint32_t _i555; - for (_i555 = 0; _i555 < _size551; ++_i555) + uint32_t _size552; + ::apache::thrift::protocol::TType _etype555; + xfer += iprot->readListBegin(_etype555, _size552); + this->success.resize(_size552); + uint32_t _i556; + for (_i556 = 0; _i556 < _size552; ++_i556) { - xfer += this->success[_i555].read(iprot); + xfer += this->success[_i556].read(iprot); } xfer += iprot->readListEnd(); } @@ -11735,10 +11735,10 @@ 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 _iter556; - for (_iter556 = this->success.begin(); _iter556 != this->success.end(); ++_iter556) + std::vector ::const_iterator _iter557; + for (_iter557 = this->success.begin(); _iter557 != this->success.end(); ++_iter557) { - xfer += (*_iter556).write(oprot); + xfer += (*_iter557).write(oprot); } xfer += oprot->writeListEnd(); } @@ -11781,14 +11781,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size557; - ::apache::thrift::protocol::TType _etype560; - xfer += iprot->readListBegin(_etype560, _size557); - (*(this->success)).resize(_size557); - uint32_t _i561; - for (_i561 = 0; _i561 < _size557; ++_i561) + uint32_t _size558; + ::apache::thrift::protocol::TType _etype561; + xfer += iprot->readListBegin(_etype561, _size558); + (*(this->success)).resize(_size558); + uint32_t _i562; + for (_i562 = 0; _i562 < _size558; ++_i562) { - xfer += (*(this->success))[_i561].read(iprot); + xfer += (*(this->success))[_i562].read(iprot); } xfer += iprot->readListEnd(); } @@ -12067,14 +12067,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->names.clear(); - uint32_t _size562; - ::apache::thrift::protocol::TType _etype565; - xfer += iprot->readListBegin(_etype565, _size562); - this->names.resize(_size562); - uint32_t _i566; - for (_i566 = 0; _i566 < _size562; ++_i566) + uint32_t _size563; + ::apache::thrift::protocol::TType _etype566; + xfer += iprot->readListBegin(_etype566, _size563); + this->names.resize(_size563); + uint32_t _i567; + for (_i567 = 0; _i567 < _size563; ++_i567) { - xfer += iprot->readString(this->names[_i566]); + xfer += iprot->readString(this->names[_i567]); } xfer += iprot->readListEnd(); } @@ -12110,10 +12110,10 @@ 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 _iter567; - for (_iter567 = this->names.begin(); _iter567 != this->names.end(); ++_iter567) + std::vector ::const_iterator _iter568; + for (_iter568 = this->names.begin(); _iter568 != this->names.end(); ++_iter568) { - xfer += oprot->writeString((*_iter567)); + xfer += oprot->writeString((*_iter568)); } xfer += oprot->writeListEnd(); } @@ -12139,10 +12139,10 @@ 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 _iter568; - for (_iter568 = (*(this->names)).begin(); _iter568 != (*(this->names)).end(); ++_iter568) + std::vector ::const_iterator _iter569; + for (_iter569 = (*(this->names)).begin(); _iter569 != (*(this->names)).end(); ++_iter569) { - xfer += oprot->writeString((*_iter568)); + xfer += oprot->writeString((*_iter569)); } xfer += oprot->writeListEnd(); } @@ -12177,14 +12177,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size569; - ::apache::thrift::protocol::TType _etype572; - xfer += iprot->readListBegin(_etype572, _size569); - this->success.resize(_size569); - uint32_t _i573; - for (_i573 = 0; _i573 < _size569; ++_i573) + uint32_t _size570; + ::apache::thrift::protocol::TType _etype573; + xfer += iprot->readListBegin(_etype573, _size570); + this->success.resize(_size570); + uint32_t _i574; + for (_i574 = 0; _i574 < _size570; ++_i574) { - xfer += this->success[_i573].read(iprot); + xfer += this->success[_i574].read(iprot); } xfer += iprot->readListEnd(); } @@ -12231,10 +12231,10 @@ 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 _iter574; - for (_iter574 = this->success.begin(); _iter574 != this->success.end(); ++_iter574) + std::vector ::const_iterator _iter575; + for (_iter575 = this->success.begin(); _iter575 != this->success.end(); ++_iter575) { - xfer += (*_iter574).write(oprot); + xfer += (*_iter575).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12277,14 +12277,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size575; - ::apache::thrift::protocol::TType _etype578; - xfer += iprot->readListBegin(_etype578, _size575); - (*(this->success)).resize(_size575); - uint32_t _i579; - for (_i579 = 0; _i579 < _size575; ++_i579) + uint32_t _size576; + ::apache::thrift::protocol::TType _etype579; + xfer += iprot->readListBegin(_etype579, _size576); + (*(this->success)).resize(_size576); + uint32_t _i580; + for (_i580 = 0; _i580 < _size576; ++_i580) { - xfer += (*(this->success))[_i579].read(iprot); + xfer += (*(this->success))[_i580].read(iprot); } xfer += iprot->readListEnd(); } @@ -12575,14 +12575,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size580; - ::apache::thrift::protocol::TType _etype583; - xfer += iprot->readListBegin(_etype583, _size580); - this->new_parts.resize(_size580); - uint32_t _i584; - for (_i584 = 0; _i584 < _size580; ++_i584) + uint32_t _size581; + ::apache::thrift::protocol::TType _etype584; + xfer += iprot->readListBegin(_etype584, _size581); + this->new_parts.resize(_size581); + uint32_t _i585; + for (_i585 = 0; _i585 < _size581; ++_i585) { - xfer += this->new_parts[_i584].read(iprot); + xfer += this->new_parts[_i585].read(iprot); } xfer += iprot->readListEnd(); } @@ -12618,10 +12618,10 @@ 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 _iter585; - for (_iter585 = this->new_parts.begin(); _iter585 != this->new_parts.end(); ++_iter585) + std::vector ::const_iterator _iter586; + for (_iter586 = this->new_parts.begin(); _iter586 != this->new_parts.end(); ++_iter586) { - xfer += (*_iter585).write(oprot); + xfer += (*_iter586).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12647,10 +12647,10 @@ 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 _iter586; - for (_iter586 = (*(this->new_parts)).begin(); _iter586 != (*(this->new_parts)).end(); ++_iter586) + std::vector ::const_iterator _iter587; + for (_iter587 = (*(this->new_parts)).begin(); _iter587 != (*(this->new_parts)).end(); ++_iter587) { - xfer += (*_iter586).write(oprot); + xfer += (*_iter587).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13047,14 +13047,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size587; - ::apache::thrift::protocol::TType _etype590; - xfer += iprot->readListBegin(_etype590, _size587); - this->part_vals.resize(_size587); - uint32_t _i591; - for (_i591 = 0; _i591 < _size587; ++_i591) + uint32_t _size588; + ::apache::thrift::protocol::TType _etype591; + xfer += iprot->readListBegin(_etype591, _size588); + this->part_vals.resize(_size588); + uint32_t _i592; + for (_i592 = 0; _i592 < _size588; ++_i592) { - xfer += iprot->readString(this->part_vals[_i591]); + xfer += iprot->readString(this->part_vals[_i592]); } xfer += iprot->readListEnd(); } @@ -13098,10 +13098,10 @@ 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 _iter592; - for (_iter592 = this->part_vals.begin(); _iter592 != this->part_vals.end(); ++_iter592) + std::vector ::const_iterator _iter593; + for (_iter593 = this->part_vals.begin(); _iter593 != this->part_vals.end(); ++_iter593) { - xfer += oprot->writeString((*_iter592)); + xfer += oprot->writeString((*_iter593)); } xfer += oprot->writeListEnd(); } @@ -13131,10 +13131,10 @@ 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 _iter593; - for (_iter593 = (*(this->part_vals)).begin(); _iter593 != (*(this->part_vals)).end(); ++_iter593) + std::vector ::const_iterator _iter594; + for (_iter594 = (*(this->part_vals)).begin(); _iter594 != (*(this->part_vals)).end(); ++_iter594) { - xfer += oprot->writeString((*_iter593)); + xfer += oprot->writeString((*_iter594)); } xfer += oprot->writeListEnd(); } @@ -13289,14 +13289,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size594; - ::apache::thrift::protocol::TType _etype597; - xfer += iprot->readListBegin(_etype597, _size594); - this->part_vals.resize(_size594); - uint32_t _i598; - for (_i598 = 0; _i598 < _size594; ++_i598) + uint32_t _size595; + ::apache::thrift::protocol::TType _etype598; + xfer += iprot->readListBegin(_etype598, _size595); + this->part_vals.resize(_size595); + uint32_t _i599; + for (_i599 = 0; _i599 < _size595; ++_i599) { - xfer += iprot->readString(this->part_vals[_i598]); + xfer += iprot->readString(this->part_vals[_i599]); } xfer += iprot->readListEnd(); } @@ -13332,10 +13332,10 @@ 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 _iter599; - for (_iter599 = this->part_vals.begin(); _iter599 != this->part_vals.end(); ++_iter599) + std::vector ::const_iterator _iter600; + for (_iter600 = this->part_vals.begin(); _iter600 != this->part_vals.end(); ++_iter600) { - xfer += oprot->writeString((*_iter599)); + xfer += oprot->writeString((*_iter600)); } xfer += oprot->writeListEnd(); } @@ -13357,10 +13357,10 @@ 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 _iter600; - for (_iter600 = (*(this->part_vals)).begin(); _iter600 != (*(this->part_vals)).end(); ++_iter600) + std::vector ::const_iterator _iter601; + for (_iter601 = (*(this->part_vals)).begin(); _iter601 != (*(this->part_vals)).end(); ++_iter601) { - xfer += oprot->writeString((*_iter600)); + xfer += oprot->writeString((*_iter601)); } xfer += oprot->writeListEnd(); } @@ -13779,14 +13779,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size601; - ::apache::thrift::protocol::TType _etype604; - xfer += iprot->readListBegin(_etype604, _size601); - this->success.resize(_size601); - uint32_t _i605; - for (_i605 = 0; _i605 < _size601; ++_i605) + uint32_t _size602; + ::apache::thrift::protocol::TType _etype605; + xfer += iprot->readListBegin(_etype605, _size602); + this->success.resize(_size602); + uint32_t _i606; + for (_i606 = 0; _i606 < _size602; ++_i606) { - xfer += iprot->readString(this->success[_i605]); + xfer += iprot->readString(this->success[_i606]); } xfer += iprot->readListEnd(); } @@ -13825,10 +13825,10 @@ 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 _iter606; - for (_iter606 = this->success.begin(); _iter606 != this->success.end(); ++_iter606) + std::vector ::const_iterator _iter607; + for (_iter607 = this->success.begin(); _iter607 != this->success.end(); ++_iter607) { - xfer += oprot->writeString((*_iter606)); + xfer += oprot->writeString((*_iter607)); } xfer += oprot->writeListEnd(); } @@ -13867,14 +13867,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size607; - ::apache::thrift::protocol::TType _etype610; - xfer += iprot->readListBegin(_etype610, _size607); - (*(this->success)).resize(_size607); - uint32_t _i611; - for (_i611 = 0; _i611 < _size607; ++_i611) + uint32_t _size608; + ::apache::thrift::protocol::TType _etype611; + xfer += iprot->readListBegin(_etype611, _size608); + (*(this->success)).resize(_size608); + uint32_t _i612; + for (_i612 = 0; _i612 < _size608; ++_i612) { - xfer += iprot->readString((*(this->success))[_i611]); + xfer += iprot->readString((*(this->success))[_i612]); } xfer += iprot->readListEnd(); } @@ -13993,17 +13993,17 @@ if (ftype == ::apache::thrift::protocol::T_MAP) { { this->success.clear(); - uint32_t _size612; - ::apache::thrift::protocol::TType _ktype613; - ::apache::thrift::protocol::TType _vtype614; - xfer += iprot->readMapBegin(_ktype613, _vtype614, _size612); - uint32_t _i616; - for (_i616 = 0; _i616 < _size612; ++_i616) + uint32_t _size613; + ::apache::thrift::protocol::TType _ktype614; + ::apache::thrift::protocol::TType _vtype615; + xfer += iprot->readMapBegin(_ktype614, _vtype615, _size613); + uint32_t _i617; + for (_i617 = 0; _i617 < _size613; ++_i617) { - std::string _key617; - xfer += iprot->readString(_key617); - std::string& _val618 = this->success[_key617]; - xfer += iprot->readString(_val618); + std::string _key618; + xfer += iprot->readString(_key618); + std::string& _val619 = this->success[_key618]; + xfer += iprot->readString(_val619); } xfer += iprot->readMapEnd(); } @@ -14042,11 +14042,11 @@ 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 _iter619; - for (_iter619 = this->success.begin(); _iter619 != this->success.end(); ++_iter619) + std::map ::const_iterator _iter620; + for (_iter620 = this->success.begin(); _iter620 != this->success.end(); ++_iter620) { - xfer += oprot->writeString(_iter619->first); - xfer += oprot->writeString(_iter619->second); + xfer += oprot->writeString(_iter620->first); + xfer += oprot->writeString(_iter620->second); } xfer += oprot->writeMapEnd(); } @@ -14085,17 +14085,17 @@ if (ftype == ::apache::thrift::protocol::T_MAP) { { (*(this->success)).clear(); - uint32_t _size620; - ::apache::thrift::protocol::TType _ktype621; - ::apache::thrift::protocol::TType _vtype622; - xfer += iprot->readMapBegin(_ktype621, _vtype622, _size620); - uint32_t _i624; - for (_i624 = 0; _i624 < _size620; ++_i624) + uint32_t _size621; + ::apache::thrift::protocol::TType _ktype622; + ::apache::thrift::protocol::TType _vtype623; + xfer += iprot->readMapBegin(_ktype622, _vtype623, _size621); + uint32_t _i625; + for (_i625 = 0; _i625 < _size621; ++_i625) { - std::string _key625; - xfer += iprot->readString(_key625); - std::string& _val626 = (*(this->success))[_key625]; - xfer += iprot->readString(_val626); + std::string _key626; + xfer += iprot->readString(_key626); + std::string& _val627 = (*(this->success))[_key626]; + xfer += iprot->readString(_val627); } xfer += iprot->readMapEnd(); } @@ -14164,17 +14164,17 @@ if (ftype == ::apache::thrift::protocol::T_MAP) { { this->part_vals.clear(); - uint32_t _size627; - ::apache::thrift::protocol::TType _ktype628; - ::apache::thrift::protocol::TType _vtype629; - xfer += iprot->readMapBegin(_ktype628, _vtype629, _size627); - uint32_t _i631; - for (_i631 = 0; _i631 < _size627; ++_i631) + uint32_t _size628; + ::apache::thrift::protocol::TType _ktype629; + ::apache::thrift::protocol::TType _vtype630; + xfer += iprot->readMapBegin(_ktype629, _vtype630, _size628); + uint32_t _i632; + for (_i632 = 0; _i632 < _size628; ++_i632) { - std::string _key632; - xfer += iprot->readString(_key632); - std::string& _val633 = this->part_vals[_key632]; - xfer += iprot->readString(_val633); + std::string _key633; + xfer += iprot->readString(_key633); + std::string& _val634 = this->part_vals[_key633]; + xfer += iprot->readString(_val634); } xfer += iprot->readMapEnd(); } @@ -14185,9 +14185,9 @@ break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast634; - xfer += iprot->readI32(ecast634); - this->eventType = (PartitionEventType::type)ecast634; + int32_t ecast635; + xfer += iprot->readI32(ecast635); + this->eventType = (PartitionEventType::type)ecast635; this->__isset.eventType = true; } else { xfer += iprot->skip(ftype); @@ -14220,11 +14220,11 @@ 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 _iter635; - for (_iter635 = this->part_vals.begin(); _iter635 != this->part_vals.end(); ++_iter635) + std::map ::const_iterator _iter636; + for (_iter636 = this->part_vals.begin(); _iter636 != this->part_vals.end(); ++_iter636) { - xfer += oprot->writeString(_iter635->first); - xfer += oprot->writeString(_iter635->second); + xfer += oprot->writeString(_iter636->first); + xfer += oprot->writeString(_iter636->second); } xfer += oprot->writeMapEnd(); } @@ -14254,11 +14254,11 @@ 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 _iter636; - for (_iter636 = (*(this->part_vals)).begin(); _iter636 != (*(this->part_vals)).end(); ++_iter636) + std::map ::const_iterator _iter637; + for (_iter637 = (*(this->part_vals)).begin(); _iter637 != (*(this->part_vals)).end(); ++_iter637) { - xfer += oprot->writeString(_iter636->first); - xfer += oprot->writeString(_iter636->second); + xfer += oprot->writeString(_iter637->first); + xfer += oprot->writeString(_iter637->second); } xfer += oprot->writeMapEnd(); } @@ -14509,17 +14509,17 @@ if (ftype == ::apache::thrift::protocol::T_MAP) { { this->part_vals.clear(); - uint32_t _size637; - ::apache::thrift::protocol::TType _ktype638; - ::apache::thrift::protocol::TType _vtype639; - xfer += iprot->readMapBegin(_ktype638, _vtype639, _size637); - uint32_t _i641; - for (_i641 = 0; _i641 < _size637; ++_i641) + uint32_t _size638; + ::apache::thrift::protocol::TType _ktype639; + ::apache::thrift::protocol::TType _vtype640; + xfer += iprot->readMapBegin(_ktype639, _vtype640, _size638); + uint32_t _i642; + for (_i642 = 0; _i642 < _size638; ++_i642) { - std::string _key642; - xfer += iprot->readString(_key642); - std::string& _val643 = this->part_vals[_key642]; - xfer += iprot->readString(_val643); + std::string _key643; + xfer += iprot->readString(_key643); + std::string& _val644 = this->part_vals[_key643]; + xfer += iprot->readString(_val644); } xfer += iprot->readMapEnd(); } @@ -14530,9 +14530,9 @@ break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast644; - xfer += iprot->readI32(ecast644); - this->eventType = (PartitionEventType::type)ecast644; + int32_t ecast645; + xfer += iprot->readI32(ecast645); + this->eventType = (PartitionEventType::type)ecast645; this->__isset.eventType = true; } else { xfer += iprot->skip(ftype); @@ -14565,11 +14565,11 @@ 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 _iter645; - for (_iter645 = this->part_vals.begin(); _iter645 != this->part_vals.end(); ++_iter645) + std::map ::const_iterator _iter646; + for (_iter646 = this->part_vals.begin(); _iter646 != this->part_vals.end(); ++_iter646) { - xfer += oprot->writeString(_iter645->first); - xfer += oprot->writeString(_iter645->second); + xfer += oprot->writeString(_iter646->first); + xfer += oprot->writeString(_iter646->second); } xfer += oprot->writeMapEnd(); } @@ -14599,11 +14599,11 @@ 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 _iter646; - for (_iter646 = (*(this->part_vals)).begin(); _iter646 != (*(this->part_vals)).end(); ++_iter646) + std::map ::const_iterator _iter647; + for (_iter647 = (*(this->part_vals)).begin(); _iter647 != (*(this->part_vals)).end(); ++_iter647) { - xfer += oprot->writeString(_iter646->first); - xfer += oprot->writeString(_iter646->second); + xfer += oprot->writeString(_iter647->first); + xfer += oprot->writeString(_iter647->second); } xfer += oprot->writeMapEnd(); } @@ -15908,14 +15908,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size647; - ::apache::thrift::protocol::TType _etype650; - xfer += iprot->readListBegin(_etype650, _size647); - this->success.resize(_size647); - uint32_t _i651; - for (_i651 = 0; _i651 < _size647; ++_i651) + uint32_t _size648; + ::apache::thrift::protocol::TType _etype651; + xfer += iprot->readListBegin(_etype651, _size648); + this->success.resize(_size648); + uint32_t _i652; + for (_i652 = 0; _i652 < _size648; ++_i652) { - xfer += this->success[_i651].read(iprot); + xfer += this->success[_i652].read(iprot); } xfer += iprot->readListEnd(); } @@ -15962,10 +15962,10 @@ 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 _iter652; - for (_iter652 = this->success.begin(); _iter652 != this->success.end(); ++_iter652) + std::vector ::const_iterator _iter653; + for (_iter653 = this->success.begin(); _iter653 != this->success.end(); ++_iter653) { - xfer += (*_iter652).write(oprot); + xfer += (*_iter653).write(oprot); } xfer += oprot->writeListEnd(); } @@ -16008,14 +16008,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size653; - ::apache::thrift::protocol::TType _etype656; - xfer += iprot->readListBegin(_etype656, _size653); - (*(this->success)).resize(_size653); - uint32_t _i657; - for (_i657 = 0; _i657 < _size653; ++_i657) + uint32_t _size654; + ::apache::thrift::protocol::TType _etype657; + xfer += iprot->readListBegin(_etype657, _size654); + (*(this->success)).resize(_size654); + uint32_t _i658; + for (_i658 = 0; _i658 < _size654; ++_i658) { - xfer += (*(this->success))[_i657].read(iprot); + xfer += (*(this->success))[_i658].read(iprot); } xfer += iprot->readListEnd(); } @@ -16174,14 +16174,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size658; - ::apache::thrift::protocol::TType _etype661; - xfer += iprot->readListBegin(_etype661, _size658); - this->success.resize(_size658); - uint32_t _i662; - for (_i662 = 0; _i662 < _size658; ++_i662) + uint32_t _size659; + ::apache::thrift::protocol::TType _etype662; + xfer += iprot->readListBegin(_etype662, _size659); + this->success.resize(_size659); + uint32_t _i663; + for (_i663 = 0; _i663 < _size659; ++_i663) { - xfer += iprot->readString(this->success[_i662]); + xfer += iprot->readString(this->success[_i663]); } xfer += iprot->readListEnd(); } @@ -16220,10 +16220,10 @@ 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 _iter663; - for (_iter663 = this->success.begin(); _iter663 != this->success.end(); ++_iter663) + std::vector ::const_iterator _iter664; + for (_iter664 = this->success.begin(); _iter664 != this->success.end(); ++_iter664) { - xfer += oprot->writeString((*_iter663)); + xfer += oprot->writeString((*_iter664)); } xfer += oprot->writeListEnd(); } @@ -16262,14 +16262,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size664; - ::apache::thrift::protocol::TType _etype667; - xfer += iprot->readListBegin(_etype667, _size664); - (*(this->success)).resize(_size664); - uint32_t _i668; - for (_i668 = 0; _i668 < _size664; ++_i668) + uint32_t _size665; + ::apache::thrift::protocol::TType _etype668; + xfer += iprot->readListBegin(_etype668, _size665); + (*(this->success)).resize(_size665); + uint32_t _i669; + for (_i669 = 0; _i669 < _size665; ++_i669) { - xfer += iprot->readString((*(this->success))[_i668]); + xfer += iprot->readString((*(this->success))[_i669]); } xfer += iprot->readListEnd(); } @@ -18747,14 +18747,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size669; - ::apache::thrift::protocol::TType _etype672; - xfer += iprot->readListBegin(_etype672, _size669); - this->success.resize(_size669); - uint32_t _i673; - for (_i673 = 0; _i673 < _size669; ++_i673) + uint32_t _size670; + ::apache::thrift::protocol::TType _etype673; + xfer += iprot->readListBegin(_etype673, _size670); + this->success.resize(_size670); + uint32_t _i674; + for (_i674 = 0; _i674 < _size670; ++_i674) { - xfer += iprot->readString(this->success[_i673]); + xfer += iprot->readString(this->success[_i674]); } xfer += iprot->readListEnd(); } @@ -18793,10 +18793,10 @@ 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 _iter674; - for (_iter674 = this->success.begin(); _iter674 != this->success.end(); ++_iter674) + std::vector ::const_iterator _iter675; + for (_iter675 = this->success.begin(); _iter675 != this->success.end(); ++_iter675) { - xfer += oprot->writeString((*_iter674)); + xfer += oprot->writeString((*_iter675)); } xfer += oprot->writeListEnd(); } @@ -18835,14 +18835,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size675; - ::apache::thrift::protocol::TType _etype678; - xfer += iprot->readListBegin(_etype678, _size675); - (*(this->success)).resize(_size675); - uint32_t _i679; - for (_i679 = 0; _i679 < _size675; ++_i679) + uint32_t _size676; + ::apache::thrift::protocol::TType _etype679; + xfer += iprot->readListBegin(_etype679, _size676); + (*(this->success)).resize(_size676); + uint32_t _i680; + for (_i680 = 0; _i680 < _size676; ++_i680) { - xfer += iprot->readString((*(this->success))[_i679]); + xfer += iprot->readString((*(this->success))[_i680]); } xfer += iprot->readListEnd(); } @@ -18909,9 +18909,9 @@ break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast680; - xfer += iprot->readI32(ecast680); - this->principal_type = (PrincipalType::type)ecast680; + int32_t ecast681; + xfer += iprot->readI32(ecast681); + this->principal_type = (PrincipalType::type)ecast681; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -18927,9 +18927,9 @@ break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast681; - xfer += iprot->readI32(ecast681); - this->grantorType = (PrincipalType::type)ecast681; + int32_t ecast682; + xfer += iprot->readI32(ecast682); + this->grantorType = (PrincipalType::type)ecast682; this->__isset.grantorType = true; } else { xfer += iprot->skip(ftype); @@ -19175,9 +19175,9 @@ break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast682; - xfer += iprot->readI32(ecast682); - this->principal_type = (PrincipalType::type)ecast682; + int32_t ecast683; + xfer += iprot->readI32(ecast683); + this->principal_type = (PrincipalType::type)ecast683; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -19383,9 +19383,9 @@ break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast683; - xfer += iprot->readI32(ecast683); - this->principal_type = (PrincipalType::type)ecast683; + int32_t ecast684; + xfer += iprot->readI32(ecast684); + this->principal_type = (PrincipalType::type)ecast684; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -19461,14 +19461,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size684; - ::apache::thrift::protocol::TType _etype687; - xfer += iprot->readListBegin(_etype687, _size684); - this->success.resize(_size684); - uint32_t _i688; - for (_i688 = 0; _i688 < _size684; ++_i688) + uint32_t _size685; + ::apache::thrift::protocol::TType _etype688; + xfer += iprot->readListBegin(_etype688, _size685); + this->success.resize(_size685); + uint32_t _i689; + for (_i689 = 0; _i689 < _size685; ++_i689) { - xfer += this->success[_i688].read(iprot); + xfer += this->success[_i689].read(iprot); } xfer += iprot->readListEnd(); } @@ -19507,10 +19507,10 @@ 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 _iter689; - for (_iter689 = this->success.begin(); _iter689 != this->success.end(); ++_iter689) + std::vector ::const_iterator _iter690; + for (_iter690 = this->success.begin(); _iter690 != this->success.end(); ++_iter690) { - xfer += (*_iter689).write(oprot); + xfer += (*_iter690).write(oprot); } xfer += oprot->writeListEnd(); } @@ -19549,14 +19549,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size690; - ::apache::thrift::protocol::TType _etype693; - xfer += iprot->readListBegin(_etype693, _size690); - (*(this->success)).resize(_size690); - uint32_t _i694; - for (_i694 = 0; _i694 < _size690; ++_i694) + uint32_t _size691; + ::apache::thrift::protocol::TType _etype694; + xfer += iprot->readListBegin(_etype694, _size691); + (*(this->success)).resize(_size691); + uint32_t _i695; + for (_i695 = 0; _i695 < _size691; ++_i695) { - xfer += (*(this->success))[_i694].read(iprot); + xfer += (*(this->success))[_i695].read(iprot); } xfer += iprot->readListEnd(); } @@ -19625,14 +19625,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size695; - ::apache::thrift::protocol::TType _etype698; - xfer += iprot->readListBegin(_etype698, _size695); - this->group_names.resize(_size695); - uint32_t _i699; - for (_i699 = 0; _i699 < _size695; ++_i699) + uint32_t _size696; + ::apache::thrift::protocol::TType _etype699; + xfer += iprot->readListBegin(_etype699, _size696); + this->group_names.resize(_size696); + uint32_t _i700; + for (_i700 = 0; _i700 < _size696; ++_i700) { - xfer += iprot->readString(this->group_names[_i699]); + xfer += iprot->readString(this->group_names[_i700]); } xfer += iprot->readListEnd(); } @@ -19668,10 +19668,10 @@ 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 _iter700; - for (_iter700 = this->group_names.begin(); _iter700 != this->group_names.end(); ++_iter700) + std::vector ::const_iterator _iter701; + for (_iter701 = this->group_names.begin(); _iter701 != this->group_names.end(); ++_iter701) { - xfer += oprot->writeString((*_iter700)); + xfer += oprot->writeString((*_iter701)); } xfer += oprot->writeListEnd(); } @@ -19697,10 +19697,10 @@ 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 _iter701; - for (_iter701 = (*(this->group_names)).begin(); _iter701 != (*(this->group_names)).end(); ++_iter701) + std::vector ::const_iterator _iter702; + for (_iter702 = (*(this->group_names)).begin(); _iter702 != (*(this->group_names)).end(); ++_iter702) { - xfer += oprot->writeString((*_iter701)); + xfer += oprot->writeString((*_iter702)); } xfer += oprot->writeListEnd(); } @@ -19857,9 +19857,9 @@ break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast702; - xfer += iprot->readI32(ecast702); - this->principal_type = (PrincipalType::type)ecast702; + int32_t ecast703; + xfer += iprot->readI32(ecast703); + this->principal_type = (PrincipalType::type)ecast703; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -19951,14 +19951,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size703; - ::apache::thrift::protocol::TType _etype706; - xfer += iprot->readListBegin(_etype706, _size703); - this->success.resize(_size703); - uint32_t _i707; - for (_i707 = 0; _i707 < _size703; ++_i707) + uint32_t _size704; + ::apache::thrift::protocol::TType _etype707; + xfer += iprot->readListBegin(_etype707, _size704); + this->success.resize(_size704); + uint32_t _i708; + for (_i708 = 0; _i708 < _size704; ++_i708) { - xfer += this->success[_i707].read(iprot); + xfer += this->success[_i708].read(iprot); } xfer += iprot->readListEnd(); } @@ -19997,10 +19997,10 @@ 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 _iter708; - for (_iter708 = this->success.begin(); _iter708 != this->success.end(); ++_iter708) + std::vector ::const_iterator _iter709; + for (_iter709 = this->success.begin(); _iter709 != this->success.end(); ++_iter709) { - xfer += (*_iter708).write(oprot); + xfer += (*_iter709).write(oprot); } xfer += oprot->writeListEnd(); } @@ -20039,14 +20039,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size709; - ::apache::thrift::protocol::TType _etype712; - xfer += iprot->readListBegin(_etype712, _size709); - (*(this->success)).resize(_size709); - uint32_t _i713; - for (_i713 = 0; _i713 < _size709; ++_i713) + uint32_t _size710; + ::apache::thrift::protocol::TType _etype713; + xfer += iprot->readListBegin(_etype713, _size710); + (*(this->success)).resize(_size710); + uint32_t _i714; + for (_i714 = 0; _i714 < _size710; ++_i714) { - xfer += (*(this->success))[_i713].read(iprot); + xfer += (*(this->success))[_i714].read(iprot); } xfer += iprot->readListEnd(); } @@ -20471,14 +20471,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size714; - ::apache::thrift::protocol::TType _etype717; - xfer += iprot->readListBegin(_etype717, _size714); - this->group_names.resize(_size714); - uint32_t _i718; - for (_i718 = 0; _i718 < _size714; ++_i718) + uint32_t _size715; + ::apache::thrift::protocol::TType _etype718; + xfer += iprot->readListBegin(_etype718, _size715); + this->group_names.resize(_size715); + uint32_t _i719; + for (_i719 = 0; _i719 < _size715; ++_i719) { - xfer += iprot->readString(this->group_names[_i718]); + xfer += iprot->readString(this->group_names[_i719]); } xfer += iprot->readListEnd(); } @@ -20510,10 +20510,10 @@ 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 _iter719; - for (_iter719 = this->group_names.begin(); _iter719 != this->group_names.end(); ++_iter719) + std::vector ::const_iterator _iter720; + for (_iter720 = this->group_names.begin(); _iter720 != this->group_names.end(); ++_iter720) { - xfer += oprot->writeString((*_iter719)); + xfer += oprot->writeString((*_iter720)); } xfer += oprot->writeListEnd(); } @@ -20535,10 +20535,10 @@ 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 _iter720; - for (_iter720 = (*(this->group_names)).begin(); _iter720 != (*(this->group_names)).end(); ++_iter720) + std::vector ::const_iterator _iter721; + for (_iter721 = (*(this->group_names)).begin(); _iter721 != (*(this->group_names)).end(); ++_iter721) { - xfer += oprot->writeString((*_iter720)); + xfer += oprot->writeString((*_iter721)); } xfer += oprot->writeListEnd(); } @@ -20573,14 +20573,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size721; - ::apache::thrift::protocol::TType _etype724; - xfer += iprot->readListBegin(_etype724, _size721); - this->success.resize(_size721); - uint32_t _i725; - for (_i725 = 0; _i725 < _size721; ++_i725) + uint32_t _size722; + ::apache::thrift::protocol::TType _etype725; + xfer += iprot->readListBegin(_etype725, _size722); + this->success.resize(_size722); + uint32_t _i726; + for (_i726 = 0; _i726 < _size722; ++_i726) { - xfer += iprot->readString(this->success[_i725]); + xfer += iprot->readString(this->success[_i726]); } xfer += iprot->readListEnd(); } @@ -20619,10 +20619,10 @@ 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 _iter726; - for (_iter726 = this->success.begin(); _iter726 != this->success.end(); ++_iter726) + std::vector ::const_iterator _iter727; + for (_iter727 = this->success.begin(); _iter727 != this->success.end(); ++_iter727) { - xfer += oprot->writeString((*_iter726)); + xfer += oprot->writeString((*_iter727)); } xfer += oprot->writeListEnd(); } @@ -20661,14 +20661,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size727; - ::apache::thrift::protocol::TType _etype730; - xfer += iprot->readListBegin(_etype730, _size727); - (*(this->success)).resize(_size727); - uint32_t _i731; - for (_i731 = 0; _i731 < _size727; ++_i731) + uint32_t _size728; + ::apache::thrift::protocol::TType _etype731; + xfer += iprot->readListBegin(_etype731, _size728); + (*(this->success)).resize(_size728); + uint32_t _i732; + for (_i732 = 0; _i732 < _size728; ++_i732) { - xfer += iprot->readString((*(this->success))[_i731]); + xfer += iprot->readString((*(this->success))[_i732]); } xfer += iprot->readListEnd(); } Index: metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp =================================================================== --- metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp (revision 1568537) +++ metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp (working copy) @@ -1148,8 +1148,8 @@ swap(a.__isset, b.__isset); } -const char* Database::ascii_fingerprint = "213967572143E49C9F1A23F7A866E2F5"; -const uint8_t Database::binary_fingerprint[16] = {0x21,0x39,0x67,0x57,0x21,0x43,0xE4,0x9C,0x9F,0x1A,0x23,0xF7,0xA8,0x66,0xE2,0xF5}; +const char* Database::ascii_fingerprint = "553495CAE243A1C583D5C3DD990AED53"; +const uint8_t Database::binary_fingerprint[16] = {0x55,0x34,0x95,0xCA,0xE2,0x43,0xA1,0xC5,0x83,0xD5,0xC3,0xDD,0x99,0x0A,0xED,0x53}; uint32_t Database::read(::apache::thrift::protocol::TProtocol* iprot) { @@ -1226,6 +1226,24 @@ xfer += iprot->skip(ftype); } break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->ownerName); + this->__isset.ownerName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast70; + xfer += iprot->readI32(ecast70); + this->ownerType = (PrincipalType::type)ecast70; + this->__isset.ownerType = true; + } else { + xfer += iprot->skip(ftype); + } + break; default: xfer += iprot->skip(ftype); break; @@ -1257,11 +1275,11 @@ 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 _iter70; - for (_iter70 = this->parameters.begin(); _iter70 != this->parameters.end(); ++_iter70) + std::map ::const_iterator _iter71; + for (_iter71 = this->parameters.begin(); _iter71 != this->parameters.end(); ++_iter71) { - xfer += oprot->writeString(_iter70->first); - xfer += oprot->writeString(_iter70->second); + xfer += oprot->writeString(_iter71->first); + xfer += oprot->writeString(_iter71->second); } xfer += oprot->writeMapEnd(); } @@ -1272,6 +1290,16 @@ xfer += this->privileges.write(oprot); xfer += oprot->writeFieldEnd(); } + if (this->__isset.ownerName) { + xfer += oprot->writeFieldBegin("ownerName", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->ownerName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.ownerType) { + xfer += oprot->writeFieldBegin("ownerType", ::apache::thrift::protocol::T_I32, 7); + xfer += oprot->writeI32((int32_t)this->ownerType); + xfer += oprot->writeFieldEnd(); + } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; @@ -1284,6 +1312,8 @@ swap(a.locationUri, b.locationUri); swap(a.parameters, b.parameters); swap(a.privileges, b.privileges); + swap(a.ownerName, b.ownerName); + swap(a.ownerType, b.ownerType); swap(a.__isset, b.__isset); } @@ -1330,17 +1360,17 @@ if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size71; - ::apache::thrift::protocol::TType _ktype72; - ::apache::thrift::protocol::TType _vtype73; - xfer += iprot->readMapBegin(_ktype72, _vtype73, _size71); - uint32_t _i75; - for (_i75 = 0; _i75 < _size71; ++_i75) + uint32_t _size72; + ::apache::thrift::protocol::TType _ktype73; + ::apache::thrift::protocol::TType _vtype74; + xfer += iprot->readMapBegin(_ktype73, _vtype74, _size72); + uint32_t _i76; + for (_i76 = 0; _i76 < _size72; ++_i76) { - std::string _key76; - xfer += iprot->readString(_key76); - std::string& _val77 = this->parameters[_key76]; - xfer += iprot->readString(_val77); + std::string _key77; + xfer += iprot->readString(_key77); + std::string& _val78 = this->parameters[_key77]; + xfer += iprot->readString(_val78); } xfer += iprot->readMapEnd(); } @@ -1376,11 +1406,11 @@ 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 _iter78; - for (_iter78 = this->parameters.begin(); _iter78 != this->parameters.end(); ++_iter78) + std::map ::const_iterator _iter79; + for (_iter79 = this->parameters.begin(); _iter79 != this->parameters.end(); ++_iter79) { - xfer += oprot->writeString(_iter78->first); - xfer += oprot->writeString(_iter78->second); + xfer += oprot->writeString(_iter79->first); + xfer += oprot->writeString(_iter79->second); } xfer += oprot->writeMapEnd(); } @@ -1501,14 +1531,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->skewedColNames.clear(); - uint32_t _size79; - ::apache::thrift::protocol::TType _etype82; - xfer += iprot->readListBegin(_etype82, _size79); - this->skewedColNames.resize(_size79); - uint32_t _i83; - for (_i83 = 0; _i83 < _size79; ++_i83) + uint32_t _size80; + ::apache::thrift::protocol::TType _etype83; + xfer += iprot->readListBegin(_etype83, _size80); + this->skewedColNames.resize(_size80); + uint32_t _i84; + for (_i84 = 0; _i84 < _size80; ++_i84) { - xfer += iprot->readString(this->skewedColNames[_i83]); + xfer += iprot->readString(this->skewedColNames[_i84]); } xfer += iprot->readListEnd(); } @@ -1521,23 +1551,23 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->skewedColValues.clear(); - uint32_t _size84; - ::apache::thrift::protocol::TType _etype87; - xfer += iprot->readListBegin(_etype87, _size84); - this->skewedColValues.resize(_size84); - uint32_t _i88; - for (_i88 = 0; _i88 < _size84; ++_i88) + uint32_t _size85; + ::apache::thrift::protocol::TType _etype88; + xfer += iprot->readListBegin(_etype88, _size85); + this->skewedColValues.resize(_size85); + uint32_t _i89; + for (_i89 = 0; _i89 < _size85; ++_i89) { { - this->skewedColValues[_i88].clear(); - uint32_t _size89; - ::apache::thrift::protocol::TType _etype92; - xfer += iprot->readListBegin(_etype92, _size89); - this->skewedColValues[_i88].resize(_size89); - uint32_t _i93; - for (_i93 = 0; _i93 < _size89; ++_i93) + this->skewedColValues[_i89].clear(); + uint32_t _size90; + ::apache::thrift::protocol::TType _etype93; + xfer += iprot->readListBegin(_etype93, _size90); + this->skewedColValues[_i89].resize(_size90); + uint32_t _i94; + for (_i94 = 0; _i94 < _size90; ++_i94) { - xfer += iprot->readString(this->skewedColValues[_i88][_i93]); + xfer += iprot->readString(this->skewedColValues[_i89][_i94]); } xfer += iprot->readListEnd(); } @@ -1553,29 +1583,29 @@ if (ftype == ::apache::thrift::protocol::T_MAP) { { this->skewedColValueLocationMaps.clear(); - uint32_t _size94; - ::apache::thrift::protocol::TType _ktype95; - ::apache::thrift::protocol::TType _vtype96; - xfer += iprot->readMapBegin(_ktype95, _vtype96, _size94); - uint32_t _i98; - for (_i98 = 0; _i98 < _size94; ++_i98) + uint32_t _size95; + ::apache::thrift::protocol::TType _ktype96; + ::apache::thrift::protocol::TType _vtype97; + xfer += iprot->readMapBegin(_ktype96, _vtype97, _size95); + uint32_t _i99; + for (_i99 = 0; _i99 < _size95; ++_i99) { - std::vector _key99; + std::vector _key100; { - _key99.clear(); - uint32_t _size101; - ::apache::thrift::protocol::TType _etype104; - xfer += iprot->readListBegin(_etype104, _size101); - _key99.resize(_size101); - uint32_t _i105; - for (_i105 = 0; _i105 < _size101; ++_i105) + _key100.clear(); + uint32_t _size102; + ::apache::thrift::protocol::TType _etype105; + xfer += iprot->readListBegin(_etype105, _size102); + _key100.resize(_size102); + uint32_t _i106; + for (_i106 = 0; _i106 < _size102; ++_i106) { - xfer += iprot->readString(_key99[_i105]); + xfer += iprot->readString(_key100[_i106]); } xfer += iprot->readListEnd(); } - std::string& _val100 = this->skewedColValueLocationMaps[_key99]; - xfer += iprot->readString(_val100); + std::string& _val101 = this->skewedColValueLocationMaps[_key100]; + xfer += iprot->readString(_val101); } xfer += iprot->readMapEnd(); } @@ -1603,10 +1633,10 @@ 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 _iter106; - for (_iter106 = this->skewedColNames.begin(); _iter106 != this->skewedColNames.end(); ++_iter106) + std::vector ::const_iterator _iter107; + for (_iter107 = this->skewedColNames.begin(); _iter107 != this->skewedColNames.end(); ++_iter107) { - xfer += oprot->writeString((*_iter106)); + xfer += oprot->writeString((*_iter107)); } xfer += oprot->writeListEnd(); } @@ -1615,15 +1645,15 @@ 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 _iter107; - for (_iter107 = this->skewedColValues.begin(); _iter107 != this->skewedColValues.end(); ++_iter107) + std::vector > ::const_iterator _iter108; + for (_iter108 = this->skewedColValues.begin(); _iter108 != this->skewedColValues.end(); ++_iter108) { { - xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*_iter107).size())); - std::vector ::const_iterator _iter108; - for (_iter108 = (*_iter107).begin(); _iter108 != (*_iter107).end(); ++_iter108) + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*_iter108).size())); + std::vector ::const_iterator _iter109; + for (_iter109 = (*_iter108).begin(); _iter109 != (*_iter108).end(); ++_iter109) { - xfer += oprot->writeString((*_iter108)); + xfer += oprot->writeString((*_iter109)); } xfer += oprot->writeListEnd(); } @@ -1635,19 +1665,19 @@ 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 _iter109; - for (_iter109 = this->skewedColValueLocationMaps.begin(); _iter109 != this->skewedColValueLocationMaps.end(); ++_iter109) + std::map , std::string> ::const_iterator _iter110; + for (_iter110 = this->skewedColValueLocationMaps.begin(); _iter110 != this->skewedColValueLocationMaps.end(); ++_iter110) { { - xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(_iter109->first.size())); - std::vector ::const_iterator _iter110; - for (_iter110 = _iter109->first.begin(); _iter110 != _iter109->first.end(); ++_iter110) + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(_iter110->first.size())); + std::vector ::const_iterator _iter111; + for (_iter111 = _iter110->first.begin(); _iter111 != _iter110->first.end(); ++_iter111) { - xfer += oprot->writeString((*_iter110)); + xfer += oprot->writeString((*_iter111)); } xfer += oprot->writeListEnd(); } - xfer += oprot->writeString(_iter109->second); + xfer += oprot->writeString(_iter110->second); } xfer += oprot->writeMapEnd(); } @@ -1693,14 +1723,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->cols.clear(); - uint32_t _size111; - ::apache::thrift::protocol::TType _etype114; - xfer += iprot->readListBegin(_etype114, _size111); - this->cols.resize(_size111); - uint32_t _i115; - for (_i115 = 0; _i115 < _size111; ++_i115) + uint32_t _size112; + ::apache::thrift::protocol::TType _etype115; + xfer += iprot->readListBegin(_etype115, _size112); + this->cols.resize(_size112); + uint32_t _i116; + for (_i116 = 0; _i116 < _size112; ++_i116) { - xfer += this->cols[_i115].read(iprot); + xfer += this->cols[_i116].read(iprot); } xfer += iprot->readListEnd(); } @@ -1761,14 +1791,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->bucketCols.clear(); - uint32_t _size116; - ::apache::thrift::protocol::TType _etype119; - xfer += iprot->readListBegin(_etype119, _size116); - this->bucketCols.resize(_size116); - uint32_t _i120; - for (_i120 = 0; _i120 < _size116; ++_i120) + uint32_t _size117; + ::apache::thrift::protocol::TType _etype120; + xfer += iprot->readListBegin(_etype120, _size117); + this->bucketCols.resize(_size117); + uint32_t _i121; + for (_i121 = 0; _i121 < _size117; ++_i121) { - xfer += iprot->readString(this->bucketCols[_i120]); + xfer += iprot->readString(this->bucketCols[_i121]); } xfer += iprot->readListEnd(); } @@ -1781,14 +1811,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->sortCols.clear(); - uint32_t _size121; - ::apache::thrift::protocol::TType _etype124; - xfer += iprot->readListBegin(_etype124, _size121); - this->sortCols.resize(_size121); - uint32_t _i125; - for (_i125 = 0; _i125 < _size121; ++_i125) + uint32_t _size122; + ::apache::thrift::protocol::TType _etype125; + xfer += iprot->readListBegin(_etype125, _size122); + this->sortCols.resize(_size122); + uint32_t _i126; + for (_i126 = 0; _i126 < _size122; ++_i126) { - xfer += this->sortCols[_i125].read(iprot); + xfer += this->sortCols[_i126].read(iprot); } xfer += iprot->readListEnd(); } @@ -1801,17 +1831,17 @@ if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size126; - ::apache::thrift::protocol::TType _ktype127; - ::apache::thrift::protocol::TType _vtype128; - xfer += iprot->readMapBegin(_ktype127, _vtype128, _size126); - uint32_t _i130; - for (_i130 = 0; _i130 < _size126; ++_i130) + uint32_t _size127; + ::apache::thrift::protocol::TType _ktype128; + ::apache::thrift::protocol::TType _vtype129; + xfer += iprot->readMapBegin(_ktype128, _vtype129, _size127); + uint32_t _i131; + for (_i131 = 0; _i131 < _size127; ++_i131) { - std::string _key131; - xfer += iprot->readString(_key131); - std::string& _val132 = this->parameters[_key131]; - xfer += iprot->readString(_val132); + std::string _key132; + xfer += iprot->readString(_key132); + std::string& _val133 = this->parameters[_key132]; + xfer += iprot->readString(_val133); } xfer += iprot->readMapEnd(); } @@ -1855,10 +1885,10 @@ 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 _iter133; - for (_iter133 = this->cols.begin(); _iter133 != this->cols.end(); ++_iter133) + std::vector ::const_iterator _iter134; + for (_iter134 = this->cols.begin(); _iter134 != this->cols.end(); ++_iter134) { - xfer += (*_iter133).write(oprot); + xfer += (*_iter134).write(oprot); } xfer += oprot->writeListEnd(); } @@ -1891,10 +1921,10 @@ 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 _iter134; - for (_iter134 = this->bucketCols.begin(); _iter134 != this->bucketCols.end(); ++_iter134) + std::vector ::const_iterator _iter135; + for (_iter135 = this->bucketCols.begin(); _iter135 != this->bucketCols.end(); ++_iter135) { - xfer += oprot->writeString((*_iter134)); + xfer += oprot->writeString((*_iter135)); } xfer += oprot->writeListEnd(); } @@ -1903,10 +1933,10 @@ 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 _iter135; - for (_iter135 = this->sortCols.begin(); _iter135 != this->sortCols.end(); ++_iter135) + std::vector ::const_iterator _iter136; + for (_iter136 = this->sortCols.begin(); _iter136 != this->sortCols.end(); ++_iter136) { - xfer += (*_iter135).write(oprot); + xfer += (*_iter136).write(oprot); } xfer += oprot->writeListEnd(); } @@ -1915,11 +1945,11 @@ 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 _iter136; - for (_iter136 = this->parameters.begin(); _iter136 != this->parameters.end(); ++_iter136) + std::map ::const_iterator _iter137; + for (_iter137 = this->parameters.begin(); _iter137 != this->parameters.end(); ++_iter137) { - xfer += oprot->writeString(_iter136->first); - xfer += oprot->writeString(_iter136->second); + xfer += oprot->writeString(_iter137->first); + xfer += oprot->writeString(_iter137->second); } xfer += oprot->writeMapEnd(); } @@ -2040,14 +2070,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionKeys.clear(); - uint32_t _size137; - ::apache::thrift::protocol::TType _etype140; - xfer += iprot->readListBegin(_etype140, _size137); - this->partitionKeys.resize(_size137); - uint32_t _i141; - for (_i141 = 0; _i141 < _size137; ++_i141) + uint32_t _size138; + ::apache::thrift::protocol::TType _etype141; + xfer += iprot->readListBegin(_etype141, _size138); + this->partitionKeys.resize(_size138); + uint32_t _i142; + for (_i142 = 0; _i142 < _size138; ++_i142) { - xfer += this->partitionKeys[_i141].read(iprot); + xfer += this->partitionKeys[_i142].read(iprot); } xfer += iprot->readListEnd(); } @@ -2060,17 +2090,17 @@ if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size142; - ::apache::thrift::protocol::TType _ktype143; - ::apache::thrift::protocol::TType _vtype144; - xfer += iprot->readMapBegin(_ktype143, _vtype144, _size142); - uint32_t _i146; - for (_i146 = 0; _i146 < _size142; ++_i146) + uint32_t _size143; + ::apache::thrift::protocol::TType _ktype144; + ::apache::thrift::protocol::TType _vtype145; + xfer += iprot->readMapBegin(_ktype144, _vtype145, _size143); + uint32_t _i147; + for (_i147 = 0; _i147 < _size143; ++_i147) { - std::string _key147; - xfer += iprot->readString(_key147); - std::string& _val148 = this->parameters[_key147]; - xfer += iprot->readString(_val148); + std::string _key148; + xfer += iprot->readString(_key148); + std::string& _val149 = this->parameters[_key148]; + xfer += iprot->readString(_val149); } xfer += iprot->readMapEnd(); } @@ -2158,10 +2188,10 @@ 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 _iter149; - for (_iter149 = this->partitionKeys.begin(); _iter149 != this->partitionKeys.end(); ++_iter149) + std::vector ::const_iterator _iter150; + for (_iter150 = this->partitionKeys.begin(); _iter150 != this->partitionKeys.end(); ++_iter150) { - xfer += (*_iter149).write(oprot); + xfer += (*_iter150).write(oprot); } xfer += oprot->writeListEnd(); } @@ -2170,11 +2200,11 @@ 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 _iter150; - for (_iter150 = this->parameters.begin(); _iter150 != this->parameters.end(); ++_iter150) + std::map ::const_iterator _iter151; + for (_iter151 = this->parameters.begin(); _iter151 != this->parameters.end(); ++_iter151) { - xfer += oprot->writeString(_iter150->first); - xfer += oprot->writeString(_iter150->second); + xfer += oprot->writeString(_iter151->first); + xfer += oprot->writeString(_iter151->second); } xfer += oprot->writeMapEnd(); } @@ -2247,14 +2277,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->values.clear(); - uint32_t _size151; - ::apache::thrift::protocol::TType _etype154; - xfer += iprot->readListBegin(_etype154, _size151); - this->values.resize(_size151); - uint32_t _i155; - for (_i155 = 0; _i155 < _size151; ++_i155) + uint32_t _size152; + ::apache::thrift::protocol::TType _etype155; + xfer += iprot->readListBegin(_etype155, _size152); + this->values.resize(_size152); + uint32_t _i156; + for (_i156 = 0; _i156 < _size152; ++_i156) { - xfer += iprot->readString(this->values[_i155]); + xfer += iprot->readString(this->values[_i156]); } xfer += iprot->readListEnd(); } @@ -2307,17 +2337,17 @@ if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size156; - ::apache::thrift::protocol::TType _ktype157; - ::apache::thrift::protocol::TType _vtype158; - xfer += iprot->readMapBegin(_ktype157, _vtype158, _size156); - uint32_t _i160; - for (_i160 = 0; _i160 < _size156; ++_i160) + uint32_t _size157; + ::apache::thrift::protocol::TType _ktype158; + ::apache::thrift::protocol::TType _vtype159; + xfer += iprot->readMapBegin(_ktype158, _vtype159, _size157); + uint32_t _i161; + for (_i161 = 0; _i161 < _size157; ++_i161) { - std::string _key161; - xfer += iprot->readString(_key161); - std::string& _val162 = this->parameters[_key161]; - xfer += iprot->readString(_val162); + std::string _key162; + xfer += iprot->readString(_key162); + std::string& _val163 = this->parameters[_key162]; + xfer += iprot->readString(_val163); } xfer += iprot->readMapEnd(); } @@ -2353,10 +2383,10 @@ 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 _iter163; - for (_iter163 = this->values.begin(); _iter163 != this->values.end(); ++_iter163) + std::vector ::const_iterator _iter164; + for (_iter164 = this->values.begin(); _iter164 != this->values.end(); ++_iter164) { - xfer += oprot->writeString((*_iter163)); + xfer += oprot->writeString((*_iter164)); } xfer += oprot->writeListEnd(); } @@ -2385,11 +2415,11 @@ 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 _iter164; - for (_iter164 = this->parameters.begin(); _iter164 != this->parameters.end(); ++_iter164) + std::map ::const_iterator _iter165; + for (_iter165 = this->parameters.begin(); _iter165 != this->parameters.end(); ++_iter165) { - xfer += oprot->writeString(_iter164->first); - xfer += oprot->writeString(_iter164->second); + xfer += oprot->writeString(_iter165->first); + xfer += oprot->writeString(_iter165->second); } xfer += oprot->writeMapEnd(); } @@ -2509,17 +2539,17 @@ if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size165; - ::apache::thrift::protocol::TType _ktype166; - ::apache::thrift::protocol::TType _vtype167; - xfer += iprot->readMapBegin(_ktype166, _vtype167, _size165); - uint32_t _i169; - for (_i169 = 0; _i169 < _size165; ++_i169) + uint32_t _size166; + ::apache::thrift::protocol::TType _ktype167; + ::apache::thrift::protocol::TType _vtype168; + xfer += iprot->readMapBegin(_ktype167, _vtype168, _size166); + uint32_t _i170; + for (_i170 = 0; _i170 < _size166; ++_i170) { - std::string _key170; - xfer += iprot->readString(_key170); - std::string& _val171 = this->parameters[_key170]; - xfer += iprot->readString(_val171); + std::string _key171; + xfer += iprot->readString(_key171); + std::string& _val172 = this->parameters[_key171]; + xfer += iprot->readString(_val172); } xfer += iprot->readMapEnd(); } @@ -2587,11 +2617,11 @@ 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 _iter172; - for (_iter172 = this->parameters.begin(); _iter172 != this->parameters.end(); ++_iter172) + std::map ::const_iterator _iter173; + for (_iter173 = this->parameters.begin(); _iter173 != this->parameters.end(); ++_iter173) { - xfer += oprot->writeString(_iter172->first); - xfer += oprot->writeString(_iter172->second); + xfer += oprot->writeString(_iter173->first); + xfer += oprot->writeString(_iter173->second); } xfer += oprot->writeMapEnd(); } @@ -3521,14 +3551,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->statsObj.clear(); - uint32_t _size173; - ::apache::thrift::protocol::TType _etype176; - xfer += iprot->readListBegin(_etype176, _size173); - this->statsObj.resize(_size173); - uint32_t _i177; - for (_i177 = 0; _i177 < _size173; ++_i177) + uint32_t _size174; + ::apache::thrift::protocol::TType _etype177; + xfer += iprot->readListBegin(_etype177, _size174); + this->statsObj.resize(_size174); + uint32_t _i178; + for (_i178 = 0; _i178 < _size174; ++_i178) { - xfer += this->statsObj[_i177].read(iprot); + xfer += this->statsObj[_i178].read(iprot); } xfer += iprot->readListEnd(); } @@ -3564,10 +3594,10 @@ 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 _iter178; - for (_iter178 = this->statsObj.begin(); _iter178 != this->statsObj.end(); ++_iter178) + std::vector ::const_iterator _iter179; + for (_iter179 = this->statsObj.begin(); _iter179 != this->statsObj.end(); ++_iter179) { - xfer += (*_iter178).write(oprot); + xfer += (*_iter179).write(oprot); } xfer += oprot->writeListEnd(); } @@ -3611,14 +3641,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fieldSchemas.clear(); - uint32_t _size179; - ::apache::thrift::protocol::TType _etype182; - xfer += iprot->readListBegin(_etype182, _size179); - this->fieldSchemas.resize(_size179); - uint32_t _i183; - for (_i183 = 0; _i183 < _size179; ++_i183) + uint32_t _size180; + ::apache::thrift::protocol::TType _etype183; + xfer += iprot->readListBegin(_etype183, _size180); + this->fieldSchemas.resize(_size180); + uint32_t _i184; + for (_i184 = 0; _i184 < _size180; ++_i184) { - xfer += this->fieldSchemas[_i183].read(iprot); + xfer += this->fieldSchemas[_i184].read(iprot); } xfer += iprot->readListEnd(); } @@ -3631,17 +3661,17 @@ if (ftype == ::apache::thrift::protocol::T_MAP) { { this->properties.clear(); - uint32_t _size184; - ::apache::thrift::protocol::TType _ktype185; - ::apache::thrift::protocol::TType _vtype186; - xfer += iprot->readMapBegin(_ktype185, _vtype186, _size184); - uint32_t _i188; - for (_i188 = 0; _i188 < _size184; ++_i188) + uint32_t _size185; + ::apache::thrift::protocol::TType _ktype186; + ::apache::thrift::protocol::TType _vtype187; + xfer += iprot->readMapBegin(_ktype186, _vtype187, _size185); + uint32_t _i189; + for (_i189 = 0; _i189 < _size185; ++_i189) { - std::string _key189; - xfer += iprot->readString(_key189); - std::string& _val190 = this->properties[_key189]; - xfer += iprot->readString(_val190); + std::string _key190; + xfer += iprot->readString(_key190); + std::string& _val191 = this->properties[_key190]; + xfer += iprot->readString(_val191); } xfer += iprot->readMapEnd(); } @@ -3669,10 +3699,10 @@ 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 _iter191; - for (_iter191 = this->fieldSchemas.begin(); _iter191 != this->fieldSchemas.end(); ++_iter191) + std::vector ::const_iterator _iter192; + for (_iter192 = this->fieldSchemas.begin(); _iter192 != this->fieldSchemas.end(); ++_iter192) { - xfer += (*_iter191).write(oprot); + xfer += (*_iter192).write(oprot); } xfer += oprot->writeListEnd(); } @@ -3681,11 +3711,11 @@ 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 _iter192; - for (_iter192 = this->properties.begin(); _iter192 != this->properties.end(); ++_iter192) + std::map ::const_iterator _iter193; + for (_iter193 = this->properties.begin(); _iter193 != this->properties.end(); ++_iter193) { - xfer += oprot->writeString(_iter192->first); - xfer += oprot->writeString(_iter192->second); + xfer += oprot->writeString(_iter193->first); + xfer += oprot->writeString(_iter193->second); } xfer += oprot->writeMapEnd(); } @@ -3730,17 +3760,17 @@ if (ftype == ::apache::thrift::protocol::T_MAP) { { this->properties.clear(); - uint32_t _size193; - ::apache::thrift::protocol::TType _ktype194; - ::apache::thrift::protocol::TType _vtype195; - xfer += iprot->readMapBegin(_ktype194, _vtype195, _size193); - uint32_t _i197; - for (_i197 = 0; _i197 < _size193; ++_i197) + uint32_t _size194; + ::apache::thrift::protocol::TType _ktype195; + ::apache::thrift::protocol::TType _vtype196; + xfer += iprot->readMapBegin(_ktype195, _vtype196, _size194); + uint32_t _i198; + for (_i198 = 0; _i198 < _size194; ++_i198) { - std::string _key198; - xfer += iprot->readString(_key198); - std::string& _val199 = this->properties[_key198]; - xfer += iprot->readString(_val199); + std::string _key199; + xfer += iprot->readString(_key199); + std::string& _val200 = this->properties[_key199]; + xfer += iprot->readString(_val200); } xfer += iprot->readMapEnd(); } @@ -3768,11 +3798,11 @@ 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 _iter200; - for (_iter200 = this->properties.begin(); _iter200 != this->properties.end(); ++_iter200) + std::map ::const_iterator _iter201; + for (_iter201 = this->properties.begin(); _iter201 != this->properties.end(); ++_iter201) { - xfer += oprot->writeString(_iter200->first); - xfer += oprot->writeString(_iter200->second); + xfer += oprot->writeString(_iter201->first); + xfer += oprot->writeString(_iter201->second); } xfer += oprot->writeMapEnd(); } @@ -3818,14 +3848,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size201; - ::apache::thrift::protocol::TType _etype204; - xfer += iprot->readListBegin(_etype204, _size201); - this->partitions.resize(_size201); - uint32_t _i205; - for (_i205 = 0; _i205 < _size201; ++_i205) + uint32_t _size202; + ::apache::thrift::protocol::TType _etype205; + xfer += iprot->readListBegin(_etype205, _size202); + this->partitions.resize(_size202); + uint32_t _i206; + for (_i206 = 0; _i206 < _size202; ++_i206) { - xfer += this->partitions[_i205].read(iprot); + xfer += this->partitions[_i206].read(iprot); } xfer += iprot->readListEnd(); } @@ -3865,10 +3895,10 @@ 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 _iter206; - for (_iter206 = this->partitions.begin(); _iter206 != this->partitions.end(); ++_iter206) + std::vector ::const_iterator _iter207; + for (_iter207 = this->partitions.begin(); _iter207 != this->partitions.end(); ++_iter207) { - xfer += (*_iter206).write(oprot); + xfer += (*_iter207).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4042,14 +4072,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tableStats.clear(); - uint32_t _size207; - ::apache::thrift::protocol::TType _etype210; - xfer += iprot->readListBegin(_etype210, _size207); - this->tableStats.resize(_size207); - uint32_t _i211; - for (_i211 = 0; _i211 < _size207; ++_i211) + uint32_t _size208; + ::apache::thrift::protocol::TType _etype211; + xfer += iprot->readListBegin(_etype211, _size208); + this->tableStats.resize(_size208); + uint32_t _i212; + for (_i212 = 0; _i212 < _size208; ++_i212) { - xfer += this->tableStats[_i211].read(iprot); + xfer += this->tableStats[_i212].read(iprot); } xfer += iprot->readListEnd(); } @@ -4079,10 +4109,10 @@ 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 _iter212; - for (_iter212 = this->tableStats.begin(); _iter212 != this->tableStats.end(); ++_iter212) + std::vector ::const_iterator _iter213; + for (_iter213 = this->tableStats.begin(); _iter213 != this->tableStats.end(); ++_iter213) { - xfer += (*_iter212).write(oprot); + xfer += (*_iter213).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4126,26 +4156,26 @@ if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partStats.clear(); - uint32_t _size213; - ::apache::thrift::protocol::TType _ktype214; - ::apache::thrift::protocol::TType _vtype215; - xfer += iprot->readMapBegin(_ktype214, _vtype215, _size213); - uint32_t _i217; - for (_i217 = 0; _i217 < _size213; ++_i217) + uint32_t _size214; + ::apache::thrift::protocol::TType _ktype215; + ::apache::thrift::protocol::TType _vtype216; + xfer += iprot->readMapBegin(_ktype215, _vtype216, _size214); + uint32_t _i218; + for (_i218 = 0; _i218 < _size214; ++_i218) { - std::string _key218; - xfer += iprot->readString(_key218); - std::vector & _val219 = this->partStats[_key218]; + std::string _key219; + xfer += iprot->readString(_key219); + std::vector & _val220 = this->partStats[_key219]; { - _val219.clear(); - uint32_t _size220; - ::apache::thrift::protocol::TType _etype223; - xfer += iprot->readListBegin(_etype223, _size220); - _val219.resize(_size220); - uint32_t _i224; - for (_i224 = 0; _i224 < _size220; ++_i224) + _val220.clear(); + uint32_t _size221; + ::apache::thrift::protocol::TType _etype224; + xfer += iprot->readListBegin(_etype224, _size221); + _val220.resize(_size221); + uint32_t _i225; + for (_i225 = 0; _i225 < _size221; ++_i225) { - xfer += _val219[_i224].read(iprot); + xfer += _val220[_i225].read(iprot); } xfer += iprot->readListEnd(); } @@ -4178,16 +4208,16 @@ 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 _iter225; - for (_iter225 = this->partStats.begin(); _iter225 != this->partStats.end(); ++_iter225) + std::map > ::const_iterator _iter226; + for (_iter226 = this->partStats.begin(); _iter226 != this->partStats.end(); ++_iter226) { - xfer += oprot->writeString(_iter225->first); + xfer += oprot->writeString(_iter226->first); { - xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(_iter225->second.size())); - std::vector ::const_iterator _iter226; - for (_iter226 = _iter225->second.begin(); _iter226 != _iter225->second.end(); ++_iter226) + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(_iter226->second.size())); + std::vector ::const_iterator _iter227; + for (_iter227 = _iter226->second.begin(); _iter227 != _iter226->second.end(); ++_iter227) { - xfer += (*_iter226).write(oprot); + xfer += (*_iter227).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4252,14 +4282,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->colNames.clear(); - uint32_t _size227; - ::apache::thrift::protocol::TType _etype230; - xfer += iprot->readListBegin(_etype230, _size227); - this->colNames.resize(_size227); - uint32_t _i231; - for (_i231 = 0; _i231 < _size227; ++_i231) + uint32_t _size228; + ::apache::thrift::protocol::TType _etype231; + xfer += iprot->readListBegin(_etype231, _size228); + this->colNames.resize(_size228); + uint32_t _i232; + for (_i232 = 0; _i232 < _size228; ++_i232) { - xfer += iprot->readString(this->colNames[_i231]); + xfer += iprot->readString(this->colNames[_i232]); } xfer += iprot->readListEnd(); } @@ -4301,10 +4331,10 @@ 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 _iter232; - for (_iter232 = this->colNames.begin(); _iter232 != this->colNames.end(); ++_iter232) + std::vector ::const_iterator _iter233; + for (_iter233 = this->colNames.begin(); _iter233 != this->colNames.end(); ++_iter233) { - xfer += oprot->writeString((*_iter232)); + xfer += oprot->writeString((*_iter233)); } xfer += oprot->writeListEnd(); } @@ -4369,14 +4399,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->colNames.clear(); - uint32_t _size233; - ::apache::thrift::protocol::TType _etype236; - xfer += iprot->readListBegin(_etype236, _size233); - this->colNames.resize(_size233); - uint32_t _i237; - for (_i237 = 0; _i237 < _size233; ++_i237) + uint32_t _size234; + ::apache::thrift::protocol::TType _etype237; + xfer += iprot->readListBegin(_etype237, _size234); + this->colNames.resize(_size234); + uint32_t _i238; + for (_i238 = 0; _i238 < _size234; ++_i238) { - xfer += iprot->readString(this->colNames[_i237]); + xfer += iprot->readString(this->colNames[_i238]); } xfer += iprot->readListEnd(); } @@ -4389,14 +4419,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partNames.clear(); - uint32_t _size238; - ::apache::thrift::protocol::TType _etype241; - xfer += iprot->readListBegin(_etype241, _size238); - this->partNames.resize(_size238); - uint32_t _i242; - for (_i242 = 0; _i242 < _size238; ++_i242) + uint32_t _size239; + ::apache::thrift::protocol::TType _etype242; + xfer += iprot->readListBegin(_etype242, _size239); + this->partNames.resize(_size239); + uint32_t _i243; + for (_i243 = 0; _i243 < _size239; ++_i243) { - xfer += iprot->readString(this->partNames[_i242]); + xfer += iprot->readString(this->partNames[_i243]); } xfer += iprot->readListEnd(); } @@ -4440,10 +4470,10 @@ 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 _iter243; - for (_iter243 = this->colNames.begin(); _iter243 != this->colNames.end(); ++_iter243) + std::vector ::const_iterator _iter244; + for (_iter244 = this->colNames.begin(); _iter244 != this->colNames.end(); ++_iter244) { - xfer += oprot->writeString((*_iter243)); + xfer += oprot->writeString((*_iter244)); } xfer += oprot->writeListEnd(); } @@ -4452,10 +4482,10 @@ 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 _iter244; - for (_iter244 = this->partNames.begin(); _iter244 != this->partNames.end(); ++_iter244) + std::vector ::const_iterator _iter245; + for (_iter245 = this->partNames.begin(); _iter245 != this->partNames.end(); ++_iter245) { - xfer += oprot->writeString((*_iter244)); + xfer += oprot->writeString((*_iter245)); } xfer += oprot->writeListEnd(); } @@ -4501,14 +4531,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size245; - ::apache::thrift::protocol::TType _etype248; - xfer += iprot->readListBegin(_etype248, _size245); - this->partitions.resize(_size245); - uint32_t _i249; - for (_i249 = 0; _i249 < _size245; ++_i249) + uint32_t _size246; + ::apache::thrift::protocol::TType _etype249; + xfer += iprot->readListBegin(_etype249, _size246); + this->partitions.resize(_size246); + uint32_t _i250; + for (_i250 = 0; _i250 < _size246; ++_i250) { - xfer += this->partitions[_i249].read(iprot); + xfer += this->partitions[_i250].read(iprot); } xfer += iprot->readListEnd(); } @@ -4537,10 +4567,10 @@ 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 _iter250; - for (_iter250 = this->partitions.begin(); _iter250 != this->partitions.end(); ++_iter250) + std::vector ::const_iterator _iter251; + for (_iter251 = this->partitions.begin(); _iter251 != this->partitions.end(); ++_iter251) { - xfer += (*_iter250).write(oprot); + xfer += (*_iter251).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4604,14 +4634,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->parts.clear(); - uint32_t _size251; - ::apache::thrift::protocol::TType _etype254; - xfer += iprot->readListBegin(_etype254, _size251); - this->parts.resize(_size251); - uint32_t _i255; - for (_i255 = 0; _i255 < _size251; ++_i255) + uint32_t _size252; + ::apache::thrift::protocol::TType _etype255; + xfer += iprot->readListBegin(_etype255, _size252); + this->parts.resize(_size252); + uint32_t _i256; + for (_i256 = 0; _i256 < _size252; ++_i256) { - xfer += this->parts[_i255].read(iprot); + xfer += this->parts[_i256].read(iprot); } xfer += iprot->readListEnd(); } @@ -4671,10 +4701,10 @@ 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 _iter256; - for (_iter256 = this->parts.begin(); _iter256 != this->parts.end(); ++_iter256) + std::vector ::const_iterator _iter257; + for (_iter257 = this->parts.begin(); _iter257 != this->parts.end(); ++_iter257) { - xfer += (*_iter256).write(oprot); + xfer += (*_iter257).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4731,14 +4761,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size257; - ::apache::thrift::protocol::TType _etype260; - xfer += iprot->readListBegin(_etype260, _size257); - this->partitions.resize(_size257); - uint32_t _i261; - for (_i261 = 0; _i261 < _size257; ++_i261) + uint32_t _size258; + ::apache::thrift::protocol::TType _etype261; + xfer += iprot->readListBegin(_etype261, _size258); + this->partitions.resize(_size258); + uint32_t _i262; + for (_i262 = 0; _i262 < _size258; ++_i262) { - xfer += this->partitions[_i261].read(iprot); + xfer += this->partitions[_i262].read(iprot); } xfer += iprot->readListEnd(); } @@ -4767,10 +4797,10 @@ 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 _iter262; - for (_iter262 = this->partitions.begin(); _iter262 != this->partitions.end(); ++_iter262) + std::vector ::const_iterator _iter263; + for (_iter263 = this->partitions.begin(); _iter263 != this->partitions.end(); ++_iter263) { - xfer += (*_iter262).write(oprot); + xfer += (*_iter263).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4893,14 +4923,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->names.clear(); - uint32_t _size263; - ::apache::thrift::protocol::TType _etype266; - xfer += iprot->readListBegin(_etype266, _size263); - this->names.resize(_size263); - uint32_t _i267; - for (_i267 = 0; _i267 < _size263; ++_i267) + uint32_t _size264; + ::apache::thrift::protocol::TType _etype267; + xfer += iprot->readListBegin(_etype267, _size264); + this->names.resize(_size264); + uint32_t _i268; + for (_i268 = 0; _i268 < _size264; ++_i268) { - xfer += iprot->readString(this->names[_i267]); + xfer += iprot->readString(this->names[_i268]); } xfer += iprot->readListEnd(); } @@ -4913,14 +4943,14 @@ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->exprs.clear(); - uint32_t _size268; - ::apache::thrift::protocol::TType _etype271; - xfer += iprot->readListBegin(_etype271, _size268); - this->exprs.resize(_size268); - uint32_t _i272; - for (_i272 = 0; _i272 < _size268; ++_i272) + uint32_t _size269; + ::apache::thrift::protocol::TType _etype272; + xfer += iprot->readListBegin(_etype272, _size269); + this->exprs.resize(_size269); + uint32_t _i273; + for (_i273 = 0; _i273 < _size269; ++_i273) { - xfer += this->exprs[_i272].read(iprot); + xfer += this->exprs[_i273].read(iprot); } xfer += iprot->readListEnd(); } @@ -4948,10 +4978,10 @@ 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 _iter273; - for (_iter273 = this->names.begin(); _iter273 != this->names.end(); ++_iter273) + std::vector ::const_iterator _iter274; + for (_iter274 = this->names.begin(); _iter274 != this->names.end(); ++_iter274) { - xfer += oprot->writeString((*_iter273)); + xfer += oprot->writeString((*_iter274)); } xfer += oprot->writeListEnd(); } @@ -4960,10 +4990,10 @@ 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 _iter274; - for (_iter274 = this->exprs.begin(); _iter274 != this->exprs.end(); ++_iter274) + std::vector ::const_iterator _iter275; + for (_iter275 = this->exprs.begin(); _iter275 != this->exprs.end(); ++_iter275) { - xfer += (*_iter274).write(oprot); + xfer += (*_iter275).write(oprot); } xfer += oprot->writeListEnd(); } Index: metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h =================================================================== --- metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h (revision 1568537) +++ metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h (working copy) @@ -667,21 +667,23 @@ void swap(Role &a, Role &b); typedef struct _Database__isset { - _Database__isset() : name(false), description(false), locationUri(false), parameters(false), privileges(false) {} + _Database__isset() : name(false), description(false), locationUri(false), parameters(false), privileges(false), ownerName(false), ownerType(false) {} bool name; bool description; bool locationUri; bool parameters; bool privileges; + bool ownerName; + bool ownerType; } _Database__isset; class Database { public: - static const char* ascii_fingerprint; // = "213967572143E49C9F1A23F7A866E2F5"; - static const uint8_t binary_fingerprint[16]; // = {0x21,0x39,0x67,0x57,0x21,0x43,0xE4,0x9C,0x9F,0x1A,0x23,0xF7,0xA8,0x66,0xE2,0xF5}; + static const char* ascii_fingerprint; // = "553495CAE243A1C583D5C3DD990AED53"; + static const uint8_t binary_fingerprint[16]; // = {0x55,0x34,0x95,0xCA,0xE2,0x43,0xA1,0xC5,0x83,0xD5,0xC3,0xDD,0x99,0x0A,0xED,0x53}; - Database() : name(), description(), locationUri() { + Database() : name(), description(), locationUri(), ownerName(), ownerType((PrincipalType::type)0) { } virtual ~Database() throw() {} @@ -691,6 +693,8 @@ std::string locationUri; std::map parameters; PrincipalPrivilegeSet privileges; + std::string ownerName; + PrincipalType::type ownerType; _Database__isset __isset; @@ -715,6 +719,16 @@ __isset.privileges = true; } + void __set_ownerName(const std::string& val) { + ownerName = val; + __isset.ownerName = true; + } + + void __set_ownerType(const PrincipalType::type val) { + ownerType = val; + __isset.ownerType = true; + } + bool operator == (const Database & rhs) const { if (!(name == rhs.name)) @@ -729,6 +743,14 @@ return false; else if (__isset.privileges && !(privileges == rhs.privileges)) return false; + if (__isset.ownerName != rhs.__isset.ownerName) + return false; + else if (__isset.ownerName && !(ownerName == rhs.ownerName)) + return false; + if (__isset.ownerType != rhs.__isset.ownerType) + return false; + else if (__isset.ownerType && !(ownerType == rhs.ownerType)) + return false; return true; } bool operator != (const Database &rhs) const { Index: metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb =================================================================== --- metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb (revision 1568537) +++ metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb (working copy) @@ -244,18 +244,25 @@ LOCATIONURI = 3 PARAMETERS = 4 PRIVILEGES = 5 + OWNERNAME = 6 + OWNERTYPE = 7 FIELDS = { NAME => {:type => ::Thrift::Types::STRING, :name => 'name'}, DESCRIPTION => {:type => ::Thrift::Types::STRING, :name => 'description'}, LOCATIONURI => {:type => ::Thrift::Types::STRING, :name => 'locationUri'}, PARAMETERS => {:type => ::Thrift::Types::MAP, :name => 'parameters', :key => {:type => ::Thrift::Types::STRING}, :value => {:type => ::Thrift::Types::STRING}}, - PRIVILEGES => {:type => ::Thrift::Types::STRUCT, :name => 'privileges', :class => ::PrincipalPrivilegeSet, :optional => true} + PRIVILEGES => {:type => ::Thrift::Types::STRUCT, :name => 'privileges', :class => ::PrincipalPrivilegeSet, :optional => true}, + OWNERNAME => {:type => ::Thrift::Types::STRING, :name => 'ownerName', :optional => true}, + OWNERTYPE => {:type => ::Thrift::Types::I32, :name => 'ownerType', :optional => true, :enum_class => ::PrincipalType} } def struct_fields; FIELDS; end def validate + unless @ownerType.nil? || ::PrincipalType::VALID_VALUES.include?(@ownerType) + raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Invalid value of field ownerType!') + end end ::Thrift::Struct.generate_accessors self Index: metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/Database.java =================================================================== --- metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/Database.java (revision 1568537) +++ metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/Database.java (working copy) @@ -39,6 +39,8 @@ private static final org.apache.thrift.protocol.TField LOCATION_URI_FIELD_DESC = new org.apache.thrift.protocol.TField("locationUri", org.apache.thrift.protocol.TType.STRING, (short)3); private static final org.apache.thrift.protocol.TField PARAMETERS_FIELD_DESC = new org.apache.thrift.protocol.TField("parameters", org.apache.thrift.protocol.TType.MAP, (short)4); private static final org.apache.thrift.protocol.TField PRIVILEGES_FIELD_DESC = new org.apache.thrift.protocol.TField("privileges", org.apache.thrift.protocol.TType.STRUCT, (short)5); + private static final org.apache.thrift.protocol.TField OWNER_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("ownerName", org.apache.thrift.protocol.TType.STRING, (short)6); + private static final org.apache.thrift.protocol.TField OWNER_TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("ownerType", org.apache.thrift.protocol.TType.I32, (short)7); private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { @@ -51,6 +53,8 @@ private String locationUri; // required private Map parameters; // required private PrincipalPrivilegeSet privileges; // optional + private String ownerName; // optional + private PrincipalType ownerType; // optional /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ public enum _Fields implements org.apache.thrift.TFieldIdEnum { @@ -58,7 +62,13 @@ DESCRIPTION((short)2, "description"), LOCATION_URI((short)3, "locationUri"), PARAMETERS((short)4, "parameters"), - PRIVILEGES((short)5, "privileges"); + PRIVILEGES((short)5, "privileges"), + OWNER_NAME((short)6, "ownerName"), + /** + * + * @see PrincipalType + */ + OWNER_TYPE((short)7, "ownerType"); private static final Map byName = new HashMap(); @@ -83,6 +93,10 @@ return PARAMETERS; case 5: // PRIVILEGES return PRIVILEGES; + case 6: // OWNER_NAME + return OWNER_NAME; + case 7: // OWNER_TYPE + return OWNER_TYPE; default: return null; } @@ -123,7 +137,7 @@ } // isset id assignments - private _Fields optionals[] = {_Fields.PRIVILEGES}; + private _Fields optionals[] = {_Fields.PRIVILEGES,_Fields.OWNER_NAME,_Fields.OWNER_TYPE}; 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); @@ -139,6 +153,10 @@ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)))); tmpMap.put(_Fields.PRIVILEGES, new org.apache.thrift.meta_data.FieldMetaData("privileges", org.apache.thrift.TFieldRequirementType.OPTIONAL, new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, PrincipalPrivilegeSet.class))); + tmpMap.put(_Fields.OWNER_NAME, new org.apache.thrift.meta_data.FieldMetaData("ownerName", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.OWNER_TYPE, new org.apache.thrift.meta_data.FieldMetaData("ownerType", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, PrincipalType.class))); metaDataMap = Collections.unmodifiableMap(tmpMap); org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(Database.class, metaDataMap); } @@ -190,6 +208,12 @@ if (other.isSetPrivileges()) { this.privileges = new PrincipalPrivilegeSet(other.privileges); } + if (other.isSetOwnerName()) { + this.ownerName = other.ownerName; + } + if (other.isSetOwnerType()) { + this.ownerType = other.ownerType; + } } public Database deepCopy() { @@ -203,6 +227,8 @@ this.locationUri = null; this.parameters = null; this.privileges = null; + this.ownerName = null; + this.ownerType = null; } public String getName() { @@ -331,6 +357,60 @@ } } + public String getOwnerName() { + return this.ownerName; + } + + public void setOwnerName(String ownerName) { + this.ownerName = ownerName; + } + + public void unsetOwnerName() { + this.ownerName = null; + } + + /** Returns true if field ownerName is set (has been assigned a value) and false otherwise */ + public boolean isSetOwnerName() { + return this.ownerName != null; + } + + public void setOwnerNameIsSet(boolean value) { + if (!value) { + this.ownerName = null; + } + } + + /** + * + * @see PrincipalType + */ + public PrincipalType getOwnerType() { + return this.ownerType; + } + + /** + * + * @see PrincipalType + */ + public void setOwnerType(PrincipalType ownerType) { + this.ownerType = ownerType; + } + + public void unsetOwnerType() { + this.ownerType = null; + } + + /** Returns true if field ownerType is set (has been assigned a value) and false otherwise */ + public boolean isSetOwnerType() { + return this.ownerType != null; + } + + public void setOwnerTypeIsSet(boolean value) { + if (!value) { + this.ownerType = null; + } + } + public void setFieldValue(_Fields field, Object value) { switch (field) { case NAME: @@ -373,6 +453,22 @@ } break; + case OWNER_NAME: + if (value == null) { + unsetOwnerName(); + } else { + setOwnerName((String)value); + } + break; + + case OWNER_TYPE: + if (value == null) { + unsetOwnerType(); + } else { + setOwnerType((PrincipalType)value); + } + break; + } } @@ -393,6 +489,12 @@ case PRIVILEGES: return getPrivileges(); + case OWNER_NAME: + return getOwnerName(); + + case OWNER_TYPE: + return getOwnerType(); + } throw new IllegalStateException(); } @@ -414,6 +516,10 @@ return isSetParameters(); case PRIVILEGES: return isSetPrivileges(); + case OWNER_NAME: + return isSetOwnerName(); + case OWNER_TYPE: + return isSetOwnerType(); } throw new IllegalStateException(); } @@ -476,6 +582,24 @@ return false; } + boolean this_present_ownerName = true && this.isSetOwnerName(); + boolean that_present_ownerName = true && that.isSetOwnerName(); + if (this_present_ownerName || that_present_ownerName) { + if (!(this_present_ownerName && that_present_ownerName)) + return false; + if (!this.ownerName.equals(that.ownerName)) + return false; + } + + boolean this_present_ownerType = true && this.isSetOwnerType(); + boolean that_present_ownerType = true && that.isSetOwnerType(); + if (this_present_ownerType || that_present_ownerType) { + if (!(this_present_ownerType && that_present_ownerType)) + return false; + if (!this.ownerType.equals(that.ownerType)) + return false; + } + return true; } @@ -508,6 +632,16 @@ if (present_privileges) builder.append(privileges); + boolean present_ownerName = true && (isSetOwnerName()); + builder.append(present_ownerName); + if (present_ownerName) + builder.append(ownerName); + + boolean present_ownerType = true && (isSetOwnerType()); + builder.append(present_ownerType); + if (present_ownerType) + builder.append(ownerType.getValue()); + return builder.toHashCode(); } @@ -569,6 +703,26 @@ return lastComparison; } } + lastComparison = Boolean.valueOf(isSetOwnerName()).compareTo(typedOther.isSetOwnerName()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetOwnerName()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ownerName, typedOther.ownerName); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetOwnerType()).compareTo(typedOther.isSetOwnerType()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetOwnerType()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ownerType, typedOther.ownerType); + if (lastComparison != 0) { + return lastComparison; + } + } return 0; } @@ -630,6 +784,26 @@ } first = false; } + if (isSetOwnerName()) { + if (!first) sb.append(", "); + sb.append("ownerName:"); + if (this.ownerName == null) { + sb.append("null"); + } else { + sb.append(this.ownerName); + } + first = false; + } + if (isSetOwnerType()) { + if (!first) sb.append(", "); + sb.append("ownerType:"); + if (this.ownerType == null) { + sb.append("null"); + } else { + sb.append(this.ownerType); + } + first = false; + } sb.append(")"); return sb.toString(); } @@ -729,6 +903,22 @@ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } break; + case 6: // OWNER_NAME + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.ownerName = iprot.readString(); + struct.setOwnerNameIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 7: // OWNER_TYPE + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.ownerType = PrincipalType.findByValue(iprot.readI32()); + struct.setOwnerTypeIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; default: org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } @@ -777,6 +967,20 @@ oprot.writeFieldEnd(); } } + if (struct.ownerName != null) { + if (struct.isSetOwnerName()) { + oprot.writeFieldBegin(OWNER_NAME_FIELD_DESC); + oprot.writeString(struct.ownerName); + oprot.writeFieldEnd(); + } + } + if (struct.ownerType != null) { + if (struct.isSetOwnerType()) { + oprot.writeFieldBegin(OWNER_TYPE_FIELD_DESC); + oprot.writeI32(struct.ownerType.getValue()); + oprot.writeFieldEnd(); + } + } oprot.writeFieldStop(); oprot.writeStructEnd(); } @@ -810,7 +1014,13 @@ if (struct.isSetPrivileges()) { optionals.set(4); } - oprot.writeBitSet(optionals, 5); + if (struct.isSetOwnerName()) { + optionals.set(5); + } + if (struct.isSetOwnerType()) { + optionals.set(6); + } + oprot.writeBitSet(optionals, 7); if (struct.isSetName()) { oprot.writeString(struct.name); } @@ -833,12 +1043,18 @@ if (struct.isSetPrivileges()) { struct.privileges.write(oprot); } + if (struct.isSetOwnerName()) { + oprot.writeString(struct.ownerName); + } + if (struct.isSetOwnerType()) { + oprot.writeI32(struct.ownerType.getValue()); + } } @Override public void read(org.apache.thrift.protocol.TProtocol prot, Database struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(5); + BitSet incoming = iprot.readBitSet(7); if (incoming.get(0)) { struct.name = iprot.readString(); struct.setNameIsSet(true); @@ -871,6 +1087,14 @@ struct.privileges.read(iprot); struct.setPrivilegesIsSet(true); } + if (incoming.get(5)) { + struct.ownerName = iprot.readString(); + struct.setOwnerNameIsSet(true); + } + if (incoming.get(6)) { + struct.ownerType = PrincipalType.findByValue(iprot.readI32()); + struct.setOwnerTypeIsSet(true); + } } } Index: metastore/src/gen/thrift/gen-php/metastore/Types.php =================================================================== --- metastore/src/gen/thrift/gen-php/metastore/Types.php (revision 1568537) +++ metastore/src/gen/thrift/gen-php/metastore/Types.php (working copy) @@ -1494,6 +1494,8 @@ public $locationUri = null; public $parameters = null; public $privileges = null; + public $ownerName = null; + public $ownerType = null; public function __construct($vals=null) { if (!isset(self::$_TSPEC)) { @@ -1527,6 +1529,14 @@ 'type' => TType::STRUCT, 'class' => '\metastore\PrincipalPrivilegeSet', ), + 6 => array( + 'var' => 'ownerName', + 'type' => TType::STRING, + ), + 7 => array( + 'var' => 'ownerType', + 'type' => TType::I32, + ), ); } if (is_array($vals)) { @@ -1545,6 +1555,12 @@ if (isset($vals['privileges'])) { $this->privileges = $vals['privileges']; } + if (isset($vals['ownerName'])) { + $this->ownerName = $vals['ownerName']; + } + if (isset($vals['ownerType'])) { + $this->ownerType = $vals['ownerType']; + } } } @@ -1616,6 +1632,20 @@ $xfer += $input->skip($ftype); } break; + case 6: + if ($ftype == TType::STRING) { + $xfer += $input->readString($this->ownerName); + } else { + $xfer += $input->skip($ftype); + } + break; + case 7: + if ($ftype == TType::I32) { + $xfer += $input->readI32($this->ownerType); + } else { + $xfer += $input->skip($ftype); + } + break; default: $xfer += $input->skip($ftype); break; @@ -1670,6 +1700,16 @@ $xfer += $this->privileges->write($output); $xfer += $output->writeFieldEnd(); } + if ($this->ownerName !== null) { + $xfer += $output->writeFieldBegin('ownerName', TType::STRING, 6); + $xfer += $output->writeString($this->ownerName); + $xfer += $output->writeFieldEnd(); + } + if ($this->ownerType !== null) { + $xfer += $output->writeFieldBegin('ownerType', TType::I32, 7); + $xfer += $output->writeI32($this->ownerType); + $xfer += $output->writeFieldEnd(); + } $xfer += $output->writeFieldStop(); $xfer += $output->writeStructEnd(); return $xfer; Index: metastore/if/hive_metastore.thrift =================================================================== --- metastore/if/hive_metastore.thrift (revision 1568537) +++ metastore/if/hive_metastore.thrift (working copy) @@ -120,7 +120,9 @@ 2: string description, 3: string locationUri, 4: map parameters, // properties associated with the database - 5: optional PrincipalPrivilegeSet privileges + 5: optional PrincipalPrivilegeSet privileges, + 6: optional string ownerName, + 7: optional PrincipalType ownerType } // This object holds the information needed by SerDes Index: itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/TestHiveMetaStore.java =================================================================== --- itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/TestHiveMetaStore.java (revision 1568537) +++ itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/TestHiveMetaStore.java (working copy) @@ -54,6 +54,7 @@ import org.apache.hadoop.hive.metastore.api.NoSuchObjectException; import org.apache.hadoop.hive.metastore.api.Order; import org.apache.hadoop.hive.metastore.api.Partition; +import org.apache.hadoop.hive.metastore.api.PrincipalType; import org.apache.hadoop.hive.metastore.api.SerDeInfo; import org.apache.hadoop.hive.metastore.api.SkewedInfo; import org.apache.hadoop.hive.metastore.api.StorageDescriptor; @@ -62,9 +63,11 @@ import org.apache.hadoop.hive.metastore.api.Type; import org.apache.hadoop.hive.metastore.api.UnknownDBException; import org.apache.hadoop.hive.ql.exec.Utilities; +import org.apache.hadoop.hive.ql.session.SessionState; import org.apache.hadoop.hive.serde.serdeConstants; import org.apache.hadoop.util.StringUtils; import org.apache.thrift.TException; +import org.junit.Test; import com.google.common.collect.Lists; @@ -923,6 +926,8 @@ Database db = new Database(); db.setName(TEST_DB1_NAME); + db.setOwnerName(SessionState.getUserFromAuthenticator()); + db.setOwnerType(PrincipalType.USER); client.createDatabase(db); db = client.getDatabase(TEST_DB1_NAME); @@ -931,7 +936,8 @@ TEST_DB1_NAME, db.getName()); assertEquals("location of the returned db is different from that of inserted db", warehouse.getDatabasePath(db).toString(), db.getLocationUri()); - + assertEquals(db.getOwnerName(), SessionState.getUserFromAuthenticator()); + assertEquals(db.getOwnerType(), PrincipalType.USER); Database db2 = new Database(); db2.setName(TEST_DB2_NAME); client.createDatabase(db2); @@ -2659,4 +2665,11 @@ createPartitions(dbName, tbl, values); } + + @Test + public void testDBOwner() throws NoSuchObjectException, MetaException, TException { + Database db = client.getDatabase(MetaStoreUtils.DEFAULT_DATABASE_NAME); + assertEquals(db.getOwnerName(), HiveMetaStore.PUBLIC); + assertEquals(db.getOwnerType(), PrincipalType.ROLE); + } } Index: serde/src/gen/thrift/gen-py/org_apache_hadoop_hive_serde/constants.py =================================================================== --- serde/src/gen/thrift/gen-py/org_apache_hadoop_hive_serde/constants.py (revision 1568537) +++ serde/src/gen/thrift/gen-py/org_apache_hadoop_hive_serde/constants.py (working copy) @@ -23,6 +23,8 @@ MAPKEY_DELIM = "mapkey.delim" QUOTE_CHAR = "quote.delim" ESCAPE_CHAR = "escape.delim" +HEADER_COUNT = "skip.header.line.count" +FOOTER_COUNT = "skip.footer.line.count" VOID_TYPE_NAME = "void" BOOLEAN_TYPE_NAME = "boolean" TINYINT_TYPE_NAME = "tinyint" Index: serde/src/gen/thrift/gen-cpp/serde_constants.cpp =================================================================== --- serde/src/gen/thrift/gen-cpp/serde_constants.cpp (revision 1568537) +++ serde/src/gen/thrift/gen-cpp/serde_constants.cpp (working copy) @@ -39,6 +39,10 @@ ESCAPE_CHAR = "escape.delim"; + HEADER_COUNT = "skip.header.line.count"; + + FOOTER_COUNT = "skip.footer.line.count"; + VOID_TYPE_NAME = "void"; BOOLEAN_TYPE_NAME = "boolean"; Index: serde/src/gen/thrift/gen-cpp/serde_constants.h =================================================================== --- serde/src/gen/thrift/gen-cpp/serde_constants.h (revision 1568537) +++ serde/src/gen/thrift/gen-cpp/serde_constants.h (working copy) @@ -29,6 +29,8 @@ std::string MAPKEY_DELIM; std::string QUOTE_CHAR; std::string ESCAPE_CHAR; + std::string HEADER_COUNT; + std::string FOOTER_COUNT; std::string VOID_TYPE_NAME; std::string BOOLEAN_TYPE_NAME; std::string TINYINT_TYPE_NAME; Index: serde/src/gen/thrift/gen-rb/serde_constants.rb =================================================================== --- serde/src/gen/thrift/gen-rb/serde_constants.rb (revision 1568537) +++ serde/src/gen/thrift/gen-rb/serde_constants.rb (working copy) @@ -35,6 +35,10 @@ ESCAPE_CHAR = %q"escape.delim" +HEADER_COUNT = %q"skip.header.line.count" + +FOOTER_COUNT = %q"skip.footer.line.count" + VOID_TYPE_NAME = %q"void" BOOLEAN_TYPE_NAME = %q"boolean" Index: serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde/test/ThriftTestObj.java =================================================================== --- serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde/test/ThriftTestObj.java (revision 1568537) +++ serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde/test/ThriftTestObj.java (working copy) @@ -528,7 +528,7 @@ struct.field3 = new ArrayList(_list0.size); for (int _i1 = 0; _i1 < _list0.size; ++_i1) { - InnerStruct _elem2; // optional + InnerStruct _elem2; // required _elem2 = new InnerStruct(); _elem2.read(iprot); struct.field3.add(_elem2); @@ -636,7 +636,7 @@ struct.field3 = new ArrayList(_list5.size); for (int _i6 = 0; _i6 < _list5.size; ++_i6) { - InnerStruct _elem7; // optional + InnerStruct _elem7; // required _elem7 = new InnerStruct(); _elem7.read(iprot); struct.field3.add(_elem7); Index: serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde2/thrift/test/Complex.java =================================================================== --- serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde2/thrift/test/Complex.java (revision 1568537) +++ serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde2/thrift/test/Complex.java (working copy) @@ -836,7 +836,7 @@ struct.lint = new ArrayList(_list0.size); for (int _i1 = 0; _i1 < _list0.size; ++_i1) { - int _elem2; // optional + int _elem2; // required _elem2 = iprot.readI32(); struct.lint.add(_elem2); } @@ -854,7 +854,7 @@ struct.lString = new ArrayList(_list3.size); for (int _i4 = 0; _i4 < _list3.size; ++_i4) { - String _elem5; // optional + String _elem5; // required _elem5 = iprot.readString(); struct.lString.add(_elem5); } @@ -872,7 +872,7 @@ struct.lintString = new ArrayList(_list6.size); for (int _i7 = 0; _i7 < _list6.size; ++_i7) { - IntString _elem8; // optional + IntString _elem8; // required _elem8 = new IntString(); _elem8.read(iprot); struct.lintString.add(_elem8); @@ -1074,7 +1074,7 @@ struct.lint = new ArrayList(_list21.size); for (int _i22 = 0; _i22 < _list21.size; ++_i22) { - int _elem23; // optional + int _elem23; // required _elem23 = iprot.readI32(); struct.lint.add(_elem23); } @@ -1087,7 +1087,7 @@ struct.lString = new ArrayList(_list24.size); for (int _i25 = 0; _i25 < _list24.size; ++_i25) { - String _elem26; // optional + String _elem26; // required _elem26 = iprot.readString(); struct.lString.add(_elem26); } @@ -1100,7 +1100,7 @@ struct.lintString = new ArrayList(_list27.size); for (int _i28 = 0; _i28 < _list27.size; ++_i28) { - IntString _elem29; // optional + IntString _elem29; // required _elem29 = new IntString(); _elem29.read(iprot); struct.lintString.add(_elem29); Index: serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde2/thrift/test/MegaStruct.java =================================================================== --- serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde2/thrift/test/MegaStruct.java (revision 1568537) +++ serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde2/thrift/test/MegaStruct.java (working copy) @@ -2280,7 +2280,7 @@ _val19 = new ArrayList(_list20.size); for (int _i21 = 0; _i21 < _list20.size; ++_i21) { - String _elem22; // optional + String _elem22; // required _elem22 = iprot.readString(); _val19.add(_elem22); } @@ -2310,7 +2310,7 @@ _val26 = new ArrayList(_list27.size); for (int _i28 = 0; _i28 < _list27.size; ++_i28) { - MiniStruct _elem29; // optional + MiniStruct _elem29; // required _elem29 = new MiniStruct(); _elem29.read(iprot); _val26.add(_elem29); @@ -2333,7 +2333,7 @@ struct.my_stringlist = new ArrayList(_list30.size); for (int _i31 = 0; _i31 < _list30.size; ++_i31) { - String _elem32; // optional + String _elem32; // required _elem32 = iprot.readString(); struct.my_stringlist.add(_elem32); } @@ -2351,7 +2351,7 @@ struct.my_structlist = new ArrayList(_list33.size); for (int _i34 = 0; _i34 < _list33.size; ++_i34) { - MiniStruct _elem35; // optional + MiniStruct _elem35; // required _elem35 = new MiniStruct(); _elem35.read(iprot); struct.my_structlist.add(_elem35); @@ -2370,7 +2370,7 @@ struct.my_enumlist = new ArrayList(_list36.size); for (int _i37 = 0; _i37 < _list36.size; ++_i37) { - MyEnum _elem38; // optional + MyEnum _elem38; // required _elem38 = MyEnum.findByValue(iprot.readI32()); struct.my_enumlist.add(_elem38); } @@ -2388,7 +2388,7 @@ struct.my_stringset = new HashSet(2*_set39.size); for (int _i40 = 0; _i40 < _set39.size; ++_i40) { - String _elem41; // optional + String _elem41; // required _elem41 = iprot.readString(); struct.my_stringset.add(_elem41); } @@ -2406,7 +2406,7 @@ struct.my_enumset = new HashSet(2*_set42.size); for (int _i43 = 0; _i43 < _set42.size; ++_i43) { - MyEnum _elem44; // optional + MyEnum _elem44; // required _elem44 = MyEnum.findByValue(iprot.readI32()); struct.my_enumset.add(_elem44); } @@ -2424,7 +2424,7 @@ struct.my_structset = new HashSet(2*_set45.size); for (int _i46 = 0; _i46 < _set45.size; ++_i46) { - MiniStruct _elem47; // optional + MiniStruct _elem47; // required _elem47 = new MiniStruct(); _elem47.read(iprot); struct.my_structset.add(_elem47); @@ -3023,7 +3023,7 @@ _val95 = new ArrayList(_list96.size); for (int _i97 = 0; _i97 < _list96.size; ++_i97) { - String _elem98; // optional + String _elem98; // required _elem98 = iprot.readString(); _val95.add(_elem98); } @@ -3047,7 +3047,7 @@ _val102 = new ArrayList(_list103.size); for (int _i104 = 0; _i104 < _list103.size; ++_i104) { - MiniStruct _elem105; // optional + MiniStruct _elem105; // required _elem105 = new MiniStruct(); _elem105.read(iprot); _val102.add(_elem105); @@ -3064,7 +3064,7 @@ struct.my_stringlist = new ArrayList(_list106.size); for (int _i107 = 0; _i107 < _list106.size; ++_i107) { - String _elem108; // optional + String _elem108; // required _elem108 = iprot.readString(); struct.my_stringlist.add(_elem108); } @@ -3077,7 +3077,7 @@ struct.my_structlist = new ArrayList(_list109.size); for (int _i110 = 0; _i110 < _list109.size; ++_i110) { - MiniStruct _elem111; // optional + MiniStruct _elem111; // required _elem111 = new MiniStruct(); _elem111.read(iprot); struct.my_structlist.add(_elem111); @@ -3091,7 +3091,7 @@ struct.my_enumlist = new ArrayList(_list112.size); for (int _i113 = 0; _i113 < _list112.size; ++_i113) { - MyEnum _elem114; // optional + MyEnum _elem114; // required _elem114 = MyEnum.findByValue(iprot.readI32()); struct.my_enumlist.add(_elem114); } @@ -3104,7 +3104,7 @@ struct.my_stringset = new HashSet(2*_set115.size); for (int _i116 = 0; _i116 < _set115.size; ++_i116) { - String _elem117; // optional + String _elem117; // required _elem117 = iprot.readString(); struct.my_stringset.add(_elem117); } @@ -3117,7 +3117,7 @@ struct.my_enumset = new HashSet(2*_set118.size); for (int _i119 = 0; _i119 < _set118.size; ++_i119) { - MyEnum _elem120; // optional + MyEnum _elem120; // required _elem120 = MyEnum.findByValue(iprot.readI32()); struct.my_enumset.add(_elem120); } @@ -3130,7 +3130,7 @@ struct.my_structset = new HashSet(2*_set121.size); for (int _i122 = 0; _i122 < _set121.size; ++_i122) { - MiniStruct _elem123; // optional + MiniStruct _elem123; // required _elem123 = new MiniStruct(); _elem123.read(iprot); struct.my_structset.add(_elem123); Index: serde/src/gen/thrift/gen-php/org/apache/hadoop/hive/serde/Types.php =================================================================== --- serde/src/gen/thrift/gen-php/org/apache/hadoop/hive/serde/Types.php (revision 1568537) +++ serde/src/gen/thrift/gen-php/org/apache/hadoop/hive/serde/Types.php (working copy) @@ -44,6 +44,10 @@ $GLOBALS['serde_CONSTANTS']['ESCAPE_CHAR'] = "escape.delim"; +$GLOBALS['serde_CONSTANTS']['HEADER_COUNT'] = "skip.header.line.count"; + +$GLOBALS['serde_CONSTANTS']['FOOTER_COUNT'] = "skip.footer.line.count"; + $GLOBALS['serde_CONSTANTS']['VOID_TYPE_NAME'] = "void"; $GLOBALS['serde_CONSTANTS']['BOOLEAN_TYPE_NAME'] = "boolean"; Index: ql/src/java/org/apache/hadoop/hive/ql/metadata/formatting/MetaDataFormatter.java =================================================================== --- ql/src/java/org/apache/hadoop/hive/ql/metadata/formatting/MetaDataFormatter.java (revision 1568537) +++ ql/src/java/org/apache/hadoop/hive/ql/metadata/formatting/MetaDataFormatter.java (working copy) @@ -93,11 +93,8 @@ /** * Describe a database. */ - public void showDatabaseDescription(DataOutputStream out, - String database, - String comment, - String location, - Map params) - throws HiveException; + public void showDatabaseDescription (DataOutputStream out, String database, String comment, + String location, String ownerName, String ownerType, Map params) + throws HiveException; } Index: ql/src/java/org/apache/hadoop/hive/ql/metadata/formatting/TextMetaDataFormatter.java =================================================================== --- ql/src/java/org/apache/hadoop/hive/ql/metadata/formatting/TextMetaDataFormatter.java (revision 1568537) +++ ql/src/java/org/apache/hadoop/hive/ql/metadata/formatting/TextMetaDataFormatter.java (working copy) @@ -430,13 +430,9 @@ * Describe a database */ @Override - public void showDatabaseDescription(DataOutputStream outStream, - String database, - String comment, - String location, - Map params) - throws HiveException - { + public void showDatabaseDescription(DataOutputStream outStream, String database, String comment, + String location, String ownerName, String ownerType, Map params) + throws HiveException { try { outStream.writeBytes(database); outStream.write(separator); @@ -448,6 +444,14 @@ outStream.writeBytes(location); } outStream.write(separator); + if (ownerName != null) { + outStream.writeBytes(ownerName); + } + outStream.write(separator); + if (ownerType != null) { + outStream.writeBytes(ownerType); + } + outStream.write(separator); if (params != null && !params.isEmpty()) { outStream.writeBytes(params.toString()); } Index: ql/src/java/org/apache/hadoop/hive/ql/metadata/formatting/JsonMetaDataFormatter.java =================================================================== --- ql/src/java/org/apache/hadoop/hive/ql/metadata/formatting/JsonMetaDataFormatter.java (revision 1568537) +++ ql/src/java/org/apache/hadoop/hive/ql/metadata/formatting/JsonMetaDataFormatter.java (working copy) @@ -398,28 +398,20 @@ * Show the description of a database */ @Override - public void showDatabaseDescription(DataOutputStream out, - String database, - String comment, - String location, - Map params) - throws HiveException - { - if (params == null || params.isEmpty()) { - asJson(out, MapBuilder - .create() - .put("database", database) - .put("comment", comment) - .put("location", location) - .build()); - } else { - asJson(out, MapBuilder - .create() - .put("database", database) - .put("comment", comment) - .put("location", location) - .put("params", params) - .build()); - } + public void showDatabaseDescription(DataOutputStream out, String database, String comment, + String location, String ownerName, String ownerType, Map params) + throws HiveException { + MapBuilder builder = MapBuilder.create().put("database", database).put("comment", comment) + .put("location", location); + if (null != ownerName) { + builder.put("owner", ownerName); + } + if (null != ownerType) { + builder.put("ownerType", ownerType); + } + if (null != params && !params.isEmpty()) { + builder.put("params", params); + } + asJson(out, builder.build()); } } Index: ql/src/java/org/apache/hadoop/hive/ql/exec/DDLTask.java =================================================================== --- ql/src/java/org/apache/hadoop/hive/ql/exec/DDLTask.java (revision 1568537) +++ ql/src/java/org/apache/hadoop/hive/ql/exec/DDLTask.java (working copy) @@ -2834,12 +2834,10 @@ if(descDatabase.isExt()) { params = database.getParameters(); } - - formatter.showDatabaseDescription(outStream, - database.getName(), - database.getDescription(), - database.getLocationUri(), - params); + PrincipalType ownerType = database.getOwnerType(); + formatter.showDatabaseDescription(outStream, database.getName(), + database.getDescription(), database.getLocationUri(), + database.getOwnerName(), (null == ownerType) ? null : ownerType.name(), params); } outStream.close(); outStream = null; @@ -3666,6 +3664,8 @@ database.setDescription(crtDb.getComment()); database.setLocationUri(crtDb.getLocationUri()); database.setParameters(crtDb.getDatabaseProperties()); + database.setOwnerName(SessionState.getUserFromAuthenticator()); + database.setOwnerType(PrincipalType.USER); try { db.createDatabase(database, crtDb.getIfNotExists()); }