diff --git a/itests/hive-unit/src/test/java/org/apache/hive/service/server/TestHS2SessionHive.java b/itests/hive-unit/src/test/java/org/apache/hive/service/server/TestHS2SessionHive.java index 022802588d3b..15cfb190d5e0 100644 --- a/itests/hive-unit/src/test/java/org/apache/hive/service/server/TestHS2SessionHive.java +++ b/itests/hive-unit/src/test/java/org/apache/hive/service/server/TestHS2SessionHive.java @@ -68,7 +68,7 @@ public DummyFilterHook(Configuration conf) { } @Override - public List filterTableMetas(String catName, String dbName, List tableMetas) + public List filterTableMetas(List tableMetas) throws MetaException { try { Assert.assertNotNull(SessionState.get()); @@ -87,7 +87,7 @@ public List filterTableMetas(String catName, String dbName, List bypassObjectTypes; + boolean shouldOutputObjs; public SQLStdHiveAuthorizationValidatorForTest(HiveMetastoreClientFactory metastoreClientFactory, HiveConf conf, HiveAuthenticationProvider authenticator, SQLStdHiveAccessControllerWrapper privController, HiveAuthzSessionContext ctx) throws HiveAuthzPluginException { super(metastoreClientFactory, conf, authenticator, privController, ctx); + shouldOutputObjs = conf.getBoolean(OUTPUT_PRIV_OBJS, false); setupBypass(conf.get(BYPASS_OBJTYPES_KEY,"")); } + static private void addIfNotNull(StringBuilder sb, String fieldName, T field) { + if (field == null) return; + sb.append(" " + fieldName + " " + field); + } + + private String privilegeObjectToStringForTest(HivePrivilegeObject privObj) { + StringBuilder sb = new StringBuilder("HIVE PRIVILEGE OBJECT {"); + addIfNotNull(sb, "objectName:", privObj.getObjectName()); + addIfNotNull(sb, "type:", privObj.getType()); + addIfNotNull(sb, "actionType:", privObj.getActionType()); + addIfNotNull(sb, "dbName:", privObj.getDbname()); + // these two are all caps to prevent these being masked, since the word [Oo]wner is masked by qtests + addIfNotNull(sb, "OWNER:", privObj.getOwnerName()); + addIfNotNull(sb, "OWNERTYPE:", privObj.getOwnerType()); + addIfNotNull(sb, "columns:", privObj.getColumns()); + addIfNotNull(sb, "partKeys", privObj.getPartKeys()); + addIfNotNull(sb, "commandKeys", privObj.getCommandParams());; + sb.append("}"); + return sb.toString(); + } + + private void outputHivePrivilegeObjects(String prefix, List privilegeObjects) { + if (!shouldOutputObjs) return; + + List privStrs = new ArrayList<>(privilegeObjects.size()); + for (HivePrivilegeObject privilege : privilegeObjects) { + privStrs.add(privilegeObjectToStringForTest(privilege)); + } + + if (privStrs.isEmpty()) return; + + // Sort to make test output stable + Collections.sort(privStrs); + + LogHelper console = SessionState.getConsole(); + console.printInfo(prefix, false); + for (String privStr : privStrs) { + console.printInfo(privStr, false); + } + } + + @Override + public List filterListCmdObjects(List listObjs, HiveAuthzContext context) { + outputHivePrivilegeObjects("filterListCmdObjects", listObjs); + return super.filterListCmdObjects(listObjs, context); + } + private void setupBypass(String bypassObjectTypesConf){ bypassObjectTypes = new HashSet(); if (!bypassObjectTypesConf.isEmpty()){ @@ -95,6 +148,8 @@ public boolean apply(@Nullable HivePrivilegeObject hivePrivilegeObject) { public void checkPrivileges(HiveOperationType hiveOpType, List inputHObjs, List outputHObjs, HiveAuthzContext context) throws HiveAuthzPluginException, HiveAccessControlException { + outputHivePrivilegeObjects("inputHObjs:", inputHObjs); + outputHivePrivilegeObjects("outputHObjs:", outputHObjs); switch (hiveOpType) { case DFS: case SET: @@ -106,6 +161,7 @@ public void checkPrivileges(HiveOperationType hiveOpType, List applyRowFilterAndColumnMasking(HiveAuthzContext context, List privObjs) throws SemanticException { + outputHivePrivilegeObjects("applyRowFilterAndColumnMasking:", privObjs); List needRewritePrivObjs = new ArrayList<>(); for (HivePrivilegeObject privObj : privObjs) { if (privObj.getObjectName().equals("masking_test") || privObj.getObjectName().startsWith("masking_test_n")) { @@ -158,5 +216,4 @@ public List applyRowFilterAndColumnMasking(HiveAuthzContext } return needRewritePrivObjs; } - } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/security/authorization/plugin/AuthorizationMetaStoreFilterHook.java b/ql/src/java/org/apache/hadoop/hive/ql/security/authorization/plugin/AuthorizationMetaStoreFilterHook.java index e40297620c20..ad218af9a05d 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/security/authorization/plugin/AuthorizationMetaStoreFilterHook.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/security/authorization/plugin/AuthorizationMetaStoreFilterHook.java @@ -19,19 +19,23 @@ import java.util.ArrayList; import java.util.List; +import java.util.Set; import java.util.stream.Collectors; +import org.apache.commons.lang3.tuple.ImmutablePair; import org.apache.hadoop.conf.Configuration; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; import org.apache.hadoop.hive.common.classification.InterfaceAudience.Private; import org.apache.hadoop.hive.metastore.DefaultMetaStoreFilterHookImpl; import org.apache.hadoop.hive.metastore.api.MetaException; +import org.apache.hadoop.hive.metastore.api.PrincipalType; import org.apache.hadoop.hive.metastore.api.Table; import org.apache.hadoop.hive.metastore.api.TableMeta; import org.apache.hadoop.hive.ql.security.authorization.plugin.HivePrivilegeObject.HivePrivilegeObjectType; import org.apache.hadoop.hive.ql.session.SessionState; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + /** * Metastore filter hook for filtering out the list of objects that the current authorization * implementation does not allow user to see @@ -51,9 +55,10 @@ public List filterTableNames(String catName, String dbName, List List listObjs = getHivePrivObjects(dbName, tableList); return getFilteredObjectNames(getFilteredObjects(listObjs)); } + @Override public List filterTables(List
tableList) throws MetaException { - List listObjs = getHivePrivObjects(tableList); + List listObjs = tablesToPrivilegeObjs(tableList); return getFilteredTableList(getFilteredObjects(listObjs),tableList); } @@ -133,25 +138,45 @@ private List getHivePrivObjects(String dbName, List return objs; } - private List getHivePrivObjects(List
tableList) { + private HivePrivilegeObject createPrivilegeObjectForTable(String dbName, String tableName, String owner, + PrincipalType ownerType) { + return new HivePrivilegeObject(HivePrivilegeObjectType.TABLE_OR_VIEW, dbName, tableName, null, null, + HivePrivilegeObject.HivePrivObjectActionType.OTHER, null, null, owner, ownerType); + } + + private List tablesToPrivilegeObjs(List
tableList) { List objs = new ArrayList(); - for(Table tableObject : tableList) { - objs.add(new HivePrivilegeObject(HivePrivilegeObjectType.TABLE_OR_VIEW, tableObject.getDbName(), tableObject.getTableName(), null, null, - HivePrivilegeObject.HivePrivObjectActionType.OTHER, null, null, tableObject.getOwner(), tableObject.getOwnerType())); + for (Table tableObject : tableList) { + objs.add(createPrivilegeObjectForTable(tableObject.getDbName(), tableObject.getTableName(), tableObject.getOwner(), + tableObject.getOwnerType())); } return objs; } - @Override - public List filterTableMetas(String catName,String dbName,List tableMetas) throws MetaException { - List tableNames = new ArrayList<>(); - for(TableMeta tableMeta: tableMetas){ - tableNames.add(tableMeta.getTableName()); - } - List filteredTableNames = filterTableNames(catName,dbName,tableNames); - return tableMetas.stream() - .filter(e -> filteredTableNames.contains(e.getTableName())).collect(Collectors.toList()); - } + private List tableMetasToPrivilegeObjs(List tableMetas) { + List objs = new ArrayList(); + for (TableMeta tableMeta : tableMetas) { + objs.add(createPrivilegeObjectForTable(tableMeta.getDbName(), tableMeta.getTableName(), tableMeta.getOwnerName(), + tableMeta.getOwnerType())); + } + return objs; + } + + private ImmutablePair tableMetaKey(String dbName, String tableName) { + return new ImmutablePair(dbName, tableName); + } + + @Override + public List filterTableMetas(List tableMetas) throws MetaException { + List listObjs = tableMetasToPrivilegeObjs(tableMetas); + List filteredList = getFilteredObjects(listObjs); + Set> filteredNames = filteredList.stream() + .map(e -> tableMetaKey(e.getDbname(), e.getObjectName())) + .collect(Collectors.toSet()); + return tableMetas.stream() + .filter(e -> filteredNames.contains(tableMetaKey(e.getDbName(), e.getTableName()))) + .collect(Collectors.toList()); + } @Override public List filterDataConnectors(List dcList) throws MetaException { diff --git a/ql/src/java/org/apache/hadoop/hive/ql/security/authorization/plugin/metastore/HiveMetaStoreAuthorizer.java b/ql/src/java/org/apache/hadoop/hive/ql/security/authorization/plugin/metastore/HiveMetaStoreAuthorizer.java index 2ec1d3bf3155..55a980bc0925 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/security/authorization/plugin/metastore/HiveMetaStoreAuthorizer.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/security/authorization/plugin/metastore/HiveMetaStoreAuthorizer.java @@ -208,7 +208,14 @@ public final List filterCatalogs(List catalogs) throws MetaExcep } @Override - public final List filterTableMetas(String catName, String dbName, List tableMetas) + @Deprecated + public List filterTableMetas(String catName, String dbName,List tableMetas) + throws MetaException { + return filterTableMetas(tableMetas); + } + + @Override + public final List filterTableMetas(List tableMetas) throws MetaException { return tableMetas; } diff --git a/ql/src/test/queries/clientpositive/authorization_privilege_objects.q b/ql/src/test/queries/clientpositive/authorization_privilege_objects.q new file mode 100644 index 000000000000..79f8c90a492a --- /dev/null +++ b/ql/src/test/queries/clientpositive/authorization_privilege_objects.q @@ -0,0 +1,21 @@ +--! qt:authorizer +set hive.security.authorization.manager=org.apache.hadoop.hive.ql.security.authorization.plugin.sqlstd.SQLStdHiveAuthorizerFactoryForTest; +set test.hive.authz.sstd.validator.outputPrivObjs=true; +set test.hive.authz.sstd.validator.bypassObjTypes=DATABASE; +set hive.test.authz.sstd.hs2.mode=true; +set user.name=testuser; + +CREATE DATABASE test_auth_obj_db; +CREATE TABLE test_auth_obj_db.test_privs(i int); +set user.name=testuser2; +CREATE TABLE test_auth_obj_db.test_privs2(s string, i int); +set user.name=testuser; +SHOW DATABASES LIKE 'test_auth_obj_db'; +SHOW TABLES IN test_auth_obj_db; +EXPLAIN SELECT * FROM test_auth_obj_db.test_privs; +EXPLAIN INSERT INTO test_auth_obj_db.test_privs VALUES (1),(2),(3); +set user.name=testuser2; +DROP TABLE test_auth_obj_db.test_privs2; +set user.name=testuser; +DROP TABLE test_auth_obj_db.test_privs; +DROP DATABASE test_auth_obj_db; diff --git a/ql/src/test/results/clientpositive/llap/authorization_privilege_objects.q.out b/ql/src/test/results/clientpositive/llap/authorization_privilege_objects.q.out new file mode 100644 index 000000000000..b110218aa6e6 --- /dev/null +++ b/ql/src/test/results/clientpositive/llap/authorization_privilege_objects.q.out @@ -0,0 +1,221 @@ +outputHObjs: +HIVE PRIVILEGE OBJECT { type: DATABASE actionType: OTHER dbName: test_auth_obj_db} +PREHOOK: query: CREATE DATABASE test_auth_obj_db +PREHOOK: type: CREATEDATABASE +PREHOOK: Output: database:test_auth_obj_db +POSTHOOK: query: CREATE DATABASE test_auth_obj_db +POSTHOOK: type: CREATEDATABASE +POSTHOOK: Output: database:test_auth_obj_db +outputHObjs: +HIVE PRIVILEGE OBJECT { objectName: test_privs type: TABLE_OR_VIEW actionType: OTHER dbName: test_auth_obj_db OWNER: testuser OWNERTYPE: USER} +HIVE PRIVILEGE OBJECT { type: DATABASE actionType: OTHER dbName: test_auth_obj_db OWNER: testuser OWNERTYPE: USER} +PREHOOK: query: CREATE TABLE test_auth_obj_db.test_privs(i int) +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:test_auth_obj_db +PREHOOK: Output: test_auth_obj_db@test_privs +POSTHOOK: query: CREATE TABLE test_auth_obj_db.test_privs(i int) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:test_auth_obj_db +POSTHOOK: Output: test_auth_obj_db@test_privs +outputHObjs: +HIVE PRIVILEGE OBJECT { objectName: test_privs2 type: TABLE_OR_VIEW actionType: OTHER dbName: test_auth_obj_db OWNER: testuser2 OWNERTYPE: USER} +HIVE PRIVILEGE OBJECT { type: DATABASE actionType: OTHER dbName: test_auth_obj_db OWNER: testuser OWNERTYPE: USER} +PREHOOK: query: CREATE TABLE test_auth_obj_db.test_privs2(s string, i int) +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:test_auth_obj_db +PREHOOK: Output: test_auth_obj_db@test_privs2 +POSTHOOK: query: CREATE TABLE test_auth_obj_db.test_privs2(s string, i int) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:test_auth_obj_db +POSTHOOK: Output: test_auth_obj_db@test_privs2 +PREHOOK: query: SHOW DATABASES LIKE 'test_auth_obj_db' +PREHOOK: type: SHOWDATABASES +filterListCmdObjects +HIVE PRIVILEGE OBJECT { objectName: default type: DATABASE actionType: OTHER dbName: default} +HIVE PRIVILEGE OBJECT { objectName: test_auth_obj_db type: DATABASE actionType: OTHER dbName: test_auth_obj_db} +POSTHOOK: query: SHOW DATABASES LIKE 'test_auth_obj_db' +POSTHOOK: type: SHOWDATABASES +test_auth_obj_db +inputHObjs: +HIVE PRIVILEGE OBJECT { type: DATABASE actionType: OTHER dbName: test_auth_obj_db OWNER: testuser OWNERTYPE: USER} +PREHOOK: query: SHOW TABLES IN test_auth_obj_db +PREHOOK: type: SHOWTABLES +PREHOOK: Input: database:test_auth_obj_db +filterListCmdObjects +HIVE PRIVILEGE OBJECT { objectName: test_privs type: TABLE_OR_VIEW actionType: OTHER dbName: test_auth_obj_db OWNER: testuser OWNERTYPE: USER} +HIVE PRIVILEGE OBJECT { objectName: test_privs2 type: TABLE_OR_VIEW actionType: OTHER dbName: test_auth_obj_db OWNER: testuser2 OWNERTYPE: USER} +POSTHOOK: query: SHOW TABLES IN test_auth_obj_db +POSTHOOK: type: SHOWTABLES +POSTHOOK: Input: database:test_auth_obj_db +test_privs +test_privs2 +applyRowFilterAndColumnMasking: +HIVE PRIVILEGE OBJECT { objectName: test_privs type: TABLE_OR_VIEW actionType: OTHER dbName: test_auth_obj_db columns: [i]} +inputHObjs: +HIVE PRIVILEGE OBJECT { objectName: test_privs type: TABLE_OR_VIEW actionType: OTHER dbName: test_auth_obj_db OWNER: testuser OWNERTYPE: USER} +PREHOOK: query: EXPLAIN SELECT * FROM test_auth_obj_db.test_privs +PREHOOK: type: QUERY +PREHOOK: Input: test_auth_obj_db@test_privs +#### A masked pattern was here #### +POSTHOOK: query: EXPLAIN SELECT * FROM test_auth_obj_db.test_privs +POSTHOOK: type: QUERY +POSTHOOK: Input: test_auth_obj_db@test_privs +#### A masked pattern was here #### +STAGE DEPENDENCIES: + Stage-0 is a root stage + +STAGE PLANS: + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + TableScan + alias: test_privs + Select Operator + expressions: i (type: int) + outputColumnNames: _col0 + ListSink + +outputHObjs: +HIVE PRIVILEGE OBJECT { objectName: test_privs type: TABLE_OR_VIEW actionType: INSERT dbName: test_auth_obj_db OWNER: testuser OWNERTYPE: USER} +PREHOOK: query: EXPLAIN INSERT INTO test_auth_obj_db.test_privs VALUES (1),(2),(3) +PREHOOK: type: QUERY +PREHOOK: Input: _dummy_database@_dummy_table +PREHOOK: Output: test_auth_obj_db@test_privs +POSTHOOK: query: EXPLAIN INSERT INTO test_auth_obj_db.test_privs VALUES (1),(2),(3) +POSTHOOK: type: QUERY +POSTHOOK: Input: _dummy_database@_dummy_table +POSTHOOK: Output: test_auth_obj_db@test_privs +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-2 depends on stages: Stage-1 + Stage-0 depends on stages: Stage-2 + Stage-3 depends on stages: Stage-0 + +STAGE PLANS: + Stage: Stage-1 + Tez +#### A masked pattern was here #### + Edges: + Reducer 2 <- Map 1 (CUSTOM_SIMPLE_EDGE) +#### A masked pattern was here #### + Vertices: + Map 1 + Map Operator Tree: + TableScan + alias: _dummy_table + Row Limit Per Split: 1 + Statistics: Num rows: 1 Data size: 10 Basic stats: COMPLETE Column stats: COMPLETE + Select Operator + expressions: array(const struct(1),const struct(2),const struct(3)) (type: array>) + outputColumnNames: _col0 + Statistics: Num rows: 1 Data size: 64 Basic stats: COMPLETE Column stats: COMPLETE + UDTF Operator + Statistics: Num rows: 1 Data size: 64 Basic stats: COMPLETE Column stats: COMPLETE + function name: inline + Select Operator + expressions: col1 (type: int) + outputColumnNames: _col0 + Statistics: Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE + File Output Operator + compressed: false + Statistics: Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + name: test_auth_obj_db.test_privs + Select Operator + expressions: _col0 (type: int) + outputColumnNames: i + Statistics: Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE + Group By Operator + aggregations: min(i), max(i), count(1), count(i), compute_bit_vector_hll(i) + minReductionHashAggr: 0.4 + mode: hash + outputColumnNames: _col0, _col1, _col2, _col3, _col4 + Statistics: Num rows: 1 Data size: 168 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + null sort order: + sort order: + Statistics: Num rows: 1 Data size: 168 Basic stats: COMPLETE Column stats: COMPLETE + value expressions: _col0 (type: int), _col1 (type: int), _col2 (type: bigint), _col3 (type: bigint), _col4 (type: binary) + Execution mode: llap + LLAP IO: no inputs + Reducer 2 + Execution mode: vectorized, llap + Reduce Operator Tree: + Group By Operator + aggregations: min(VALUE._col0), max(VALUE._col1), count(VALUE._col2), count(VALUE._col3), compute_bit_vector_hll(VALUE._col4) + mode: mergepartial + outputColumnNames: _col0, _col1, _col2, _col3, _col4 + Statistics: Num rows: 1 Data size: 168 Basic stats: COMPLETE Column stats: COMPLETE + Select Operator + expressions: 'LONG' (type: string), UDFToLong(_col0) (type: bigint), UDFToLong(_col1) (type: bigint), (_col2 - _col3) (type: bigint), COALESCE(ndv_compute_bit_vector(_col4),0) (type: bigint), _col4 (type: binary) + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5 + Statistics: Num rows: 1 Data size: 264 Basic stats: COMPLETE Column stats: COMPLETE + File Output Operator + compressed: false + Statistics: Num rows: 1 Data size: 264 Basic stats: COMPLETE Column stats: COMPLETE + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-2 + Dependency Collection + + Stage: Stage-0 + Move Operator + tables: + replace: false + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + name: test_auth_obj_db.test_privs + + Stage: Stage-3 + Stats Work + Basic Stats Work: + Column Stats Desc: + Columns: i + Column Types: int + Table: test_auth_obj_db.test_privs + +inputHObjs: +HIVE PRIVILEGE OBJECT { objectName: test_privs2 type: TABLE_OR_VIEW actionType: OTHER dbName: test_auth_obj_db OWNER: testuser2 OWNERTYPE: USER} +outputHObjs: +HIVE PRIVILEGE OBJECT { objectName: test_privs2 type: TABLE_OR_VIEW actionType: OTHER dbName: test_auth_obj_db OWNER: testuser2 OWNERTYPE: USER} +PREHOOK: query: DROP TABLE test_auth_obj_db.test_privs2 +PREHOOK: type: DROPTABLE +PREHOOK: Input: test_auth_obj_db@test_privs2 +PREHOOK: Output: test_auth_obj_db@test_privs2 +POSTHOOK: query: DROP TABLE test_auth_obj_db.test_privs2 +POSTHOOK: type: DROPTABLE +POSTHOOK: Input: test_auth_obj_db@test_privs2 +POSTHOOK: Output: test_auth_obj_db@test_privs2 +inputHObjs: +HIVE PRIVILEGE OBJECT { objectName: test_privs type: TABLE_OR_VIEW actionType: OTHER dbName: test_auth_obj_db OWNER: testuser OWNERTYPE: USER} +outputHObjs: +HIVE PRIVILEGE OBJECT { objectName: test_privs type: TABLE_OR_VIEW actionType: OTHER dbName: test_auth_obj_db OWNER: testuser OWNERTYPE: USER} +PREHOOK: query: DROP TABLE test_auth_obj_db.test_privs +PREHOOK: type: DROPTABLE +PREHOOK: Input: test_auth_obj_db@test_privs +PREHOOK: Output: test_auth_obj_db@test_privs +POSTHOOK: query: DROP TABLE test_auth_obj_db.test_privs +POSTHOOK: type: DROPTABLE +POSTHOOK: Input: test_auth_obj_db@test_privs +POSTHOOK: Output: test_auth_obj_db@test_privs +inputHObjs: +HIVE PRIVILEGE OBJECT { type: DATABASE actionType: OTHER dbName: test_auth_obj_db OWNER: testuser OWNERTYPE: USER} +outputHObjs: +HIVE PRIVILEGE OBJECT { type: DATABASE actionType: OTHER dbName: test_auth_obj_db OWNER: testuser OWNERTYPE: USER} +PREHOOK: query: DROP DATABASE test_auth_obj_db +PREHOOK: type: DROPDATABASE +PREHOOK: Input: database:test_auth_obj_db +PREHOOK: Output: database:test_auth_obj_db +POSTHOOK: query: DROP DATABASE test_auth_obj_db +POSTHOOK: type: DROPDATABASE +POSTHOOK: Input: database:test_auth_obj_db +POSTHOOK: Output: database:test_auth_obj_db diff --git a/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp b/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp index e60ce29550c3..db3d08800147 100644 --- a/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp +++ b/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp @@ -2975,14 +2975,14 @@ uint32_t ThriftHiveMetastore_get_databases_result::read(::apache::thrift::protoc if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1787; - ::apache::thrift::protocol::TType _etype1790; - xfer += iprot->readListBegin(_etype1790, _size1787); - this->success.resize(_size1787); - uint32_t _i1791; - for (_i1791 = 0; _i1791 < _size1787; ++_i1791) + uint32_t _size1788; + ::apache::thrift::protocol::TType _etype1791; + xfer += iprot->readListBegin(_etype1791, _size1788); + this->success.resize(_size1788); + uint32_t _i1792; + for (_i1792 = 0; _i1792 < _size1788; ++_i1792) { - xfer += iprot->readString(this->success[_i1791]); + xfer += iprot->readString(this->success[_i1792]); } xfer += iprot->readListEnd(); } @@ -3021,10 +3021,10 @@ uint32_t ThriftHiveMetastore_get_databases_result::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1792; - for (_iter1792 = this->success.begin(); _iter1792 != this->success.end(); ++_iter1792) + std::vector ::const_iterator _iter1793; + for (_iter1793 = this->success.begin(); _iter1793 != this->success.end(); ++_iter1793) { - xfer += oprot->writeString((*_iter1792)); + xfer += oprot->writeString((*_iter1793)); } xfer += oprot->writeListEnd(); } @@ -3069,14 +3069,14 @@ uint32_t ThriftHiveMetastore_get_databases_presult::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1793; - ::apache::thrift::protocol::TType _etype1796; - xfer += iprot->readListBegin(_etype1796, _size1793); - (*(this->success)).resize(_size1793); - uint32_t _i1797; - for (_i1797 = 0; _i1797 < _size1793; ++_i1797) + uint32_t _size1794; + ::apache::thrift::protocol::TType _etype1797; + xfer += iprot->readListBegin(_etype1797, _size1794); + (*(this->success)).resize(_size1794); + uint32_t _i1798; + for (_i1798 = 0; _i1798 < _size1794; ++_i1798) { - xfer += iprot->readString((*(this->success))[_i1797]); + xfer += iprot->readString((*(this->success))[_i1798]); } xfer += iprot->readListEnd(); } @@ -3193,14 +3193,14 @@ uint32_t ThriftHiveMetastore_get_all_databases_result::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1798; - ::apache::thrift::protocol::TType _etype1801; - xfer += iprot->readListBegin(_etype1801, _size1798); - this->success.resize(_size1798); - uint32_t _i1802; - for (_i1802 = 0; _i1802 < _size1798; ++_i1802) + uint32_t _size1799; + ::apache::thrift::protocol::TType _etype1802; + xfer += iprot->readListBegin(_etype1802, _size1799); + this->success.resize(_size1799); + uint32_t _i1803; + for (_i1803 = 0; _i1803 < _size1799; ++_i1803) { - xfer += iprot->readString(this->success[_i1802]); + xfer += iprot->readString(this->success[_i1803]); } xfer += iprot->readListEnd(); } @@ -3239,10 +3239,10 @@ uint32_t ThriftHiveMetastore_get_all_databases_result::write(::apache::thrift::p xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1803; - for (_iter1803 = this->success.begin(); _iter1803 != this->success.end(); ++_iter1803) + std::vector ::const_iterator _iter1804; + for (_iter1804 = this->success.begin(); _iter1804 != this->success.end(); ++_iter1804) { - xfer += oprot->writeString((*_iter1803)); + xfer += oprot->writeString((*_iter1804)); } xfer += oprot->writeListEnd(); } @@ -3287,14 +3287,14 @@ uint32_t ThriftHiveMetastore_get_all_databases_presult::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1804; - ::apache::thrift::protocol::TType _etype1807; - xfer += iprot->readListBegin(_etype1807, _size1804); - (*(this->success)).resize(_size1804); - uint32_t _i1808; - for (_i1808 = 0; _i1808 < _size1804; ++_i1808) + uint32_t _size1805; + ::apache::thrift::protocol::TType _etype1808; + xfer += iprot->readListBegin(_etype1808, _size1805); + (*(this->success)).resize(_size1805); + uint32_t _i1809; + for (_i1809 = 0; _i1809 < _size1805; ++_i1809) { - xfer += iprot->readString((*(this->success))[_i1808]); + xfer += iprot->readString((*(this->success))[_i1809]); } xfer += iprot->readListEnd(); } @@ -4347,14 +4347,14 @@ uint32_t ThriftHiveMetastore_get_dataconnectors_result::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1809; - ::apache::thrift::protocol::TType _etype1812; - xfer += iprot->readListBegin(_etype1812, _size1809); - this->success.resize(_size1809); - uint32_t _i1813; - for (_i1813 = 0; _i1813 < _size1809; ++_i1813) + uint32_t _size1810; + ::apache::thrift::protocol::TType _etype1813; + xfer += iprot->readListBegin(_etype1813, _size1810); + this->success.resize(_size1810); + uint32_t _i1814; + for (_i1814 = 0; _i1814 < _size1810; ++_i1814) { - xfer += iprot->readString(this->success[_i1813]); + xfer += iprot->readString(this->success[_i1814]); } xfer += iprot->readListEnd(); } @@ -4393,10 +4393,10 @@ uint32_t ThriftHiveMetastore_get_dataconnectors_result::write(::apache::thrift:: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1814; - for (_iter1814 = this->success.begin(); _iter1814 != this->success.end(); ++_iter1814) + std::vector ::const_iterator _iter1815; + for (_iter1815 = this->success.begin(); _iter1815 != this->success.end(); ++_iter1815) { - xfer += oprot->writeString((*_iter1814)); + xfer += oprot->writeString((*_iter1815)); } xfer += oprot->writeListEnd(); } @@ -4441,14 +4441,14 @@ uint32_t ThriftHiveMetastore_get_dataconnectors_presult::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1815; - ::apache::thrift::protocol::TType _etype1818; - xfer += iprot->readListBegin(_etype1818, _size1815); - (*(this->success)).resize(_size1815); - uint32_t _i1819; - for (_i1819 = 0; _i1819 < _size1815; ++_i1819) + uint32_t _size1816; + ::apache::thrift::protocol::TType _etype1819; + xfer += iprot->readListBegin(_etype1819, _size1816); + (*(this->success)).resize(_size1816); + uint32_t _i1820; + for (_i1820 = 0; _i1820 < _size1816; ++_i1820) { - xfer += iprot->readString((*(this->success))[_i1819]); + xfer += iprot->readString((*(this->success))[_i1820]); } xfer += iprot->readListEnd(); } @@ -5510,17 +5510,17 @@ uint32_t ThriftHiveMetastore_get_type_all_result::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_MAP) { { this->success.clear(); - uint32_t _size1820; - ::apache::thrift::protocol::TType _ktype1821; - ::apache::thrift::protocol::TType _vtype1822; - xfer += iprot->readMapBegin(_ktype1821, _vtype1822, _size1820); - uint32_t _i1824; - for (_i1824 = 0; _i1824 < _size1820; ++_i1824) + uint32_t _size1821; + ::apache::thrift::protocol::TType _ktype1822; + ::apache::thrift::protocol::TType _vtype1823; + xfer += iprot->readMapBegin(_ktype1822, _vtype1823, _size1821); + uint32_t _i1825; + for (_i1825 = 0; _i1825 < _size1821; ++_i1825) { - std::string _key1825; - xfer += iprot->readString(_key1825); - Type& _val1826 = this->success[_key1825]; - xfer += _val1826.read(iprot); + std::string _key1826; + xfer += iprot->readString(_key1826); + Type& _val1827 = this->success[_key1826]; + xfer += _val1827.read(iprot); } xfer += iprot->readMapEnd(); } @@ -5559,11 +5559,11 @@ uint32_t ThriftHiveMetastore_get_type_all_result::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_MAP, 0); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::map ::const_iterator _iter1827; - for (_iter1827 = this->success.begin(); _iter1827 != this->success.end(); ++_iter1827) + std::map ::const_iterator _iter1828; + for (_iter1828 = this->success.begin(); _iter1828 != this->success.end(); ++_iter1828) { - xfer += oprot->writeString(_iter1827->first); - xfer += _iter1827->second.write(oprot); + xfer += oprot->writeString(_iter1828->first); + xfer += _iter1828->second.write(oprot); } xfer += oprot->writeMapEnd(); } @@ -5608,17 +5608,17 @@ uint32_t ThriftHiveMetastore_get_type_all_presult::read(::apache::thrift::protoc if (ftype == ::apache::thrift::protocol::T_MAP) { { (*(this->success)).clear(); - uint32_t _size1828; - ::apache::thrift::protocol::TType _ktype1829; - ::apache::thrift::protocol::TType _vtype1830; - xfer += iprot->readMapBegin(_ktype1829, _vtype1830, _size1828); - uint32_t _i1832; - for (_i1832 = 0; _i1832 < _size1828; ++_i1832) + uint32_t _size1829; + ::apache::thrift::protocol::TType _ktype1830; + ::apache::thrift::protocol::TType _vtype1831; + xfer += iprot->readMapBegin(_ktype1830, _vtype1831, _size1829); + uint32_t _i1833; + for (_i1833 = 0; _i1833 < _size1829; ++_i1833) { - std::string _key1833; - xfer += iprot->readString(_key1833); - Type& _val1834 = (*(this->success))[_key1833]; - xfer += _val1834.read(iprot); + std::string _key1834; + xfer += iprot->readString(_key1834); + Type& _val1835 = (*(this->success))[_key1834]; + xfer += _val1835.read(iprot); } xfer += iprot->readMapEnd(); } @@ -5772,14 +5772,14 @@ uint32_t ThriftHiveMetastore_get_fields_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1835; - ::apache::thrift::protocol::TType _etype1838; - xfer += iprot->readListBegin(_etype1838, _size1835); - this->success.resize(_size1835); - uint32_t _i1839; - for (_i1839 = 0; _i1839 < _size1835; ++_i1839) + uint32_t _size1836; + ::apache::thrift::protocol::TType _etype1839; + xfer += iprot->readListBegin(_etype1839, _size1836); + this->success.resize(_size1836); + uint32_t _i1840; + for (_i1840 = 0; _i1840 < _size1836; ++_i1840) { - xfer += this->success[_i1839].read(iprot); + xfer += this->success[_i1840].read(iprot); } xfer += iprot->readListEnd(); } @@ -5834,10 +5834,10 @@ uint32_t ThriftHiveMetastore_get_fields_result::write(::apache::thrift::protocol xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1840; - for (_iter1840 = this->success.begin(); _iter1840 != this->success.end(); ++_iter1840) + std::vector ::const_iterator _iter1841; + for (_iter1841 = this->success.begin(); _iter1841 != this->success.end(); ++_iter1841) { - xfer += (*_iter1840).write(oprot); + xfer += (*_iter1841).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5890,14 +5890,14 @@ uint32_t ThriftHiveMetastore_get_fields_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1841; - ::apache::thrift::protocol::TType _etype1844; - xfer += iprot->readListBegin(_etype1844, _size1841); - (*(this->success)).resize(_size1841); - uint32_t _i1845; - for (_i1845 = 0; _i1845 < _size1841; ++_i1845) + uint32_t _size1842; + ::apache::thrift::protocol::TType _etype1845; + xfer += iprot->readListBegin(_etype1845, _size1842); + (*(this->success)).resize(_size1842); + uint32_t _i1846; + for (_i1846 = 0; _i1846 < _size1842; ++_i1846) { - xfer += (*(this->success))[_i1845].read(iprot); + xfer += (*(this->success))[_i1846].read(iprot); } xfer += iprot->readListEnd(); } @@ -6083,14 +6083,14 @@ uint32_t ThriftHiveMetastore_get_fields_with_environment_context_result::read(:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1846; - ::apache::thrift::protocol::TType _etype1849; - xfer += iprot->readListBegin(_etype1849, _size1846); - this->success.resize(_size1846); - uint32_t _i1850; - for (_i1850 = 0; _i1850 < _size1846; ++_i1850) + uint32_t _size1847; + ::apache::thrift::protocol::TType _etype1850; + xfer += iprot->readListBegin(_etype1850, _size1847); + this->success.resize(_size1847); + uint32_t _i1851; + for (_i1851 = 0; _i1851 < _size1847; ++_i1851) { - xfer += this->success[_i1850].read(iprot); + xfer += this->success[_i1851].read(iprot); } xfer += iprot->readListEnd(); } @@ -6145,10 +6145,10 @@ uint32_t ThriftHiveMetastore_get_fields_with_environment_context_result::write(: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1851; - for (_iter1851 = this->success.begin(); _iter1851 != this->success.end(); ++_iter1851) + std::vector ::const_iterator _iter1852; + for (_iter1852 = this->success.begin(); _iter1852 != this->success.end(); ++_iter1852) { - xfer += (*_iter1851).write(oprot); + xfer += (*_iter1852).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6201,14 +6201,14 @@ uint32_t ThriftHiveMetastore_get_fields_with_environment_context_presult::read(: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1852; - ::apache::thrift::protocol::TType _etype1855; - xfer += iprot->readListBegin(_etype1855, _size1852); - (*(this->success)).resize(_size1852); - uint32_t _i1856; - for (_i1856 = 0; _i1856 < _size1852; ++_i1856) + uint32_t _size1853; + ::apache::thrift::protocol::TType _etype1856; + xfer += iprot->readListBegin(_etype1856, _size1853); + (*(this->success)).resize(_size1853); + uint32_t _i1857; + for (_i1857 = 0; _i1857 < _size1853; ++_i1857) { - xfer += (*(this->success))[_i1856].read(iprot); + xfer += (*(this->success))[_i1857].read(iprot); } xfer += iprot->readListEnd(); } @@ -6625,14 +6625,14 @@ uint32_t ThriftHiveMetastore_get_schema_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1857; - ::apache::thrift::protocol::TType _etype1860; - xfer += iprot->readListBegin(_etype1860, _size1857); - this->success.resize(_size1857); - uint32_t _i1861; - for (_i1861 = 0; _i1861 < _size1857; ++_i1861) + uint32_t _size1858; + ::apache::thrift::protocol::TType _etype1861; + xfer += iprot->readListBegin(_etype1861, _size1858); + this->success.resize(_size1858); + uint32_t _i1862; + for (_i1862 = 0; _i1862 < _size1858; ++_i1862) { - xfer += this->success[_i1861].read(iprot); + xfer += this->success[_i1862].read(iprot); } xfer += iprot->readListEnd(); } @@ -6687,10 +6687,10 @@ uint32_t ThriftHiveMetastore_get_schema_result::write(::apache::thrift::protocol xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1862; - for (_iter1862 = this->success.begin(); _iter1862 != this->success.end(); ++_iter1862) + std::vector ::const_iterator _iter1863; + for (_iter1863 = this->success.begin(); _iter1863 != this->success.end(); ++_iter1863) { - xfer += (*_iter1862).write(oprot); + xfer += (*_iter1863).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6743,14 +6743,14 @@ uint32_t ThriftHiveMetastore_get_schema_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1863; - ::apache::thrift::protocol::TType _etype1866; - xfer += iprot->readListBegin(_etype1866, _size1863); - (*(this->success)).resize(_size1863); - uint32_t _i1867; - for (_i1867 = 0; _i1867 < _size1863; ++_i1867) + uint32_t _size1864; + ::apache::thrift::protocol::TType _etype1867; + xfer += iprot->readListBegin(_etype1867, _size1864); + (*(this->success)).resize(_size1864); + uint32_t _i1868; + for (_i1868 = 0; _i1868 < _size1864; ++_i1868) { - xfer += (*(this->success))[_i1867].read(iprot); + xfer += (*(this->success))[_i1868].read(iprot); } xfer += iprot->readListEnd(); } @@ -6936,14 +6936,14 @@ uint32_t ThriftHiveMetastore_get_schema_with_environment_context_result::read(:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1868; - ::apache::thrift::protocol::TType _etype1871; - xfer += iprot->readListBegin(_etype1871, _size1868); - this->success.resize(_size1868); - uint32_t _i1872; - for (_i1872 = 0; _i1872 < _size1868; ++_i1872) + uint32_t _size1869; + ::apache::thrift::protocol::TType _etype1872; + xfer += iprot->readListBegin(_etype1872, _size1869); + this->success.resize(_size1869); + uint32_t _i1873; + for (_i1873 = 0; _i1873 < _size1869; ++_i1873) { - xfer += this->success[_i1872].read(iprot); + xfer += this->success[_i1873].read(iprot); } xfer += iprot->readListEnd(); } @@ -6998,10 +6998,10 @@ uint32_t ThriftHiveMetastore_get_schema_with_environment_context_result::write(: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1873; - for (_iter1873 = this->success.begin(); _iter1873 != this->success.end(); ++_iter1873) + std::vector ::const_iterator _iter1874; + for (_iter1874 = this->success.begin(); _iter1874 != this->success.end(); ++_iter1874) { - xfer += (*_iter1873).write(oprot); + xfer += (*_iter1874).write(oprot); } xfer += oprot->writeListEnd(); } @@ -7054,14 +7054,14 @@ uint32_t ThriftHiveMetastore_get_schema_with_environment_context_presult::read(: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1874; - ::apache::thrift::protocol::TType _etype1877; - xfer += iprot->readListBegin(_etype1877, _size1874); - (*(this->success)).resize(_size1874); - uint32_t _i1878; - for (_i1878 = 0; _i1878 < _size1874; ++_i1878) + uint32_t _size1875; + ::apache::thrift::protocol::TType _etype1878; + xfer += iprot->readListBegin(_etype1878, _size1875); + (*(this->success)).resize(_size1875); + uint32_t _i1879; + for (_i1879 = 0; _i1879 < _size1875; ++_i1879) { - xfer += (*(this->success))[_i1878].read(iprot); + xfer += (*(this->success))[_i1879].read(iprot); } xfer += iprot->readListEnd(); } @@ -7901,14 +7901,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->primaryKeys.clear(); - uint32_t _size1879; - ::apache::thrift::protocol::TType _etype1882; - xfer += iprot->readListBegin(_etype1882, _size1879); - this->primaryKeys.resize(_size1879); - uint32_t _i1883; - for (_i1883 = 0; _i1883 < _size1879; ++_i1883) + uint32_t _size1880; + ::apache::thrift::protocol::TType _etype1883; + xfer += iprot->readListBegin(_etype1883, _size1880); + this->primaryKeys.resize(_size1880); + uint32_t _i1884; + for (_i1884 = 0; _i1884 < _size1880; ++_i1884) { - xfer += this->primaryKeys[_i1883].read(iprot); + xfer += this->primaryKeys[_i1884].read(iprot); } xfer += iprot->readListEnd(); } @@ -7921,14 +7921,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->foreignKeys.clear(); - uint32_t _size1884; - ::apache::thrift::protocol::TType _etype1887; - xfer += iprot->readListBegin(_etype1887, _size1884); - this->foreignKeys.resize(_size1884); - uint32_t _i1888; - for (_i1888 = 0; _i1888 < _size1884; ++_i1888) + uint32_t _size1885; + ::apache::thrift::protocol::TType _etype1888; + xfer += iprot->readListBegin(_etype1888, _size1885); + this->foreignKeys.resize(_size1885); + uint32_t _i1889; + for (_i1889 = 0; _i1889 < _size1885; ++_i1889) { - xfer += this->foreignKeys[_i1888].read(iprot); + xfer += this->foreignKeys[_i1889].read(iprot); } xfer += iprot->readListEnd(); } @@ -7941,14 +7941,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->uniqueConstraints.clear(); - uint32_t _size1889; - ::apache::thrift::protocol::TType _etype1892; - xfer += iprot->readListBegin(_etype1892, _size1889); - this->uniqueConstraints.resize(_size1889); - uint32_t _i1893; - for (_i1893 = 0; _i1893 < _size1889; ++_i1893) + uint32_t _size1890; + ::apache::thrift::protocol::TType _etype1893; + xfer += iprot->readListBegin(_etype1893, _size1890); + this->uniqueConstraints.resize(_size1890); + uint32_t _i1894; + for (_i1894 = 0; _i1894 < _size1890; ++_i1894) { - xfer += this->uniqueConstraints[_i1893].read(iprot); + xfer += this->uniqueConstraints[_i1894].read(iprot); } xfer += iprot->readListEnd(); } @@ -7961,14 +7961,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->notNullConstraints.clear(); - uint32_t _size1894; - ::apache::thrift::protocol::TType _etype1897; - xfer += iprot->readListBegin(_etype1897, _size1894); - this->notNullConstraints.resize(_size1894); - uint32_t _i1898; - for (_i1898 = 0; _i1898 < _size1894; ++_i1898) + uint32_t _size1895; + ::apache::thrift::protocol::TType _etype1898; + xfer += iprot->readListBegin(_etype1898, _size1895); + this->notNullConstraints.resize(_size1895); + uint32_t _i1899; + for (_i1899 = 0; _i1899 < _size1895; ++_i1899) { - xfer += this->notNullConstraints[_i1898].read(iprot); + xfer += this->notNullConstraints[_i1899].read(iprot); } xfer += iprot->readListEnd(); } @@ -7981,14 +7981,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->defaultConstraints.clear(); - uint32_t _size1899; - ::apache::thrift::protocol::TType _etype1902; - xfer += iprot->readListBegin(_etype1902, _size1899); - this->defaultConstraints.resize(_size1899); - uint32_t _i1903; - for (_i1903 = 0; _i1903 < _size1899; ++_i1903) + uint32_t _size1900; + ::apache::thrift::protocol::TType _etype1903; + xfer += iprot->readListBegin(_etype1903, _size1900); + this->defaultConstraints.resize(_size1900); + uint32_t _i1904; + for (_i1904 = 0; _i1904 < _size1900; ++_i1904) { - xfer += this->defaultConstraints[_i1903].read(iprot); + xfer += this->defaultConstraints[_i1904].read(iprot); } xfer += iprot->readListEnd(); } @@ -8001,14 +8001,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->checkConstraints.clear(); - uint32_t _size1904; - ::apache::thrift::protocol::TType _etype1907; - xfer += iprot->readListBegin(_etype1907, _size1904); - this->checkConstraints.resize(_size1904); - uint32_t _i1908; - for (_i1908 = 0; _i1908 < _size1904; ++_i1908) + uint32_t _size1905; + ::apache::thrift::protocol::TType _etype1908; + xfer += iprot->readListBegin(_etype1908, _size1905); + this->checkConstraints.resize(_size1905); + uint32_t _i1909; + for (_i1909 = 0; _i1909 < _size1905; ++_i1909) { - xfer += this->checkConstraints[_i1908].read(iprot); + xfer += this->checkConstraints[_i1909].read(iprot); } xfer += iprot->readListEnd(); } @@ -8041,10 +8041,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache: xfer += oprot->writeFieldBegin("primaryKeys", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->primaryKeys.size())); - std::vector ::const_iterator _iter1909; - for (_iter1909 = this->primaryKeys.begin(); _iter1909 != this->primaryKeys.end(); ++_iter1909) + std::vector ::const_iterator _iter1910; + for (_iter1910 = this->primaryKeys.begin(); _iter1910 != this->primaryKeys.end(); ++_iter1910) { - xfer += (*_iter1909).write(oprot); + xfer += (*_iter1910).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8053,10 +8053,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache: xfer += oprot->writeFieldBegin("foreignKeys", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->foreignKeys.size())); - std::vector ::const_iterator _iter1910; - for (_iter1910 = this->foreignKeys.begin(); _iter1910 != this->foreignKeys.end(); ++_iter1910) + std::vector ::const_iterator _iter1911; + for (_iter1911 = this->foreignKeys.begin(); _iter1911 != this->foreignKeys.end(); ++_iter1911) { - xfer += (*_iter1910).write(oprot); + xfer += (*_iter1911).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8065,10 +8065,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache: xfer += oprot->writeFieldBegin("uniqueConstraints", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->uniqueConstraints.size())); - std::vector ::const_iterator _iter1911; - for (_iter1911 = this->uniqueConstraints.begin(); _iter1911 != this->uniqueConstraints.end(); ++_iter1911) + std::vector ::const_iterator _iter1912; + for (_iter1912 = this->uniqueConstraints.begin(); _iter1912 != this->uniqueConstraints.end(); ++_iter1912) { - xfer += (*_iter1911).write(oprot); + xfer += (*_iter1912).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8077,10 +8077,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache: xfer += oprot->writeFieldBegin("notNullConstraints", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->notNullConstraints.size())); - std::vector ::const_iterator _iter1912; - for (_iter1912 = this->notNullConstraints.begin(); _iter1912 != this->notNullConstraints.end(); ++_iter1912) + std::vector ::const_iterator _iter1913; + for (_iter1913 = this->notNullConstraints.begin(); _iter1913 != this->notNullConstraints.end(); ++_iter1913) { - xfer += (*_iter1912).write(oprot); + xfer += (*_iter1913).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8089,10 +8089,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache: xfer += oprot->writeFieldBegin("defaultConstraints", ::apache::thrift::protocol::T_LIST, 6); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->defaultConstraints.size())); - std::vector ::const_iterator _iter1913; - for (_iter1913 = this->defaultConstraints.begin(); _iter1913 != this->defaultConstraints.end(); ++_iter1913) + std::vector ::const_iterator _iter1914; + for (_iter1914 = this->defaultConstraints.begin(); _iter1914 != this->defaultConstraints.end(); ++_iter1914) { - xfer += (*_iter1913).write(oprot); + xfer += (*_iter1914).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8101,10 +8101,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache: xfer += oprot->writeFieldBegin("checkConstraints", ::apache::thrift::protocol::T_LIST, 7); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->checkConstraints.size())); - std::vector ::const_iterator _iter1914; - for (_iter1914 = this->checkConstraints.begin(); _iter1914 != this->checkConstraints.end(); ++_iter1914) + std::vector ::const_iterator _iter1915; + for (_iter1915 = this->checkConstraints.begin(); _iter1915 != this->checkConstraints.end(); ++_iter1915) { - xfer += (*_iter1914).write(oprot); + xfer += (*_iter1915).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8132,10 +8132,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache xfer += oprot->writeFieldBegin("primaryKeys", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->primaryKeys)).size())); - std::vector ::const_iterator _iter1915; - for (_iter1915 = (*(this->primaryKeys)).begin(); _iter1915 != (*(this->primaryKeys)).end(); ++_iter1915) + std::vector ::const_iterator _iter1916; + for (_iter1916 = (*(this->primaryKeys)).begin(); _iter1916 != (*(this->primaryKeys)).end(); ++_iter1916) { - xfer += (*_iter1915).write(oprot); + xfer += (*_iter1916).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8144,10 +8144,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache xfer += oprot->writeFieldBegin("foreignKeys", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->foreignKeys)).size())); - std::vector ::const_iterator _iter1916; - for (_iter1916 = (*(this->foreignKeys)).begin(); _iter1916 != (*(this->foreignKeys)).end(); ++_iter1916) + std::vector ::const_iterator _iter1917; + for (_iter1917 = (*(this->foreignKeys)).begin(); _iter1917 != (*(this->foreignKeys)).end(); ++_iter1917) { - xfer += (*_iter1916).write(oprot); + xfer += (*_iter1917).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8156,10 +8156,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache xfer += oprot->writeFieldBegin("uniqueConstraints", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->uniqueConstraints)).size())); - std::vector ::const_iterator _iter1917; - for (_iter1917 = (*(this->uniqueConstraints)).begin(); _iter1917 != (*(this->uniqueConstraints)).end(); ++_iter1917) + std::vector ::const_iterator _iter1918; + for (_iter1918 = (*(this->uniqueConstraints)).begin(); _iter1918 != (*(this->uniqueConstraints)).end(); ++_iter1918) { - xfer += (*_iter1917).write(oprot); + xfer += (*_iter1918).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8168,10 +8168,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache xfer += oprot->writeFieldBegin("notNullConstraints", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->notNullConstraints)).size())); - std::vector ::const_iterator _iter1918; - for (_iter1918 = (*(this->notNullConstraints)).begin(); _iter1918 != (*(this->notNullConstraints)).end(); ++_iter1918) + std::vector ::const_iterator _iter1919; + for (_iter1919 = (*(this->notNullConstraints)).begin(); _iter1919 != (*(this->notNullConstraints)).end(); ++_iter1919) { - xfer += (*_iter1918).write(oprot); + xfer += (*_iter1919).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8180,10 +8180,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache xfer += oprot->writeFieldBegin("defaultConstraints", ::apache::thrift::protocol::T_LIST, 6); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->defaultConstraints)).size())); - std::vector ::const_iterator _iter1919; - for (_iter1919 = (*(this->defaultConstraints)).begin(); _iter1919 != (*(this->defaultConstraints)).end(); ++_iter1919) + std::vector ::const_iterator _iter1920; + for (_iter1920 = (*(this->defaultConstraints)).begin(); _iter1920 != (*(this->defaultConstraints)).end(); ++_iter1920) { - xfer += (*_iter1919).write(oprot); + xfer += (*_iter1920).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8192,10 +8192,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache xfer += oprot->writeFieldBegin("checkConstraints", ::apache::thrift::protocol::T_LIST, 7); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->checkConstraints)).size())); - std::vector ::const_iterator _iter1920; - for (_iter1920 = (*(this->checkConstraints)).begin(); _iter1920 != (*(this->checkConstraints)).end(); ++_iter1920) + std::vector ::const_iterator _iter1921; + for (_iter1921 = (*(this->checkConstraints)).begin(); _iter1921 != (*(this->checkConstraints)).end(); ++_iter1921) { - xfer += (*_iter1920).write(oprot); + xfer += (*_iter1921).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10877,14 +10877,14 @@ uint32_t ThriftHiveMetastore_truncate_table_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partNames.clear(); - uint32_t _size1921; - ::apache::thrift::protocol::TType _etype1924; - xfer += iprot->readListBegin(_etype1924, _size1921); - this->partNames.resize(_size1921); - uint32_t _i1925; - for (_i1925 = 0; _i1925 < _size1921; ++_i1925) + uint32_t _size1922; + ::apache::thrift::protocol::TType _etype1925; + xfer += iprot->readListBegin(_etype1925, _size1922); + this->partNames.resize(_size1922); + uint32_t _i1926; + for (_i1926 = 0; _i1926 < _size1922; ++_i1926) { - xfer += iprot->readString(this->partNames[_i1925]); + xfer += iprot->readString(this->partNames[_i1926]); } xfer += iprot->readListEnd(); } @@ -10921,10 +10921,10 @@ uint32_t ThriftHiveMetastore_truncate_table_args::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("partNames", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partNames.size())); - std::vector ::const_iterator _iter1926; - for (_iter1926 = this->partNames.begin(); _iter1926 != this->partNames.end(); ++_iter1926) + std::vector ::const_iterator _iter1927; + for (_iter1927 = this->partNames.begin(); _iter1927 != this->partNames.end(); ++_iter1927) { - xfer += oprot->writeString((*_iter1926)); + xfer += oprot->writeString((*_iter1927)); } xfer += oprot->writeListEnd(); } @@ -10956,10 +10956,10 @@ uint32_t ThriftHiveMetastore_truncate_table_pargs::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("partNames", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->partNames)).size())); - std::vector ::const_iterator _iter1927; - for (_iter1927 = (*(this->partNames)).begin(); _iter1927 != (*(this->partNames)).end(); ++_iter1927) + std::vector ::const_iterator _iter1928; + for (_iter1928 = (*(this->partNames)).begin(); _iter1928 != (*(this->partNames)).end(); ++_iter1928) { - xfer += oprot->writeString((*_iter1927)); + xfer += oprot->writeString((*_iter1928)); } xfer += oprot->writeListEnd(); } @@ -11410,14 +11410,14 @@ uint32_t ThriftHiveMetastore_get_tables_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1928; - ::apache::thrift::protocol::TType _etype1931; - xfer += iprot->readListBegin(_etype1931, _size1928); - this->success.resize(_size1928); - uint32_t _i1932; - for (_i1932 = 0; _i1932 < _size1928; ++_i1932) + uint32_t _size1929; + ::apache::thrift::protocol::TType _etype1932; + xfer += iprot->readListBegin(_etype1932, _size1929); + this->success.resize(_size1929); + uint32_t _i1933; + for (_i1933 = 0; _i1933 < _size1929; ++_i1933) { - xfer += iprot->readString(this->success[_i1932]); + xfer += iprot->readString(this->success[_i1933]); } xfer += iprot->readListEnd(); } @@ -11456,10 +11456,10 @@ uint32_t ThriftHiveMetastore_get_tables_result::write(::apache::thrift::protocol xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1933; - for (_iter1933 = this->success.begin(); _iter1933 != this->success.end(); ++_iter1933) + std::vector ::const_iterator _iter1934; + for (_iter1934 = this->success.begin(); _iter1934 != this->success.end(); ++_iter1934) { - xfer += oprot->writeString((*_iter1933)); + xfer += oprot->writeString((*_iter1934)); } xfer += oprot->writeListEnd(); } @@ -11504,14 +11504,14 @@ uint32_t ThriftHiveMetastore_get_tables_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1934; - ::apache::thrift::protocol::TType _etype1937; - xfer += iprot->readListBegin(_etype1937, _size1934); - (*(this->success)).resize(_size1934); - uint32_t _i1938; - for (_i1938 = 0; _i1938 < _size1934; ++_i1938) + uint32_t _size1935; + ::apache::thrift::protocol::TType _etype1938; + xfer += iprot->readListBegin(_etype1938, _size1935); + (*(this->success)).resize(_size1935); + uint32_t _i1939; + for (_i1939 = 0; _i1939 < _size1935; ++_i1939) { - xfer += iprot->readString((*(this->success))[_i1938]); + xfer += iprot->readString((*(this->success))[_i1939]); } xfer += iprot->readListEnd(); } @@ -11681,14 +11681,14 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_result::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1939; - ::apache::thrift::protocol::TType _etype1942; - xfer += iprot->readListBegin(_etype1942, _size1939); - this->success.resize(_size1939); - uint32_t _i1943; - for (_i1943 = 0; _i1943 < _size1939; ++_i1943) + uint32_t _size1940; + ::apache::thrift::protocol::TType _etype1943; + xfer += iprot->readListBegin(_etype1943, _size1940); + this->success.resize(_size1940); + uint32_t _i1944; + for (_i1944 = 0; _i1944 < _size1940; ++_i1944) { - xfer += iprot->readString(this->success[_i1943]); + xfer += iprot->readString(this->success[_i1944]); } xfer += iprot->readListEnd(); } @@ -11727,10 +11727,10 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_result::write(::apache::thrift:: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1944; - for (_iter1944 = this->success.begin(); _iter1944 != this->success.end(); ++_iter1944) + std::vector ::const_iterator _iter1945; + for (_iter1945 = this->success.begin(); _iter1945 != this->success.end(); ++_iter1945) { - xfer += oprot->writeString((*_iter1944)); + xfer += oprot->writeString((*_iter1945)); } xfer += oprot->writeListEnd(); } @@ -11775,14 +11775,14 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_presult::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1945; - ::apache::thrift::protocol::TType _etype1948; - xfer += iprot->readListBegin(_etype1948, _size1945); - (*(this->success)).resize(_size1945); - uint32_t _i1949; - for (_i1949 = 0; _i1949 < _size1945; ++_i1949) + uint32_t _size1946; + ::apache::thrift::protocol::TType _etype1949; + xfer += iprot->readListBegin(_etype1949, _size1946); + (*(this->success)).resize(_size1946); + uint32_t _i1950; + for (_i1950 = 0; _i1950 < _size1946; ++_i1950) { - xfer += iprot->readString((*(this->success))[_i1949]); + xfer += iprot->readString((*(this->success))[_i1950]); } xfer += iprot->readListEnd(); } @@ -11899,14 +11899,14 @@ uint32_t ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_res if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1950; - ::apache::thrift::protocol::TType _etype1953; - xfer += iprot->readListBegin(_etype1953, _size1950); - this->success.resize(_size1950); - uint32_t _i1954; - for (_i1954 = 0; _i1954 < _size1950; ++_i1954) + uint32_t _size1951; + ::apache::thrift::protocol::TType _etype1954; + xfer += iprot->readListBegin(_etype1954, _size1951); + this->success.resize(_size1951); + uint32_t _i1955; + for (_i1955 = 0; _i1955 < _size1951; ++_i1955) { - xfer += this->success[_i1954].read(iprot); + xfer += this->success[_i1955].read(iprot); } xfer += iprot->readListEnd(); } @@ -11945,10 +11945,10 @@ uint32_t ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_res 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 _iter1955; - for (_iter1955 = this->success.begin(); _iter1955 != this->success.end(); ++_iter1955) + std::vector
::const_iterator _iter1956; + for (_iter1956 = this->success.begin(); _iter1956 != this->success.end(); ++_iter1956) { - xfer += (*_iter1955).write(oprot); + xfer += (*_iter1956).write(oprot); } xfer += oprot->writeListEnd(); } @@ -11993,14 +11993,14 @@ uint32_t ThriftHiveMetastore_get_all_materialized_view_objects_for_rewriting_pre if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1956; - ::apache::thrift::protocol::TType _etype1959; - xfer += iprot->readListBegin(_etype1959, _size1956); - (*(this->success)).resize(_size1956); - uint32_t _i1960; - for (_i1960 = 0; _i1960 < _size1956; ++_i1960) + uint32_t _size1957; + ::apache::thrift::protocol::TType _etype1960; + xfer += iprot->readListBegin(_etype1960, _size1957); + (*(this->success)).resize(_size1957); + uint32_t _i1961; + for (_i1961 = 0; _i1961 < _size1957; ++_i1961) { - xfer += (*(this->success))[_i1960].read(iprot); + xfer += (*(this->success))[_i1961].read(iprot); } xfer += iprot->readListEnd(); } @@ -12138,14 +12138,14 @@ uint32_t ThriftHiveMetastore_get_materialized_views_for_rewriting_result::read(: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1961; - ::apache::thrift::protocol::TType _etype1964; - xfer += iprot->readListBegin(_etype1964, _size1961); - this->success.resize(_size1961); - uint32_t _i1965; - for (_i1965 = 0; _i1965 < _size1961; ++_i1965) + uint32_t _size1962; + ::apache::thrift::protocol::TType _etype1965; + xfer += iprot->readListBegin(_etype1965, _size1962); + this->success.resize(_size1962); + uint32_t _i1966; + for (_i1966 = 0; _i1966 < _size1962; ++_i1966) { - xfer += iprot->readString(this->success[_i1965]); + xfer += iprot->readString(this->success[_i1966]); } xfer += iprot->readListEnd(); } @@ -12184,10 +12184,10 @@ uint32_t ThriftHiveMetastore_get_materialized_views_for_rewriting_result::write( xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1966; - for (_iter1966 = this->success.begin(); _iter1966 != this->success.end(); ++_iter1966) + std::vector ::const_iterator _iter1967; + for (_iter1967 = this->success.begin(); _iter1967 != this->success.end(); ++_iter1967) { - xfer += oprot->writeString((*_iter1966)); + xfer += oprot->writeString((*_iter1967)); } xfer += oprot->writeListEnd(); } @@ -12232,14 +12232,14 @@ uint32_t ThriftHiveMetastore_get_materialized_views_for_rewriting_presult::read( if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1967; - ::apache::thrift::protocol::TType _etype1970; - xfer += iprot->readListBegin(_etype1970, _size1967); - (*(this->success)).resize(_size1967); - uint32_t _i1971; - for (_i1971 = 0; _i1971 < _size1967; ++_i1971) + uint32_t _size1968; + ::apache::thrift::protocol::TType _etype1971; + xfer += iprot->readListBegin(_etype1971, _size1968); + (*(this->success)).resize(_size1968); + uint32_t _i1972; + for (_i1972 = 0; _i1972 < _size1968; ++_i1972) { - xfer += iprot->readString((*(this->success))[_i1971]); + xfer += iprot->readString((*(this->success))[_i1972]); } xfer += iprot->readListEnd(); } @@ -12314,14 +12314,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tbl_types.clear(); - uint32_t _size1972; - ::apache::thrift::protocol::TType _etype1975; - xfer += iprot->readListBegin(_etype1975, _size1972); - this->tbl_types.resize(_size1972); - uint32_t _i1976; - for (_i1976 = 0; _i1976 < _size1972; ++_i1976) + uint32_t _size1973; + ::apache::thrift::protocol::TType _etype1976; + xfer += iprot->readListBegin(_etype1976, _size1973); + this->tbl_types.resize(_size1973); + uint32_t _i1977; + for (_i1977 = 0; _i1977 < _size1973; ++_i1977) { - xfer += iprot->readString(this->tbl_types[_i1976]); + xfer += iprot->readString(this->tbl_types[_i1977]); } xfer += iprot->readListEnd(); } @@ -12358,10 +12358,10 @@ uint32_t ThriftHiveMetastore_get_table_meta_args::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("tbl_types", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->tbl_types.size())); - std::vector ::const_iterator _iter1977; - for (_iter1977 = this->tbl_types.begin(); _iter1977 != this->tbl_types.end(); ++_iter1977) + std::vector ::const_iterator _iter1978; + for (_iter1978 = this->tbl_types.begin(); _iter1978 != this->tbl_types.end(); ++_iter1978) { - xfer += oprot->writeString((*_iter1977)); + xfer += oprot->writeString((*_iter1978)); } xfer += oprot->writeListEnd(); } @@ -12393,10 +12393,10 @@ uint32_t ThriftHiveMetastore_get_table_meta_pargs::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("tbl_types", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->tbl_types)).size())); - std::vector ::const_iterator _iter1978; - for (_iter1978 = (*(this->tbl_types)).begin(); _iter1978 != (*(this->tbl_types)).end(); ++_iter1978) + std::vector ::const_iterator _iter1979; + for (_iter1979 = (*(this->tbl_types)).begin(); _iter1979 != (*(this->tbl_types)).end(); ++_iter1979) { - xfer += oprot->writeString((*_iter1978)); + xfer += oprot->writeString((*_iter1979)); } xfer += oprot->writeListEnd(); } @@ -12437,14 +12437,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1979; - ::apache::thrift::protocol::TType _etype1982; - xfer += iprot->readListBegin(_etype1982, _size1979); - this->success.resize(_size1979); - uint32_t _i1983; - for (_i1983 = 0; _i1983 < _size1979; ++_i1983) + uint32_t _size1980; + ::apache::thrift::protocol::TType _etype1983; + xfer += iprot->readListBegin(_etype1983, _size1980); + this->success.resize(_size1980); + uint32_t _i1984; + for (_i1984 = 0; _i1984 < _size1980; ++_i1984) { - xfer += this->success[_i1983].read(iprot); + xfer += this->success[_i1984].read(iprot); } xfer += iprot->readListEnd(); } @@ -12483,10 +12483,10 @@ uint32_t ThriftHiveMetastore_get_table_meta_result::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1984; - for (_iter1984 = this->success.begin(); _iter1984 != this->success.end(); ++_iter1984) + std::vector ::const_iterator _iter1985; + for (_iter1985 = this->success.begin(); _iter1985 != this->success.end(); ++_iter1985) { - xfer += (*_iter1984).write(oprot); + xfer += (*_iter1985).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12531,14 +12531,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1985; - ::apache::thrift::protocol::TType _etype1988; - xfer += iprot->readListBegin(_etype1988, _size1985); - (*(this->success)).resize(_size1985); - uint32_t _i1989; - for (_i1989 = 0; _i1989 < _size1985; ++_i1989) + uint32_t _size1986; + ::apache::thrift::protocol::TType _etype1989; + xfer += iprot->readListBegin(_etype1989, _size1986); + (*(this->success)).resize(_size1986); + uint32_t _i1990; + for (_i1990 = 0; _i1990 < _size1986; ++_i1990) { - xfer += (*(this->success))[_i1989].read(iprot); + xfer += (*(this->success))[_i1990].read(iprot); } xfer += iprot->readListEnd(); } @@ -12676,14 +12676,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1990; - ::apache::thrift::protocol::TType _etype1993; - xfer += iprot->readListBegin(_etype1993, _size1990); - this->success.resize(_size1990); - uint32_t _i1994; - for (_i1994 = 0; _i1994 < _size1990; ++_i1994) + uint32_t _size1991; + ::apache::thrift::protocol::TType _etype1994; + xfer += iprot->readListBegin(_etype1994, _size1991); + this->success.resize(_size1991); + uint32_t _i1995; + for (_i1995 = 0; _i1995 < _size1991; ++_i1995) { - xfer += iprot->readString(this->success[_i1994]); + xfer += iprot->readString(this->success[_i1995]); } xfer += iprot->readListEnd(); } @@ -12722,10 +12722,10 @@ uint32_t ThriftHiveMetastore_get_all_tables_result::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1995; - for (_iter1995 = this->success.begin(); _iter1995 != this->success.end(); ++_iter1995) + std::vector ::const_iterator _iter1996; + for (_iter1996 = this->success.begin(); _iter1996 != this->success.end(); ++_iter1996) { - xfer += oprot->writeString((*_iter1995)); + xfer += oprot->writeString((*_iter1996)); } xfer += oprot->writeListEnd(); } @@ -12770,14 +12770,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1996; - ::apache::thrift::protocol::TType _etype1999; - xfer += iprot->readListBegin(_etype1999, _size1996); - (*(this->success)).resize(_size1996); - uint32_t _i2000; - for (_i2000 = 0; _i2000 < _size1996; ++_i2000) + uint32_t _size1997; + ::apache::thrift::protocol::TType _etype2000; + xfer += iprot->readListBegin(_etype2000, _size1997); + (*(this->success)).resize(_size1997); + uint32_t _i2001; + for (_i2001 = 0; _i2001 < _size1997; ++_i2001) { - xfer += iprot->readString((*(this->success))[_i2000]); + xfer += iprot->readString((*(this->success))[_i2001]); } xfer += iprot->readListEnd(); } @@ -13087,14 +13087,14 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_args::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tbl_names.clear(); - uint32_t _size2001; - ::apache::thrift::protocol::TType _etype2004; - xfer += iprot->readListBegin(_etype2004, _size2001); - this->tbl_names.resize(_size2001); - uint32_t _i2005; - for (_i2005 = 0; _i2005 < _size2001; ++_i2005) + uint32_t _size2002; + ::apache::thrift::protocol::TType _etype2005; + xfer += iprot->readListBegin(_etype2005, _size2002); + this->tbl_names.resize(_size2002); + uint32_t _i2006; + for (_i2006 = 0; _i2006 < _size2002; ++_i2006) { - xfer += iprot->readString(this->tbl_names[_i2005]); + xfer += iprot->readString(this->tbl_names[_i2006]); } xfer += iprot->readListEnd(); } @@ -13127,10 +13127,10 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_args::write(::apache::thr xfer += oprot->writeFieldBegin("tbl_names", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->tbl_names.size())); - std::vector ::const_iterator _iter2006; - for (_iter2006 = this->tbl_names.begin(); _iter2006 != this->tbl_names.end(); ++_iter2006) + std::vector ::const_iterator _iter2007; + for (_iter2007 = this->tbl_names.begin(); _iter2007 != this->tbl_names.end(); ++_iter2007) { - xfer += oprot->writeString((*_iter2006)); + xfer += oprot->writeString((*_iter2007)); } xfer += oprot->writeListEnd(); } @@ -13158,10 +13158,10 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_pargs::write(::apache::th xfer += oprot->writeFieldBegin("tbl_names", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->tbl_names)).size())); - std::vector ::const_iterator _iter2007; - for (_iter2007 = (*(this->tbl_names)).begin(); _iter2007 != (*(this->tbl_names)).end(); ++_iter2007) + std::vector ::const_iterator _iter2008; + for (_iter2008 = (*(this->tbl_names)).begin(); _iter2008 != (*(this->tbl_names)).end(); ++_iter2008) { - xfer += oprot->writeString((*_iter2007)); + xfer += oprot->writeString((*_iter2008)); } xfer += oprot->writeListEnd(); } @@ -13202,14 +13202,14 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_result::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2008; - ::apache::thrift::protocol::TType _etype2011; - xfer += iprot->readListBegin(_etype2011, _size2008); - this->success.resize(_size2008); - uint32_t _i2012; - for (_i2012 = 0; _i2012 < _size2008; ++_i2012) + uint32_t _size2009; + ::apache::thrift::protocol::TType _etype2012; + xfer += iprot->readListBegin(_etype2012, _size2009); + this->success.resize(_size2009); + uint32_t _i2013; + for (_i2013 = 0; _i2013 < _size2009; ++_i2013) { - xfer += this->success[_i2012].read(iprot); + xfer += this->success[_i2013].read(iprot); } xfer += iprot->readListEnd(); } @@ -13240,10 +13240,10 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_result::write(::apache::t xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector
::const_iterator _iter2013; - for (_iter2013 = this->success.begin(); _iter2013 != this->success.end(); ++_iter2013) + std::vector
::const_iterator _iter2014; + for (_iter2014 = this->success.begin(); _iter2014 != this->success.end(); ++_iter2014) { - xfer += (*_iter2013).write(oprot); + xfer += (*_iter2014).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13284,14 +13284,14 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_presult::read(::apache::t if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2014; - ::apache::thrift::protocol::TType _etype2017; - xfer += iprot->readListBegin(_etype2017, _size2014); - (*(this->success)).resize(_size2014); - uint32_t _i2018; - for (_i2018 = 0; _i2018 < _size2014; ++_i2018) + uint32_t _size2015; + ::apache::thrift::protocol::TType _etype2018; + xfer += iprot->readListBegin(_etype2018, _size2015); + (*(this->success)).resize(_size2015); + uint32_t _i2019; + for (_i2019 = 0; _i2019 < _size2015; ++_i2019) { - xfer += (*(this->success))[_i2018].read(iprot); + xfer += (*(this->success))[_i2019].read(iprot); } xfer += iprot->readListEnd(); } @@ -13421,14 +13421,14 @@ uint32_t ThriftHiveMetastore_get_tables_ext_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2019; - ::apache::thrift::protocol::TType _etype2022; - xfer += iprot->readListBegin(_etype2022, _size2019); - this->success.resize(_size2019); - uint32_t _i2023; - for (_i2023 = 0; _i2023 < _size2019; ++_i2023) + uint32_t _size2020; + ::apache::thrift::protocol::TType _etype2023; + xfer += iprot->readListBegin(_etype2023, _size2020); + this->success.resize(_size2020); + uint32_t _i2024; + for (_i2024 = 0; _i2024 < _size2020; ++_i2024) { - xfer += this->success[_i2023].read(iprot); + xfer += this->success[_i2024].read(iprot); } xfer += iprot->readListEnd(); } @@ -13467,10 +13467,10 @@ uint32_t ThriftHiveMetastore_get_tables_ext_result::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter2024; - for (_iter2024 = this->success.begin(); _iter2024 != this->success.end(); ++_iter2024) + std::vector ::const_iterator _iter2025; + for (_iter2025 = this->success.begin(); _iter2025 != this->success.end(); ++_iter2025) { - xfer += (*_iter2024).write(oprot); + xfer += (*_iter2025).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13515,14 +13515,14 @@ uint32_t ThriftHiveMetastore_get_tables_ext_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2025; - ::apache::thrift::protocol::TType _etype2028; - xfer += iprot->readListBegin(_etype2028, _size2025); - (*(this->success)).resize(_size2025); - uint32_t _i2029; - for (_i2029 = 0; _i2029 < _size2025; ++_i2029) + uint32_t _size2026; + ::apache::thrift::protocol::TType _etype2029; + xfer += iprot->readListBegin(_etype2029, _size2026); + (*(this->success)).resize(_size2026); + uint32_t _i2030; + for (_i2030 = 0; _i2030 < _size2026; ++_i2030) { - xfer += (*(this->success))[_i2029].read(iprot); + xfer += (*(this->success))[_i2030].read(iprot); } xfer += iprot->readListEnd(); } @@ -14704,14 +14704,14 @@ uint32_t ThriftHiveMetastore_get_table_names_by_filter_result::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2030; - ::apache::thrift::protocol::TType _etype2033; - xfer += iprot->readListBegin(_etype2033, _size2030); - this->success.resize(_size2030); - uint32_t _i2034; - for (_i2034 = 0; _i2034 < _size2030; ++_i2034) + uint32_t _size2031; + ::apache::thrift::protocol::TType _etype2034; + xfer += iprot->readListBegin(_etype2034, _size2031); + this->success.resize(_size2031); + uint32_t _i2035; + for (_i2035 = 0; _i2035 < _size2031; ++_i2035) { - xfer += iprot->readString(this->success[_i2034]); + xfer += iprot->readString(this->success[_i2035]); } xfer += iprot->readListEnd(); } @@ -14766,10 +14766,10 @@ uint32_t ThriftHiveMetastore_get_table_names_by_filter_result::write(::apache::t xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter2035; - for (_iter2035 = this->success.begin(); _iter2035 != this->success.end(); ++_iter2035) + std::vector ::const_iterator _iter2036; + for (_iter2036 = this->success.begin(); _iter2036 != this->success.end(); ++_iter2036) { - xfer += oprot->writeString((*_iter2035)); + xfer += oprot->writeString((*_iter2036)); } xfer += oprot->writeListEnd(); } @@ -14822,14 +14822,14 @@ uint32_t ThriftHiveMetastore_get_table_names_by_filter_presult::read(::apache::t if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2036; - ::apache::thrift::protocol::TType _etype2039; - xfer += iprot->readListBegin(_etype2039, _size2036); - (*(this->success)).resize(_size2036); - uint32_t _i2040; - for (_i2040 = 0; _i2040 < _size2036; ++_i2040) + uint32_t _size2037; + ::apache::thrift::protocol::TType _etype2040; + xfer += iprot->readListBegin(_etype2040, _size2037); + (*(this->success)).resize(_size2037); + uint32_t _i2041; + for (_i2041 = 0; _i2041 < _size2037; ++_i2041) { - xfer += iprot->readString((*(this->success))[_i2040]); + xfer += iprot->readString((*(this->success))[_i2041]); } xfer += iprot->readListEnd(); } @@ -16390,14 +16390,14 @@ uint32_t ThriftHiveMetastore_add_partitions_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size2041; - ::apache::thrift::protocol::TType _etype2044; - xfer += iprot->readListBegin(_etype2044, _size2041); - this->new_parts.resize(_size2041); - uint32_t _i2045; - for (_i2045 = 0; _i2045 < _size2041; ++_i2045) + uint32_t _size2042; + ::apache::thrift::protocol::TType _etype2045; + xfer += iprot->readListBegin(_etype2045, _size2042); + this->new_parts.resize(_size2042); + uint32_t _i2046; + for (_i2046 = 0; _i2046 < _size2042; ++_i2046) { - xfer += this->new_parts[_i2045].read(iprot); + xfer += this->new_parts[_i2046].read(iprot); } xfer += iprot->readListEnd(); } @@ -16426,10 +16426,10 @@ uint32_t ThriftHiveMetastore_add_partitions_args::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->new_parts.size())); - std::vector ::const_iterator _iter2046; - for (_iter2046 = this->new_parts.begin(); _iter2046 != this->new_parts.end(); ++_iter2046) + std::vector ::const_iterator _iter2047; + for (_iter2047 = this->new_parts.begin(); _iter2047 != this->new_parts.end(); ++_iter2047) { - xfer += (*_iter2046).write(oprot); + xfer += (*_iter2047).write(oprot); } xfer += oprot->writeListEnd(); } @@ -16453,10 +16453,10 @@ uint32_t ThriftHiveMetastore_add_partitions_pargs::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->new_parts)).size())); - std::vector ::const_iterator _iter2047; - for (_iter2047 = (*(this->new_parts)).begin(); _iter2047 != (*(this->new_parts)).end(); ++_iter2047) + std::vector ::const_iterator _iter2048; + for (_iter2048 = (*(this->new_parts)).begin(); _iter2048 != (*(this->new_parts)).end(); ++_iter2048) { - xfer += (*_iter2047).write(oprot); + xfer += (*_iter2048).write(oprot); } xfer += oprot->writeListEnd(); } @@ -16665,14 +16665,14 @@ uint32_t ThriftHiveMetastore_add_partitions_pspec_args::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size2048; - ::apache::thrift::protocol::TType _etype2051; - xfer += iprot->readListBegin(_etype2051, _size2048); - this->new_parts.resize(_size2048); - uint32_t _i2052; - for (_i2052 = 0; _i2052 < _size2048; ++_i2052) + uint32_t _size2049; + ::apache::thrift::protocol::TType _etype2052; + xfer += iprot->readListBegin(_etype2052, _size2049); + this->new_parts.resize(_size2049); + uint32_t _i2053; + for (_i2053 = 0; _i2053 < _size2049; ++_i2053) { - xfer += this->new_parts[_i2052].read(iprot); + xfer += this->new_parts[_i2053].read(iprot); } xfer += iprot->readListEnd(); } @@ -16701,10 +16701,10 @@ uint32_t ThriftHiveMetastore_add_partitions_pspec_args::write(::apache::thrift:: xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->new_parts.size())); - std::vector ::const_iterator _iter2053; - for (_iter2053 = this->new_parts.begin(); _iter2053 != this->new_parts.end(); ++_iter2053) + std::vector ::const_iterator _iter2054; + for (_iter2054 = this->new_parts.begin(); _iter2054 != this->new_parts.end(); ++_iter2054) { - xfer += (*_iter2053).write(oprot); + xfer += (*_iter2054).write(oprot); } xfer += oprot->writeListEnd(); } @@ -16728,10 +16728,10 @@ uint32_t ThriftHiveMetastore_add_partitions_pspec_pargs::write(::apache::thrift: xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->new_parts)).size())); - std::vector ::const_iterator _iter2054; - for (_iter2054 = (*(this->new_parts)).begin(); _iter2054 != (*(this->new_parts)).end(); ++_iter2054) + std::vector ::const_iterator _iter2055; + for (_iter2055 = (*(this->new_parts)).begin(); _iter2055 != (*(this->new_parts)).end(); ++_iter2055) { - xfer += (*_iter2054).write(oprot); + xfer += (*_iter2055).write(oprot); } xfer += oprot->writeListEnd(); } @@ -16956,14 +16956,14 @@ uint32_t ThriftHiveMetastore_append_partition_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size2055; - ::apache::thrift::protocol::TType _etype2058; - xfer += iprot->readListBegin(_etype2058, _size2055); - this->part_vals.resize(_size2055); - uint32_t _i2059; - for (_i2059 = 0; _i2059 < _size2055; ++_i2059) + uint32_t _size2056; + ::apache::thrift::protocol::TType _etype2059; + xfer += iprot->readListBegin(_etype2059, _size2056); + this->part_vals.resize(_size2056); + uint32_t _i2060; + for (_i2060 = 0; _i2060 < _size2056; ++_i2060) { - xfer += iprot->readString(this->part_vals[_i2059]); + xfer += iprot->readString(this->part_vals[_i2060]); } xfer += iprot->readListEnd(); } @@ -17000,10 +17000,10 @@ uint32_t ThriftHiveMetastore_append_partition_args::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter2060; - for (_iter2060 = this->part_vals.begin(); _iter2060 != this->part_vals.end(); ++_iter2060) + std::vector ::const_iterator _iter2061; + for (_iter2061 = this->part_vals.begin(); _iter2061 != this->part_vals.end(); ++_iter2061) { - xfer += oprot->writeString((*_iter2060)); + xfer += oprot->writeString((*_iter2061)); } xfer += oprot->writeListEnd(); } @@ -17035,10 +17035,10 @@ uint32_t ThriftHiveMetastore_append_partition_pargs::write(::apache::thrift::pro xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter2061; - for (_iter2061 = (*(this->part_vals)).begin(); _iter2061 != (*(this->part_vals)).end(); ++_iter2061) + std::vector ::const_iterator _iter2062; + for (_iter2062 = (*(this->part_vals)).begin(); _iter2062 != (*(this->part_vals)).end(); ++_iter2062) { - xfer += oprot->writeString((*_iter2061)); + xfer += oprot->writeString((*_iter2062)); } xfer += oprot->writeListEnd(); } @@ -17510,14 +17510,14 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::rea if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size2062; - ::apache::thrift::protocol::TType _etype2065; - xfer += iprot->readListBegin(_etype2065, _size2062); - this->part_vals.resize(_size2062); - uint32_t _i2066; - for (_i2066 = 0; _i2066 < _size2062; ++_i2066) + uint32_t _size2063; + ::apache::thrift::protocol::TType _etype2066; + xfer += iprot->readListBegin(_etype2066, _size2063); + this->part_vals.resize(_size2063); + uint32_t _i2067; + for (_i2067 = 0; _i2067 < _size2063; ++_i2067) { - xfer += iprot->readString(this->part_vals[_i2066]); + xfer += iprot->readString(this->part_vals[_i2067]); } xfer += iprot->readListEnd(); } @@ -17562,10 +17562,10 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::wri xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter2067; - for (_iter2067 = this->part_vals.begin(); _iter2067 != this->part_vals.end(); ++_iter2067) + std::vector ::const_iterator _iter2068; + for (_iter2068 = this->part_vals.begin(); _iter2068 != this->part_vals.end(); ++_iter2068) { - xfer += oprot->writeString((*_iter2067)); + xfer += oprot->writeString((*_iter2068)); } xfer += oprot->writeListEnd(); } @@ -17601,10 +17601,10 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_pargs::wr xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter2068; - for (_iter2068 = (*(this->part_vals)).begin(); _iter2068 != (*(this->part_vals)).end(); ++_iter2068) + std::vector ::const_iterator _iter2069; + for (_iter2069 = (*(this->part_vals)).begin(); _iter2069 != (*(this->part_vals)).end(); ++_iter2069) { - xfer += oprot->writeString((*_iter2068)); + xfer += oprot->writeString((*_iter2069)); } xfer += oprot->writeListEnd(); } @@ -18407,14 +18407,14 @@ uint32_t ThriftHiveMetastore_drop_partition_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size2069; - ::apache::thrift::protocol::TType _etype2072; - xfer += iprot->readListBegin(_etype2072, _size2069); - this->part_vals.resize(_size2069); - uint32_t _i2073; - for (_i2073 = 0; _i2073 < _size2069; ++_i2073) + uint32_t _size2070; + ::apache::thrift::protocol::TType _etype2073; + xfer += iprot->readListBegin(_etype2073, _size2070); + this->part_vals.resize(_size2070); + uint32_t _i2074; + for (_i2074 = 0; _i2074 < _size2070; ++_i2074) { - xfer += iprot->readString(this->part_vals[_i2073]); + xfer += iprot->readString(this->part_vals[_i2074]); } xfer += iprot->readListEnd(); } @@ -18459,10 +18459,10 @@ uint32_t ThriftHiveMetastore_drop_partition_args::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter2074; - for (_iter2074 = this->part_vals.begin(); _iter2074 != this->part_vals.end(); ++_iter2074) + std::vector ::const_iterator _iter2075; + for (_iter2075 = this->part_vals.begin(); _iter2075 != this->part_vals.end(); ++_iter2075) { - xfer += oprot->writeString((*_iter2074)); + xfer += oprot->writeString((*_iter2075)); } xfer += oprot->writeListEnd(); } @@ -18498,10 +18498,10 @@ uint32_t ThriftHiveMetastore_drop_partition_pargs::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter2075; - for (_iter2075 = (*(this->part_vals)).begin(); _iter2075 != (*(this->part_vals)).end(); ++_iter2075) + std::vector ::const_iterator _iter2076; + for (_iter2076 = (*(this->part_vals)).begin(); _iter2076 != (*(this->part_vals)).end(); ++_iter2076) { - xfer += oprot->writeString((*_iter2075)); + xfer += oprot->writeString((*_iter2076)); } xfer += oprot->writeListEnd(); } @@ -18710,14 +18710,14 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::read( if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size2076; - ::apache::thrift::protocol::TType _etype2079; - xfer += iprot->readListBegin(_etype2079, _size2076); - this->part_vals.resize(_size2076); - uint32_t _i2080; - for (_i2080 = 0; _i2080 < _size2076; ++_i2080) + uint32_t _size2077; + ::apache::thrift::protocol::TType _etype2080; + xfer += iprot->readListBegin(_etype2080, _size2077); + this->part_vals.resize(_size2077); + uint32_t _i2081; + for (_i2081 = 0; _i2081 < _size2077; ++_i2081) { - xfer += iprot->readString(this->part_vals[_i2080]); + xfer += iprot->readString(this->part_vals[_i2081]); } xfer += iprot->readListEnd(); } @@ -18770,10 +18770,10 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::write xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter2081; - for (_iter2081 = this->part_vals.begin(); _iter2081 != this->part_vals.end(); ++_iter2081) + std::vector ::const_iterator _iter2082; + for (_iter2082 = this->part_vals.begin(); _iter2082 != this->part_vals.end(); ++_iter2082) { - xfer += oprot->writeString((*_iter2081)); + xfer += oprot->writeString((*_iter2082)); } xfer += oprot->writeListEnd(); } @@ -18813,10 +18813,10 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_pargs::writ xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter2082; - for (_iter2082 = (*(this->part_vals)).begin(); _iter2082 != (*(this->part_vals)).end(); ++_iter2082) + std::vector ::const_iterator _iter2083; + for (_iter2083 = (*(this->part_vals)).begin(); _iter2083 != (*(this->part_vals)).end(); ++_iter2083) { - xfer += oprot->writeString((*_iter2082)); + xfer += oprot->writeString((*_iter2083)); } xfer += oprot->writeListEnd(); } @@ -19822,14 +19822,14 @@ uint32_t ThriftHiveMetastore_get_partition_args::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size2083; - ::apache::thrift::protocol::TType _etype2086; - xfer += iprot->readListBegin(_etype2086, _size2083); - this->part_vals.resize(_size2083); - uint32_t _i2087; - for (_i2087 = 0; _i2087 < _size2083; ++_i2087) + uint32_t _size2084; + ::apache::thrift::protocol::TType _etype2087; + xfer += iprot->readListBegin(_etype2087, _size2084); + this->part_vals.resize(_size2084); + uint32_t _i2088; + for (_i2088 = 0; _i2088 < _size2084; ++_i2088) { - xfer += iprot->readString(this->part_vals[_i2087]); + xfer += iprot->readString(this->part_vals[_i2088]); } xfer += iprot->readListEnd(); } @@ -19866,10 +19866,10 @@ uint32_t ThriftHiveMetastore_get_partition_args::write(::apache::thrift::protoco xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter2088; - for (_iter2088 = this->part_vals.begin(); _iter2088 != this->part_vals.end(); ++_iter2088) + std::vector ::const_iterator _iter2089; + for (_iter2089 = this->part_vals.begin(); _iter2089 != this->part_vals.end(); ++_iter2089) { - xfer += oprot->writeString((*_iter2088)); + xfer += oprot->writeString((*_iter2089)); } xfer += oprot->writeListEnd(); } @@ -19901,10 +19901,10 @@ uint32_t ThriftHiveMetastore_get_partition_pargs::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter2089; - for (_iter2089 = (*(this->part_vals)).begin(); _iter2089 != (*(this->part_vals)).end(); ++_iter2089) + std::vector ::const_iterator _iter2090; + for (_iter2090 = (*(this->part_vals)).begin(); _iter2090 != (*(this->part_vals)).end(); ++_iter2090) { - xfer += oprot->writeString((*_iter2089)); + xfer += oprot->writeString((*_iter2090)); } xfer += oprot->writeListEnd(); } @@ -20320,17 +20320,17 @@ uint32_t ThriftHiveMetastore_exchange_partition_args::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size2090; - ::apache::thrift::protocol::TType _ktype2091; - ::apache::thrift::protocol::TType _vtype2092; - xfer += iprot->readMapBegin(_ktype2091, _vtype2092, _size2090); - uint32_t _i2094; - for (_i2094 = 0; _i2094 < _size2090; ++_i2094) + uint32_t _size2091; + ::apache::thrift::protocol::TType _ktype2092; + ::apache::thrift::protocol::TType _vtype2093; + xfer += iprot->readMapBegin(_ktype2092, _vtype2093, _size2091); + uint32_t _i2095; + for (_i2095 = 0; _i2095 < _size2091; ++_i2095) { - std::string _key2095; - xfer += iprot->readString(_key2095); - std::string& _val2096 = this->partitionSpecs[_key2095]; - xfer += iprot->readString(_val2096); + std::string _key2096; + xfer += iprot->readString(_key2096); + std::string& _val2097 = this->partitionSpecs[_key2096]; + xfer += iprot->readString(_val2097); } xfer += iprot->readMapEnd(); } @@ -20391,11 +20391,11 @@ uint32_t ThriftHiveMetastore_exchange_partition_args::write(::apache::thrift::pr xfer += oprot->writeFieldBegin("partitionSpecs", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->partitionSpecs.size())); - std::map ::const_iterator _iter2097; - for (_iter2097 = this->partitionSpecs.begin(); _iter2097 != this->partitionSpecs.end(); ++_iter2097) + std::map ::const_iterator _iter2098; + for (_iter2098 = this->partitionSpecs.begin(); _iter2098 != this->partitionSpecs.end(); ++_iter2098) { - xfer += oprot->writeString(_iter2097->first); - xfer += oprot->writeString(_iter2097->second); + xfer += oprot->writeString(_iter2098->first); + xfer += oprot->writeString(_iter2098->second); } xfer += oprot->writeMapEnd(); } @@ -20435,11 +20435,11 @@ uint32_t ThriftHiveMetastore_exchange_partition_pargs::write(::apache::thrift::p xfer += oprot->writeFieldBegin("partitionSpecs", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast((*(this->partitionSpecs)).size())); - std::map ::const_iterator _iter2098; - for (_iter2098 = (*(this->partitionSpecs)).begin(); _iter2098 != (*(this->partitionSpecs)).end(); ++_iter2098) + std::map ::const_iterator _iter2099; + for (_iter2099 = (*(this->partitionSpecs)).begin(); _iter2099 != (*(this->partitionSpecs)).end(); ++_iter2099) { - xfer += oprot->writeString(_iter2098->first); - xfer += oprot->writeString(_iter2098->second); + xfer += oprot->writeString(_iter2099->first); + xfer += oprot->writeString(_iter2099->second); } xfer += oprot->writeMapEnd(); } @@ -20684,17 +20684,17 @@ uint32_t ThriftHiveMetastore_exchange_partitions_args::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size2099; - ::apache::thrift::protocol::TType _ktype2100; - ::apache::thrift::protocol::TType _vtype2101; - xfer += iprot->readMapBegin(_ktype2100, _vtype2101, _size2099); - uint32_t _i2103; - for (_i2103 = 0; _i2103 < _size2099; ++_i2103) + uint32_t _size2100; + ::apache::thrift::protocol::TType _ktype2101; + ::apache::thrift::protocol::TType _vtype2102; + xfer += iprot->readMapBegin(_ktype2101, _vtype2102, _size2100); + uint32_t _i2104; + for (_i2104 = 0; _i2104 < _size2100; ++_i2104) { - std::string _key2104; - xfer += iprot->readString(_key2104); - std::string& _val2105 = this->partitionSpecs[_key2104]; - xfer += iprot->readString(_val2105); + std::string _key2105; + xfer += iprot->readString(_key2105); + std::string& _val2106 = this->partitionSpecs[_key2105]; + xfer += iprot->readString(_val2106); } xfer += iprot->readMapEnd(); } @@ -20755,11 +20755,11 @@ uint32_t ThriftHiveMetastore_exchange_partitions_args::write(::apache::thrift::p xfer += oprot->writeFieldBegin("partitionSpecs", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->partitionSpecs.size())); - std::map ::const_iterator _iter2106; - for (_iter2106 = this->partitionSpecs.begin(); _iter2106 != this->partitionSpecs.end(); ++_iter2106) + std::map ::const_iterator _iter2107; + for (_iter2107 = this->partitionSpecs.begin(); _iter2107 != this->partitionSpecs.end(); ++_iter2107) { - xfer += oprot->writeString(_iter2106->first); - xfer += oprot->writeString(_iter2106->second); + xfer += oprot->writeString(_iter2107->first); + xfer += oprot->writeString(_iter2107->second); } xfer += oprot->writeMapEnd(); } @@ -20799,11 +20799,11 @@ uint32_t ThriftHiveMetastore_exchange_partitions_pargs::write(::apache::thrift:: xfer += oprot->writeFieldBegin("partitionSpecs", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast((*(this->partitionSpecs)).size())); - std::map ::const_iterator _iter2107; - for (_iter2107 = (*(this->partitionSpecs)).begin(); _iter2107 != (*(this->partitionSpecs)).end(); ++_iter2107) + std::map ::const_iterator _iter2108; + for (_iter2108 = (*(this->partitionSpecs)).begin(); _iter2108 != (*(this->partitionSpecs)).end(); ++_iter2108) { - xfer += oprot->writeString(_iter2107->first); - xfer += oprot->writeString(_iter2107->second); + xfer += oprot->writeString(_iter2108->first); + xfer += oprot->writeString(_iter2108->second); } xfer += oprot->writeMapEnd(); } @@ -20860,14 +20860,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2108; - ::apache::thrift::protocol::TType _etype2111; - xfer += iprot->readListBegin(_etype2111, _size2108); - this->success.resize(_size2108); - uint32_t _i2112; - for (_i2112 = 0; _i2112 < _size2108; ++_i2112) + uint32_t _size2109; + ::apache::thrift::protocol::TType _etype2112; + xfer += iprot->readListBegin(_etype2112, _size2109); + this->success.resize(_size2109); + uint32_t _i2113; + for (_i2113 = 0; _i2113 < _size2109; ++_i2113) { - xfer += this->success[_i2112].read(iprot); + xfer += this->success[_i2113].read(iprot); } xfer += iprot->readListEnd(); } @@ -20930,10 +20930,10 @@ uint32_t ThriftHiveMetastore_exchange_partitions_result::write(::apache::thrift: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter2113; - for (_iter2113 = this->success.begin(); _iter2113 != this->success.end(); ++_iter2113) + std::vector ::const_iterator _iter2114; + for (_iter2114 = this->success.begin(); _iter2114 != this->success.end(); ++_iter2114) { - xfer += (*_iter2113).write(oprot); + xfer += (*_iter2114).write(oprot); } xfer += oprot->writeListEnd(); } @@ -20990,14 +20990,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2114; - ::apache::thrift::protocol::TType _etype2117; - xfer += iprot->readListBegin(_etype2117, _size2114); - (*(this->success)).resize(_size2114); - uint32_t _i2118; - for (_i2118 = 0; _i2118 < _size2114; ++_i2118) + uint32_t _size2115; + ::apache::thrift::protocol::TType _etype2118; + xfer += iprot->readListBegin(_etype2118, _size2115); + (*(this->success)).resize(_size2115); + uint32_t _i2119; + for (_i2119 = 0; _i2119 < _size2115; ++_i2119) { - xfer += (*(this->success))[_i2118].read(iprot); + xfer += (*(this->success))[_i2119].read(iprot); } xfer += iprot->readListEnd(); } @@ -21096,14 +21096,14 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_args::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size2119; - ::apache::thrift::protocol::TType _etype2122; - xfer += iprot->readListBegin(_etype2122, _size2119); - this->part_vals.resize(_size2119); - uint32_t _i2123; - for (_i2123 = 0; _i2123 < _size2119; ++_i2123) + uint32_t _size2120; + ::apache::thrift::protocol::TType _etype2123; + xfer += iprot->readListBegin(_etype2123, _size2120); + this->part_vals.resize(_size2120); + uint32_t _i2124; + for (_i2124 = 0; _i2124 < _size2120; ++_i2124) { - xfer += iprot->readString(this->part_vals[_i2123]); + xfer += iprot->readString(this->part_vals[_i2124]); } xfer += iprot->readListEnd(); } @@ -21124,14 +21124,14 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_args::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size2124; - ::apache::thrift::protocol::TType _etype2127; - xfer += iprot->readListBegin(_etype2127, _size2124); - this->group_names.resize(_size2124); - uint32_t _i2128; - for (_i2128 = 0; _i2128 < _size2124; ++_i2128) + uint32_t _size2125; + ::apache::thrift::protocol::TType _etype2128; + xfer += iprot->readListBegin(_etype2128, _size2125); + this->group_names.resize(_size2125); + uint32_t _i2129; + for (_i2129 = 0; _i2129 < _size2125; ++_i2129) { - xfer += iprot->readString(this->group_names[_i2128]); + xfer += iprot->readString(this->group_names[_i2129]); } xfer += iprot->readListEnd(); } @@ -21168,10 +21168,10 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_args::write(::apache::thrif xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter2129; - for (_iter2129 = this->part_vals.begin(); _iter2129 != this->part_vals.end(); ++_iter2129) + std::vector ::const_iterator _iter2130; + for (_iter2130 = this->part_vals.begin(); _iter2130 != this->part_vals.end(); ++_iter2130) { - xfer += oprot->writeString((*_iter2129)); + xfer += oprot->writeString((*_iter2130)); } xfer += oprot->writeListEnd(); } @@ -21184,10 +21184,10 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_args::write(::apache::thrif xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->group_names.size())); - std::vector ::const_iterator _iter2130; - for (_iter2130 = this->group_names.begin(); _iter2130 != this->group_names.end(); ++_iter2130) + std::vector ::const_iterator _iter2131; + for (_iter2131 = this->group_names.begin(); _iter2131 != this->group_names.end(); ++_iter2131) { - xfer += oprot->writeString((*_iter2130)); + xfer += oprot->writeString((*_iter2131)); } xfer += oprot->writeListEnd(); } @@ -21219,10 +21219,10 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_pargs::write(::apache::thri xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter2131; - for (_iter2131 = (*(this->part_vals)).begin(); _iter2131 != (*(this->part_vals)).end(); ++_iter2131) + std::vector ::const_iterator _iter2132; + for (_iter2132 = (*(this->part_vals)).begin(); _iter2132 != (*(this->part_vals)).end(); ++_iter2132) { - xfer += oprot->writeString((*_iter2131)); + xfer += oprot->writeString((*_iter2132)); } xfer += oprot->writeListEnd(); } @@ -21235,10 +21235,10 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_pargs::write(::apache::thri xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->group_names)).size())); - std::vector ::const_iterator _iter2132; - for (_iter2132 = (*(this->group_names)).begin(); _iter2132 != (*(this->group_names)).end(); ++_iter2132) + std::vector ::const_iterator _iter2133; + for (_iter2133 = (*(this->group_names)).begin(); _iter2133 != (*(this->group_names)).end(); ++_iter2133) { - xfer += oprot->writeString((*_iter2132)); + xfer += oprot->writeString((*_iter2133)); } xfer += oprot->writeListEnd(); } @@ -21797,14 +21797,14 @@ uint32_t ThriftHiveMetastore_get_partitions_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2133; - ::apache::thrift::protocol::TType _etype2136; - xfer += iprot->readListBegin(_etype2136, _size2133); - this->success.resize(_size2133); - uint32_t _i2137; - for (_i2137 = 0; _i2137 < _size2133; ++_i2137) + uint32_t _size2134; + ::apache::thrift::protocol::TType _etype2137; + xfer += iprot->readListBegin(_etype2137, _size2134); + this->success.resize(_size2134); + uint32_t _i2138; + for (_i2138 = 0; _i2138 < _size2134; ++_i2138) { - xfer += this->success[_i2137].read(iprot); + xfer += this->success[_i2138].read(iprot); } xfer += iprot->readListEnd(); } @@ -21851,10 +21851,10 @@ uint32_t ThriftHiveMetastore_get_partitions_result::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter2138; - for (_iter2138 = this->success.begin(); _iter2138 != this->success.end(); ++_iter2138) + std::vector ::const_iterator _iter2139; + for (_iter2139 = this->success.begin(); _iter2139 != this->success.end(); ++_iter2139) { - xfer += (*_iter2138).write(oprot); + xfer += (*_iter2139).write(oprot); } xfer += oprot->writeListEnd(); } @@ -21903,14 +21903,14 @@ uint32_t ThriftHiveMetastore_get_partitions_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2139; - ::apache::thrift::protocol::TType _etype2142; - xfer += iprot->readListBegin(_etype2142, _size2139); - (*(this->success)).resize(_size2139); - uint32_t _i2143; - for (_i2143 = 0; _i2143 < _size2139; ++_i2143) + uint32_t _size2140; + ::apache::thrift::protocol::TType _etype2143; + xfer += iprot->readListBegin(_etype2143, _size2140); + (*(this->success)).resize(_size2140); + uint32_t _i2144; + for (_i2144 = 0; _i2144 < _size2140; ++_i2144) { - xfer += (*(this->success))[_i2143].read(iprot); + xfer += (*(this->success))[_i2144].read(iprot); } xfer += iprot->readListEnd(); } @@ -22236,14 +22236,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_args::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size2144; - ::apache::thrift::protocol::TType _etype2147; - xfer += iprot->readListBegin(_etype2147, _size2144); - this->group_names.resize(_size2144); - uint32_t _i2148; - for (_i2148 = 0; _i2148 < _size2144; ++_i2148) + uint32_t _size2145; + ::apache::thrift::protocol::TType _etype2148; + xfer += iprot->readListBegin(_etype2148, _size2145); + this->group_names.resize(_size2145); + uint32_t _i2149; + for (_i2149 = 0; _i2149 < _size2145; ++_i2149) { - xfer += iprot->readString(this->group_names[_i2148]); + xfer += iprot->readString(this->group_names[_i2149]); } xfer += iprot->readListEnd(); } @@ -22288,10 +22288,10 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_args::write(::apache::thri xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->group_names.size())); - std::vector ::const_iterator _iter2149; - for (_iter2149 = this->group_names.begin(); _iter2149 != this->group_names.end(); ++_iter2149) + std::vector ::const_iterator _iter2150; + for (_iter2150 = this->group_names.begin(); _iter2150 != this->group_names.end(); ++_iter2150) { - xfer += oprot->writeString((*_iter2149)); + xfer += oprot->writeString((*_iter2150)); } xfer += oprot->writeListEnd(); } @@ -22331,10 +22331,10 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_pargs::write(::apache::thr xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->group_names)).size())); - std::vector ::const_iterator _iter2150; - for (_iter2150 = (*(this->group_names)).begin(); _iter2150 != (*(this->group_names)).end(); ++_iter2150) + std::vector ::const_iterator _iter2151; + for (_iter2151 = (*(this->group_names)).begin(); _iter2151 != (*(this->group_names)).end(); ++_iter2151) { - xfer += oprot->writeString((*_iter2150)); + xfer += oprot->writeString((*_iter2151)); } xfer += oprot->writeListEnd(); } @@ -22375,14 +22375,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2151; - ::apache::thrift::protocol::TType _etype2154; - xfer += iprot->readListBegin(_etype2154, _size2151); - this->success.resize(_size2151); - uint32_t _i2155; - for (_i2155 = 0; _i2155 < _size2151; ++_i2155) + uint32_t _size2152; + ::apache::thrift::protocol::TType _etype2155; + xfer += iprot->readListBegin(_etype2155, _size2152); + this->success.resize(_size2152); + uint32_t _i2156; + for (_i2156 = 0; _i2156 < _size2152; ++_i2156) { - xfer += this->success[_i2155].read(iprot); + xfer += this->success[_i2156].read(iprot); } xfer += iprot->readListEnd(); } @@ -22429,10 +22429,10 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_result::write(::apache::th xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter2156; - for (_iter2156 = this->success.begin(); _iter2156 != this->success.end(); ++_iter2156) + std::vector ::const_iterator _iter2157; + for (_iter2157 = this->success.begin(); _iter2157 != this->success.end(); ++_iter2157) { - xfer += (*_iter2156).write(oprot); + xfer += (*_iter2157).write(oprot); } xfer += oprot->writeListEnd(); } @@ -22481,14 +22481,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2157; - ::apache::thrift::protocol::TType _etype2160; - xfer += iprot->readListBegin(_etype2160, _size2157); - (*(this->success)).resize(_size2157); - uint32_t _i2161; - for (_i2161 = 0; _i2161 < _size2157; ++_i2161) + uint32_t _size2158; + ::apache::thrift::protocol::TType _etype2161; + xfer += iprot->readListBegin(_etype2161, _size2158); + (*(this->success)).resize(_size2158); + uint32_t _i2162; + for (_i2162 = 0; _i2162 < _size2158; ++_i2162) { - xfer += (*(this->success))[_i2161].read(iprot); + xfer += (*(this->success))[_i2162].read(iprot); } xfer += iprot->readListEnd(); } @@ -22666,14 +22666,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_result::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2162; - ::apache::thrift::protocol::TType _etype2165; - xfer += iprot->readListBegin(_etype2165, _size2162); - this->success.resize(_size2162); - uint32_t _i2166; - for (_i2166 = 0; _i2166 < _size2162; ++_i2166) + uint32_t _size2163; + ::apache::thrift::protocol::TType _etype2166; + xfer += iprot->readListBegin(_etype2166, _size2163); + this->success.resize(_size2163); + uint32_t _i2167; + for (_i2167 = 0; _i2167 < _size2163; ++_i2167) { - xfer += this->success[_i2166].read(iprot); + xfer += this->success[_i2167].read(iprot); } xfer += iprot->readListEnd(); } @@ -22720,10 +22720,10 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_result::write(::apache::thrift xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter2167; - for (_iter2167 = this->success.begin(); _iter2167 != this->success.end(); ++_iter2167) + std::vector ::const_iterator _iter2168; + for (_iter2168 = this->success.begin(); _iter2168 != this->success.end(); ++_iter2168) { - xfer += (*_iter2167).write(oprot); + xfer += (*_iter2168).write(oprot); } xfer += oprot->writeListEnd(); } @@ -22772,14 +22772,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_presult::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2168; - ::apache::thrift::protocol::TType _etype2171; - xfer += iprot->readListBegin(_etype2171, _size2168); - (*(this->success)).resize(_size2168); - uint32_t _i2172; - for (_i2172 = 0; _i2172 < _size2168; ++_i2172) + uint32_t _size2169; + ::apache::thrift::protocol::TType _etype2172; + xfer += iprot->readListBegin(_etype2172, _size2169); + (*(this->success)).resize(_size2169); + uint32_t _i2173; + for (_i2173 = 0; _i2173 < _size2169; ++_i2173) { - xfer += (*(this->success))[_i2172].read(iprot); + xfer += (*(this->success))[_i2173].read(iprot); } xfer += iprot->readListEnd(); } @@ -22957,14 +22957,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2173; - ::apache::thrift::protocol::TType _etype2176; - xfer += iprot->readListBegin(_etype2176, _size2173); - this->success.resize(_size2173); - uint32_t _i2177; - for (_i2177 = 0; _i2177 < _size2173; ++_i2177) + uint32_t _size2174; + ::apache::thrift::protocol::TType _etype2177; + xfer += iprot->readListBegin(_etype2177, _size2174); + this->success.resize(_size2174); + uint32_t _i2178; + for (_i2178 = 0; _i2178 < _size2174; ++_i2178) { - xfer += iprot->readString(this->success[_i2177]); + xfer += iprot->readString(this->success[_i2178]); } xfer += iprot->readListEnd(); } @@ -23011,10 +23011,10 @@ uint32_t ThriftHiveMetastore_get_partition_names_result::write(::apache::thrift: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter2178; - for (_iter2178 = this->success.begin(); _iter2178 != this->success.end(); ++_iter2178) + std::vector ::const_iterator _iter2179; + for (_iter2179 = this->success.begin(); _iter2179 != this->success.end(); ++_iter2179) { - xfer += oprot->writeString((*_iter2178)); + xfer += oprot->writeString((*_iter2179)); } xfer += oprot->writeListEnd(); } @@ -23063,14 +23063,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2179; - ::apache::thrift::protocol::TType _etype2182; - xfer += iprot->readListBegin(_etype2182, _size2179); - (*(this->success)).resize(_size2179); - uint32_t _i2183; - for (_i2183 = 0; _i2183 < _size2179; ++_i2183) + uint32_t _size2180; + ::apache::thrift::protocol::TType _etype2183; + xfer += iprot->readListBegin(_etype2183, _size2180); + (*(this->success)).resize(_size2180); + uint32_t _i2184; + for (_i2184 = 0; _i2184 < _size2180; ++_i2184) { - xfer += iprot->readString((*(this->success))[_i2183]); + xfer += iprot->readString((*(this->success))[_i2184]); } xfer += iprot->readListEnd(); } @@ -23380,14 +23380,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_args::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size2184; - ::apache::thrift::protocol::TType _etype2187; - xfer += iprot->readListBegin(_etype2187, _size2184); - this->part_vals.resize(_size2184); - uint32_t _i2188; - for (_i2188 = 0; _i2188 < _size2184; ++_i2188) + uint32_t _size2185; + ::apache::thrift::protocol::TType _etype2188; + xfer += iprot->readListBegin(_etype2188, _size2185); + this->part_vals.resize(_size2185); + uint32_t _i2189; + for (_i2189 = 0; _i2189 < _size2185; ++_i2189) { - xfer += iprot->readString(this->part_vals[_i2188]); + xfer += iprot->readString(this->part_vals[_i2189]); } xfer += iprot->readListEnd(); } @@ -23432,10 +23432,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_args::write(::apache::thrift::pro xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter2189; - for (_iter2189 = this->part_vals.begin(); _iter2189 != this->part_vals.end(); ++_iter2189) + std::vector ::const_iterator _iter2190; + for (_iter2190 = this->part_vals.begin(); _iter2190 != this->part_vals.end(); ++_iter2190) { - xfer += oprot->writeString((*_iter2189)); + xfer += oprot->writeString((*_iter2190)); } xfer += oprot->writeListEnd(); } @@ -23471,10 +23471,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_pargs::write(::apache::thrift::pr xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter2190; - for (_iter2190 = (*(this->part_vals)).begin(); _iter2190 != (*(this->part_vals)).end(); ++_iter2190) + std::vector ::const_iterator _iter2191; + for (_iter2191 = (*(this->part_vals)).begin(); _iter2191 != (*(this->part_vals)).end(); ++_iter2191) { - xfer += oprot->writeString((*_iter2190)); + xfer += oprot->writeString((*_iter2191)); } xfer += oprot->writeListEnd(); } @@ -23519,14 +23519,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_result::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2191; - ::apache::thrift::protocol::TType _etype2194; - xfer += iprot->readListBegin(_etype2194, _size2191); - this->success.resize(_size2191); - uint32_t _i2195; - for (_i2195 = 0; _i2195 < _size2191; ++_i2195) + uint32_t _size2192; + ::apache::thrift::protocol::TType _etype2195; + xfer += iprot->readListBegin(_etype2195, _size2192); + this->success.resize(_size2192); + uint32_t _i2196; + for (_i2196 = 0; _i2196 < _size2192; ++_i2196) { - xfer += this->success[_i2195].read(iprot); + xfer += this->success[_i2196].read(iprot); } xfer += iprot->readListEnd(); } @@ -23573,10 +23573,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_result::write(::apache::thrift::p xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter2196; - for (_iter2196 = this->success.begin(); _iter2196 != this->success.end(); ++_iter2196) + std::vector ::const_iterator _iter2197; + for (_iter2197 = this->success.begin(); _iter2197 != this->success.end(); ++_iter2197) { - xfer += (*_iter2196).write(oprot); + xfer += (*_iter2197).write(oprot); } xfer += oprot->writeListEnd(); } @@ -23625,14 +23625,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_presult::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2197; - ::apache::thrift::protocol::TType _etype2200; - xfer += iprot->readListBegin(_etype2200, _size2197); - (*(this->success)).resize(_size2197); - uint32_t _i2201; - for (_i2201 = 0; _i2201 < _size2197; ++_i2201) + uint32_t _size2198; + ::apache::thrift::protocol::TType _etype2201; + xfer += iprot->readListBegin(_etype2201, _size2198); + (*(this->success)).resize(_size2198); + uint32_t _i2202; + for (_i2202 = 0; _i2202 < _size2198; ++_i2202) { - xfer += (*(this->success))[_i2201].read(iprot); + xfer += (*(this->success))[_i2202].read(iprot); } xfer += iprot->readListEnd(); } @@ -23715,14 +23715,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size2202; - ::apache::thrift::protocol::TType _etype2205; - xfer += iprot->readListBegin(_etype2205, _size2202); - this->part_vals.resize(_size2202); - uint32_t _i2206; - for (_i2206 = 0; _i2206 < _size2202; ++_i2206) + uint32_t _size2203; + ::apache::thrift::protocol::TType _etype2206; + xfer += iprot->readListBegin(_etype2206, _size2203); + this->part_vals.resize(_size2203); + uint32_t _i2207; + for (_i2207 = 0; _i2207 < _size2203; ++_i2207) { - xfer += iprot->readString(this->part_vals[_i2206]); + xfer += iprot->readString(this->part_vals[_i2207]); } xfer += iprot->readListEnd(); } @@ -23751,14 +23751,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size2207; - ::apache::thrift::protocol::TType _etype2210; - xfer += iprot->readListBegin(_etype2210, _size2207); - this->group_names.resize(_size2207); - uint32_t _i2211; - for (_i2211 = 0; _i2211 < _size2207; ++_i2211) + uint32_t _size2208; + ::apache::thrift::protocol::TType _etype2211; + xfer += iprot->readListBegin(_etype2211, _size2208); + this->group_names.resize(_size2208); + uint32_t _i2212; + for (_i2212 = 0; _i2212 < _size2208; ++_i2212) { - xfer += iprot->readString(this->group_names[_i2211]); + xfer += iprot->readString(this->group_names[_i2212]); } xfer += iprot->readListEnd(); } @@ -23795,10 +23795,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::write(::apache::t xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter2212; - for (_iter2212 = this->part_vals.begin(); _iter2212 != this->part_vals.end(); ++_iter2212) + std::vector ::const_iterator _iter2213; + for (_iter2213 = this->part_vals.begin(); _iter2213 != this->part_vals.end(); ++_iter2213) { - xfer += oprot->writeString((*_iter2212)); + xfer += oprot->writeString((*_iter2213)); } xfer += oprot->writeListEnd(); } @@ -23815,10 +23815,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::write(::apache::t xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 6); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->group_names.size())); - std::vector ::const_iterator _iter2213; - for (_iter2213 = this->group_names.begin(); _iter2213 != this->group_names.end(); ++_iter2213) + std::vector ::const_iterator _iter2214; + for (_iter2214 = this->group_names.begin(); _iter2214 != this->group_names.end(); ++_iter2214) { - xfer += oprot->writeString((*_iter2213)); + xfer += oprot->writeString((*_iter2214)); } xfer += oprot->writeListEnd(); } @@ -23850,10 +23850,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_pargs::write(::apache:: xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter2214; - for (_iter2214 = (*(this->part_vals)).begin(); _iter2214 != (*(this->part_vals)).end(); ++_iter2214) + std::vector ::const_iterator _iter2215; + for (_iter2215 = (*(this->part_vals)).begin(); _iter2215 != (*(this->part_vals)).end(); ++_iter2215) { - xfer += oprot->writeString((*_iter2214)); + xfer += oprot->writeString((*_iter2215)); } xfer += oprot->writeListEnd(); } @@ -23870,10 +23870,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_pargs::write(::apache:: xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 6); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->group_names)).size())); - std::vector ::const_iterator _iter2215; - for (_iter2215 = (*(this->group_names)).begin(); _iter2215 != (*(this->group_names)).end(); ++_iter2215) + std::vector ::const_iterator _iter2216; + for (_iter2216 = (*(this->group_names)).begin(); _iter2216 != (*(this->group_names)).end(); ++_iter2216) { - xfer += oprot->writeString((*_iter2215)); + xfer += oprot->writeString((*_iter2216)); } xfer += oprot->writeListEnd(); } @@ -23914,14 +23914,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_result::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2216; - ::apache::thrift::protocol::TType _etype2219; - xfer += iprot->readListBegin(_etype2219, _size2216); - this->success.resize(_size2216); - uint32_t _i2220; - for (_i2220 = 0; _i2220 < _size2216; ++_i2220) + uint32_t _size2217; + ::apache::thrift::protocol::TType _etype2220; + xfer += iprot->readListBegin(_etype2220, _size2217); + this->success.resize(_size2217); + uint32_t _i2221; + for (_i2221 = 0; _i2221 < _size2217; ++_i2221) { - xfer += this->success[_i2220].read(iprot); + xfer += this->success[_i2221].read(iprot); } xfer += iprot->readListEnd(); } @@ -23968,10 +23968,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_result::write(::apache: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter2221; - for (_iter2221 = this->success.begin(); _iter2221 != this->success.end(); ++_iter2221) + std::vector ::const_iterator _iter2222; + for (_iter2222 = this->success.begin(); _iter2222 != this->success.end(); ++_iter2222) { - xfer += (*_iter2221).write(oprot); + xfer += (*_iter2222).write(oprot); } xfer += oprot->writeListEnd(); } @@ -24020,14 +24020,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_presult::read(::apache: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2222; - ::apache::thrift::protocol::TType _etype2225; - xfer += iprot->readListBegin(_etype2225, _size2222); - (*(this->success)).resize(_size2222); - uint32_t _i2226; - for (_i2226 = 0; _i2226 < _size2222; ++_i2226) + uint32_t _size2223; + ::apache::thrift::protocol::TType _etype2226; + xfer += iprot->readListBegin(_etype2226, _size2223); + (*(this->success)).resize(_size2223); + uint32_t _i2227; + for (_i2227 = 0; _i2227 < _size2223; ++_i2227) { - xfer += (*(this->success))[_i2226].read(iprot); + xfer += (*(this->success))[_i2227].read(iprot); } xfer += iprot->readListEnd(); } @@ -24337,14 +24337,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_args::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size2227; - ::apache::thrift::protocol::TType _etype2230; - xfer += iprot->readListBegin(_etype2230, _size2227); - this->part_vals.resize(_size2227); - uint32_t _i2231; - for (_i2231 = 0; _i2231 < _size2227; ++_i2231) + uint32_t _size2228; + ::apache::thrift::protocol::TType _etype2231; + xfer += iprot->readListBegin(_etype2231, _size2228); + this->part_vals.resize(_size2228); + uint32_t _i2232; + for (_i2232 = 0; _i2232 < _size2228; ++_i2232) { - xfer += iprot->readString(this->part_vals[_i2231]); + xfer += iprot->readString(this->part_vals[_i2232]); } xfer += iprot->readListEnd(); } @@ -24389,10 +24389,10 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_args::write(::apache::thrift xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter2232; - for (_iter2232 = this->part_vals.begin(); _iter2232 != this->part_vals.end(); ++_iter2232) + std::vector ::const_iterator _iter2233; + for (_iter2233 = this->part_vals.begin(); _iter2233 != this->part_vals.end(); ++_iter2233) { - xfer += oprot->writeString((*_iter2232)); + xfer += oprot->writeString((*_iter2233)); } xfer += oprot->writeListEnd(); } @@ -24428,10 +24428,10 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_pargs::write(::apache::thrif xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter2233; - for (_iter2233 = (*(this->part_vals)).begin(); _iter2233 != (*(this->part_vals)).end(); ++_iter2233) + std::vector ::const_iterator _iter2234; + for (_iter2234 = (*(this->part_vals)).begin(); _iter2234 != (*(this->part_vals)).end(); ++_iter2234) { - xfer += oprot->writeString((*_iter2233)); + xfer += oprot->writeString((*_iter2234)); } xfer += oprot->writeListEnd(); } @@ -24476,14 +24476,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2234; - ::apache::thrift::protocol::TType _etype2237; - xfer += iprot->readListBegin(_etype2237, _size2234); - this->success.resize(_size2234); - uint32_t _i2238; - for (_i2238 = 0; _i2238 < _size2234; ++_i2238) + uint32_t _size2235; + ::apache::thrift::protocol::TType _etype2238; + xfer += iprot->readListBegin(_etype2238, _size2235); + this->success.resize(_size2235); + uint32_t _i2239; + for (_i2239 = 0; _i2239 < _size2235; ++_i2239) { - xfer += iprot->readString(this->success[_i2238]); + xfer += iprot->readString(this->success[_i2239]); } xfer += iprot->readListEnd(); } @@ -24530,10 +24530,10 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_result::write(::apache::thri xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter2239; - for (_iter2239 = this->success.begin(); _iter2239 != this->success.end(); ++_iter2239) + std::vector ::const_iterator _iter2240; + for (_iter2240 = this->success.begin(); _iter2240 != this->success.end(); ++_iter2240) { - xfer += oprot->writeString((*_iter2239)); + xfer += oprot->writeString((*_iter2240)); } xfer += oprot->writeListEnd(); } @@ -24582,14 +24582,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2240; - ::apache::thrift::protocol::TType _etype2243; - xfer += iprot->readListBegin(_etype2243, _size2240); - (*(this->success)).resize(_size2240); - uint32_t _i2244; - for (_i2244 = 0; _i2244 < _size2240; ++_i2244) + uint32_t _size2241; + ::apache::thrift::protocol::TType _etype2244; + xfer += iprot->readListBegin(_etype2244, _size2241); + (*(this->success)).resize(_size2241); + uint32_t _i2245; + for (_i2245 = 0; _i2245 < _size2241; ++_i2245) { - xfer += iprot->readString((*(this->success))[_i2244]); + xfer += iprot->readString((*(this->success))[_i2245]); } xfer += iprot->readListEnd(); } @@ -24962,14 +24962,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_req_result::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2245; - ::apache::thrift::protocol::TType _etype2248; - xfer += iprot->readListBegin(_etype2248, _size2245); - this->success.resize(_size2245); - uint32_t _i2249; - for (_i2249 = 0; _i2249 < _size2245; ++_i2249) + uint32_t _size2246; + ::apache::thrift::protocol::TType _etype2249; + xfer += iprot->readListBegin(_etype2249, _size2246); + this->success.resize(_size2246); + uint32_t _i2250; + for (_i2250 = 0; _i2250 < _size2246; ++_i2250) { - xfer += iprot->readString(this->success[_i2249]); + xfer += iprot->readString(this->success[_i2250]); } xfer += iprot->readListEnd(); } @@ -25016,10 +25016,10 @@ uint32_t ThriftHiveMetastore_get_partition_names_req_result::write(::apache::thr 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 _iter2250; - for (_iter2250 = this->success.begin(); _iter2250 != this->success.end(); ++_iter2250) + std::vector ::const_iterator _iter2251; + for (_iter2251 = this->success.begin(); _iter2251 != this->success.end(); ++_iter2251) { - xfer += oprot->writeString((*_iter2250)); + xfer += oprot->writeString((*_iter2251)); } xfer += oprot->writeListEnd(); } @@ -25068,14 +25068,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_req_presult::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2251; - ::apache::thrift::protocol::TType _etype2254; - xfer += iprot->readListBegin(_etype2254, _size2251); - (*(this->success)).resize(_size2251); - uint32_t _i2255; - for (_i2255 = 0; _i2255 < _size2251; ++_i2255) + uint32_t _size2252; + ::apache::thrift::protocol::TType _etype2255; + xfer += iprot->readListBegin(_etype2255, _size2252); + (*(this->success)).resize(_size2252); + uint32_t _i2256; + for (_i2256 = 0; _i2256 < _size2252; ++_i2256) { - xfer += iprot->readString((*(this->success))[_i2255]); + xfer += iprot->readString((*(this->success))[_i2256]); } xfer += iprot->readListEnd(); } @@ -25269,14 +25269,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2256; - ::apache::thrift::protocol::TType _etype2259; - xfer += iprot->readListBegin(_etype2259, _size2256); - this->success.resize(_size2256); - uint32_t _i2260; - for (_i2260 = 0; _i2260 < _size2256; ++_i2260) + uint32_t _size2257; + ::apache::thrift::protocol::TType _etype2260; + xfer += iprot->readListBegin(_etype2260, _size2257); + this->success.resize(_size2257); + uint32_t _i2261; + for (_i2261 = 0; _i2261 < _size2257; ++_i2261) { - xfer += this->success[_i2260].read(iprot); + xfer += this->success[_i2261].read(iprot); } xfer += iprot->readListEnd(); } @@ -25323,10 +25323,10 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_result::write(::apache::th xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter2261; - for (_iter2261 = this->success.begin(); _iter2261 != this->success.end(); ++_iter2261) + std::vector ::const_iterator _iter2262; + for (_iter2262 = this->success.begin(); _iter2262 != this->success.end(); ++_iter2262) { - xfer += (*_iter2261).write(oprot); + xfer += (*_iter2262).write(oprot); } xfer += oprot->writeListEnd(); } @@ -25375,14 +25375,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2262; - ::apache::thrift::protocol::TType _etype2265; - xfer += iprot->readListBegin(_etype2265, _size2262); - (*(this->success)).resize(_size2262); - uint32_t _i2266; - for (_i2266 = 0; _i2266 < _size2262; ++_i2266) + uint32_t _size2263; + ::apache::thrift::protocol::TType _etype2266; + xfer += iprot->readListBegin(_etype2266, _size2263); + (*(this->success)).resize(_size2263); + uint32_t _i2267; + for (_i2267 = 0; _i2267 < _size2263; ++_i2267) { - xfer += (*(this->success))[_i2266].read(iprot); + xfer += (*(this->success))[_i2267].read(iprot); } xfer += iprot->readListEnd(); } @@ -25576,14 +25576,14 @@ uint32_t ThriftHiveMetastore_get_part_specs_by_filter_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2267; - ::apache::thrift::protocol::TType _etype2270; - xfer += iprot->readListBegin(_etype2270, _size2267); - this->success.resize(_size2267); - uint32_t _i2271; - for (_i2271 = 0; _i2271 < _size2267; ++_i2271) + uint32_t _size2268; + ::apache::thrift::protocol::TType _etype2271; + xfer += iprot->readListBegin(_etype2271, _size2268); + this->success.resize(_size2268); + uint32_t _i2272; + for (_i2272 = 0; _i2272 < _size2268; ++_i2272) { - xfer += this->success[_i2271].read(iprot); + xfer += this->success[_i2272].read(iprot); } xfer += iprot->readListEnd(); } @@ -25630,10 +25630,10 @@ uint32_t ThriftHiveMetastore_get_part_specs_by_filter_result::write(::apache::th xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter2272; - for (_iter2272 = this->success.begin(); _iter2272 != this->success.end(); ++_iter2272) + std::vector ::const_iterator _iter2273; + for (_iter2273 = this->success.begin(); _iter2273 != this->success.end(); ++_iter2273) { - xfer += (*_iter2272).write(oprot); + xfer += (*_iter2273).write(oprot); } xfer += oprot->writeListEnd(); } @@ -25682,14 +25682,14 @@ uint32_t ThriftHiveMetastore_get_part_specs_by_filter_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2273; - ::apache::thrift::protocol::TType _etype2276; - xfer += iprot->readListBegin(_etype2276, _size2273); - (*(this->success)).resize(_size2273); - uint32_t _i2277; - for (_i2277 = 0; _i2277 < _size2273; ++_i2277) + uint32_t _size2274; + ::apache::thrift::protocol::TType _etype2277; + xfer += iprot->readListBegin(_etype2277, _size2274); + (*(this->success)).resize(_size2274); + uint32_t _i2278; + for (_i2278 = 0; _i2278 < _size2274; ++_i2278) { - xfer += (*(this->success))[_i2277].read(iprot); + xfer += (*(this->success))[_i2278].read(iprot); } xfer += iprot->readListEnd(); } @@ -26485,14 +26485,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_args::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { this->names.clear(); - uint32_t _size2278; - ::apache::thrift::protocol::TType _etype2281; - xfer += iprot->readListBegin(_etype2281, _size2278); - this->names.resize(_size2278); - uint32_t _i2282; - for (_i2282 = 0; _i2282 < _size2278; ++_i2282) + uint32_t _size2279; + ::apache::thrift::protocol::TType _etype2282; + xfer += iprot->readListBegin(_etype2282, _size2279); + this->names.resize(_size2279); + uint32_t _i2283; + for (_i2283 = 0; _i2283 < _size2279; ++_i2283) { - xfer += iprot->readString(this->names[_i2282]); + xfer += iprot->readString(this->names[_i2283]); } xfer += iprot->readListEnd(); } @@ -26529,10 +26529,10 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_args::write(::apache::thrif xfer += oprot->writeFieldBegin("names", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->names.size())); - std::vector ::const_iterator _iter2283; - for (_iter2283 = this->names.begin(); _iter2283 != this->names.end(); ++_iter2283) + std::vector ::const_iterator _iter2284; + for (_iter2284 = this->names.begin(); _iter2284 != this->names.end(); ++_iter2284) { - xfer += oprot->writeString((*_iter2283)); + xfer += oprot->writeString((*_iter2284)); } xfer += oprot->writeListEnd(); } @@ -26564,10 +26564,10 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_pargs::write(::apache::thri xfer += oprot->writeFieldBegin("names", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->names)).size())); - std::vector ::const_iterator _iter2284; - for (_iter2284 = (*(this->names)).begin(); _iter2284 != (*(this->names)).end(); ++_iter2284) + std::vector ::const_iterator _iter2285; + for (_iter2285 = (*(this->names)).begin(); _iter2285 != (*(this->names)).end(); ++_iter2285) { - xfer += oprot->writeString((*_iter2284)); + xfer += oprot->writeString((*_iter2285)); } xfer += oprot->writeListEnd(); } @@ -26608,14 +26608,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_result::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2285; - ::apache::thrift::protocol::TType _etype2288; - xfer += iprot->readListBegin(_etype2288, _size2285); - this->success.resize(_size2285); - uint32_t _i2289; - for (_i2289 = 0; _i2289 < _size2285; ++_i2289) + uint32_t _size2286; + ::apache::thrift::protocol::TType _etype2289; + xfer += iprot->readListBegin(_etype2289, _size2286); + this->success.resize(_size2286); + uint32_t _i2290; + for (_i2290 = 0; _i2290 < _size2286; ++_i2290) { - xfer += this->success[_i2289].read(iprot); + xfer += this->success[_i2290].read(iprot); } xfer += iprot->readListEnd(); } @@ -26662,10 +26662,10 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_result::write(::apache::thr xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter2290; - for (_iter2290 = this->success.begin(); _iter2290 != this->success.end(); ++_iter2290) + std::vector ::const_iterator _iter2291; + for (_iter2291 = this->success.begin(); _iter2291 != this->success.end(); ++_iter2291) { - xfer += (*_iter2290).write(oprot); + xfer += (*_iter2291).write(oprot); } xfer += oprot->writeListEnd(); } @@ -26714,14 +26714,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_presult::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2291; - ::apache::thrift::protocol::TType _etype2294; - xfer += iprot->readListBegin(_etype2294, _size2291); - (*(this->success)).resize(_size2291); - uint32_t _i2295; - for (_i2295 = 0; _i2295 < _size2291; ++_i2295) + uint32_t _size2292; + ::apache::thrift::protocol::TType _etype2295; + xfer += iprot->readListBegin(_etype2295, _size2292); + (*(this->success)).resize(_size2292); + uint32_t _i2296; + for (_i2296 = 0; _i2296 < _size2292; ++_i2296) { - xfer += (*(this->success))[_i2295].read(iprot); + xfer += (*(this->success))[_i2296].read(iprot); } xfer += iprot->readListEnd(); } @@ -27270,14 +27270,14 @@ uint32_t ThriftHiveMetastore_alter_partitions_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size2296; - ::apache::thrift::protocol::TType _etype2299; - xfer += iprot->readListBegin(_etype2299, _size2296); - this->new_parts.resize(_size2296); - uint32_t _i2300; - for (_i2300 = 0; _i2300 < _size2296; ++_i2300) + uint32_t _size2297; + ::apache::thrift::protocol::TType _etype2300; + xfer += iprot->readListBegin(_etype2300, _size2297); + this->new_parts.resize(_size2297); + uint32_t _i2301; + for (_i2301 = 0; _i2301 < _size2297; ++_i2301) { - xfer += this->new_parts[_i2300].read(iprot); + xfer += this->new_parts[_i2301].read(iprot); } xfer += iprot->readListEnd(); } @@ -27314,10 +27314,10 @@ uint32_t ThriftHiveMetastore_alter_partitions_args::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->new_parts.size())); - std::vector ::const_iterator _iter2301; - for (_iter2301 = this->new_parts.begin(); _iter2301 != this->new_parts.end(); ++_iter2301) + std::vector ::const_iterator _iter2302; + for (_iter2302 = this->new_parts.begin(); _iter2302 != this->new_parts.end(); ++_iter2302) { - xfer += (*_iter2301).write(oprot); + xfer += (*_iter2302).write(oprot); } xfer += oprot->writeListEnd(); } @@ -27349,10 +27349,10 @@ uint32_t ThriftHiveMetastore_alter_partitions_pargs::write(::apache::thrift::pro xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->new_parts)).size())); - std::vector ::const_iterator _iter2302; - for (_iter2302 = (*(this->new_parts)).begin(); _iter2302 != (*(this->new_parts)).end(); ++_iter2302) + std::vector ::const_iterator _iter2303; + for (_iter2303 = (*(this->new_parts)).begin(); _iter2303 != (*(this->new_parts)).end(); ++_iter2303) { - xfer += (*_iter2302).write(oprot); + xfer += (*_iter2303).write(oprot); } xfer += oprot->writeListEnd(); } @@ -27537,14 +27537,14 @@ uint32_t ThriftHiveMetastore_alter_partitions_with_environment_context_args::rea if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size2303; - ::apache::thrift::protocol::TType _etype2306; - xfer += iprot->readListBegin(_etype2306, _size2303); - this->new_parts.resize(_size2303); - uint32_t _i2307; - for (_i2307 = 0; _i2307 < _size2303; ++_i2307) + uint32_t _size2304; + ::apache::thrift::protocol::TType _etype2307; + xfer += iprot->readListBegin(_etype2307, _size2304); + this->new_parts.resize(_size2304); + uint32_t _i2308; + for (_i2308 = 0; _i2308 < _size2304; ++_i2308) { - xfer += this->new_parts[_i2307].read(iprot); + xfer += this->new_parts[_i2308].read(iprot); } xfer += iprot->readListEnd(); } @@ -27589,10 +27589,10 @@ uint32_t ThriftHiveMetastore_alter_partitions_with_environment_context_args::wri xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->new_parts.size())); - std::vector ::const_iterator _iter2308; - for (_iter2308 = this->new_parts.begin(); _iter2308 != this->new_parts.end(); ++_iter2308) + std::vector ::const_iterator _iter2309; + for (_iter2309 = this->new_parts.begin(); _iter2309 != this->new_parts.end(); ++_iter2309) { - xfer += (*_iter2308).write(oprot); + xfer += (*_iter2309).write(oprot); } xfer += oprot->writeListEnd(); } @@ -27628,10 +27628,10 @@ uint32_t ThriftHiveMetastore_alter_partitions_with_environment_context_pargs::wr xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->new_parts)).size())); - std::vector ::const_iterator _iter2309; - for (_iter2309 = (*(this->new_parts)).begin(); _iter2309 != (*(this->new_parts)).end(); ++_iter2309) + std::vector ::const_iterator _iter2310; + for (_iter2310 = (*(this->new_parts)).begin(); _iter2310 != (*(this->new_parts)).end(); ++_iter2310) { - xfer += (*_iter2309).write(oprot); + xfer += (*_iter2310).write(oprot); } xfer += oprot->writeListEnd(); } @@ -28302,14 +28302,14 @@ uint32_t ThriftHiveMetastore_rename_partition_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size2310; - ::apache::thrift::protocol::TType _etype2313; - xfer += iprot->readListBegin(_etype2313, _size2310); - this->part_vals.resize(_size2310); - uint32_t _i2314; - for (_i2314 = 0; _i2314 < _size2310; ++_i2314) + uint32_t _size2311; + ::apache::thrift::protocol::TType _etype2314; + xfer += iprot->readListBegin(_etype2314, _size2311); + this->part_vals.resize(_size2311); + uint32_t _i2315; + for (_i2315 = 0; _i2315 < _size2311; ++_i2315) { - xfer += iprot->readString(this->part_vals[_i2314]); + xfer += iprot->readString(this->part_vals[_i2315]); } xfer += iprot->readListEnd(); } @@ -28354,10 +28354,10 @@ uint32_t ThriftHiveMetastore_rename_partition_args::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter2315; - for (_iter2315 = this->part_vals.begin(); _iter2315 != this->part_vals.end(); ++_iter2315) + std::vector ::const_iterator _iter2316; + for (_iter2316 = this->part_vals.begin(); _iter2316 != this->part_vals.end(); ++_iter2316) { - xfer += oprot->writeString((*_iter2315)); + xfer += oprot->writeString((*_iter2316)); } xfer += oprot->writeListEnd(); } @@ -28393,10 +28393,10 @@ uint32_t ThriftHiveMetastore_rename_partition_pargs::write(::apache::thrift::pro xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter2316; - for (_iter2316 = (*(this->part_vals)).begin(); _iter2316 != (*(this->part_vals)).end(); ++_iter2316) + std::vector ::const_iterator _iter2317; + for (_iter2317 = (*(this->part_vals)).begin(); _iter2317 != (*(this->part_vals)).end(); ++_iter2317) { - xfer += oprot->writeString((*_iter2316)); + xfer += oprot->writeString((*_iter2317)); } xfer += oprot->writeListEnd(); } @@ -28796,14 +28796,14 @@ uint32_t ThriftHiveMetastore_partition_name_has_valid_characters_args::read(::ap if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size2317; - ::apache::thrift::protocol::TType _etype2320; - xfer += iprot->readListBegin(_etype2320, _size2317); - this->part_vals.resize(_size2317); - uint32_t _i2321; - for (_i2321 = 0; _i2321 < _size2317; ++_i2321) + uint32_t _size2318; + ::apache::thrift::protocol::TType _etype2321; + xfer += iprot->readListBegin(_etype2321, _size2318); + this->part_vals.resize(_size2318); + uint32_t _i2322; + for (_i2322 = 0; _i2322 < _size2318; ++_i2322) { - xfer += iprot->readString(this->part_vals[_i2321]); + xfer += iprot->readString(this->part_vals[_i2322]); } xfer += iprot->readListEnd(); } @@ -28840,10 +28840,10 @@ uint32_t ThriftHiveMetastore_partition_name_has_valid_characters_args::write(::a xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter2322; - for (_iter2322 = this->part_vals.begin(); _iter2322 != this->part_vals.end(); ++_iter2322) + std::vector ::const_iterator _iter2323; + for (_iter2323 = this->part_vals.begin(); _iter2323 != this->part_vals.end(); ++_iter2323) { - xfer += oprot->writeString((*_iter2322)); + xfer += oprot->writeString((*_iter2323)); } xfer += oprot->writeListEnd(); } @@ -28871,10 +28871,10 @@ uint32_t ThriftHiveMetastore_partition_name_has_valid_characters_pargs::write(:: xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter2323; - for (_iter2323 = (*(this->part_vals)).begin(); _iter2323 != (*(this->part_vals)).end(); ++_iter2323) + std::vector ::const_iterator _iter2324; + for (_iter2324 = (*(this->part_vals)).begin(); _iter2324 != (*(this->part_vals)).end(); ++_iter2324) { - xfer += oprot->writeString((*_iter2323)); + xfer += oprot->writeString((*_iter2324)); } xfer += oprot->writeListEnd(); } @@ -29349,14 +29349,14 @@ uint32_t ThriftHiveMetastore_partition_name_to_vals_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2324; - ::apache::thrift::protocol::TType _etype2327; - xfer += iprot->readListBegin(_etype2327, _size2324); - this->success.resize(_size2324); - uint32_t _i2328; - for (_i2328 = 0; _i2328 < _size2324; ++_i2328) + uint32_t _size2325; + ::apache::thrift::protocol::TType _etype2328; + xfer += iprot->readListBegin(_etype2328, _size2325); + this->success.resize(_size2325); + uint32_t _i2329; + for (_i2329 = 0; _i2329 < _size2325; ++_i2329) { - xfer += iprot->readString(this->success[_i2328]); + xfer += iprot->readString(this->success[_i2329]); } xfer += iprot->readListEnd(); } @@ -29395,10 +29395,10 @@ uint32_t ThriftHiveMetastore_partition_name_to_vals_result::write(::apache::thri xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter2329; - for (_iter2329 = this->success.begin(); _iter2329 != this->success.end(); ++_iter2329) + std::vector ::const_iterator _iter2330; + for (_iter2330 = this->success.begin(); _iter2330 != this->success.end(); ++_iter2330) { - xfer += oprot->writeString((*_iter2329)); + xfer += oprot->writeString((*_iter2330)); } xfer += oprot->writeListEnd(); } @@ -29443,14 +29443,14 @@ uint32_t ThriftHiveMetastore_partition_name_to_vals_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2330; - ::apache::thrift::protocol::TType _etype2333; - xfer += iprot->readListBegin(_etype2333, _size2330); - (*(this->success)).resize(_size2330); - uint32_t _i2334; - for (_i2334 = 0; _i2334 < _size2330; ++_i2334) + uint32_t _size2331; + ::apache::thrift::protocol::TType _etype2334; + xfer += iprot->readListBegin(_etype2334, _size2331); + (*(this->success)).resize(_size2331); + uint32_t _i2335; + for (_i2335 = 0; _i2335 < _size2331; ++_i2335) { - xfer += iprot->readString((*(this->success))[_i2334]); + xfer += iprot->readString((*(this->success))[_i2335]); } xfer += iprot->readListEnd(); } @@ -29588,17 +29588,17 @@ uint32_t ThriftHiveMetastore_partition_name_to_spec_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_MAP) { { this->success.clear(); - uint32_t _size2335; - ::apache::thrift::protocol::TType _ktype2336; - ::apache::thrift::protocol::TType _vtype2337; - xfer += iprot->readMapBegin(_ktype2336, _vtype2337, _size2335); - uint32_t _i2339; - for (_i2339 = 0; _i2339 < _size2335; ++_i2339) + uint32_t _size2336; + ::apache::thrift::protocol::TType _ktype2337; + ::apache::thrift::protocol::TType _vtype2338; + xfer += iprot->readMapBegin(_ktype2337, _vtype2338, _size2336); + uint32_t _i2340; + for (_i2340 = 0; _i2340 < _size2336; ++_i2340) { - std::string _key2340; - xfer += iprot->readString(_key2340); - std::string& _val2341 = this->success[_key2340]; - xfer += iprot->readString(_val2341); + std::string _key2341; + xfer += iprot->readString(_key2341); + std::string& _val2342 = this->success[_key2341]; + xfer += iprot->readString(_val2342); } xfer += iprot->readMapEnd(); } @@ -29637,11 +29637,11 @@ uint32_t ThriftHiveMetastore_partition_name_to_spec_result::write(::apache::thri xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_MAP, 0); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::map ::const_iterator _iter2342; - for (_iter2342 = this->success.begin(); _iter2342 != this->success.end(); ++_iter2342) + std::map ::const_iterator _iter2343; + for (_iter2343 = this->success.begin(); _iter2343 != this->success.end(); ++_iter2343) { - xfer += oprot->writeString(_iter2342->first); - xfer += oprot->writeString(_iter2342->second); + xfer += oprot->writeString(_iter2343->first); + xfer += oprot->writeString(_iter2343->second); } xfer += oprot->writeMapEnd(); } @@ -29686,17 +29686,17 @@ uint32_t ThriftHiveMetastore_partition_name_to_spec_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_MAP) { { (*(this->success)).clear(); - uint32_t _size2343; - ::apache::thrift::protocol::TType _ktype2344; - ::apache::thrift::protocol::TType _vtype2345; - xfer += iprot->readMapBegin(_ktype2344, _vtype2345, _size2343); - uint32_t _i2347; - for (_i2347 = 0; _i2347 < _size2343; ++_i2347) + uint32_t _size2344; + ::apache::thrift::protocol::TType _ktype2345; + ::apache::thrift::protocol::TType _vtype2346; + xfer += iprot->readMapBegin(_ktype2345, _vtype2346, _size2344); + uint32_t _i2348; + for (_i2348 = 0; _i2348 < _size2344; ++_i2348) { - std::string _key2348; - xfer += iprot->readString(_key2348); - std::string& _val2349 = (*(this->success))[_key2348]; - xfer += iprot->readString(_val2349); + std::string _key2349; + xfer += iprot->readString(_key2349); + std::string& _val2350 = (*(this->success))[_key2349]; + xfer += iprot->readString(_val2350); } xfer += iprot->readMapEnd(); } @@ -29771,17 +29771,17 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_args::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_MAP) { { this->part_vals.clear(); - uint32_t _size2350; - ::apache::thrift::protocol::TType _ktype2351; - ::apache::thrift::protocol::TType _vtype2352; - xfer += iprot->readMapBegin(_ktype2351, _vtype2352, _size2350); - uint32_t _i2354; - for (_i2354 = 0; _i2354 < _size2350; ++_i2354) + uint32_t _size2351; + ::apache::thrift::protocol::TType _ktype2352; + ::apache::thrift::protocol::TType _vtype2353; + xfer += iprot->readMapBegin(_ktype2352, _vtype2353, _size2351); + uint32_t _i2355; + for (_i2355 = 0; _i2355 < _size2351; ++_i2355) { - std::string _key2355; - xfer += iprot->readString(_key2355); - std::string& _val2356 = this->part_vals[_key2355]; - xfer += iprot->readString(_val2356); + std::string _key2356; + xfer += iprot->readString(_key2356); + std::string& _val2357 = this->part_vals[_key2356]; + xfer += iprot->readString(_val2357); } xfer += iprot->readMapEnd(); } @@ -29792,9 +29792,9 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_args::read(::apache::thrift:: break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast2357; - xfer += iprot->readI32(ecast2357); - this->eventType = static_cast(ecast2357); + int32_t ecast2358; + xfer += iprot->readI32(ecast2358); + this->eventType = static_cast(ecast2358); this->__isset.eventType = true; } else { xfer += iprot->skip(ftype); @@ -29828,11 +29828,11 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_args::write(::apache::thrift: xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_MAP, 3); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::map ::const_iterator _iter2358; - for (_iter2358 = this->part_vals.begin(); _iter2358 != this->part_vals.end(); ++_iter2358) + std::map ::const_iterator _iter2359; + for (_iter2359 = this->part_vals.begin(); _iter2359 != this->part_vals.end(); ++_iter2359) { - xfer += oprot->writeString(_iter2358->first); - xfer += oprot->writeString(_iter2358->second); + xfer += oprot->writeString(_iter2359->first); + xfer += oprot->writeString(_iter2359->second); } xfer += oprot->writeMapEnd(); } @@ -29868,11 +29868,11 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_pargs::write(::apache::thrift xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_MAP, 3); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::map ::const_iterator _iter2359; - for (_iter2359 = (*(this->part_vals)).begin(); _iter2359 != (*(this->part_vals)).end(); ++_iter2359) + std::map ::const_iterator _iter2360; + for (_iter2360 = (*(this->part_vals)).begin(); _iter2360 != (*(this->part_vals)).end(); ++_iter2360) { - xfer += oprot->writeString(_iter2359->first); - xfer += oprot->writeString(_iter2359->second); + xfer += oprot->writeString(_iter2360->first); + xfer += oprot->writeString(_iter2360->second); } xfer += oprot->writeMapEnd(); } @@ -30141,17 +30141,17 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_MAP) { { this->part_vals.clear(); - uint32_t _size2360; - ::apache::thrift::protocol::TType _ktype2361; - ::apache::thrift::protocol::TType _vtype2362; - xfer += iprot->readMapBegin(_ktype2361, _vtype2362, _size2360); - uint32_t _i2364; - for (_i2364 = 0; _i2364 < _size2360; ++_i2364) + uint32_t _size2361; + ::apache::thrift::protocol::TType _ktype2362; + ::apache::thrift::protocol::TType _vtype2363; + xfer += iprot->readMapBegin(_ktype2362, _vtype2363, _size2361); + uint32_t _i2365; + for (_i2365 = 0; _i2365 < _size2361; ++_i2365) { - std::string _key2365; - xfer += iprot->readString(_key2365); - std::string& _val2366 = this->part_vals[_key2365]; - xfer += iprot->readString(_val2366); + std::string _key2366; + xfer += iprot->readString(_key2366); + std::string& _val2367 = this->part_vals[_key2366]; + xfer += iprot->readString(_val2367); } xfer += iprot->readMapEnd(); } @@ -30162,9 +30162,9 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::read(::apache::thri break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast2367; - xfer += iprot->readI32(ecast2367); - this->eventType = static_cast(ecast2367); + int32_t ecast2368; + xfer += iprot->readI32(ecast2368); + this->eventType = static_cast(ecast2368); this->__isset.eventType = true; } else { xfer += iprot->skip(ftype); @@ -30198,11 +30198,11 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::write(::apache::thr xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_MAP, 3); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::map ::const_iterator _iter2368; - for (_iter2368 = this->part_vals.begin(); _iter2368 != this->part_vals.end(); ++_iter2368) + std::map ::const_iterator _iter2369; + for (_iter2369 = this->part_vals.begin(); _iter2369 != this->part_vals.end(); ++_iter2369) { - xfer += oprot->writeString(_iter2368->first); - xfer += oprot->writeString(_iter2368->second); + xfer += oprot->writeString(_iter2369->first); + xfer += oprot->writeString(_iter2369->second); } xfer += oprot->writeMapEnd(); } @@ -30238,11 +30238,11 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_pargs::write(::apache::th xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_MAP, 3); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::map ::const_iterator _iter2369; - for (_iter2369 = (*(this->part_vals)).begin(); _iter2369 != (*(this->part_vals)).end(); ++_iter2369) + std::map ::const_iterator _iter2370; + for (_iter2370 = (*(this->part_vals)).begin(); _iter2370 != (*(this->part_vals)).end(); ++_iter2370) { - xfer += oprot->writeString(_iter2369->first); - xfer += oprot->writeString(_iter2369->second); + xfer += oprot->writeString(_iter2370->first); + xfer += oprot->writeString(_iter2370->second); } xfer += oprot->writeMapEnd(); } @@ -36371,14 +36371,14 @@ uint32_t ThriftHiveMetastore_get_functions_result::read(::apache::thrift::protoc if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2370; - ::apache::thrift::protocol::TType _etype2373; - xfer += iprot->readListBegin(_etype2373, _size2370); - this->success.resize(_size2370); - uint32_t _i2374; - for (_i2374 = 0; _i2374 < _size2370; ++_i2374) + uint32_t _size2371; + ::apache::thrift::protocol::TType _etype2374; + xfer += iprot->readListBegin(_etype2374, _size2371); + this->success.resize(_size2371); + uint32_t _i2375; + for (_i2375 = 0; _i2375 < _size2371; ++_i2375) { - xfer += iprot->readString(this->success[_i2374]); + xfer += iprot->readString(this->success[_i2375]); } xfer += iprot->readListEnd(); } @@ -36417,10 +36417,10 @@ uint32_t ThriftHiveMetastore_get_functions_result::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter2375; - for (_iter2375 = this->success.begin(); _iter2375 != this->success.end(); ++_iter2375) + std::vector ::const_iterator _iter2376; + for (_iter2376 = this->success.begin(); _iter2376 != this->success.end(); ++_iter2376) { - xfer += oprot->writeString((*_iter2375)); + xfer += oprot->writeString((*_iter2376)); } xfer += oprot->writeListEnd(); } @@ -36465,14 +36465,14 @@ uint32_t ThriftHiveMetastore_get_functions_presult::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2376; - ::apache::thrift::protocol::TType _etype2379; - xfer += iprot->readListBegin(_etype2379, _size2376); - (*(this->success)).resize(_size2376); - uint32_t _i2380; - for (_i2380 = 0; _i2380 < _size2376; ++_i2380) + uint32_t _size2377; + ::apache::thrift::protocol::TType _etype2380; + xfer += iprot->readListBegin(_etype2380, _size2377); + (*(this->success)).resize(_size2377); + uint32_t _i2381; + for (_i2381 = 0; _i2381 < _size2377; ++_i2381) { - xfer += iprot->readString((*(this->success))[_i2380]); + xfer += iprot->readString((*(this->success))[_i2381]); } xfer += iprot->readListEnd(); } @@ -37432,14 +37432,14 @@ uint32_t ThriftHiveMetastore_get_role_names_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2381; - ::apache::thrift::protocol::TType _etype2384; - xfer += iprot->readListBegin(_etype2384, _size2381); - this->success.resize(_size2381); - uint32_t _i2385; - for (_i2385 = 0; _i2385 < _size2381; ++_i2385) + uint32_t _size2382; + ::apache::thrift::protocol::TType _etype2385; + xfer += iprot->readListBegin(_etype2385, _size2382); + this->success.resize(_size2382); + uint32_t _i2386; + for (_i2386 = 0; _i2386 < _size2382; ++_i2386) { - xfer += iprot->readString(this->success[_i2385]); + xfer += iprot->readString(this->success[_i2386]); } xfer += iprot->readListEnd(); } @@ -37478,10 +37478,10 @@ uint32_t ThriftHiveMetastore_get_role_names_result::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter2386; - for (_iter2386 = this->success.begin(); _iter2386 != this->success.end(); ++_iter2386) + std::vector ::const_iterator _iter2387; + for (_iter2387 = this->success.begin(); _iter2387 != this->success.end(); ++_iter2387) { - xfer += oprot->writeString((*_iter2386)); + xfer += oprot->writeString((*_iter2387)); } xfer += oprot->writeListEnd(); } @@ -37526,14 +37526,14 @@ uint32_t ThriftHiveMetastore_get_role_names_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2387; - ::apache::thrift::protocol::TType _etype2390; - xfer += iprot->readListBegin(_etype2390, _size2387); - (*(this->success)).resize(_size2387); - uint32_t _i2391; - for (_i2391 = 0; _i2391 < _size2387; ++_i2391) + uint32_t _size2388; + ::apache::thrift::protocol::TType _etype2391; + xfer += iprot->readListBegin(_etype2391, _size2388); + (*(this->success)).resize(_size2388); + uint32_t _i2392; + for (_i2392 = 0; _i2392 < _size2388; ++_i2392) { - xfer += iprot->readString((*(this->success))[_i2391]); + xfer += iprot->readString((*(this->success))[_i2392]); } xfer += iprot->readListEnd(); } @@ -37606,9 +37606,9 @@ uint32_t ThriftHiveMetastore_grant_role_args::read(::apache::thrift::protocol::T break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast2392; - xfer += iprot->readI32(ecast2392); - this->principal_type = static_cast(ecast2392); + int32_t ecast2393; + xfer += iprot->readI32(ecast2393); + this->principal_type = static_cast(ecast2393); this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -37624,9 +37624,9 @@ uint32_t ThriftHiveMetastore_grant_role_args::read(::apache::thrift::protocol::T break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast2393; - xfer += iprot->readI32(ecast2393); - this->grantorType = static_cast(ecast2393); + int32_t ecast2394; + xfer += iprot->readI32(ecast2394); + this->grantorType = static_cast(ecast2394); this->__isset.grantorType = true; } else { xfer += iprot->skip(ftype); @@ -37897,9 +37897,9 @@ uint32_t ThriftHiveMetastore_revoke_role_args::read(::apache::thrift::protocol:: break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast2394; - xfer += iprot->readI32(ecast2394); - this->principal_type = static_cast(ecast2394); + int32_t ecast2395; + xfer += iprot->readI32(ecast2395); + this->principal_type = static_cast(ecast2395); this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -38130,9 +38130,9 @@ uint32_t ThriftHiveMetastore_list_roles_args::read(::apache::thrift::protocol::T break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast2395; - xfer += iprot->readI32(ecast2395); - this->principal_type = static_cast(ecast2395); + int32_t ecast2396; + xfer += iprot->readI32(ecast2396); + this->principal_type = static_cast(ecast2396); this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -38221,14 +38221,14 @@ uint32_t ThriftHiveMetastore_list_roles_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2396; - ::apache::thrift::protocol::TType _etype2399; - xfer += iprot->readListBegin(_etype2399, _size2396); - this->success.resize(_size2396); - uint32_t _i2400; - for (_i2400 = 0; _i2400 < _size2396; ++_i2400) + uint32_t _size2397; + ::apache::thrift::protocol::TType _etype2400; + xfer += iprot->readListBegin(_etype2400, _size2397); + this->success.resize(_size2397); + uint32_t _i2401; + for (_i2401 = 0; _i2401 < _size2397; ++_i2401) { - xfer += this->success[_i2400].read(iprot); + xfer += this->success[_i2401].read(iprot); } xfer += iprot->readListEnd(); } @@ -38267,10 +38267,10 @@ uint32_t ThriftHiveMetastore_list_roles_result::write(::apache::thrift::protocol xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter2401; - for (_iter2401 = this->success.begin(); _iter2401 != this->success.end(); ++_iter2401) + std::vector ::const_iterator _iter2402; + for (_iter2402 = this->success.begin(); _iter2402 != this->success.end(); ++_iter2402) { - xfer += (*_iter2401).write(oprot); + xfer += (*_iter2402).write(oprot); } xfer += oprot->writeListEnd(); } @@ -38315,14 +38315,14 @@ uint32_t ThriftHiveMetastore_list_roles_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2402; - ::apache::thrift::protocol::TType _etype2405; - xfer += iprot->readListBegin(_etype2405, _size2402); - (*(this->success)).resize(_size2402); - uint32_t _i2406; - for (_i2406 = 0; _i2406 < _size2402; ++_i2406) + uint32_t _size2403; + ::apache::thrift::protocol::TType _etype2406; + xfer += iprot->readListBegin(_etype2406, _size2403); + (*(this->success)).resize(_size2403); + uint32_t _i2407; + for (_i2407 = 0; _i2407 < _size2403; ++_i2407) { - xfer += (*(this->success))[_i2406].read(iprot); + xfer += (*(this->success))[_i2407].read(iprot); } xfer += iprot->readListEnd(); } @@ -39018,14 +39018,14 @@ uint32_t ThriftHiveMetastore_get_privilege_set_args::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size2407; - ::apache::thrift::protocol::TType _etype2410; - xfer += iprot->readListBegin(_etype2410, _size2407); - this->group_names.resize(_size2407); - uint32_t _i2411; - for (_i2411 = 0; _i2411 < _size2407; ++_i2411) + uint32_t _size2408; + ::apache::thrift::protocol::TType _etype2411; + xfer += iprot->readListBegin(_etype2411, _size2408); + this->group_names.resize(_size2408); + uint32_t _i2412; + for (_i2412 = 0; _i2412 < _size2408; ++_i2412) { - xfer += iprot->readString(this->group_names[_i2411]); + xfer += iprot->readString(this->group_names[_i2412]); } xfer += iprot->readListEnd(); } @@ -39062,10 +39062,10 @@ uint32_t ThriftHiveMetastore_get_privilege_set_args::write(::apache::thrift::pro xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->group_names.size())); - std::vector ::const_iterator _iter2412; - for (_iter2412 = this->group_names.begin(); _iter2412 != this->group_names.end(); ++_iter2412) + std::vector ::const_iterator _iter2413; + for (_iter2413 = this->group_names.begin(); _iter2413 != this->group_names.end(); ++_iter2413) { - xfer += oprot->writeString((*_iter2412)); + xfer += oprot->writeString((*_iter2413)); } xfer += oprot->writeListEnd(); } @@ -39097,10 +39097,10 @@ uint32_t ThriftHiveMetastore_get_privilege_set_pargs::write(::apache::thrift::pr xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->group_names)).size())); - std::vector ::const_iterator _iter2413; - for (_iter2413 = (*(this->group_names)).begin(); _iter2413 != (*(this->group_names)).end(); ++_iter2413) + std::vector ::const_iterator _iter2414; + for (_iter2414 = (*(this->group_names)).begin(); _iter2414 != (*(this->group_names)).end(); ++_iter2414) { - xfer += oprot->writeString((*_iter2413)); + xfer += oprot->writeString((*_iter2414)); } xfer += oprot->writeListEnd(); } @@ -39275,9 +39275,9 @@ uint32_t ThriftHiveMetastore_list_privileges_args::read(::apache::thrift::protoc break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast2414; - xfer += iprot->readI32(ecast2414); - this->principal_type = static_cast(ecast2414); + int32_t ecast2415; + xfer += iprot->readI32(ecast2415); + this->principal_type = static_cast(ecast2415); this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -39382,14 +39382,14 @@ uint32_t ThriftHiveMetastore_list_privileges_result::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2415; - ::apache::thrift::protocol::TType _etype2418; - xfer += iprot->readListBegin(_etype2418, _size2415); - this->success.resize(_size2415); - uint32_t _i2419; - for (_i2419 = 0; _i2419 < _size2415; ++_i2419) + uint32_t _size2416; + ::apache::thrift::protocol::TType _etype2419; + xfer += iprot->readListBegin(_etype2419, _size2416); + this->success.resize(_size2416); + uint32_t _i2420; + for (_i2420 = 0; _i2420 < _size2416; ++_i2420) { - xfer += this->success[_i2419].read(iprot); + xfer += this->success[_i2420].read(iprot); } xfer += iprot->readListEnd(); } @@ -39428,10 +39428,10 @@ uint32_t ThriftHiveMetastore_list_privileges_result::write(::apache::thrift::pro xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter2420; - for (_iter2420 = this->success.begin(); _iter2420 != this->success.end(); ++_iter2420) + std::vector ::const_iterator _iter2421; + for (_iter2421 = this->success.begin(); _iter2421 != this->success.end(); ++_iter2421) { - xfer += (*_iter2420).write(oprot); + xfer += (*_iter2421).write(oprot); } xfer += oprot->writeListEnd(); } @@ -39476,14 +39476,14 @@ uint32_t ThriftHiveMetastore_list_privileges_presult::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2421; - ::apache::thrift::protocol::TType _etype2424; - xfer += iprot->readListBegin(_etype2424, _size2421); - (*(this->success)).resize(_size2421); - uint32_t _i2425; - for (_i2425 = 0; _i2425 < _size2421; ++_i2425) + uint32_t _size2422; + ::apache::thrift::protocol::TType _etype2425; + xfer += iprot->readListBegin(_etype2425, _size2422); + (*(this->success)).resize(_size2422); + uint32_t _i2426; + for (_i2426 = 0; _i2426 < _size2422; ++_i2426) { - xfer += (*(this->success))[_i2425].read(iprot); + xfer += (*(this->success))[_i2426].read(iprot); } xfer += iprot->readListEnd(); } @@ -40410,14 +40410,14 @@ uint32_t ThriftHiveMetastore_set_ugi_args::read(::apache::thrift::protocol::TPro if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size2426; - ::apache::thrift::protocol::TType _etype2429; - xfer += iprot->readListBegin(_etype2429, _size2426); - this->group_names.resize(_size2426); - uint32_t _i2430; - for (_i2430 = 0; _i2430 < _size2426; ++_i2430) + uint32_t _size2427; + ::apache::thrift::protocol::TType _etype2430; + xfer += iprot->readListBegin(_etype2430, _size2427); + this->group_names.resize(_size2427); + uint32_t _i2431; + for (_i2431 = 0; _i2431 < _size2427; ++_i2431) { - xfer += iprot->readString(this->group_names[_i2430]); + xfer += iprot->readString(this->group_names[_i2431]); } xfer += iprot->readListEnd(); } @@ -40450,10 +40450,10 @@ uint32_t ThriftHiveMetastore_set_ugi_args::write(::apache::thrift::protocol::TPr xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->group_names.size())); - std::vector ::const_iterator _iter2431; - for (_iter2431 = this->group_names.begin(); _iter2431 != this->group_names.end(); ++_iter2431) + std::vector ::const_iterator _iter2432; + for (_iter2432 = this->group_names.begin(); _iter2432 != this->group_names.end(); ++_iter2432) { - xfer += oprot->writeString((*_iter2431)); + xfer += oprot->writeString((*_iter2432)); } xfer += oprot->writeListEnd(); } @@ -40481,10 +40481,10 @@ uint32_t ThriftHiveMetastore_set_ugi_pargs::write(::apache::thrift::protocol::TP xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->group_names)).size())); - std::vector ::const_iterator _iter2432; - for (_iter2432 = (*(this->group_names)).begin(); _iter2432 != (*(this->group_names)).end(); ++_iter2432) + std::vector ::const_iterator _iter2433; + for (_iter2433 = (*(this->group_names)).begin(); _iter2433 != (*(this->group_names)).end(); ++_iter2433) { - xfer += oprot->writeString((*_iter2432)); + xfer += oprot->writeString((*_iter2433)); } xfer += oprot->writeListEnd(); } @@ -40525,14 +40525,14 @@ uint32_t ThriftHiveMetastore_set_ugi_result::read(::apache::thrift::protocol::TP if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2433; - ::apache::thrift::protocol::TType _etype2436; - xfer += iprot->readListBegin(_etype2436, _size2433); - this->success.resize(_size2433); - uint32_t _i2437; - for (_i2437 = 0; _i2437 < _size2433; ++_i2437) + uint32_t _size2434; + ::apache::thrift::protocol::TType _etype2437; + xfer += iprot->readListBegin(_etype2437, _size2434); + this->success.resize(_size2434); + uint32_t _i2438; + for (_i2438 = 0; _i2438 < _size2434; ++_i2438) { - xfer += iprot->readString(this->success[_i2437]); + xfer += iprot->readString(this->success[_i2438]); } xfer += iprot->readListEnd(); } @@ -40571,10 +40571,10 @@ uint32_t ThriftHiveMetastore_set_ugi_result::write(::apache::thrift::protocol::T xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter2438; - for (_iter2438 = this->success.begin(); _iter2438 != this->success.end(); ++_iter2438) + std::vector ::const_iterator _iter2439; + for (_iter2439 = this->success.begin(); _iter2439 != this->success.end(); ++_iter2439) { - xfer += oprot->writeString((*_iter2438)); + xfer += oprot->writeString((*_iter2439)); } xfer += oprot->writeListEnd(); } @@ -40619,14 +40619,14 @@ uint32_t ThriftHiveMetastore_set_ugi_presult::read(::apache::thrift::protocol::T if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2439; - ::apache::thrift::protocol::TType _etype2442; - xfer += iprot->readListBegin(_etype2442, _size2439); - (*(this->success)).resize(_size2439); - uint32_t _i2443; - for (_i2443 = 0; _i2443 < _size2439; ++_i2443) + uint32_t _size2440; + ::apache::thrift::protocol::TType _etype2443; + xfer += iprot->readListBegin(_etype2443, _size2440); + (*(this->success)).resize(_size2440); + uint32_t _i2444; + for (_i2444 = 0; _i2444 < _size2440; ++_i2444) { - xfer += iprot->readString((*(this->success))[_i2443]); + xfer += iprot->readString((*(this->success))[_i2444]); } xfer += iprot->readListEnd(); } @@ -41937,14 +41937,14 @@ uint32_t ThriftHiveMetastore_get_all_token_identifiers_result::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2444; - ::apache::thrift::protocol::TType _etype2447; - xfer += iprot->readListBegin(_etype2447, _size2444); - this->success.resize(_size2444); - uint32_t _i2448; - for (_i2448 = 0; _i2448 < _size2444; ++_i2448) + uint32_t _size2445; + ::apache::thrift::protocol::TType _etype2448; + xfer += iprot->readListBegin(_etype2448, _size2445); + this->success.resize(_size2445); + uint32_t _i2449; + for (_i2449 = 0; _i2449 < _size2445; ++_i2449) { - xfer += iprot->readString(this->success[_i2448]); + xfer += iprot->readString(this->success[_i2449]); } xfer += iprot->readListEnd(); } @@ -41975,10 +41975,10 @@ uint32_t ThriftHiveMetastore_get_all_token_identifiers_result::write(::apache::t xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter2449; - for (_iter2449 = this->success.begin(); _iter2449 != this->success.end(); ++_iter2449) + std::vector ::const_iterator _iter2450; + for (_iter2450 = this->success.begin(); _iter2450 != this->success.end(); ++_iter2450) { - xfer += oprot->writeString((*_iter2449)); + xfer += oprot->writeString((*_iter2450)); } xfer += oprot->writeListEnd(); } @@ -42019,14 +42019,14 @@ uint32_t ThriftHiveMetastore_get_all_token_identifiers_presult::read(::apache::t if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2450; - ::apache::thrift::protocol::TType _etype2453; - xfer += iprot->readListBegin(_etype2453, _size2450); - (*(this->success)).resize(_size2450); - uint32_t _i2454; - for (_i2454 = 0; _i2454 < _size2450; ++_i2454) + uint32_t _size2451; + ::apache::thrift::protocol::TType _etype2454; + xfer += iprot->readListBegin(_etype2454, _size2451); + (*(this->success)).resize(_size2451); + uint32_t _i2455; + for (_i2455 = 0; _i2455 < _size2451; ++_i2455) { - xfer += iprot->readString((*(this->success))[_i2454]); + xfer += iprot->readString((*(this->success))[_i2455]); } xfer += iprot->readListEnd(); } @@ -42752,14 +42752,14 @@ uint32_t ThriftHiveMetastore_get_master_keys_result::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2455; - ::apache::thrift::protocol::TType _etype2458; - xfer += iprot->readListBegin(_etype2458, _size2455); - this->success.resize(_size2455); - uint32_t _i2459; - for (_i2459 = 0; _i2459 < _size2455; ++_i2459) + uint32_t _size2456; + ::apache::thrift::protocol::TType _etype2459; + xfer += iprot->readListBegin(_etype2459, _size2456); + this->success.resize(_size2456); + uint32_t _i2460; + for (_i2460 = 0; _i2460 < _size2456; ++_i2460) { - xfer += iprot->readString(this->success[_i2459]); + xfer += iprot->readString(this->success[_i2460]); } xfer += iprot->readListEnd(); } @@ -42790,10 +42790,10 @@ uint32_t ThriftHiveMetastore_get_master_keys_result::write(::apache::thrift::pro xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter2460; - for (_iter2460 = this->success.begin(); _iter2460 != this->success.end(); ++_iter2460) + std::vector ::const_iterator _iter2461; + for (_iter2461 = this->success.begin(); _iter2461 != this->success.end(); ++_iter2461) { - xfer += oprot->writeString((*_iter2460)); + xfer += oprot->writeString((*_iter2461)); } xfer += oprot->writeListEnd(); } @@ -42834,14 +42834,14 @@ uint32_t ThriftHiveMetastore_get_master_keys_presult::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2461; - ::apache::thrift::protocol::TType _etype2464; - xfer += iprot->readListBegin(_etype2464, _size2461); - (*(this->success)).resize(_size2461); - uint32_t _i2465; - for (_i2465 = 0; _i2465 < _size2461; ++_i2465) + uint32_t _size2462; + ::apache::thrift::protocol::TType _etype2465; + xfer += iprot->readListBegin(_etype2465, _size2462); + (*(this->success)).resize(_size2462); + uint32_t _i2466; + for (_i2466 = 0; _i2466 < _size2462; ++_i2466) { - xfer += iprot->readString((*(this->success))[_i2465]); + xfer += iprot->readString((*(this->success))[_i2466]); } xfer += iprot->readListEnd(); } @@ -44590,17 +44590,17 @@ uint32_t ThriftHiveMetastore_add_write_ids_to_min_history_args::read(::apache::t if (ftype == ::apache::thrift::protocol::T_MAP) { { this->writeIds.clear(); - uint32_t _size2466; - ::apache::thrift::protocol::TType _ktype2467; - ::apache::thrift::protocol::TType _vtype2468; - xfer += iprot->readMapBegin(_ktype2467, _vtype2468, _size2466); - uint32_t _i2470; - for (_i2470 = 0; _i2470 < _size2466; ++_i2470) + uint32_t _size2467; + ::apache::thrift::protocol::TType _ktype2468; + ::apache::thrift::protocol::TType _vtype2469; + xfer += iprot->readMapBegin(_ktype2468, _vtype2469, _size2467); + uint32_t _i2471; + for (_i2471 = 0; _i2471 < _size2467; ++_i2471) { - std::string _key2471; - xfer += iprot->readString(_key2471); - int64_t& _val2472 = this->writeIds[_key2471]; - xfer += iprot->readI64(_val2472); + std::string _key2472; + xfer += iprot->readString(_key2472); + int64_t& _val2473 = this->writeIds[_key2472]; + xfer += iprot->readI64(_val2473); } xfer += iprot->readMapEnd(); } @@ -44633,11 +44633,11 @@ uint32_t ThriftHiveMetastore_add_write_ids_to_min_history_args::write(::apache:: xfer += oprot->writeFieldBegin("writeIds", ::apache::thrift::protocol::T_MAP, 2); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_I64, static_cast(this->writeIds.size())); - std::map ::const_iterator _iter2473; - for (_iter2473 = this->writeIds.begin(); _iter2473 != this->writeIds.end(); ++_iter2473) + std::map ::const_iterator _iter2474; + for (_iter2474 = this->writeIds.begin(); _iter2474 != this->writeIds.end(); ++_iter2474) { - xfer += oprot->writeString(_iter2473->first); - xfer += oprot->writeI64(_iter2473->second); + xfer += oprot->writeString(_iter2474->first); + xfer += oprot->writeI64(_iter2474->second); } xfer += oprot->writeMapEnd(); } @@ -44665,11 +44665,11 @@ uint32_t ThriftHiveMetastore_add_write_ids_to_min_history_pargs::write(::apache: xfer += oprot->writeFieldBegin("writeIds", ::apache::thrift::protocol::T_MAP, 2); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_I64, static_cast((*(this->writeIds)).size())); - std::map ::const_iterator _iter2474; - for (_iter2474 = (*(this->writeIds)).begin(); _iter2474 != (*(this->writeIds)).end(); ++_iter2474) + std::map ::const_iterator _iter2475; + for (_iter2475 = (*(this->writeIds)).begin(); _iter2475 != (*(this->writeIds)).end(); ++_iter2475) { - xfer += oprot->writeString(_iter2474->first); - xfer += oprot->writeI64(_iter2474->second); + xfer += oprot->writeString(_iter2475->first); + xfer += oprot->writeI64(_iter2475->second); } xfer += oprot->writeMapEnd(); } @@ -48569,14 +48569,14 @@ uint32_t ThriftHiveMetastore_find_columns_with_stats_result::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2475; - ::apache::thrift::protocol::TType _etype2478; - xfer += iprot->readListBegin(_etype2478, _size2475); - this->success.resize(_size2475); - uint32_t _i2479; - for (_i2479 = 0; _i2479 < _size2475; ++_i2479) + uint32_t _size2476; + ::apache::thrift::protocol::TType _etype2479; + xfer += iprot->readListBegin(_etype2479, _size2476); + this->success.resize(_size2476); + uint32_t _i2480; + for (_i2480 = 0; _i2480 < _size2476; ++_i2480) { - xfer += iprot->readString(this->success[_i2479]); + xfer += iprot->readString(this->success[_i2480]); } xfer += iprot->readListEnd(); } @@ -48607,10 +48607,10 @@ uint32_t ThriftHiveMetastore_find_columns_with_stats_result::write(::apache::thr 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 _iter2480; - for (_iter2480 = this->success.begin(); _iter2480 != this->success.end(); ++_iter2480) + std::vector ::const_iterator _iter2481; + for (_iter2481 = this->success.begin(); _iter2481 != this->success.end(); ++_iter2481) { - xfer += oprot->writeString((*_iter2480)); + xfer += oprot->writeString((*_iter2481)); } xfer += oprot->writeListEnd(); } @@ -48651,14 +48651,14 @@ uint32_t ThriftHiveMetastore_find_columns_with_stats_presult::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2481; - ::apache::thrift::protocol::TType _etype2484; - xfer += iprot->readListBegin(_etype2484, _size2481); - (*(this->success)).resize(_size2481); - uint32_t _i2485; - for (_i2485 = 0; _i2485 < _size2481; ++_i2485) + uint32_t _size2482; + ::apache::thrift::protocol::TType _etype2485; + xfer += iprot->readListBegin(_etype2485, _size2482); + (*(this->success)).resize(_size2482); + uint32_t _i2486; + for (_i2486 = 0; _i2486 < _size2482; ++_i2486) { - xfer += iprot->readString((*(this->success))[_i2485]); + xfer += iprot->readString((*(this->success))[_i2486]); } xfer += iprot->readListEnd(); } @@ -58581,14 +58581,14 @@ uint32_t ThriftHiveMetastore_get_schema_all_versions_result::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2486; - ::apache::thrift::protocol::TType _etype2489; - xfer += iprot->readListBegin(_etype2489, _size2486); - this->success.resize(_size2486); - uint32_t _i2490; - for (_i2490 = 0; _i2490 < _size2486; ++_i2490) + uint32_t _size2487; + ::apache::thrift::protocol::TType _etype2490; + xfer += iprot->readListBegin(_etype2490, _size2487); + this->success.resize(_size2487); + uint32_t _i2491; + for (_i2491 = 0; _i2491 < _size2487; ++_i2491) { - xfer += this->success[_i2490].read(iprot); + xfer += this->success[_i2491].read(iprot); } xfer += iprot->readListEnd(); } @@ -58635,10 +58635,10 @@ uint32_t ThriftHiveMetastore_get_schema_all_versions_result::write(::apache::thr xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter2491; - for (_iter2491 = this->success.begin(); _iter2491 != this->success.end(); ++_iter2491) + std::vector ::const_iterator _iter2492; + for (_iter2492 = this->success.begin(); _iter2492 != this->success.end(); ++_iter2492) { - xfer += (*_iter2491).write(oprot); + xfer += (*_iter2492).write(oprot); } xfer += oprot->writeListEnd(); } @@ -58687,14 +58687,14 @@ uint32_t ThriftHiveMetastore_get_schema_all_versions_presult::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2492; - ::apache::thrift::protocol::TType _etype2495; - xfer += iprot->readListBegin(_etype2495, _size2492); - (*(this->success)).resize(_size2492); - uint32_t _i2496; - for (_i2496 = 0; _i2496 < _size2492; ++_i2496) + uint32_t _size2493; + ::apache::thrift::protocol::TType _etype2496; + xfer += iprot->readListBegin(_etype2496, _size2493); + (*(this->success)).resize(_size2493); + uint32_t _i2497; + for (_i2497 = 0; _i2497 < _size2493; ++_i2497) { - xfer += (*(this->success))[_i2496].read(iprot); + xfer += (*(this->success))[_i2497].read(iprot); } xfer += iprot->readListEnd(); } @@ -60747,14 +60747,14 @@ uint32_t ThriftHiveMetastore_get_runtime_stats_result::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2497; - ::apache::thrift::protocol::TType _etype2500; - xfer += iprot->readListBegin(_etype2500, _size2497); - this->success.resize(_size2497); - uint32_t _i2501; - for (_i2501 = 0; _i2501 < _size2497; ++_i2501) + uint32_t _size2498; + ::apache::thrift::protocol::TType _etype2501; + xfer += iprot->readListBegin(_etype2501, _size2498); + this->success.resize(_size2498); + uint32_t _i2502; + for (_i2502 = 0; _i2502 < _size2498; ++_i2502) { - xfer += this->success[_i2501].read(iprot); + xfer += this->success[_i2502].read(iprot); } xfer += iprot->readListEnd(); } @@ -60793,10 +60793,10 @@ uint32_t ThriftHiveMetastore_get_runtime_stats_result::write(::apache::thrift::p xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter2502; - for (_iter2502 = this->success.begin(); _iter2502 != this->success.end(); ++_iter2502) + std::vector ::const_iterator _iter2503; + for (_iter2503 = this->success.begin(); _iter2503 != this->success.end(); ++_iter2503) { - xfer += (*_iter2502).write(oprot); + xfer += (*_iter2503).write(oprot); } xfer += oprot->writeListEnd(); } @@ -60841,14 +60841,14 @@ uint32_t ThriftHiveMetastore_get_runtime_stats_presult::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2503; - ::apache::thrift::protocol::TType _etype2506; - xfer += iprot->readListBegin(_etype2506, _size2503); - (*(this->success)).resize(_size2503); - uint32_t _i2507; - for (_i2507 = 0; _i2507 < _size2503; ++_i2507) + uint32_t _size2504; + ::apache::thrift::protocol::TType _etype2507; + xfer += iprot->readListBegin(_etype2507, _size2504); + (*(this->success)).resize(_size2504); + uint32_t _i2508; + for (_i2508 = 0; _i2508 < _size2504; ++_i2508) { - xfer += (*(this->success))[_i2507].read(iprot); + xfer += (*(this->success))[_i2508].read(iprot); } xfer += iprot->readListEnd(); } @@ -63283,14 +63283,14 @@ uint32_t ThriftHiveMetastore_get_all_stored_procedures_result::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2508; - ::apache::thrift::protocol::TType _etype2511; - xfer += iprot->readListBegin(_etype2511, _size2508); - this->success.resize(_size2508); - uint32_t _i2512; - for (_i2512 = 0; _i2512 < _size2508; ++_i2512) + uint32_t _size2509; + ::apache::thrift::protocol::TType _etype2512; + xfer += iprot->readListBegin(_etype2512, _size2509); + this->success.resize(_size2509); + uint32_t _i2513; + for (_i2513 = 0; _i2513 < _size2509; ++_i2513) { - xfer += iprot->readString(this->success[_i2512]); + xfer += iprot->readString(this->success[_i2513]); } xfer += iprot->readListEnd(); } @@ -63329,10 +63329,10 @@ uint32_t ThriftHiveMetastore_get_all_stored_procedures_result::write(::apache::t xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter2513; - for (_iter2513 = this->success.begin(); _iter2513 != this->success.end(); ++_iter2513) + std::vector ::const_iterator _iter2514; + for (_iter2514 = this->success.begin(); _iter2514 != this->success.end(); ++_iter2514) { - xfer += oprot->writeString((*_iter2513)); + xfer += oprot->writeString((*_iter2514)); } xfer += oprot->writeListEnd(); } @@ -63377,14 +63377,14 @@ uint32_t ThriftHiveMetastore_get_all_stored_procedures_presult::read(::apache::t if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2514; - ::apache::thrift::protocol::TType _etype2517; - xfer += iprot->readListBegin(_etype2517, _size2514); - (*(this->success)).resize(_size2514); - uint32_t _i2518; - for (_i2518 = 0; _i2518 < _size2514; ++_i2518) + uint32_t _size2515; + ::apache::thrift::protocol::TType _etype2518; + xfer += iprot->readListBegin(_etype2518, _size2515); + (*(this->success)).resize(_size2515); + uint32_t _i2519; + for (_i2519 = 0; _i2519 < _size2515; ++_i2519) { - xfer += iprot->readString((*(this->success))[_i2518]); + xfer += iprot->readString((*(this->success))[_i2519]); } xfer += iprot->readListEnd(); } @@ -63936,14 +63936,14 @@ uint32_t ThriftHiveMetastore_get_all_packages_result::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2519; - ::apache::thrift::protocol::TType _etype2522; - xfer += iprot->readListBegin(_etype2522, _size2519); - this->success.resize(_size2519); - uint32_t _i2523; - for (_i2523 = 0; _i2523 < _size2519; ++_i2523) + uint32_t _size2520; + ::apache::thrift::protocol::TType _etype2523; + xfer += iprot->readListBegin(_etype2523, _size2520); + this->success.resize(_size2520); + uint32_t _i2524; + for (_i2524 = 0; _i2524 < _size2520; ++_i2524) { - xfer += iprot->readString(this->success[_i2523]); + xfer += iprot->readString(this->success[_i2524]); } xfer += iprot->readListEnd(); } @@ -63982,10 +63982,10 @@ uint32_t ThriftHiveMetastore_get_all_packages_result::write(::apache::thrift::pr 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 _iter2524; - for (_iter2524 = this->success.begin(); _iter2524 != this->success.end(); ++_iter2524) + std::vector ::const_iterator _iter2525; + for (_iter2525 = this->success.begin(); _iter2525 != this->success.end(); ++_iter2525) { - xfer += oprot->writeString((*_iter2524)); + xfer += oprot->writeString((*_iter2525)); } xfer += oprot->writeListEnd(); } @@ -64030,14 +64030,14 @@ uint32_t ThriftHiveMetastore_get_all_packages_presult::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2525; - ::apache::thrift::protocol::TType _etype2528; - xfer += iprot->readListBegin(_etype2528, _size2525); - (*(this->success)).resize(_size2525); - uint32_t _i2529; - for (_i2529 = 0; _i2529 < _size2525; ++_i2529) + uint32_t _size2526; + ::apache::thrift::protocol::TType _etype2529; + xfer += iprot->readListBegin(_etype2529, _size2526); + (*(this->success)).resize(_size2526); + uint32_t _i2530; + for (_i2530 = 0; _i2530 < _size2526; ++_i2530) { - xfer += iprot->readString((*(this->success))[_i2529]); + xfer += iprot->readString((*(this->success))[_i2530]); } xfer += iprot->readListEnd(); } @@ -64362,14 +64362,14 @@ uint32_t ThriftHiveMetastore_get_all_write_event_info_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size2530; - ::apache::thrift::protocol::TType _etype2533; - xfer += iprot->readListBegin(_etype2533, _size2530); - this->success.resize(_size2530); - uint32_t _i2534; - for (_i2534 = 0; _i2534 < _size2530; ++_i2534) + uint32_t _size2531; + ::apache::thrift::protocol::TType _etype2534; + xfer += iprot->readListBegin(_etype2534, _size2531); + this->success.resize(_size2531); + uint32_t _i2535; + for (_i2535 = 0; _i2535 < _size2531; ++_i2535) { - xfer += this->success[_i2534].read(iprot); + xfer += this->success[_i2535].read(iprot); } xfer += iprot->readListEnd(); } @@ -64408,10 +64408,10 @@ uint32_t ThriftHiveMetastore_get_all_write_event_info_result::write(::apache::th xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter2535; - for (_iter2535 = this->success.begin(); _iter2535 != this->success.end(); ++_iter2535) + std::vector ::const_iterator _iter2536; + for (_iter2536 = this->success.begin(); _iter2536 != this->success.end(); ++_iter2536) { - xfer += (*_iter2535).write(oprot); + xfer += (*_iter2536).write(oprot); } xfer += oprot->writeListEnd(); } @@ -64456,14 +64456,14 @@ uint32_t ThriftHiveMetastore_get_all_write_event_info_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size2536; - ::apache::thrift::protocol::TType _etype2539; - xfer += iprot->readListBegin(_etype2539, _size2536); - (*(this->success)).resize(_size2536); - uint32_t _i2540; - for (_i2540 = 0; _i2540 < _size2536; ++_i2540) + uint32_t _size2537; + ::apache::thrift::protocol::TType _etype2540; + xfer += iprot->readListBegin(_etype2540, _size2537); + (*(this->success)).resize(_size2537); + uint32_t _i2541; + for (_i2541 = 0; _i2541 < _size2537; ++_i2541) { - xfer += (*(this->success))[_i2540].read(iprot); + xfer += (*(this->success))[_i2541].read(iprot); } xfer += iprot->readListEnd(); } diff --git a/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/hive_metastore_types.cpp b/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/hive_metastore_types.cpp index 77fb40bacd03..38ab1894ebcc 100644 --- a/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/hive_metastore_types.cpp +++ b/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/hive_metastore_types.cpp @@ -36577,6 +36577,16 @@ void TableMeta::__set_catName(const std::string& val) { this->catName = val; __isset.catName = true; } + +void TableMeta::__set_ownerName(const std::string& val) { + this->ownerName = val; +__isset.ownerName = true; +} + +void TableMeta::__set_ownerType(const PrincipalType::type val) { + this->ownerType = val; +__isset.ownerType = true; +} std::ostream& operator<<(std::ostream& out, const TableMeta& obj) { obj.printTo(out); @@ -36648,6 +36658,24 @@ uint32_t TableMeta::read(::apache::thrift::protocol::TProtocol* iprot) { 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 ecast1323; + xfer += iprot->readI32(ecast1323); + this->ownerType = static_cast(ecast1323); + this->__isset.ownerType = true; + } else { + xfer += iprot->skip(ftype); + } + break; default: xfer += iprot->skip(ftype); break; @@ -36693,6 +36721,16 @@ uint32_t TableMeta::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeString(this->catName); 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(static_cast(this->ownerType)); + xfer += oprot->writeFieldEnd(); + } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; @@ -36705,24 +36743,30 @@ void swap(TableMeta &a, TableMeta &b) { swap(a.tableType, b.tableType); swap(a.comments, b.comments); swap(a.catName, b.catName); + swap(a.ownerName, b.ownerName); + swap(a.ownerType, b.ownerType); swap(a.__isset, b.__isset); } -TableMeta::TableMeta(const TableMeta& other1323) { - dbName = other1323.dbName; - tableName = other1323.tableName; - tableType = other1323.tableType; - comments = other1323.comments; - catName = other1323.catName; - __isset = other1323.__isset; -} -TableMeta& TableMeta::operator=(const TableMeta& other1324) { +TableMeta::TableMeta(const TableMeta& other1324) { dbName = other1324.dbName; tableName = other1324.tableName; tableType = other1324.tableType; comments = other1324.comments; catName = other1324.catName; + ownerName = other1324.ownerName; + ownerType = other1324.ownerType; __isset = other1324.__isset; +} +TableMeta& TableMeta::operator=(const TableMeta& other1325) { + dbName = other1325.dbName; + tableName = other1325.tableName; + tableType = other1325.tableType; + comments = other1325.comments; + catName = other1325.catName; + ownerName = other1325.ownerName; + ownerType = other1325.ownerType; + __isset = other1325.__isset; return *this; } void TableMeta::printTo(std::ostream& out) const { @@ -36733,6 +36777,8 @@ void TableMeta::printTo(std::ostream& out) const { out << ", " << "tableType=" << to_string(tableType); out << ", " << "comments="; (__isset.comments ? (out << to_string(comments)) : (out << "")); out << ", " << "catName="; (__isset.catName ? (out << to_string(catName)) : (out << "")); + out << ", " << "ownerName="; (__isset.ownerName ? (out << to_string(ownerName)) : (out << "")); + out << ", " << "ownerType="; (__isset.ownerType ? (out << to_string(ownerType)) : (out << "")); out << ")"; } @@ -36834,13 +36880,13 @@ void swap(Materialization &a, Materialization &b) { swap(a.sourceTablesCompacted, b.sourceTablesCompacted); } -Materialization::Materialization(const Materialization& other1325) noexcept { - sourceTablesUpdateDeleteModified = other1325.sourceTablesUpdateDeleteModified; - sourceTablesCompacted = other1325.sourceTablesCompacted; -} -Materialization& Materialization::operator=(const Materialization& other1326) noexcept { +Materialization::Materialization(const Materialization& other1326) noexcept { sourceTablesUpdateDeleteModified = other1326.sourceTablesUpdateDeleteModified; sourceTablesCompacted = other1326.sourceTablesCompacted; +} +Materialization& Materialization::operator=(const Materialization& other1327) noexcept { + sourceTablesUpdateDeleteModified = other1327.sourceTablesUpdateDeleteModified; + sourceTablesCompacted = other1327.sourceTablesCompacted; return *this; } void Materialization::printTo(std::ostream& out) const { @@ -36918,9 +36964,9 @@ uint32_t WMResourcePlan::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1327; - xfer += iprot->readI32(ecast1327); - this->status = static_cast(ecast1327); + int32_t ecast1328; + xfer += iprot->readI32(ecast1328); + this->status = static_cast(ecast1328); this->__isset.status = true; } else { xfer += iprot->skip(ftype); @@ -37008,21 +37054,21 @@ void swap(WMResourcePlan &a, WMResourcePlan &b) { swap(a.__isset, b.__isset); } -WMResourcePlan::WMResourcePlan(const WMResourcePlan& other1328) { - name = other1328.name; - status = other1328.status; - queryParallelism = other1328.queryParallelism; - defaultPoolPath = other1328.defaultPoolPath; - ns = other1328.ns; - __isset = other1328.__isset; -} -WMResourcePlan& WMResourcePlan::operator=(const WMResourcePlan& other1329) { +WMResourcePlan::WMResourcePlan(const WMResourcePlan& other1329) { name = other1329.name; status = other1329.status; queryParallelism = other1329.queryParallelism; defaultPoolPath = other1329.defaultPoolPath; ns = other1329.ns; __isset = other1329.__isset; +} +WMResourcePlan& WMResourcePlan::operator=(const WMResourcePlan& other1330) { + name = other1330.name; + status = other1330.status; + queryParallelism = other1330.queryParallelism; + defaultPoolPath = other1330.defaultPoolPath; + ns = other1330.ns; + __isset = other1330.__isset; return *this; } void WMResourcePlan::printTo(std::ostream& out) const { @@ -37113,9 +37159,9 @@ uint32_t WMNullableResourcePlan::read(::apache::thrift::protocol::TProtocol* ipr break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1330; - xfer += iprot->readI32(ecast1330); - this->status = static_cast(ecast1330); + int32_t ecast1331; + xfer += iprot->readI32(ecast1331); + this->status = static_cast(ecast1331); this->__isset.status = true; } else { xfer += iprot->skip(ftype); @@ -37230,17 +37276,7 @@ void swap(WMNullableResourcePlan &a, WMNullableResourcePlan &b) { swap(a.__isset, b.__isset); } -WMNullableResourcePlan::WMNullableResourcePlan(const WMNullableResourcePlan& other1331) { - name = other1331.name; - status = other1331.status; - queryParallelism = other1331.queryParallelism; - isSetQueryParallelism = other1331.isSetQueryParallelism; - defaultPoolPath = other1331.defaultPoolPath; - isSetDefaultPoolPath = other1331.isSetDefaultPoolPath; - ns = other1331.ns; - __isset = other1331.__isset; -} -WMNullableResourcePlan& WMNullableResourcePlan::operator=(const WMNullableResourcePlan& other1332) { +WMNullableResourcePlan::WMNullableResourcePlan(const WMNullableResourcePlan& other1332) { name = other1332.name; status = other1332.status; queryParallelism = other1332.queryParallelism; @@ -37249,6 +37285,16 @@ WMNullableResourcePlan& WMNullableResourcePlan::operator=(const WMNullableResour isSetDefaultPoolPath = other1332.isSetDefaultPoolPath; ns = other1332.ns; __isset = other1332.__isset; +} +WMNullableResourcePlan& WMNullableResourcePlan::operator=(const WMNullableResourcePlan& other1333) { + name = other1333.name; + status = other1333.status; + queryParallelism = other1333.queryParallelism; + isSetQueryParallelism = other1333.isSetQueryParallelism; + defaultPoolPath = other1333.defaultPoolPath; + isSetDefaultPoolPath = other1333.isSetDefaultPoolPath; + ns = other1333.ns; + __isset = other1333.__isset; return *this; } void WMNullableResourcePlan::printTo(std::ostream& out) const { @@ -37439,16 +37485,7 @@ void swap(WMPool &a, WMPool &b) { swap(a.__isset, b.__isset); } -WMPool::WMPool(const WMPool& other1333) { - resourcePlanName = other1333.resourcePlanName; - poolPath = other1333.poolPath; - allocFraction = other1333.allocFraction; - queryParallelism = other1333.queryParallelism; - schedulingPolicy = other1333.schedulingPolicy; - ns = other1333.ns; - __isset = other1333.__isset; -} -WMPool& WMPool::operator=(const WMPool& other1334) { +WMPool::WMPool(const WMPool& other1334) { resourcePlanName = other1334.resourcePlanName; poolPath = other1334.poolPath; allocFraction = other1334.allocFraction; @@ -37456,6 +37493,15 @@ WMPool& WMPool::operator=(const WMPool& other1334) { schedulingPolicy = other1334.schedulingPolicy; ns = other1334.ns; __isset = other1334.__isset; +} +WMPool& WMPool::operator=(const WMPool& other1335) { + resourcePlanName = other1335.resourcePlanName; + poolPath = other1335.poolPath; + allocFraction = other1335.allocFraction; + queryParallelism = other1335.queryParallelism; + schedulingPolicy = other1335.schedulingPolicy; + ns = other1335.ns; + __isset = other1335.__isset; return *this; } void WMPool::printTo(std::ostream& out) const { @@ -37664,17 +37710,7 @@ void swap(WMNullablePool &a, WMNullablePool &b) { swap(a.__isset, b.__isset); } -WMNullablePool::WMNullablePool(const WMNullablePool& other1335) { - resourcePlanName = other1335.resourcePlanName; - poolPath = other1335.poolPath; - allocFraction = other1335.allocFraction; - queryParallelism = other1335.queryParallelism; - schedulingPolicy = other1335.schedulingPolicy; - isSetSchedulingPolicy = other1335.isSetSchedulingPolicy; - ns = other1335.ns; - __isset = other1335.__isset; -} -WMNullablePool& WMNullablePool::operator=(const WMNullablePool& other1336) { +WMNullablePool::WMNullablePool(const WMNullablePool& other1336) { resourcePlanName = other1336.resourcePlanName; poolPath = other1336.poolPath; allocFraction = other1336.allocFraction; @@ -37683,6 +37719,16 @@ WMNullablePool& WMNullablePool::operator=(const WMNullablePool& other1336) { isSetSchedulingPolicy = other1336.isSetSchedulingPolicy; ns = other1336.ns; __isset = other1336.__isset; +} +WMNullablePool& WMNullablePool::operator=(const WMNullablePool& other1337) { + resourcePlanName = other1337.resourcePlanName; + poolPath = other1337.poolPath; + allocFraction = other1337.allocFraction; + queryParallelism = other1337.queryParallelism; + schedulingPolicy = other1337.schedulingPolicy; + isSetSchedulingPolicy = other1337.isSetSchedulingPolicy; + ns = other1337.ns; + __isset = other1337.__isset; return *this; } void WMNullablePool::printTo(std::ostream& out) const { @@ -37873,16 +37919,7 @@ void swap(WMTrigger &a, WMTrigger &b) { swap(a.__isset, b.__isset); } -WMTrigger::WMTrigger(const WMTrigger& other1337) { - resourcePlanName = other1337.resourcePlanName; - triggerName = other1337.triggerName; - triggerExpression = other1337.triggerExpression; - actionExpression = other1337.actionExpression; - isInUnmanaged = other1337.isInUnmanaged; - ns = other1337.ns; - __isset = other1337.__isset; -} -WMTrigger& WMTrigger::operator=(const WMTrigger& other1338) { +WMTrigger::WMTrigger(const WMTrigger& other1338) { resourcePlanName = other1338.resourcePlanName; triggerName = other1338.triggerName; triggerExpression = other1338.triggerExpression; @@ -37890,6 +37927,15 @@ WMTrigger& WMTrigger::operator=(const WMTrigger& other1338) { isInUnmanaged = other1338.isInUnmanaged; ns = other1338.ns; __isset = other1338.__isset; +} +WMTrigger& WMTrigger::operator=(const WMTrigger& other1339) { + resourcePlanName = other1339.resourcePlanName; + triggerName = other1339.triggerName; + triggerExpression = other1339.triggerExpression; + actionExpression = other1339.actionExpression; + isInUnmanaged = other1339.isInUnmanaged; + ns = other1339.ns; + __isset = other1339.__isset; return *this; } void WMTrigger::printTo(std::ostream& out) const { @@ -38080,16 +38126,7 @@ void swap(WMMapping &a, WMMapping &b) { swap(a.__isset, b.__isset); } -WMMapping::WMMapping(const WMMapping& other1339) { - resourcePlanName = other1339.resourcePlanName; - entityType = other1339.entityType; - entityName = other1339.entityName; - poolPath = other1339.poolPath; - ordering = other1339.ordering; - ns = other1339.ns; - __isset = other1339.__isset; -} -WMMapping& WMMapping::operator=(const WMMapping& other1340) { +WMMapping::WMMapping(const WMMapping& other1340) { resourcePlanName = other1340.resourcePlanName; entityType = other1340.entityType; entityName = other1340.entityName; @@ -38097,6 +38134,15 @@ WMMapping& WMMapping::operator=(const WMMapping& other1340) { ordering = other1340.ordering; ns = other1340.ns; __isset = other1340.__isset; +} +WMMapping& WMMapping::operator=(const WMMapping& other1341) { + resourcePlanName = other1341.resourcePlanName; + entityType = other1341.entityType; + entityName = other1341.entityName; + poolPath = other1341.poolPath; + ordering = other1341.ordering; + ns = other1341.ns; + __isset = other1341.__isset; return *this; } void WMMapping::printTo(std::ostream& out) const { @@ -38229,17 +38275,17 @@ void swap(WMPoolTrigger &a, WMPoolTrigger &b) { swap(a.__isset, b.__isset); } -WMPoolTrigger::WMPoolTrigger(const WMPoolTrigger& other1341) { - pool = other1341.pool; - trigger = other1341.trigger; - ns = other1341.ns; - __isset = other1341.__isset; -} -WMPoolTrigger& WMPoolTrigger::operator=(const WMPoolTrigger& other1342) { +WMPoolTrigger::WMPoolTrigger(const WMPoolTrigger& other1342) { pool = other1342.pool; trigger = other1342.trigger; ns = other1342.ns; __isset = other1342.__isset; +} +WMPoolTrigger& WMPoolTrigger::operator=(const WMPoolTrigger& other1343) { + pool = other1343.pool; + trigger = other1343.trigger; + ns = other1343.ns; + __isset = other1343.__isset; return *this; } void WMPoolTrigger::printTo(std::ostream& out) const { @@ -38320,14 +38366,14 @@ uint32_t WMFullResourcePlan::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->pools.clear(); - uint32_t _size1343; - ::apache::thrift::protocol::TType _etype1346; - xfer += iprot->readListBegin(_etype1346, _size1343); - this->pools.resize(_size1343); - uint32_t _i1347; - for (_i1347 = 0; _i1347 < _size1343; ++_i1347) + uint32_t _size1344; + ::apache::thrift::protocol::TType _etype1347; + xfer += iprot->readListBegin(_etype1347, _size1344); + this->pools.resize(_size1344); + uint32_t _i1348; + for (_i1348 = 0; _i1348 < _size1344; ++_i1348) { - xfer += this->pools[_i1347].read(iprot); + xfer += this->pools[_i1348].read(iprot); } xfer += iprot->readListEnd(); } @@ -38340,14 +38386,14 @@ uint32_t WMFullResourcePlan::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->mappings.clear(); - uint32_t _size1348; - ::apache::thrift::protocol::TType _etype1351; - xfer += iprot->readListBegin(_etype1351, _size1348); - this->mappings.resize(_size1348); - uint32_t _i1352; - for (_i1352 = 0; _i1352 < _size1348; ++_i1352) + uint32_t _size1349; + ::apache::thrift::protocol::TType _etype1352; + xfer += iprot->readListBegin(_etype1352, _size1349); + this->mappings.resize(_size1349); + uint32_t _i1353; + for (_i1353 = 0; _i1353 < _size1349; ++_i1353) { - xfer += this->mappings[_i1352].read(iprot); + xfer += this->mappings[_i1353].read(iprot); } xfer += iprot->readListEnd(); } @@ -38360,14 +38406,14 @@ uint32_t WMFullResourcePlan::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->triggers.clear(); - uint32_t _size1353; - ::apache::thrift::protocol::TType _etype1356; - xfer += iprot->readListBegin(_etype1356, _size1353); - this->triggers.resize(_size1353); - uint32_t _i1357; - for (_i1357 = 0; _i1357 < _size1353; ++_i1357) + uint32_t _size1354; + ::apache::thrift::protocol::TType _etype1357; + xfer += iprot->readListBegin(_etype1357, _size1354); + this->triggers.resize(_size1354); + uint32_t _i1358; + for (_i1358 = 0; _i1358 < _size1354; ++_i1358) { - xfer += this->triggers[_i1357].read(iprot); + xfer += this->triggers[_i1358].read(iprot); } xfer += iprot->readListEnd(); } @@ -38380,14 +38426,14 @@ uint32_t WMFullResourcePlan::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->poolTriggers.clear(); - uint32_t _size1358; - ::apache::thrift::protocol::TType _etype1361; - xfer += iprot->readListBegin(_etype1361, _size1358); - this->poolTriggers.resize(_size1358); - uint32_t _i1362; - for (_i1362 = 0; _i1362 < _size1358; ++_i1362) + uint32_t _size1359; + ::apache::thrift::protocol::TType _etype1362; + xfer += iprot->readListBegin(_etype1362, _size1359); + this->poolTriggers.resize(_size1359); + uint32_t _i1363; + for (_i1363 = 0; _i1363 < _size1359; ++_i1363) { - xfer += this->poolTriggers[_i1362].read(iprot); + xfer += this->poolTriggers[_i1363].read(iprot); } xfer += iprot->readListEnd(); } @@ -38424,10 +38470,10 @@ uint32_t WMFullResourcePlan::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("pools", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->pools.size())); - std::vector ::const_iterator _iter1363; - for (_iter1363 = this->pools.begin(); _iter1363 != this->pools.end(); ++_iter1363) + std::vector ::const_iterator _iter1364; + for (_iter1364 = this->pools.begin(); _iter1364 != this->pools.end(); ++_iter1364) { - xfer += (*_iter1363).write(oprot); + xfer += (*_iter1364).write(oprot); } xfer += oprot->writeListEnd(); } @@ -38437,10 +38483,10 @@ uint32_t WMFullResourcePlan::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("mappings", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->mappings.size())); - std::vector ::const_iterator _iter1364; - for (_iter1364 = this->mappings.begin(); _iter1364 != this->mappings.end(); ++_iter1364) + std::vector ::const_iterator _iter1365; + for (_iter1365 = this->mappings.begin(); _iter1365 != this->mappings.end(); ++_iter1365) { - xfer += (*_iter1364).write(oprot); + xfer += (*_iter1365).write(oprot); } xfer += oprot->writeListEnd(); } @@ -38450,10 +38496,10 @@ uint32_t WMFullResourcePlan::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("triggers", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->triggers.size())); - std::vector ::const_iterator _iter1365; - for (_iter1365 = this->triggers.begin(); _iter1365 != this->triggers.end(); ++_iter1365) + std::vector ::const_iterator _iter1366; + for (_iter1366 = this->triggers.begin(); _iter1366 != this->triggers.end(); ++_iter1366) { - xfer += (*_iter1365).write(oprot); + xfer += (*_iter1366).write(oprot); } xfer += oprot->writeListEnd(); } @@ -38463,10 +38509,10 @@ uint32_t WMFullResourcePlan::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("poolTriggers", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->poolTriggers.size())); - std::vector ::const_iterator _iter1366; - for (_iter1366 = this->poolTriggers.begin(); _iter1366 != this->poolTriggers.end(); ++_iter1366) + std::vector ::const_iterator _iter1367; + for (_iter1367 = this->poolTriggers.begin(); _iter1367 != this->poolTriggers.end(); ++_iter1367) { - xfer += (*_iter1366).write(oprot); + xfer += (*_iter1367).write(oprot); } xfer += oprot->writeListEnd(); } @@ -38487,21 +38533,21 @@ void swap(WMFullResourcePlan &a, WMFullResourcePlan &b) { swap(a.__isset, b.__isset); } -WMFullResourcePlan::WMFullResourcePlan(const WMFullResourcePlan& other1367) { - plan = other1367.plan; - pools = other1367.pools; - mappings = other1367.mappings; - triggers = other1367.triggers; - poolTriggers = other1367.poolTriggers; - __isset = other1367.__isset; -} -WMFullResourcePlan& WMFullResourcePlan::operator=(const WMFullResourcePlan& other1368) { +WMFullResourcePlan::WMFullResourcePlan(const WMFullResourcePlan& other1368) { plan = other1368.plan; pools = other1368.pools; mappings = other1368.mappings; triggers = other1368.triggers; poolTriggers = other1368.poolTriggers; __isset = other1368.__isset; +} +WMFullResourcePlan& WMFullResourcePlan::operator=(const WMFullResourcePlan& other1369) { + plan = other1369.plan; + pools = other1369.pools; + mappings = other1369.mappings; + triggers = other1369.triggers; + poolTriggers = other1369.poolTriggers; + __isset = other1369.__isset; return *this; } void WMFullResourcePlan::printTo(std::ostream& out) const { @@ -38612,15 +38658,15 @@ void swap(WMCreateResourcePlanRequest &a, WMCreateResourcePlanRequest &b) { swap(a.__isset, b.__isset); } -WMCreateResourcePlanRequest::WMCreateResourcePlanRequest(const WMCreateResourcePlanRequest& other1369) { - resourcePlan = other1369.resourcePlan; - copyFrom = other1369.copyFrom; - __isset = other1369.__isset; -} -WMCreateResourcePlanRequest& WMCreateResourcePlanRequest::operator=(const WMCreateResourcePlanRequest& other1370) { +WMCreateResourcePlanRequest::WMCreateResourcePlanRequest(const WMCreateResourcePlanRequest& other1370) { resourcePlan = other1370.resourcePlan; copyFrom = other1370.copyFrom; __isset = other1370.__isset; +} +WMCreateResourcePlanRequest& WMCreateResourcePlanRequest::operator=(const WMCreateResourcePlanRequest& other1371) { + resourcePlan = other1371.resourcePlan; + copyFrom = other1371.copyFrom; + __isset = other1371.__isset; return *this; } void WMCreateResourcePlanRequest::printTo(std::ostream& out) const { @@ -38686,11 +38732,11 @@ void swap(WMCreateResourcePlanResponse &a, WMCreateResourcePlanResponse &b) { (void) b; } -WMCreateResourcePlanResponse::WMCreateResourcePlanResponse(const WMCreateResourcePlanResponse& other1371) noexcept { - (void) other1371; -} -WMCreateResourcePlanResponse& WMCreateResourcePlanResponse::operator=(const WMCreateResourcePlanResponse& other1372) noexcept { +WMCreateResourcePlanResponse::WMCreateResourcePlanResponse(const WMCreateResourcePlanResponse& other1372) noexcept { (void) other1372; +} +WMCreateResourcePlanResponse& WMCreateResourcePlanResponse::operator=(const WMCreateResourcePlanResponse& other1373) noexcept { + (void) other1373; return *this; } void WMCreateResourcePlanResponse::printTo(std::ostream& out) const { @@ -38777,13 +38823,13 @@ void swap(WMGetActiveResourcePlanRequest &a, WMGetActiveResourcePlanRequest &b) swap(a.__isset, b.__isset); } -WMGetActiveResourcePlanRequest::WMGetActiveResourcePlanRequest(const WMGetActiveResourcePlanRequest& other1373) { - ns = other1373.ns; - __isset = other1373.__isset; -} -WMGetActiveResourcePlanRequest& WMGetActiveResourcePlanRequest::operator=(const WMGetActiveResourcePlanRequest& other1374) { +WMGetActiveResourcePlanRequest::WMGetActiveResourcePlanRequest(const WMGetActiveResourcePlanRequest& other1374) { ns = other1374.ns; __isset = other1374.__isset; +} +WMGetActiveResourcePlanRequest& WMGetActiveResourcePlanRequest::operator=(const WMGetActiveResourcePlanRequest& other1375) { + ns = other1375.ns; + __isset = other1375.__isset; return *this; } void WMGetActiveResourcePlanRequest::printTo(std::ostream& out) const { @@ -38871,13 +38917,13 @@ void swap(WMGetActiveResourcePlanResponse &a, WMGetActiveResourcePlanResponse &b swap(a.__isset, b.__isset); } -WMGetActiveResourcePlanResponse::WMGetActiveResourcePlanResponse(const WMGetActiveResourcePlanResponse& other1375) { - resourcePlan = other1375.resourcePlan; - __isset = other1375.__isset; -} -WMGetActiveResourcePlanResponse& WMGetActiveResourcePlanResponse::operator=(const WMGetActiveResourcePlanResponse& other1376) { +WMGetActiveResourcePlanResponse::WMGetActiveResourcePlanResponse(const WMGetActiveResourcePlanResponse& other1376) { resourcePlan = other1376.resourcePlan; __isset = other1376.__isset; +} +WMGetActiveResourcePlanResponse& WMGetActiveResourcePlanResponse::operator=(const WMGetActiveResourcePlanResponse& other1377) { + resourcePlan = other1377.resourcePlan; + __isset = other1377.__isset; return *this; } void WMGetActiveResourcePlanResponse::printTo(std::ostream& out) const { @@ -38984,15 +39030,15 @@ void swap(WMGetResourcePlanRequest &a, WMGetResourcePlanRequest &b) { swap(a.__isset, b.__isset); } -WMGetResourcePlanRequest::WMGetResourcePlanRequest(const WMGetResourcePlanRequest& other1377) { - resourcePlanName = other1377.resourcePlanName; - ns = other1377.ns; - __isset = other1377.__isset; -} -WMGetResourcePlanRequest& WMGetResourcePlanRequest::operator=(const WMGetResourcePlanRequest& other1378) { +WMGetResourcePlanRequest::WMGetResourcePlanRequest(const WMGetResourcePlanRequest& other1378) { resourcePlanName = other1378.resourcePlanName; ns = other1378.ns; __isset = other1378.__isset; +} +WMGetResourcePlanRequest& WMGetResourcePlanRequest::operator=(const WMGetResourcePlanRequest& other1379) { + resourcePlanName = other1379.resourcePlanName; + ns = other1379.ns; + __isset = other1379.__isset; return *this; } void WMGetResourcePlanRequest::printTo(std::ostream& out) const { @@ -39081,13 +39127,13 @@ void swap(WMGetResourcePlanResponse &a, WMGetResourcePlanResponse &b) { swap(a.__isset, b.__isset); } -WMGetResourcePlanResponse::WMGetResourcePlanResponse(const WMGetResourcePlanResponse& other1379) { - resourcePlan = other1379.resourcePlan; - __isset = other1379.__isset; -} -WMGetResourcePlanResponse& WMGetResourcePlanResponse::operator=(const WMGetResourcePlanResponse& other1380) { +WMGetResourcePlanResponse::WMGetResourcePlanResponse(const WMGetResourcePlanResponse& other1380) { resourcePlan = other1380.resourcePlan; __isset = other1380.__isset; +} +WMGetResourcePlanResponse& WMGetResourcePlanResponse::operator=(const WMGetResourcePlanResponse& other1381) { + resourcePlan = other1381.resourcePlan; + __isset = other1381.__isset; return *this; } void WMGetResourcePlanResponse::printTo(std::ostream& out) const { @@ -39175,13 +39221,13 @@ void swap(WMGetAllResourcePlanRequest &a, WMGetAllResourcePlanRequest &b) { swap(a.__isset, b.__isset); } -WMGetAllResourcePlanRequest::WMGetAllResourcePlanRequest(const WMGetAllResourcePlanRequest& other1381) { - ns = other1381.ns; - __isset = other1381.__isset; -} -WMGetAllResourcePlanRequest& WMGetAllResourcePlanRequest::operator=(const WMGetAllResourcePlanRequest& other1382) { +WMGetAllResourcePlanRequest::WMGetAllResourcePlanRequest(const WMGetAllResourcePlanRequest& other1382) { ns = other1382.ns; __isset = other1382.__isset; +} +WMGetAllResourcePlanRequest& WMGetAllResourcePlanRequest::operator=(const WMGetAllResourcePlanRequest& other1383) { + ns = other1383.ns; + __isset = other1383.__isset; return *this; } void WMGetAllResourcePlanRequest::printTo(std::ostream& out) const { @@ -39232,14 +39278,14 @@ uint32_t WMGetAllResourcePlanResponse::read(::apache::thrift::protocol::TProtoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->resourcePlans.clear(); - uint32_t _size1383; - ::apache::thrift::protocol::TType _etype1386; - xfer += iprot->readListBegin(_etype1386, _size1383); - this->resourcePlans.resize(_size1383); - uint32_t _i1387; - for (_i1387 = 0; _i1387 < _size1383; ++_i1387) + uint32_t _size1384; + ::apache::thrift::protocol::TType _etype1387; + xfer += iprot->readListBegin(_etype1387, _size1384); + this->resourcePlans.resize(_size1384); + uint32_t _i1388; + for (_i1388 = 0; _i1388 < _size1384; ++_i1388) { - xfer += this->resourcePlans[_i1387].read(iprot); + xfer += this->resourcePlans[_i1388].read(iprot); } xfer += iprot->readListEnd(); } @@ -39269,10 +39315,10 @@ uint32_t WMGetAllResourcePlanResponse::write(::apache::thrift::protocol::TProtoc xfer += oprot->writeFieldBegin("resourcePlans", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->resourcePlans.size())); - std::vector ::const_iterator _iter1388; - for (_iter1388 = this->resourcePlans.begin(); _iter1388 != this->resourcePlans.end(); ++_iter1388) + std::vector ::const_iterator _iter1389; + for (_iter1389 = this->resourcePlans.begin(); _iter1389 != this->resourcePlans.end(); ++_iter1389) { - xfer += (*_iter1388).write(oprot); + xfer += (*_iter1389).write(oprot); } xfer += oprot->writeListEnd(); } @@ -39289,13 +39335,13 @@ void swap(WMGetAllResourcePlanResponse &a, WMGetAllResourcePlanResponse &b) { swap(a.__isset, b.__isset); } -WMGetAllResourcePlanResponse::WMGetAllResourcePlanResponse(const WMGetAllResourcePlanResponse& other1389) { - resourcePlans = other1389.resourcePlans; - __isset = other1389.__isset; -} -WMGetAllResourcePlanResponse& WMGetAllResourcePlanResponse::operator=(const WMGetAllResourcePlanResponse& other1390) { +WMGetAllResourcePlanResponse::WMGetAllResourcePlanResponse(const WMGetAllResourcePlanResponse& other1390) { resourcePlans = other1390.resourcePlans; __isset = other1390.__isset; +} +WMGetAllResourcePlanResponse& WMGetAllResourcePlanResponse::operator=(const WMGetAllResourcePlanResponse& other1391) { + resourcePlans = other1391.resourcePlans; + __isset = other1391.__isset; return *this; } void WMGetAllResourcePlanResponse::printTo(std::ostream& out) const { @@ -39478,16 +39524,7 @@ void swap(WMAlterResourcePlanRequest &a, WMAlterResourcePlanRequest &b) { swap(a.__isset, b.__isset); } -WMAlterResourcePlanRequest::WMAlterResourcePlanRequest(const WMAlterResourcePlanRequest& other1391) { - resourcePlanName = other1391.resourcePlanName; - resourcePlan = other1391.resourcePlan; - isEnableAndActivate = other1391.isEnableAndActivate; - isForceDeactivate = other1391.isForceDeactivate; - isReplace = other1391.isReplace; - ns = other1391.ns; - __isset = other1391.__isset; -} -WMAlterResourcePlanRequest& WMAlterResourcePlanRequest::operator=(const WMAlterResourcePlanRequest& other1392) { +WMAlterResourcePlanRequest::WMAlterResourcePlanRequest(const WMAlterResourcePlanRequest& other1392) { resourcePlanName = other1392.resourcePlanName; resourcePlan = other1392.resourcePlan; isEnableAndActivate = other1392.isEnableAndActivate; @@ -39495,6 +39532,15 @@ WMAlterResourcePlanRequest& WMAlterResourcePlanRequest::operator=(const WMAlterR isReplace = other1392.isReplace; ns = other1392.ns; __isset = other1392.__isset; +} +WMAlterResourcePlanRequest& WMAlterResourcePlanRequest::operator=(const WMAlterResourcePlanRequest& other1393) { + resourcePlanName = other1393.resourcePlanName; + resourcePlan = other1393.resourcePlan; + isEnableAndActivate = other1393.isEnableAndActivate; + isForceDeactivate = other1393.isForceDeactivate; + isReplace = other1393.isReplace; + ns = other1393.ns; + __isset = other1393.__isset; return *this; } void WMAlterResourcePlanRequest::printTo(std::ostream& out) const { @@ -39587,13 +39633,13 @@ void swap(WMAlterResourcePlanResponse &a, WMAlterResourcePlanResponse &b) { swap(a.__isset, b.__isset); } -WMAlterResourcePlanResponse::WMAlterResourcePlanResponse(const WMAlterResourcePlanResponse& other1393) { - fullResourcePlan = other1393.fullResourcePlan; - __isset = other1393.__isset; -} -WMAlterResourcePlanResponse& WMAlterResourcePlanResponse::operator=(const WMAlterResourcePlanResponse& other1394) { +WMAlterResourcePlanResponse::WMAlterResourcePlanResponse(const WMAlterResourcePlanResponse& other1394) { fullResourcePlan = other1394.fullResourcePlan; __isset = other1394.__isset; +} +WMAlterResourcePlanResponse& WMAlterResourcePlanResponse::operator=(const WMAlterResourcePlanResponse& other1395) { + fullResourcePlan = other1395.fullResourcePlan; + __isset = other1395.__isset; return *this; } void WMAlterResourcePlanResponse::printTo(std::ostream& out) const { @@ -39700,15 +39746,15 @@ void swap(WMValidateResourcePlanRequest &a, WMValidateResourcePlanRequest &b) { swap(a.__isset, b.__isset); } -WMValidateResourcePlanRequest::WMValidateResourcePlanRequest(const WMValidateResourcePlanRequest& other1395) { - resourcePlanName = other1395.resourcePlanName; - ns = other1395.ns; - __isset = other1395.__isset; -} -WMValidateResourcePlanRequest& WMValidateResourcePlanRequest::operator=(const WMValidateResourcePlanRequest& other1396) { +WMValidateResourcePlanRequest::WMValidateResourcePlanRequest(const WMValidateResourcePlanRequest& other1396) { resourcePlanName = other1396.resourcePlanName; ns = other1396.ns; __isset = other1396.__isset; +} +WMValidateResourcePlanRequest& WMValidateResourcePlanRequest::operator=(const WMValidateResourcePlanRequest& other1397) { + resourcePlanName = other1397.resourcePlanName; + ns = other1397.ns; + __isset = other1397.__isset; return *this; } void WMValidateResourcePlanRequest::printTo(std::ostream& out) const { @@ -39765,14 +39811,14 @@ uint32_t WMValidateResourcePlanResponse::read(::apache::thrift::protocol::TProto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->errors.clear(); - uint32_t _size1397; - ::apache::thrift::protocol::TType _etype1400; - xfer += iprot->readListBegin(_etype1400, _size1397); - this->errors.resize(_size1397); - uint32_t _i1401; - for (_i1401 = 0; _i1401 < _size1397; ++_i1401) + uint32_t _size1398; + ::apache::thrift::protocol::TType _etype1401; + xfer += iprot->readListBegin(_etype1401, _size1398); + this->errors.resize(_size1398); + uint32_t _i1402; + for (_i1402 = 0; _i1402 < _size1398; ++_i1402) { - xfer += iprot->readString(this->errors[_i1401]); + xfer += iprot->readString(this->errors[_i1402]); } xfer += iprot->readListEnd(); } @@ -39785,14 +39831,14 @@ uint32_t WMValidateResourcePlanResponse::read(::apache::thrift::protocol::TProto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->warnings.clear(); - uint32_t _size1402; - ::apache::thrift::protocol::TType _etype1405; - xfer += iprot->readListBegin(_etype1405, _size1402); - this->warnings.resize(_size1402); - uint32_t _i1406; - for (_i1406 = 0; _i1406 < _size1402; ++_i1406) + uint32_t _size1403; + ::apache::thrift::protocol::TType _etype1406; + xfer += iprot->readListBegin(_etype1406, _size1403); + this->warnings.resize(_size1403); + uint32_t _i1407; + for (_i1407 = 0; _i1407 < _size1403; ++_i1407) { - xfer += iprot->readString(this->warnings[_i1406]); + xfer += iprot->readString(this->warnings[_i1407]); } xfer += iprot->readListEnd(); } @@ -39822,10 +39868,10 @@ uint32_t WMValidateResourcePlanResponse::write(::apache::thrift::protocol::TProt xfer += oprot->writeFieldBegin("errors", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->errors.size())); - std::vector ::const_iterator _iter1407; - for (_iter1407 = this->errors.begin(); _iter1407 != this->errors.end(); ++_iter1407) + std::vector ::const_iterator _iter1408; + for (_iter1408 = this->errors.begin(); _iter1408 != this->errors.end(); ++_iter1408) { - xfer += oprot->writeString((*_iter1407)); + xfer += oprot->writeString((*_iter1408)); } xfer += oprot->writeListEnd(); } @@ -39835,10 +39881,10 @@ uint32_t WMValidateResourcePlanResponse::write(::apache::thrift::protocol::TProt xfer += oprot->writeFieldBegin("warnings", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->warnings.size())); - std::vector ::const_iterator _iter1408; - for (_iter1408 = this->warnings.begin(); _iter1408 != this->warnings.end(); ++_iter1408) + std::vector ::const_iterator _iter1409; + for (_iter1409 = this->warnings.begin(); _iter1409 != this->warnings.end(); ++_iter1409) { - xfer += oprot->writeString((*_iter1408)); + xfer += oprot->writeString((*_iter1409)); } xfer += oprot->writeListEnd(); } @@ -39856,15 +39902,15 @@ void swap(WMValidateResourcePlanResponse &a, WMValidateResourcePlanResponse &b) swap(a.__isset, b.__isset); } -WMValidateResourcePlanResponse::WMValidateResourcePlanResponse(const WMValidateResourcePlanResponse& other1409) { - errors = other1409.errors; - warnings = other1409.warnings; - __isset = other1409.__isset; -} -WMValidateResourcePlanResponse& WMValidateResourcePlanResponse::operator=(const WMValidateResourcePlanResponse& other1410) { +WMValidateResourcePlanResponse::WMValidateResourcePlanResponse(const WMValidateResourcePlanResponse& other1410) { errors = other1410.errors; warnings = other1410.warnings; __isset = other1410.__isset; +} +WMValidateResourcePlanResponse& WMValidateResourcePlanResponse::operator=(const WMValidateResourcePlanResponse& other1411) { + errors = other1411.errors; + warnings = other1411.warnings; + __isset = other1411.__isset; return *this; } void WMValidateResourcePlanResponse::printTo(std::ostream& out) const { @@ -39972,15 +40018,15 @@ void swap(WMDropResourcePlanRequest &a, WMDropResourcePlanRequest &b) { swap(a.__isset, b.__isset); } -WMDropResourcePlanRequest::WMDropResourcePlanRequest(const WMDropResourcePlanRequest& other1411) { - resourcePlanName = other1411.resourcePlanName; - ns = other1411.ns; - __isset = other1411.__isset; -} -WMDropResourcePlanRequest& WMDropResourcePlanRequest::operator=(const WMDropResourcePlanRequest& other1412) { +WMDropResourcePlanRequest::WMDropResourcePlanRequest(const WMDropResourcePlanRequest& other1412) { resourcePlanName = other1412.resourcePlanName; ns = other1412.ns; __isset = other1412.__isset; +} +WMDropResourcePlanRequest& WMDropResourcePlanRequest::operator=(const WMDropResourcePlanRequest& other1413) { + resourcePlanName = other1413.resourcePlanName; + ns = other1413.ns; + __isset = other1413.__isset; return *this; } void WMDropResourcePlanRequest::printTo(std::ostream& out) const { @@ -40046,11 +40092,11 @@ void swap(WMDropResourcePlanResponse &a, WMDropResourcePlanResponse &b) { (void) b; } -WMDropResourcePlanResponse::WMDropResourcePlanResponse(const WMDropResourcePlanResponse& other1413) noexcept { - (void) other1413; -} -WMDropResourcePlanResponse& WMDropResourcePlanResponse::operator=(const WMDropResourcePlanResponse& other1414) noexcept { +WMDropResourcePlanResponse::WMDropResourcePlanResponse(const WMDropResourcePlanResponse& other1414) noexcept { (void) other1414; +} +WMDropResourcePlanResponse& WMDropResourcePlanResponse::operator=(const WMDropResourcePlanResponse& other1415) noexcept { + (void) other1415; return *this; } void WMDropResourcePlanResponse::printTo(std::ostream& out) const { @@ -40137,13 +40183,13 @@ void swap(WMCreateTriggerRequest &a, WMCreateTriggerRequest &b) { swap(a.__isset, b.__isset); } -WMCreateTriggerRequest::WMCreateTriggerRequest(const WMCreateTriggerRequest& other1415) { - trigger = other1415.trigger; - __isset = other1415.__isset; -} -WMCreateTriggerRequest& WMCreateTriggerRequest::operator=(const WMCreateTriggerRequest& other1416) { +WMCreateTriggerRequest::WMCreateTriggerRequest(const WMCreateTriggerRequest& other1416) { trigger = other1416.trigger; __isset = other1416.__isset; +} +WMCreateTriggerRequest& WMCreateTriggerRequest::operator=(const WMCreateTriggerRequest& other1417) { + trigger = other1417.trigger; + __isset = other1417.__isset; return *this; } void WMCreateTriggerRequest::printTo(std::ostream& out) const { @@ -40208,11 +40254,11 @@ void swap(WMCreateTriggerResponse &a, WMCreateTriggerResponse &b) { (void) b; } -WMCreateTriggerResponse::WMCreateTriggerResponse(const WMCreateTriggerResponse& other1417) noexcept { - (void) other1417; -} -WMCreateTriggerResponse& WMCreateTriggerResponse::operator=(const WMCreateTriggerResponse& other1418) noexcept { +WMCreateTriggerResponse::WMCreateTriggerResponse(const WMCreateTriggerResponse& other1418) noexcept { (void) other1418; +} +WMCreateTriggerResponse& WMCreateTriggerResponse::operator=(const WMCreateTriggerResponse& other1419) noexcept { + (void) other1419; return *this; } void WMCreateTriggerResponse::printTo(std::ostream& out) const { @@ -40299,13 +40345,13 @@ void swap(WMAlterTriggerRequest &a, WMAlterTriggerRequest &b) { swap(a.__isset, b.__isset); } -WMAlterTriggerRequest::WMAlterTriggerRequest(const WMAlterTriggerRequest& other1419) { - trigger = other1419.trigger; - __isset = other1419.__isset; -} -WMAlterTriggerRequest& WMAlterTriggerRequest::operator=(const WMAlterTriggerRequest& other1420) { +WMAlterTriggerRequest::WMAlterTriggerRequest(const WMAlterTriggerRequest& other1420) { trigger = other1420.trigger; __isset = other1420.__isset; +} +WMAlterTriggerRequest& WMAlterTriggerRequest::operator=(const WMAlterTriggerRequest& other1421) { + trigger = other1421.trigger; + __isset = other1421.__isset; return *this; } void WMAlterTriggerRequest::printTo(std::ostream& out) const { @@ -40370,11 +40416,11 @@ void swap(WMAlterTriggerResponse &a, WMAlterTriggerResponse &b) { (void) b; } -WMAlterTriggerResponse::WMAlterTriggerResponse(const WMAlterTriggerResponse& other1421) noexcept { - (void) other1421; -} -WMAlterTriggerResponse& WMAlterTriggerResponse::operator=(const WMAlterTriggerResponse& other1422) noexcept { +WMAlterTriggerResponse::WMAlterTriggerResponse(const WMAlterTriggerResponse& other1422) noexcept { (void) other1422; +} +WMAlterTriggerResponse& WMAlterTriggerResponse::operator=(const WMAlterTriggerResponse& other1423) noexcept { + (void) other1423; return *this; } void WMAlterTriggerResponse::printTo(std::ostream& out) const { @@ -40499,17 +40545,17 @@ void swap(WMDropTriggerRequest &a, WMDropTriggerRequest &b) { swap(a.__isset, b.__isset); } -WMDropTriggerRequest::WMDropTriggerRequest(const WMDropTriggerRequest& other1423) { - resourcePlanName = other1423.resourcePlanName; - triggerName = other1423.triggerName; - ns = other1423.ns; - __isset = other1423.__isset; -} -WMDropTriggerRequest& WMDropTriggerRequest::operator=(const WMDropTriggerRequest& other1424) { +WMDropTriggerRequest::WMDropTriggerRequest(const WMDropTriggerRequest& other1424) { resourcePlanName = other1424.resourcePlanName; triggerName = other1424.triggerName; ns = other1424.ns; __isset = other1424.__isset; +} +WMDropTriggerRequest& WMDropTriggerRequest::operator=(const WMDropTriggerRequest& other1425) { + resourcePlanName = other1425.resourcePlanName; + triggerName = other1425.triggerName; + ns = other1425.ns; + __isset = other1425.__isset; return *this; } void WMDropTriggerRequest::printTo(std::ostream& out) const { @@ -40576,11 +40622,11 @@ void swap(WMDropTriggerResponse &a, WMDropTriggerResponse &b) { (void) b; } -WMDropTriggerResponse::WMDropTriggerResponse(const WMDropTriggerResponse& other1425) noexcept { - (void) other1425; -} -WMDropTriggerResponse& WMDropTriggerResponse::operator=(const WMDropTriggerResponse& other1426) noexcept { +WMDropTriggerResponse::WMDropTriggerResponse(const WMDropTriggerResponse& other1426) noexcept { (void) other1426; +} +WMDropTriggerResponse& WMDropTriggerResponse::operator=(const WMDropTriggerResponse& other1427) noexcept { + (void) other1427; return *this; } void WMDropTriggerResponse::printTo(std::ostream& out) const { @@ -40686,15 +40732,15 @@ void swap(WMGetTriggersForResourePlanRequest &a, WMGetTriggersForResourePlanRequ swap(a.__isset, b.__isset); } -WMGetTriggersForResourePlanRequest::WMGetTriggersForResourePlanRequest(const WMGetTriggersForResourePlanRequest& other1427) { - resourcePlanName = other1427.resourcePlanName; - ns = other1427.ns; - __isset = other1427.__isset; -} -WMGetTriggersForResourePlanRequest& WMGetTriggersForResourePlanRequest::operator=(const WMGetTriggersForResourePlanRequest& other1428) { +WMGetTriggersForResourePlanRequest::WMGetTriggersForResourePlanRequest(const WMGetTriggersForResourePlanRequest& other1428) { resourcePlanName = other1428.resourcePlanName; ns = other1428.ns; __isset = other1428.__isset; +} +WMGetTriggersForResourePlanRequest& WMGetTriggersForResourePlanRequest::operator=(const WMGetTriggersForResourePlanRequest& other1429) { + resourcePlanName = other1429.resourcePlanName; + ns = other1429.ns; + __isset = other1429.__isset; return *this; } void WMGetTriggersForResourePlanRequest::printTo(std::ostream& out) const { @@ -40746,14 +40792,14 @@ uint32_t WMGetTriggersForResourePlanResponse::read(::apache::thrift::protocol::T if (ftype == ::apache::thrift::protocol::T_LIST) { { this->triggers.clear(); - uint32_t _size1429; - ::apache::thrift::protocol::TType _etype1432; - xfer += iprot->readListBegin(_etype1432, _size1429); - this->triggers.resize(_size1429); - uint32_t _i1433; - for (_i1433 = 0; _i1433 < _size1429; ++_i1433) + uint32_t _size1430; + ::apache::thrift::protocol::TType _etype1433; + xfer += iprot->readListBegin(_etype1433, _size1430); + this->triggers.resize(_size1430); + uint32_t _i1434; + for (_i1434 = 0; _i1434 < _size1430; ++_i1434) { - xfer += this->triggers[_i1433].read(iprot); + xfer += this->triggers[_i1434].read(iprot); } xfer += iprot->readListEnd(); } @@ -40783,10 +40829,10 @@ uint32_t WMGetTriggersForResourePlanResponse::write(::apache::thrift::protocol:: xfer += oprot->writeFieldBegin("triggers", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->triggers.size())); - std::vector ::const_iterator _iter1434; - for (_iter1434 = this->triggers.begin(); _iter1434 != this->triggers.end(); ++_iter1434) + std::vector ::const_iterator _iter1435; + for (_iter1435 = this->triggers.begin(); _iter1435 != this->triggers.end(); ++_iter1435) { - xfer += (*_iter1434).write(oprot); + xfer += (*_iter1435).write(oprot); } xfer += oprot->writeListEnd(); } @@ -40803,13 +40849,13 @@ void swap(WMGetTriggersForResourePlanResponse &a, WMGetTriggersForResourePlanRes swap(a.__isset, b.__isset); } -WMGetTriggersForResourePlanResponse::WMGetTriggersForResourePlanResponse(const WMGetTriggersForResourePlanResponse& other1435) { - triggers = other1435.triggers; - __isset = other1435.__isset; -} -WMGetTriggersForResourePlanResponse& WMGetTriggersForResourePlanResponse::operator=(const WMGetTriggersForResourePlanResponse& other1436) { +WMGetTriggersForResourePlanResponse::WMGetTriggersForResourePlanResponse(const WMGetTriggersForResourePlanResponse& other1436) { triggers = other1436.triggers; __isset = other1436.__isset; +} +WMGetTriggersForResourePlanResponse& WMGetTriggersForResourePlanResponse::operator=(const WMGetTriggersForResourePlanResponse& other1437) { + triggers = other1437.triggers; + __isset = other1437.__isset; return *this; } void WMGetTriggersForResourePlanResponse::printTo(std::ostream& out) const { @@ -40897,13 +40943,13 @@ void swap(WMCreatePoolRequest &a, WMCreatePoolRequest &b) { swap(a.__isset, b.__isset); } -WMCreatePoolRequest::WMCreatePoolRequest(const WMCreatePoolRequest& other1437) { - pool = other1437.pool; - __isset = other1437.__isset; -} -WMCreatePoolRequest& WMCreatePoolRequest::operator=(const WMCreatePoolRequest& other1438) { +WMCreatePoolRequest::WMCreatePoolRequest(const WMCreatePoolRequest& other1438) { pool = other1438.pool; __isset = other1438.__isset; +} +WMCreatePoolRequest& WMCreatePoolRequest::operator=(const WMCreatePoolRequest& other1439) { + pool = other1439.pool; + __isset = other1439.__isset; return *this; } void WMCreatePoolRequest::printTo(std::ostream& out) const { @@ -40968,11 +41014,11 @@ void swap(WMCreatePoolResponse &a, WMCreatePoolResponse &b) { (void) b; } -WMCreatePoolResponse::WMCreatePoolResponse(const WMCreatePoolResponse& other1439) noexcept { - (void) other1439; -} -WMCreatePoolResponse& WMCreatePoolResponse::operator=(const WMCreatePoolResponse& other1440) noexcept { +WMCreatePoolResponse::WMCreatePoolResponse(const WMCreatePoolResponse& other1440) noexcept { (void) other1440; +} +WMCreatePoolResponse& WMCreatePoolResponse::operator=(const WMCreatePoolResponse& other1441) noexcept { + (void) other1441; return *this; } void WMCreatePoolResponse::printTo(std::ostream& out) const { @@ -41078,15 +41124,15 @@ void swap(WMAlterPoolRequest &a, WMAlterPoolRequest &b) { swap(a.__isset, b.__isset); } -WMAlterPoolRequest::WMAlterPoolRequest(const WMAlterPoolRequest& other1441) { - pool = other1441.pool; - poolPath = other1441.poolPath; - __isset = other1441.__isset; -} -WMAlterPoolRequest& WMAlterPoolRequest::operator=(const WMAlterPoolRequest& other1442) { +WMAlterPoolRequest::WMAlterPoolRequest(const WMAlterPoolRequest& other1442) { pool = other1442.pool; poolPath = other1442.poolPath; __isset = other1442.__isset; +} +WMAlterPoolRequest& WMAlterPoolRequest::operator=(const WMAlterPoolRequest& other1443) { + pool = other1443.pool; + poolPath = other1443.poolPath; + __isset = other1443.__isset; return *this; } void WMAlterPoolRequest::printTo(std::ostream& out) const { @@ -41152,11 +41198,11 @@ void swap(WMAlterPoolResponse &a, WMAlterPoolResponse &b) { (void) b; } -WMAlterPoolResponse::WMAlterPoolResponse(const WMAlterPoolResponse& other1443) noexcept { - (void) other1443; -} -WMAlterPoolResponse& WMAlterPoolResponse::operator=(const WMAlterPoolResponse& other1444) noexcept { +WMAlterPoolResponse::WMAlterPoolResponse(const WMAlterPoolResponse& other1444) noexcept { (void) other1444; +} +WMAlterPoolResponse& WMAlterPoolResponse::operator=(const WMAlterPoolResponse& other1445) noexcept { + (void) other1445; return *this; } void WMAlterPoolResponse::printTo(std::ostream& out) const { @@ -41281,17 +41327,17 @@ void swap(WMDropPoolRequest &a, WMDropPoolRequest &b) { swap(a.__isset, b.__isset); } -WMDropPoolRequest::WMDropPoolRequest(const WMDropPoolRequest& other1445) { - resourcePlanName = other1445.resourcePlanName; - poolPath = other1445.poolPath; - ns = other1445.ns; - __isset = other1445.__isset; -} -WMDropPoolRequest& WMDropPoolRequest::operator=(const WMDropPoolRequest& other1446) { +WMDropPoolRequest::WMDropPoolRequest(const WMDropPoolRequest& other1446) { resourcePlanName = other1446.resourcePlanName; poolPath = other1446.poolPath; ns = other1446.ns; __isset = other1446.__isset; +} +WMDropPoolRequest& WMDropPoolRequest::operator=(const WMDropPoolRequest& other1447) { + resourcePlanName = other1447.resourcePlanName; + poolPath = other1447.poolPath; + ns = other1447.ns; + __isset = other1447.__isset; return *this; } void WMDropPoolRequest::printTo(std::ostream& out) const { @@ -41358,11 +41404,11 @@ void swap(WMDropPoolResponse &a, WMDropPoolResponse &b) { (void) b; } -WMDropPoolResponse::WMDropPoolResponse(const WMDropPoolResponse& other1447) noexcept { - (void) other1447; -} -WMDropPoolResponse& WMDropPoolResponse::operator=(const WMDropPoolResponse& other1448) noexcept { +WMDropPoolResponse::WMDropPoolResponse(const WMDropPoolResponse& other1448) noexcept { (void) other1448; +} +WMDropPoolResponse& WMDropPoolResponse::operator=(const WMDropPoolResponse& other1449) noexcept { + (void) other1449; return *this; } void WMDropPoolResponse::printTo(std::ostream& out) const { @@ -41468,15 +41514,15 @@ void swap(WMCreateOrUpdateMappingRequest &a, WMCreateOrUpdateMappingRequest &b) swap(a.__isset, b.__isset); } -WMCreateOrUpdateMappingRequest::WMCreateOrUpdateMappingRequest(const WMCreateOrUpdateMappingRequest& other1449) { - mapping = other1449.mapping; - update = other1449.update; - __isset = other1449.__isset; -} -WMCreateOrUpdateMappingRequest& WMCreateOrUpdateMappingRequest::operator=(const WMCreateOrUpdateMappingRequest& other1450) { +WMCreateOrUpdateMappingRequest::WMCreateOrUpdateMappingRequest(const WMCreateOrUpdateMappingRequest& other1450) { mapping = other1450.mapping; update = other1450.update; __isset = other1450.__isset; +} +WMCreateOrUpdateMappingRequest& WMCreateOrUpdateMappingRequest::operator=(const WMCreateOrUpdateMappingRequest& other1451) { + mapping = other1451.mapping; + update = other1451.update; + __isset = other1451.__isset; return *this; } void WMCreateOrUpdateMappingRequest::printTo(std::ostream& out) const { @@ -41542,11 +41588,11 @@ void swap(WMCreateOrUpdateMappingResponse &a, WMCreateOrUpdateMappingResponse &b (void) b; } -WMCreateOrUpdateMappingResponse::WMCreateOrUpdateMappingResponse(const WMCreateOrUpdateMappingResponse& other1451) noexcept { - (void) other1451; -} -WMCreateOrUpdateMappingResponse& WMCreateOrUpdateMappingResponse::operator=(const WMCreateOrUpdateMappingResponse& other1452) noexcept { +WMCreateOrUpdateMappingResponse::WMCreateOrUpdateMappingResponse(const WMCreateOrUpdateMappingResponse& other1452) noexcept { (void) other1452; +} +WMCreateOrUpdateMappingResponse& WMCreateOrUpdateMappingResponse::operator=(const WMCreateOrUpdateMappingResponse& other1453) noexcept { + (void) other1453; return *this; } void WMCreateOrUpdateMappingResponse::printTo(std::ostream& out) const { @@ -41633,13 +41679,13 @@ void swap(WMDropMappingRequest &a, WMDropMappingRequest &b) { swap(a.__isset, b.__isset); } -WMDropMappingRequest::WMDropMappingRequest(const WMDropMappingRequest& other1453) { - mapping = other1453.mapping; - __isset = other1453.__isset; -} -WMDropMappingRequest& WMDropMappingRequest::operator=(const WMDropMappingRequest& other1454) { +WMDropMappingRequest::WMDropMappingRequest(const WMDropMappingRequest& other1454) { mapping = other1454.mapping; __isset = other1454.__isset; +} +WMDropMappingRequest& WMDropMappingRequest::operator=(const WMDropMappingRequest& other1455) { + mapping = other1455.mapping; + __isset = other1455.__isset; return *this; } void WMDropMappingRequest::printTo(std::ostream& out) const { @@ -41704,11 +41750,11 @@ void swap(WMDropMappingResponse &a, WMDropMappingResponse &b) { (void) b; } -WMDropMappingResponse::WMDropMappingResponse(const WMDropMappingResponse& other1455) noexcept { - (void) other1455; -} -WMDropMappingResponse& WMDropMappingResponse::operator=(const WMDropMappingResponse& other1456) noexcept { +WMDropMappingResponse::WMDropMappingResponse(const WMDropMappingResponse& other1456) noexcept { (void) other1456; +} +WMDropMappingResponse& WMDropMappingResponse::operator=(const WMDropMappingResponse& other1457) noexcept { + (void) other1457; return *this; } void WMDropMappingResponse::printTo(std::ostream& out) const { @@ -41871,21 +41917,21 @@ void swap(WMCreateOrDropTriggerToPoolMappingRequest &a, WMCreateOrDropTriggerToP swap(a.__isset, b.__isset); } -WMCreateOrDropTriggerToPoolMappingRequest::WMCreateOrDropTriggerToPoolMappingRequest(const WMCreateOrDropTriggerToPoolMappingRequest& other1457) { - resourcePlanName = other1457.resourcePlanName; - triggerName = other1457.triggerName; - poolPath = other1457.poolPath; - drop = other1457.drop; - ns = other1457.ns; - __isset = other1457.__isset; -} -WMCreateOrDropTriggerToPoolMappingRequest& WMCreateOrDropTriggerToPoolMappingRequest::operator=(const WMCreateOrDropTriggerToPoolMappingRequest& other1458) { +WMCreateOrDropTriggerToPoolMappingRequest::WMCreateOrDropTriggerToPoolMappingRequest(const WMCreateOrDropTriggerToPoolMappingRequest& other1458) { resourcePlanName = other1458.resourcePlanName; triggerName = other1458.triggerName; poolPath = other1458.poolPath; drop = other1458.drop; ns = other1458.ns; __isset = other1458.__isset; +} +WMCreateOrDropTriggerToPoolMappingRequest& WMCreateOrDropTriggerToPoolMappingRequest::operator=(const WMCreateOrDropTriggerToPoolMappingRequest& other1459) { + resourcePlanName = other1459.resourcePlanName; + triggerName = other1459.triggerName; + poolPath = other1459.poolPath; + drop = other1459.drop; + ns = other1459.ns; + __isset = other1459.__isset; return *this; } void WMCreateOrDropTriggerToPoolMappingRequest::printTo(std::ostream& out) const { @@ -41954,11 +42000,11 @@ void swap(WMCreateOrDropTriggerToPoolMappingResponse &a, WMCreateOrDropTriggerTo (void) b; } -WMCreateOrDropTriggerToPoolMappingResponse::WMCreateOrDropTriggerToPoolMappingResponse(const WMCreateOrDropTriggerToPoolMappingResponse& other1459) noexcept { - (void) other1459; -} -WMCreateOrDropTriggerToPoolMappingResponse& WMCreateOrDropTriggerToPoolMappingResponse::operator=(const WMCreateOrDropTriggerToPoolMappingResponse& other1460) noexcept { +WMCreateOrDropTriggerToPoolMappingResponse::WMCreateOrDropTriggerToPoolMappingResponse(const WMCreateOrDropTriggerToPoolMappingResponse& other1460) noexcept { (void) other1460; +} +WMCreateOrDropTriggerToPoolMappingResponse& WMCreateOrDropTriggerToPoolMappingResponse::operator=(const WMCreateOrDropTriggerToPoolMappingResponse& other1461) noexcept { + (void) other1461; return *this; } void WMCreateOrDropTriggerToPoolMappingResponse::printTo(std::ostream& out) const { @@ -42039,9 +42085,9 @@ uint32_t ISchema::read(::apache::thrift::protocol::TProtocol* iprot) { { case 1: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1461; - xfer += iprot->readI32(ecast1461); - this->schemaType = static_cast(ecast1461); + int32_t ecast1462; + xfer += iprot->readI32(ecast1462); + this->schemaType = static_cast(ecast1462); this->__isset.schemaType = true; } else { xfer += iprot->skip(ftype); @@ -42073,9 +42119,9 @@ uint32_t ISchema::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1462; - xfer += iprot->readI32(ecast1462); - this->compatibility = static_cast(ecast1462); + int32_t ecast1463; + xfer += iprot->readI32(ecast1463); + this->compatibility = static_cast(ecast1463); this->__isset.compatibility = true; } else { xfer += iprot->skip(ftype); @@ -42083,9 +42129,9 @@ uint32_t ISchema::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 6: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1463; - xfer += iprot->readI32(ecast1463); - this->validationLevel = static_cast(ecast1463); + int32_t ecast1464; + xfer += iprot->readI32(ecast1464); + this->validationLevel = static_cast(ecast1464); this->__isset.validationLevel = true; } else { xfer += iprot->skip(ftype); @@ -42189,19 +42235,7 @@ void swap(ISchema &a, ISchema &b) { swap(a.__isset, b.__isset); } -ISchema::ISchema(const ISchema& other1464) { - schemaType = other1464.schemaType; - name = other1464.name; - catName = other1464.catName; - dbName = other1464.dbName; - compatibility = other1464.compatibility; - validationLevel = other1464.validationLevel; - canEvolve = other1464.canEvolve; - schemaGroup = other1464.schemaGroup; - description = other1464.description; - __isset = other1464.__isset; -} -ISchema& ISchema::operator=(const ISchema& other1465) { +ISchema::ISchema(const ISchema& other1465) { schemaType = other1465.schemaType; name = other1465.name; catName = other1465.catName; @@ -42212,6 +42246,18 @@ ISchema& ISchema::operator=(const ISchema& other1465) { schemaGroup = other1465.schemaGroup; description = other1465.description; __isset = other1465.__isset; +} +ISchema& ISchema::operator=(const ISchema& other1466) { + schemaType = other1466.schemaType; + name = other1466.name; + catName = other1466.catName; + dbName = other1466.dbName; + compatibility = other1466.compatibility; + validationLevel = other1466.validationLevel; + canEvolve = other1466.canEvolve; + schemaGroup = other1466.schemaGroup; + description = other1466.description; + __isset = other1466.__isset; return *this; } void ISchema::printTo(std::ostream& out) const { @@ -42339,17 +42385,17 @@ void swap(ISchemaName &a, ISchemaName &b) { swap(a.__isset, b.__isset); } -ISchemaName::ISchemaName(const ISchemaName& other1466) { - catName = other1466.catName; - dbName = other1466.dbName; - schemaName = other1466.schemaName; - __isset = other1466.__isset; -} -ISchemaName& ISchemaName::operator=(const ISchemaName& other1467) { +ISchemaName::ISchemaName(const ISchemaName& other1467) { catName = other1467.catName; dbName = other1467.dbName; schemaName = other1467.schemaName; __isset = other1467.__isset; +} +ISchemaName& ISchemaName::operator=(const ISchemaName& other1468) { + catName = other1468.catName; + dbName = other1468.dbName; + schemaName = other1468.schemaName; + __isset = other1468.__isset; return *this; } void ISchemaName::printTo(std::ostream& out) const { @@ -42454,15 +42500,15 @@ void swap(AlterISchemaRequest &a, AlterISchemaRequest &b) { swap(a.__isset, b.__isset); } -AlterISchemaRequest::AlterISchemaRequest(const AlterISchemaRequest& other1468) { - name = other1468.name; - newSchema = other1468.newSchema; - __isset = other1468.__isset; -} -AlterISchemaRequest& AlterISchemaRequest::operator=(const AlterISchemaRequest& other1469) { +AlterISchemaRequest::AlterISchemaRequest(const AlterISchemaRequest& other1469) { name = other1469.name; newSchema = other1469.newSchema; __isset = other1469.__isset; +} +AlterISchemaRequest& AlterISchemaRequest::operator=(const AlterISchemaRequest& other1470) { + name = other1470.name; + newSchema = other1470.newSchema; + __isset = other1470.__isset; return *this; } void AlterISchemaRequest::printTo(std::ostream& out) const { @@ -42579,14 +42625,14 @@ uint32_t SchemaVersion::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->cols.clear(); - uint32_t _size1470; - ::apache::thrift::protocol::TType _etype1473; - xfer += iprot->readListBegin(_etype1473, _size1470); - this->cols.resize(_size1470); - uint32_t _i1474; - for (_i1474 = 0; _i1474 < _size1470; ++_i1474) + uint32_t _size1471; + ::apache::thrift::protocol::TType _etype1474; + xfer += iprot->readListBegin(_etype1474, _size1471); + this->cols.resize(_size1471); + uint32_t _i1475; + for (_i1475 = 0; _i1475 < _size1471; ++_i1475) { - xfer += this->cols[_i1474].read(iprot); + xfer += this->cols[_i1475].read(iprot); } xfer += iprot->readListEnd(); } @@ -42597,9 +42643,9 @@ uint32_t SchemaVersion::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1475; - xfer += iprot->readI32(ecast1475); - this->state = static_cast(ecast1475); + int32_t ecast1476; + xfer += iprot->readI32(ecast1476); + this->state = static_cast(ecast1476); this->__isset.state = true; } else { xfer += iprot->skip(ftype); @@ -42677,10 +42723,10 @@ uint32_t SchemaVersion::write(::apache::thrift::protocol::TProtocol* oprot) cons xfer += oprot->writeFieldBegin("cols", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->cols.size())); - std::vector ::const_iterator _iter1476; - for (_iter1476 = this->cols.begin(); _iter1476 != this->cols.end(); ++_iter1476) + std::vector ::const_iterator _iter1477; + for (_iter1477 = this->cols.begin(); _iter1477 != this->cols.end(); ++_iter1477) { - xfer += (*_iter1476).write(oprot); + xfer += (*_iter1477).write(oprot); } xfer += oprot->writeListEnd(); } @@ -42736,20 +42782,7 @@ void swap(SchemaVersion &a, SchemaVersion &b) { swap(a.__isset, b.__isset); } -SchemaVersion::SchemaVersion(const SchemaVersion& other1477) { - schema = other1477.schema; - version = other1477.version; - createdAt = other1477.createdAt; - cols = other1477.cols; - state = other1477.state; - description = other1477.description; - schemaText = other1477.schemaText; - fingerprint = other1477.fingerprint; - name = other1477.name; - serDe = other1477.serDe; - __isset = other1477.__isset; -} -SchemaVersion& SchemaVersion::operator=(const SchemaVersion& other1478) { +SchemaVersion::SchemaVersion(const SchemaVersion& other1478) { schema = other1478.schema; version = other1478.version; createdAt = other1478.createdAt; @@ -42761,6 +42794,19 @@ SchemaVersion& SchemaVersion::operator=(const SchemaVersion& other1478) { name = other1478.name; serDe = other1478.serDe; __isset = other1478.__isset; +} +SchemaVersion& SchemaVersion::operator=(const SchemaVersion& other1479) { + schema = other1479.schema; + version = other1479.version; + createdAt = other1479.createdAt; + cols = other1479.cols; + state = other1479.state; + description = other1479.description; + schemaText = other1479.schemaText; + fingerprint = other1479.fingerprint; + name = other1479.name; + serDe = other1479.serDe; + __isset = other1479.__isset; return *this; } void SchemaVersion::printTo(std::ostream& out) const { @@ -42872,15 +42918,15 @@ void swap(SchemaVersionDescriptor &a, SchemaVersionDescriptor &b) { swap(a.__isset, b.__isset); } -SchemaVersionDescriptor::SchemaVersionDescriptor(const SchemaVersionDescriptor& other1479) { - schema = other1479.schema; - version = other1479.version; - __isset = other1479.__isset; -} -SchemaVersionDescriptor& SchemaVersionDescriptor::operator=(const SchemaVersionDescriptor& other1480) { +SchemaVersionDescriptor::SchemaVersionDescriptor(const SchemaVersionDescriptor& other1480) { schema = other1480.schema; version = other1480.version; __isset = other1480.__isset; +} +SchemaVersionDescriptor& SchemaVersionDescriptor::operator=(const SchemaVersionDescriptor& other1481) { + schema = other1481.schema; + version = other1481.version; + __isset = other1481.__isset; return *this; } void SchemaVersionDescriptor::printTo(std::ostream& out) const { @@ -43007,17 +43053,17 @@ void swap(FindSchemasByColsRqst &a, FindSchemasByColsRqst &b) { swap(a.__isset, b.__isset); } -FindSchemasByColsRqst::FindSchemasByColsRqst(const FindSchemasByColsRqst& other1481) { - colName = other1481.colName; - colNamespace = other1481.colNamespace; - type = other1481.type; - __isset = other1481.__isset; -} -FindSchemasByColsRqst& FindSchemasByColsRqst::operator=(const FindSchemasByColsRqst& other1482) { +FindSchemasByColsRqst::FindSchemasByColsRqst(const FindSchemasByColsRqst& other1482) { colName = other1482.colName; colNamespace = other1482.colNamespace; type = other1482.type; __isset = other1482.__isset; +} +FindSchemasByColsRqst& FindSchemasByColsRqst::operator=(const FindSchemasByColsRqst& other1483) { + colName = other1483.colName; + colNamespace = other1483.colNamespace; + type = other1483.type; + __isset = other1483.__isset; return *this; } void FindSchemasByColsRqst::printTo(std::ostream& out) const { @@ -43069,14 +43115,14 @@ uint32_t FindSchemasByColsResp::read(::apache::thrift::protocol::TProtocol* ipro if (ftype == ::apache::thrift::protocol::T_LIST) { { this->schemaVersions.clear(); - uint32_t _size1483; - ::apache::thrift::protocol::TType _etype1486; - xfer += iprot->readListBegin(_etype1486, _size1483); - this->schemaVersions.resize(_size1483); - uint32_t _i1487; - for (_i1487 = 0; _i1487 < _size1483; ++_i1487) + uint32_t _size1484; + ::apache::thrift::protocol::TType _etype1487; + xfer += iprot->readListBegin(_etype1487, _size1484); + this->schemaVersions.resize(_size1484); + uint32_t _i1488; + for (_i1488 = 0; _i1488 < _size1484; ++_i1488) { - xfer += this->schemaVersions[_i1487].read(iprot); + xfer += this->schemaVersions[_i1488].read(iprot); } xfer += iprot->readListEnd(); } @@ -43105,10 +43151,10 @@ uint32_t FindSchemasByColsResp::write(::apache::thrift::protocol::TProtocol* opr xfer += oprot->writeFieldBegin("schemaVersions", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->schemaVersions.size())); - std::vector ::const_iterator _iter1488; - for (_iter1488 = this->schemaVersions.begin(); _iter1488 != this->schemaVersions.end(); ++_iter1488) + std::vector ::const_iterator _iter1489; + for (_iter1489 = this->schemaVersions.begin(); _iter1489 != this->schemaVersions.end(); ++_iter1489) { - xfer += (*_iter1488).write(oprot); + xfer += (*_iter1489).write(oprot); } xfer += oprot->writeListEnd(); } @@ -43125,13 +43171,13 @@ void swap(FindSchemasByColsResp &a, FindSchemasByColsResp &b) { swap(a.__isset, b.__isset); } -FindSchemasByColsResp::FindSchemasByColsResp(const FindSchemasByColsResp& other1489) { - schemaVersions = other1489.schemaVersions; - __isset = other1489.__isset; -} -FindSchemasByColsResp& FindSchemasByColsResp::operator=(const FindSchemasByColsResp& other1490) { +FindSchemasByColsResp::FindSchemasByColsResp(const FindSchemasByColsResp& other1490) { schemaVersions = other1490.schemaVersions; __isset = other1490.__isset; +} +FindSchemasByColsResp& FindSchemasByColsResp::operator=(const FindSchemasByColsResp& other1491) { + schemaVersions = other1491.schemaVersions; + __isset = other1491.__isset; return *this; } void FindSchemasByColsResp::printTo(std::ostream& out) const { @@ -43234,15 +43280,15 @@ void swap(MapSchemaVersionToSerdeRequest &a, MapSchemaVersionToSerdeRequest &b) swap(a.__isset, b.__isset); } -MapSchemaVersionToSerdeRequest::MapSchemaVersionToSerdeRequest(const MapSchemaVersionToSerdeRequest& other1491) { - schemaVersion = other1491.schemaVersion; - serdeName = other1491.serdeName; - __isset = other1491.__isset; -} -MapSchemaVersionToSerdeRequest& MapSchemaVersionToSerdeRequest::operator=(const MapSchemaVersionToSerdeRequest& other1492) { +MapSchemaVersionToSerdeRequest::MapSchemaVersionToSerdeRequest(const MapSchemaVersionToSerdeRequest& other1492) { schemaVersion = other1492.schemaVersion; serdeName = other1492.serdeName; __isset = other1492.__isset; +} +MapSchemaVersionToSerdeRequest& MapSchemaVersionToSerdeRequest::operator=(const MapSchemaVersionToSerdeRequest& other1493) { + schemaVersion = other1493.schemaVersion; + serdeName = other1493.serdeName; + __isset = other1493.__isset; return *this; } void MapSchemaVersionToSerdeRequest::printTo(std::ostream& out) const { @@ -43303,9 +43349,9 @@ uint32_t SetSchemaVersionStateRequest::read(::apache::thrift::protocol::TProtoco break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1493; - xfer += iprot->readI32(ecast1493); - this->state = static_cast(ecast1493); + int32_t ecast1494; + xfer += iprot->readI32(ecast1494); + this->state = static_cast(ecast1494); this->__isset.state = true; } else { xfer += iprot->skip(ftype); @@ -43348,15 +43394,15 @@ void swap(SetSchemaVersionStateRequest &a, SetSchemaVersionStateRequest &b) { swap(a.__isset, b.__isset); } -SetSchemaVersionStateRequest::SetSchemaVersionStateRequest(const SetSchemaVersionStateRequest& other1494) { - schemaVersion = other1494.schemaVersion; - state = other1494.state; - __isset = other1494.__isset; -} -SetSchemaVersionStateRequest& SetSchemaVersionStateRequest::operator=(const SetSchemaVersionStateRequest& other1495) { +SetSchemaVersionStateRequest::SetSchemaVersionStateRequest(const SetSchemaVersionStateRequest& other1495) { schemaVersion = other1495.schemaVersion; state = other1495.state; __isset = other1495.__isset; +} +SetSchemaVersionStateRequest& SetSchemaVersionStateRequest::operator=(const SetSchemaVersionStateRequest& other1496) { + schemaVersion = other1496.schemaVersion; + state = other1496.state; + __isset = other1496.__isset; return *this; } void SetSchemaVersionStateRequest::printTo(std::ostream& out) const { @@ -43443,13 +43489,13 @@ void swap(GetSerdeRequest &a, GetSerdeRequest &b) { swap(a.__isset, b.__isset); } -GetSerdeRequest::GetSerdeRequest(const GetSerdeRequest& other1496) { - serdeName = other1496.serdeName; - __isset = other1496.__isset; -} -GetSerdeRequest& GetSerdeRequest::operator=(const GetSerdeRequest& other1497) { +GetSerdeRequest::GetSerdeRequest(const GetSerdeRequest& other1497) { serdeName = other1497.serdeName; __isset = other1497.__isset; +} +GetSerdeRequest& GetSerdeRequest::operator=(const GetSerdeRequest& other1498) { + serdeName = other1498.serdeName; + __isset = other1498.__isset; return *this; } void GetSerdeRequest::printTo(std::ostream& out) const { @@ -43577,17 +43623,17 @@ void swap(RuntimeStat &a, RuntimeStat &b) { swap(a.__isset, b.__isset); } -RuntimeStat::RuntimeStat(const RuntimeStat& other1498) { - createTime = other1498.createTime; - weight = other1498.weight; - payload = other1498.payload; - __isset = other1498.__isset; -} -RuntimeStat& RuntimeStat::operator=(const RuntimeStat& other1499) { +RuntimeStat::RuntimeStat(const RuntimeStat& other1499) { createTime = other1499.createTime; weight = other1499.weight; payload = other1499.payload; __isset = other1499.__isset; +} +RuntimeStat& RuntimeStat::operator=(const RuntimeStat& other1500) { + createTime = other1500.createTime; + weight = other1500.weight; + payload = other1500.payload; + __isset = other1500.__isset; return *this; } void RuntimeStat::printTo(std::ostream& out) const { @@ -43697,13 +43743,13 @@ void swap(GetRuntimeStatsRequest &a, GetRuntimeStatsRequest &b) { swap(a.maxCreateTime, b.maxCreateTime); } -GetRuntimeStatsRequest::GetRuntimeStatsRequest(const GetRuntimeStatsRequest& other1500) noexcept { - maxWeight = other1500.maxWeight; - maxCreateTime = other1500.maxCreateTime; -} -GetRuntimeStatsRequest& GetRuntimeStatsRequest::operator=(const GetRuntimeStatsRequest& other1501) noexcept { +GetRuntimeStatsRequest::GetRuntimeStatsRequest(const GetRuntimeStatsRequest& other1501) noexcept { maxWeight = other1501.maxWeight; maxCreateTime = other1501.maxCreateTime; +} +GetRuntimeStatsRequest& GetRuntimeStatsRequest::operator=(const GetRuntimeStatsRequest& other1502) noexcept { + maxWeight = other1502.maxWeight; + maxCreateTime = other1502.maxCreateTime; return *this; } void GetRuntimeStatsRequest::printTo(std::ostream& out) const { @@ -43816,14 +43862,14 @@ uint32_t CreateTableRequest::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->primaryKeys.clear(); - uint32_t _size1502; - ::apache::thrift::protocol::TType _etype1505; - xfer += iprot->readListBegin(_etype1505, _size1502); - this->primaryKeys.resize(_size1502); - uint32_t _i1506; - for (_i1506 = 0; _i1506 < _size1502; ++_i1506) + uint32_t _size1503; + ::apache::thrift::protocol::TType _etype1506; + xfer += iprot->readListBegin(_etype1506, _size1503); + this->primaryKeys.resize(_size1503); + uint32_t _i1507; + for (_i1507 = 0; _i1507 < _size1503; ++_i1507) { - xfer += this->primaryKeys[_i1506].read(iprot); + xfer += this->primaryKeys[_i1507].read(iprot); } xfer += iprot->readListEnd(); } @@ -43836,14 +43882,14 @@ uint32_t CreateTableRequest::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->foreignKeys.clear(); - uint32_t _size1507; - ::apache::thrift::protocol::TType _etype1510; - xfer += iprot->readListBegin(_etype1510, _size1507); - this->foreignKeys.resize(_size1507); - uint32_t _i1511; - for (_i1511 = 0; _i1511 < _size1507; ++_i1511) + uint32_t _size1508; + ::apache::thrift::protocol::TType _etype1511; + xfer += iprot->readListBegin(_etype1511, _size1508); + this->foreignKeys.resize(_size1508); + uint32_t _i1512; + for (_i1512 = 0; _i1512 < _size1508; ++_i1512) { - xfer += this->foreignKeys[_i1511].read(iprot); + xfer += this->foreignKeys[_i1512].read(iprot); } xfer += iprot->readListEnd(); } @@ -43856,14 +43902,14 @@ uint32_t CreateTableRequest::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->uniqueConstraints.clear(); - uint32_t _size1512; - ::apache::thrift::protocol::TType _etype1515; - xfer += iprot->readListBegin(_etype1515, _size1512); - this->uniqueConstraints.resize(_size1512); - uint32_t _i1516; - for (_i1516 = 0; _i1516 < _size1512; ++_i1516) + uint32_t _size1513; + ::apache::thrift::protocol::TType _etype1516; + xfer += iprot->readListBegin(_etype1516, _size1513); + this->uniqueConstraints.resize(_size1513); + uint32_t _i1517; + for (_i1517 = 0; _i1517 < _size1513; ++_i1517) { - xfer += this->uniqueConstraints[_i1516].read(iprot); + xfer += this->uniqueConstraints[_i1517].read(iprot); } xfer += iprot->readListEnd(); } @@ -43876,14 +43922,14 @@ uint32_t CreateTableRequest::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->notNullConstraints.clear(); - uint32_t _size1517; - ::apache::thrift::protocol::TType _etype1520; - xfer += iprot->readListBegin(_etype1520, _size1517); - this->notNullConstraints.resize(_size1517); - uint32_t _i1521; - for (_i1521 = 0; _i1521 < _size1517; ++_i1521) + uint32_t _size1518; + ::apache::thrift::protocol::TType _etype1521; + xfer += iprot->readListBegin(_etype1521, _size1518); + this->notNullConstraints.resize(_size1518); + uint32_t _i1522; + for (_i1522 = 0; _i1522 < _size1518; ++_i1522) { - xfer += this->notNullConstraints[_i1521].read(iprot); + xfer += this->notNullConstraints[_i1522].read(iprot); } xfer += iprot->readListEnd(); } @@ -43896,14 +43942,14 @@ uint32_t CreateTableRequest::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->defaultConstraints.clear(); - uint32_t _size1522; - ::apache::thrift::protocol::TType _etype1525; - xfer += iprot->readListBegin(_etype1525, _size1522); - this->defaultConstraints.resize(_size1522); - uint32_t _i1526; - for (_i1526 = 0; _i1526 < _size1522; ++_i1526) + uint32_t _size1523; + ::apache::thrift::protocol::TType _etype1526; + xfer += iprot->readListBegin(_etype1526, _size1523); + this->defaultConstraints.resize(_size1523); + uint32_t _i1527; + for (_i1527 = 0; _i1527 < _size1523; ++_i1527) { - xfer += this->defaultConstraints[_i1526].read(iprot); + xfer += this->defaultConstraints[_i1527].read(iprot); } xfer += iprot->readListEnd(); } @@ -43916,14 +43962,14 @@ uint32_t CreateTableRequest::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->checkConstraints.clear(); - uint32_t _size1527; - ::apache::thrift::protocol::TType _etype1530; - xfer += iprot->readListBegin(_etype1530, _size1527); - this->checkConstraints.resize(_size1527); - uint32_t _i1531; - for (_i1531 = 0; _i1531 < _size1527; ++_i1531) + uint32_t _size1528; + ::apache::thrift::protocol::TType _etype1531; + xfer += iprot->readListBegin(_etype1531, _size1528); + this->checkConstraints.resize(_size1528); + uint32_t _i1532; + for (_i1532 = 0; _i1532 < _size1528; ++_i1532) { - xfer += this->checkConstraints[_i1531].read(iprot); + xfer += this->checkConstraints[_i1532].read(iprot); } xfer += iprot->readListEnd(); } @@ -43936,14 +43982,14 @@ uint32_t CreateTableRequest::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->processorCapabilities.clear(); - uint32_t _size1532; - ::apache::thrift::protocol::TType _etype1535; - xfer += iprot->readListBegin(_etype1535, _size1532); - this->processorCapabilities.resize(_size1532); - uint32_t _i1536; - for (_i1536 = 0; _i1536 < _size1532; ++_i1536) + uint32_t _size1533; + ::apache::thrift::protocol::TType _etype1536; + xfer += iprot->readListBegin(_etype1536, _size1533); + this->processorCapabilities.resize(_size1533); + uint32_t _i1537; + for (_i1537 = 0; _i1537 < _size1533; ++_i1537) { - xfer += iprot->readString(this->processorCapabilities[_i1536]); + xfer += iprot->readString(this->processorCapabilities[_i1537]); } xfer += iprot->readListEnd(); } @@ -43992,10 +44038,10 @@ uint32_t CreateTableRequest::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("primaryKeys", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->primaryKeys.size())); - std::vector ::const_iterator _iter1537; - for (_iter1537 = this->primaryKeys.begin(); _iter1537 != this->primaryKeys.end(); ++_iter1537) + std::vector ::const_iterator _iter1538; + for (_iter1538 = this->primaryKeys.begin(); _iter1538 != this->primaryKeys.end(); ++_iter1538) { - xfer += (*_iter1537).write(oprot); + xfer += (*_iter1538).write(oprot); } xfer += oprot->writeListEnd(); } @@ -44005,10 +44051,10 @@ uint32_t CreateTableRequest::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("foreignKeys", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->foreignKeys.size())); - std::vector ::const_iterator _iter1538; - for (_iter1538 = this->foreignKeys.begin(); _iter1538 != this->foreignKeys.end(); ++_iter1538) + std::vector ::const_iterator _iter1539; + for (_iter1539 = this->foreignKeys.begin(); _iter1539 != this->foreignKeys.end(); ++_iter1539) { - xfer += (*_iter1538).write(oprot); + xfer += (*_iter1539).write(oprot); } xfer += oprot->writeListEnd(); } @@ -44018,10 +44064,10 @@ uint32_t CreateTableRequest::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("uniqueConstraints", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->uniqueConstraints.size())); - std::vector ::const_iterator _iter1539; - for (_iter1539 = this->uniqueConstraints.begin(); _iter1539 != this->uniqueConstraints.end(); ++_iter1539) + std::vector ::const_iterator _iter1540; + for (_iter1540 = this->uniqueConstraints.begin(); _iter1540 != this->uniqueConstraints.end(); ++_iter1540) { - xfer += (*_iter1539).write(oprot); + xfer += (*_iter1540).write(oprot); } xfer += oprot->writeListEnd(); } @@ -44031,10 +44077,10 @@ uint32_t CreateTableRequest::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("notNullConstraints", ::apache::thrift::protocol::T_LIST, 6); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->notNullConstraints.size())); - std::vector ::const_iterator _iter1540; - for (_iter1540 = this->notNullConstraints.begin(); _iter1540 != this->notNullConstraints.end(); ++_iter1540) + std::vector ::const_iterator _iter1541; + for (_iter1541 = this->notNullConstraints.begin(); _iter1541 != this->notNullConstraints.end(); ++_iter1541) { - xfer += (*_iter1540).write(oprot); + xfer += (*_iter1541).write(oprot); } xfer += oprot->writeListEnd(); } @@ -44044,10 +44090,10 @@ uint32_t CreateTableRequest::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("defaultConstraints", ::apache::thrift::protocol::T_LIST, 7); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->defaultConstraints.size())); - std::vector ::const_iterator _iter1541; - for (_iter1541 = this->defaultConstraints.begin(); _iter1541 != this->defaultConstraints.end(); ++_iter1541) + std::vector ::const_iterator _iter1542; + for (_iter1542 = this->defaultConstraints.begin(); _iter1542 != this->defaultConstraints.end(); ++_iter1542) { - xfer += (*_iter1541).write(oprot); + xfer += (*_iter1542).write(oprot); } xfer += oprot->writeListEnd(); } @@ -44057,10 +44103,10 @@ uint32_t CreateTableRequest::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("checkConstraints", ::apache::thrift::protocol::T_LIST, 8); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->checkConstraints.size())); - std::vector ::const_iterator _iter1542; - for (_iter1542 = this->checkConstraints.begin(); _iter1542 != this->checkConstraints.end(); ++_iter1542) + std::vector ::const_iterator _iter1543; + for (_iter1543 = this->checkConstraints.begin(); _iter1543 != this->checkConstraints.end(); ++_iter1543) { - xfer += (*_iter1542).write(oprot); + xfer += (*_iter1543).write(oprot); } xfer += oprot->writeListEnd(); } @@ -44070,10 +44116,10 @@ uint32_t CreateTableRequest::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("processorCapabilities", ::apache::thrift::protocol::T_LIST, 9); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->processorCapabilities.size())); - std::vector ::const_iterator _iter1543; - for (_iter1543 = this->processorCapabilities.begin(); _iter1543 != this->processorCapabilities.end(); ++_iter1543) + std::vector ::const_iterator _iter1544; + for (_iter1544 = this->processorCapabilities.begin(); _iter1544 != this->processorCapabilities.end(); ++_iter1544) { - xfer += oprot->writeString((*_iter1543)); + xfer += oprot->writeString((*_iter1544)); } xfer += oprot->writeListEnd(); } @@ -44104,20 +44150,7 @@ void swap(CreateTableRequest &a, CreateTableRequest &b) { swap(a.__isset, b.__isset); } -CreateTableRequest::CreateTableRequest(const CreateTableRequest& other1544) { - table = other1544.table; - envContext = other1544.envContext; - primaryKeys = other1544.primaryKeys; - foreignKeys = other1544.foreignKeys; - uniqueConstraints = other1544.uniqueConstraints; - notNullConstraints = other1544.notNullConstraints; - defaultConstraints = other1544.defaultConstraints; - checkConstraints = other1544.checkConstraints; - processorCapabilities = other1544.processorCapabilities; - processorIdentifier = other1544.processorIdentifier; - __isset = other1544.__isset; -} -CreateTableRequest& CreateTableRequest::operator=(const CreateTableRequest& other1545) { +CreateTableRequest::CreateTableRequest(const CreateTableRequest& other1545) { table = other1545.table; envContext = other1545.envContext; primaryKeys = other1545.primaryKeys; @@ -44129,6 +44162,19 @@ CreateTableRequest& CreateTableRequest::operator=(const CreateTableRequest& othe processorCapabilities = other1545.processorCapabilities; processorIdentifier = other1545.processorIdentifier; __isset = other1545.__isset; +} +CreateTableRequest& CreateTableRequest::operator=(const CreateTableRequest& other1546) { + table = other1546.table; + envContext = other1546.envContext; + primaryKeys = other1546.primaryKeys; + foreignKeys = other1546.foreignKeys; + uniqueConstraints = other1546.uniqueConstraints; + notNullConstraints = other1546.notNullConstraints; + defaultConstraints = other1546.defaultConstraints; + checkConstraints = other1546.checkConstraints; + processorCapabilities = other1546.processorCapabilities; + processorIdentifier = other1546.processorIdentifier; + __isset = other1546.__isset; return *this; } void CreateTableRequest::printTo(std::ostream& out) const { @@ -44267,17 +44313,17 @@ uint32_t CreateDatabaseRequest::read(::apache::thrift::protocol::TProtocol* ipro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size1546; - ::apache::thrift::protocol::TType _ktype1547; - ::apache::thrift::protocol::TType _vtype1548; - xfer += iprot->readMapBegin(_ktype1547, _vtype1548, _size1546); - uint32_t _i1550; - for (_i1550 = 0; _i1550 < _size1546; ++_i1550) + uint32_t _size1547; + ::apache::thrift::protocol::TType _ktype1548; + ::apache::thrift::protocol::TType _vtype1549; + xfer += iprot->readMapBegin(_ktype1548, _vtype1549, _size1547); + uint32_t _i1551; + for (_i1551 = 0; _i1551 < _size1547; ++_i1551) { - std::string _key1551; - xfer += iprot->readString(_key1551); - std::string& _val1552 = this->parameters[_key1551]; - xfer += iprot->readString(_val1552); + std::string _key1552; + xfer += iprot->readString(_key1552); + std::string& _val1553 = this->parameters[_key1552]; + xfer += iprot->readString(_val1553); } xfer += iprot->readMapEnd(); } @@ -44304,9 +44350,9 @@ uint32_t CreateDatabaseRequest::read(::apache::thrift::protocol::TProtocol* ipro break; case 7: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1553; - xfer += iprot->readI32(ecast1553); - this->ownerType = static_cast(ecast1553); + int32_t ecast1554; + xfer += iprot->readI32(ecast1554); + this->ownerType = static_cast(ecast1554); this->__isset.ownerType = true; } else { xfer += iprot->skip(ftype); @@ -44389,11 +44435,11 @@ uint32_t CreateDatabaseRequest::write(::apache::thrift::protocol::TProtocol* opr 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 _iter1554; - for (_iter1554 = this->parameters.begin(); _iter1554 != this->parameters.end(); ++_iter1554) + std::map ::const_iterator _iter1555; + for (_iter1555 = this->parameters.begin(); _iter1555 != this->parameters.end(); ++_iter1555) { - xfer += oprot->writeString(_iter1554->first); - xfer += oprot->writeString(_iter1554->second); + xfer += oprot->writeString(_iter1555->first); + xfer += oprot->writeString(_iter1555->second); } xfer += oprot->writeMapEnd(); } @@ -44461,22 +44507,7 @@ void swap(CreateDatabaseRequest &a, CreateDatabaseRequest &b) { swap(a.__isset, b.__isset); } -CreateDatabaseRequest::CreateDatabaseRequest(const CreateDatabaseRequest& other1555) { - databaseName = other1555.databaseName; - description = other1555.description; - locationUri = other1555.locationUri; - parameters = other1555.parameters; - privileges = other1555.privileges; - ownerName = other1555.ownerName; - ownerType = other1555.ownerType; - catalogName = other1555.catalogName; - createTime = other1555.createTime; - managedLocationUri = other1555.managedLocationUri; - type = other1555.type; - dataConnectorName = other1555.dataConnectorName; - __isset = other1555.__isset; -} -CreateDatabaseRequest& CreateDatabaseRequest::operator=(const CreateDatabaseRequest& other1556) { +CreateDatabaseRequest::CreateDatabaseRequest(const CreateDatabaseRequest& other1556) { databaseName = other1556.databaseName; description = other1556.description; locationUri = other1556.locationUri; @@ -44490,6 +44521,21 @@ CreateDatabaseRequest& CreateDatabaseRequest::operator=(const CreateDatabaseRequ type = other1556.type; dataConnectorName = other1556.dataConnectorName; __isset = other1556.__isset; +} +CreateDatabaseRequest& CreateDatabaseRequest::operator=(const CreateDatabaseRequest& other1557) { + databaseName = other1557.databaseName; + description = other1557.description; + locationUri = other1557.locationUri; + parameters = other1557.parameters; + privileges = other1557.privileges; + ownerName = other1557.ownerName; + ownerType = other1557.ownerType; + catalogName = other1557.catalogName; + createTime = other1557.createTime; + managedLocationUri = other1557.managedLocationUri; + type = other1557.type; + dataConnectorName = other1557.dataConnectorName; + __isset = other1557.__isset; return *this; } void CreateDatabaseRequest::printTo(std::ostream& out) const { @@ -44586,13 +44632,13 @@ void swap(CreateDataConnectorRequest &a, CreateDataConnectorRequest &b) { swap(a.__isset, b.__isset); } -CreateDataConnectorRequest::CreateDataConnectorRequest(const CreateDataConnectorRequest& other1557) { - connector = other1557.connector; - __isset = other1557.__isset; -} -CreateDataConnectorRequest& CreateDataConnectorRequest::operator=(const CreateDataConnectorRequest& other1558) { +CreateDataConnectorRequest::CreateDataConnectorRequest(const CreateDataConnectorRequest& other1558) { connector = other1558.connector; __isset = other1558.__isset; +} +CreateDataConnectorRequest& CreateDataConnectorRequest::operator=(const CreateDataConnectorRequest& other1559) { + connector = other1559.connector; + __isset = other1559.__isset; return *this; } void CreateDataConnectorRequest::printTo(std::ostream& out) const { @@ -44680,11 +44726,11 @@ void swap(GetDataConnectorRequest &a, GetDataConnectorRequest &b) { swap(a.connectorName, b.connectorName); } -GetDataConnectorRequest::GetDataConnectorRequest(const GetDataConnectorRequest& other1559) { - connectorName = other1559.connectorName; -} -GetDataConnectorRequest& GetDataConnectorRequest::operator=(const GetDataConnectorRequest& other1560) { +GetDataConnectorRequest::GetDataConnectorRequest(const GetDataConnectorRequest& other1560) { connectorName = other1560.connectorName; +} +GetDataConnectorRequest& GetDataConnectorRequest::operator=(const GetDataConnectorRequest& other1561) { + connectorName = other1561.connectorName; return *this; } void GetDataConnectorRequest::printTo(std::ostream& out) const { @@ -44772,11 +44818,11 @@ void swap(ScheduledQueryPollRequest &a, ScheduledQueryPollRequest &b) { swap(a.clusterNamespace, b.clusterNamespace); } -ScheduledQueryPollRequest::ScheduledQueryPollRequest(const ScheduledQueryPollRequest& other1561) { - clusterNamespace = other1561.clusterNamespace; -} -ScheduledQueryPollRequest& ScheduledQueryPollRequest::operator=(const ScheduledQueryPollRequest& other1562) { +ScheduledQueryPollRequest::ScheduledQueryPollRequest(const ScheduledQueryPollRequest& other1562) { clusterNamespace = other1562.clusterNamespace; +} +ScheduledQueryPollRequest& ScheduledQueryPollRequest::operator=(const ScheduledQueryPollRequest& other1563) { + clusterNamespace = other1563.clusterNamespace; return *this; } void ScheduledQueryPollRequest::printTo(std::ostream& out) const { @@ -44884,13 +44930,13 @@ void swap(ScheduledQueryKey &a, ScheduledQueryKey &b) { swap(a.clusterNamespace, b.clusterNamespace); } -ScheduledQueryKey::ScheduledQueryKey(const ScheduledQueryKey& other1563) { - scheduleName = other1563.scheduleName; - clusterNamespace = other1563.clusterNamespace; -} -ScheduledQueryKey& ScheduledQueryKey::operator=(const ScheduledQueryKey& other1564) { +ScheduledQueryKey::ScheduledQueryKey(const ScheduledQueryKey& other1564) { scheduleName = other1564.scheduleName; clusterNamespace = other1564.clusterNamespace; +} +ScheduledQueryKey& ScheduledQueryKey::operator=(const ScheduledQueryKey& other1565) { + scheduleName = other1565.scheduleName; + clusterNamespace = other1565.clusterNamespace; return *this; } void ScheduledQueryKey::printTo(std::ostream& out) const { @@ -45036,19 +45082,19 @@ void swap(ScheduledQueryPollResponse &a, ScheduledQueryPollResponse &b) { swap(a.__isset, b.__isset); } -ScheduledQueryPollResponse::ScheduledQueryPollResponse(const ScheduledQueryPollResponse& other1565) { - scheduleKey = other1565.scheduleKey; - executionId = other1565.executionId; - query = other1565.query; - user = other1565.user; - __isset = other1565.__isset; -} -ScheduledQueryPollResponse& ScheduledQueryPollResponse::operator=(const ScheduledQueryPollResponse& other1566) { +ScheduledQueryPollResponse::ScheduledQueryPollResponse(const ScheduledQueryPollResponse& other1566) { scheduleKey = other1566.scheduleKey; executionId = other1566.executionId; query = other1566.query; user = other1566.user; __isset = other1566.__isset; +} +ScheduledQueryPollResponse& ScheduledQueryPollResponse::operator=(const ScheduledQueryPollResponse& other1567) { + scheduleKey = other1567.scheduleKey; + executionId = other1567.executionId; + query = other1567.query; + user = other1567.user; + __isset = other1567.__isset; return *this; } void ScheduledQueryPollResponse::printTo(std::ostream& out) const { @@ -45235,16 +45281,7 @@ void swap(ScheduledQuery &a, ScheduledQuery &b) { swap(a.__isset, b.__isset); } -ScheduledQuery::ScheduledQuery(const ScheduledQuery& other1567) { - scheduleKey = other1567.scheduleKey; - enabled = other1567.enabled; - schedule = other1567.schedule; - user = other1567.user; - query = other1567.query; - nextExecution = other1567.nextExecution; - __isset = other1567.__isset; -} -ScheduledQuery& ScheduledQuery::operator=(const ScheduledQuery& other1568) { +ScheduledQuery::ScheduledQuery(const ScheduledQuery& other1568) { scheduleKey = other1568.scheduleKey; enabled = other1568.enabled; schedule = other1568.schedule; @@ -45252,6 +45289,15 @@ ScheduledQuery& ScheduledQuery::operator=(const ScheduledQuery& other1568) { query = other1568.query; nextExecution = other1568.nextExecution; __isset = other1568.__isset; +} +ScheduledQuery& ScheduledQuery::operator=(const ScheduledQuery& other1569) { + scheduleKey = other1569.scheduleKey; + enabled = other1569.enabled; + schedule = other1569.schedule; + user = other1569.user; + query = other1569.query; + nextExecution = other1569.nextExecution; + __isset = other1569.__isset; return *this; } void ScheduledQuery::printTo(std::ostream& out) const { @@ -45310,9 +45356,9 @@ uint32_t ScheduledQueryMaintenanceRequest::read(::apache::thrift::protocol::TPro { case 1: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1569; - xfer += iprot->readI32(ecast1569); - this->type = static_cast(ecast1569); + int32_t ecast1570; + xfer += iprot->readI32(ecast1570); + this->type = static_cast(ecast1570); isset_type = true; } else { xfer += iprot->skip(ftype); @@ -45366,13 +45412,13 @@ void swap(ScheduledQueryMaintenanceRequest &a, ScheduledQueryMaintenanceRequest swap(a.scheduledQuery, b.scheduledQuery); } -ScheduledQueryMaintenanceRequest::ScheduledQueryMaintenanceRequest(const ScheduledQueryMaintenanceRequest& other1570) { - type = other1570.type; - scheduledQuery = other1570.scheduledQuery; -} -ScheduledQueryMaintenanceRequest& ScheduledQueryMaintenanceRequest::operator=(const ScheduledQueryMaintenanceRequest& other1571) { +ScheduledQueryMaintenanceRequest::ScheduledQueryMaintenanceRequest(const ScheduledQueryMaintenanceRequest& other1571) { type = other1571.type; scheduledQuery = other1571.scheduledQuery; +} +ScheduledQueryMaintenanceRequest& ScheduledQueryMaintenanceRequest::operator=(const ScheduledQueryMaintenanceRequest& other1572) { + type = other1572.type; + scheduledQuery = other1572.scheduledQuery; return *this; } void ScheduledQueryMaintenanceRequest::printTo(std::ostream& out) const { @@ -45445,9 +45491,9 @@ uint32_t ScheduledQueryProgressInfo::read(::apache::thrift::protocol::TProtocol* break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1572; - xfer += iprot->readI32(ecast1572); - this->state = static_cast(ecast1572); + int32_t ecast1573; + xfer += iprot->readI32(ecast1573); + this->state = static_cast(ecast1573); isset_state = true; } else { xfer += iprot->skip(ftype); @@ -45523,19 +45569,19 @@ void swap(ScheduledQueryProgressInfo &a, ScheduledQueryProgressInfo &b) { swap(a.__isset, b.__isset); } -ScheduledQueryProgressInfo::ScheduledQueryProgressInfo(const ScheduledQueryProgressInfo& other1573) { - scheduledExecutionId = other1573.scheduledExecutionId; - state = other1573.state; - executorQueryId = other1573.executorQueryId; - errorMessage = other1573.errorMessage; - __isset = other1573.__isset; -} -ScheduledQueryProgressInfo& ScheduledQueryProgressInfo::operator=(const ScheduledQueryProgressInfo& other1574) { +ScheduledQueryProgressInfo::ScheduledQueryProgressInfo(const ScheduledQueryProgressInfo& other1574) { scheduledExecutionId = other1574.scheduledExecutionId; state = other1574.state; executorQueryId = other1574.executorQueryId; errorMessage = other1574.errorMessage; __isset = other1574.__isset; +} +ScheduledQueryProgressInfo& ScheduledQueryProgressInfo::operator=(const ScheduledQueryProgressInfo& other1575) { + scheduledExecutionId = other1575.scheduledExecutionId; + state = other1575.state; + executorQueryId = other1575.executorQueryId; + errorMessage = other1575.errorMessage; + __isset = other1575.__isset; return *this; } void ScheduledQueryProgressInfo::printTo(std::ostream& out) const { @@ -45643,14 +45689,14 @@ uint32_t AlterPartitionsRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size1575; - ::apache::thrift::protocol::TType _etype1578; - xfer += iprot->readListBegin(_etype1578, _size1575); - this->partitions.resize(_size1575); - uint32_t _i1579; - for (_i1579 = 0; _i1579 < _size1575; ++_i1579) + uint32_t _size1576; + ::apache::thrift::protocol::TType _etype1579; + xfer += iprot->readListBegin(_etype1579, _size1576); + this->partitions.resize(_size1576); + uint32_t _i1580; + for (_i1580 = 0; _i1580 < _size1576; ++_i1580) { - xfer += this->partitions[_i1579].read(iprot); + xfer += this->partitions[_i1580].read(iprot); } xfer += iprot->readListEnd(); } @@ -45722,10 +45768,10 @@ uint32_t AlterPartitionsRequest::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitions.size())); - std::vector ::const_iterator _iter1580; - for (_iter1580 = this->partitions.begin(); _iter1580 != this->partitions.end(); ++_iter1580) + std::vector ::const_iterator _iter1581; + for (_iter1581 = this->partitions.begin(); _iter1581 != this->partitions.end(); ++_iter1581) { - xfer += (*_iter1580).write(oprot); + xfer += (*_iter1581).write(oprot); } xfer += oprot->writeListEnd(); } @@ -45763,17 +45809,7 @@ void swap(AlterPartitionsRequest &a, AlterPartitionsRequest &b) { swap(a.__isset, b.__isset); } -AlterPartitionsRequest::AlterPartitionsRequest(const AlterPartitionsRequest& other1581) { - catName = other1581.catName; - dbName = other1581.dbName; - tableName = other1581.tableName; - partitions = other1581.partitions; - environmentContext = other1581.environmentContext; - writeId = other1581.writeId; - validWriteIdList = other1581.validWriteIdList; - __isset = other1581.__isset; -} -AlterPartitionsRequest& AlterPartitionsRequest::operator=(const AlterPartitionsRequest& other1582) { +AlterPartitionsRequest::AlterPartitionsRequest(const AlterPartitionsRequest& other1582) { catName = other1582.catName; dbName = other1582.dbName; tableName = other1582.tableName; @@ -45782,6 +45818,16 @@ AlterPartitionsRequest& AlterPartitionsRequest::operator=(const AlterPartitionsR writeId = other1582.writeId; validWriteIdList = other1582.validWriteIdList; __isset = other1582.__isset; +} +AlterPartitionsRequest& AlterPartitionsRequest::operator=(const AlterPartitionsRequest& other1583) { + catName = other1583.catName; + dbName = other1583.dbName; + tableName = other1583.tableName; + partitions = other1583.partitions; + environmentContext = other1583.environmentContext; + writeId = other1583.writeId; + validWriteIdList = other1583.validWriteIdList; + __isset = other1583.__isset; return *this; } void AlterPartitionsRequest::printTo(std::ostream& out) const { @@ -45852,11 +45898,11 @@ void swap(AlterPartitionsResponse &a, AlterPartitionsResponse &b) { (void) b; } -AlterPartitionsResponse::AlterPartitionsResponse(const AlterPartitionsResponse& other1583) noexcept { - (void) other1583; -} -AlterPartitionsResponse& AlterPartitionsResponse::operator=(const AlterPartitionsResponse& other1584) noexcept { +AlterPartitionsResponse::AlterPartitionsResponse(const AlterPartitionsResponse& other1584) noexcept { (void) other1584; +} +AlterPartitionsResponse& AlterPartitionsResponse::operator=(const AlterPartitionsResponse& other1585) noexcept { + (void) other1585; return *this; } void AlterPartitionsResponse::printTo(std::ostream& out) const { @@ -45965,14 +46011,14 @@ uint32_t RenamePartitionRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partVals.clear(); - uint32_t _size1585; - ::apache::thrift::protocol::TType _etype1588; - xfer += iprot->readListBegin(_etype1588, _size1585); - this->partVals.resize(_size1585); - uint32_t _i1589; - for (_i1589 = 0; _i1589 < _size1585; ++_i1589) + uint32_t _size1586; + ::apache::thrift::protocol::TType _etype1589; + xfer += iprot->readListBegin(_etype1589, _size1586); + this->partVals.resize(_size1586); + uint32_t _i1590; + for (_i1590 = 0; _i1590 < _size1586; ++_i1590) { - xfer += iprot->readString(this->partVals[_i1589]); + xfer += iprot->readString(this->partVals[_i1590]); } xfer += iprot->readListEnd(); } @@ -46054,10 +46100,10 @@ uint32_t RenamePartitionRequest::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("partVals", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partVals.size())); - std::vector ::const_iterator _iter1590; - for (_iter1590 = this->partVals.begin(); _iter1590 != this->partVals.end(); ++_iter1590) + std::vector ::const_iterator _iter1591; + for (_iter1591 = this->partVals.begin(); _iter1591 != this->partVals.end(); ++_iter1591) { - xfer += oprot->writeString((*_iter1590)); + xfer += oprot->writeString((*_iter1591)); } xfer += oprot->writeListEnd(); } @@ -46100,18 +46146,7 @@ void swap(RenamePartitionRequest &a, RenamePartitionRequest &b) { swap(a.__isset, b.__isset); } -RenamePartitionRequest::RenamePartitionRequest(const RenamePartitionRequest& other1591) { - catName = other1591.catName; - dbName = other1591.dbName; - tableName = other1591.tableName; - partVals = other1591.partVals; - newPart = other1591.newPart; - validWriteIdList = other1591.validWriteIdList; - txnId = other1591.txnId; - clonePart = other1591.clonePart; - __isset = other1591.__isset; -} -RenamePartitionRequest& RenamePartitionRequest::operator=(const RenamePartitionRequest& other1592) { +RenamePartitionRequest::RenamePartitionRequest(const RenamePartitionRequest& other1592) { catName = other1592.catName; dbName = other1592.dbName; tableName = other1592.tableName; @@ -46121,6 +46156,17 @@ RenamePartitionRequest& RenamePartitionRequest::operator=(const RenamePartitionR txnId = other1592.txnId; clonePart = other1592.clonePart; __isset = other1592.__isset; +} +RenamePartitionRequest& RenamePartitionRequest::operator=(const RenamePartitionRequest& other1593) { + catName = other1593.catName; + dbName = other1593.dbName; + tableName = other1593.tableName; + partVals = other1593.partVals; + newPart = other1593.newPart; + validWriteIdList = other1593.validWriteIdList; + txnId = other1593.txnId; + clonePart = other1593.clonePart; + __isset = other1593.__isset; return *this; } void RenamePartitionRequest::printTo(std::ostream& out) const { @@ -46192,11 +46238,11 @@ void swap(RenamePartitionResponse &a, RenamePartitionResponse &b) { (void) b; } -RenamePartitionResponse::RenamePartitionResponse(const RenamePartitionResponse& other1593) noexcept { - (void) other1593; -} -RenamePartitionResponse& RenamePartitionResponse::operator=(const RenamePartitionResponse& other1594) noexcept { +RenamePartitionResponse::RenamePartitionResponse(const RenamePartitionResponse& other1594) noexcept { (void) other1594; +} +RenamePartitionResponse& RenamePartitionResponse::operator=(const RenamePartitionResponse& other1595) noexcept { + (void) other1595; return *this; } void RenamePartitionResponse::printTo(std::ostream& out) const { @@ -46352,14 +46398,14 @@ uint32_t AlterTableRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->processorCapabilities.clear(); - uint32_t _size1595; - ::apache::thrift::protocol::TType _etype1598; - xfer += iprot->readListBegin(_etype1598, _size1595); - this->processorCapabilities.resize(_size1595); - uint32_t _i1599; - for (_i1599 = 0; _i1599 < _size1595; ++_i1599) + uint32_t _size1596; + ::apache::thrift::protocol::TType _etype1599; + xfer += iprot->readListBegin(_etype1599, _size1596); + this->processorCapabilities.resize(_size1596); + uint32_t _i1600; + for (_i1600 = 0; _i1600 < _size1596; ++_i1600) { - xfer += iprot->readString(this->processorCapabilities[_i1599]); + xfer += iprot->readString(this->processorCapabilities[_i1600]); } xfer += iprot->readListEnd(); } @@ -46451,10 +46497,10 @@ uint32_t AlterTableRequest::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("processorCapabilities", ::apache::thrift::protocol::T_LIST, 8); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->processorCapabilities.size())); - std::vector ::const_iterator _iter1600; - for (_iter1600 = this->processorCapabilities.begin(); _iter1600 != this->processorCapabilities.end(); ++_iter1600) + std::vector ::const_iterator _iter1601; + for (_iter1601 = this->processorCapabilities.begin(); _iter1601 != this->processorCapabilities.end(); ++_iter1601) { - xfer += oprot->writeString((*_iter1600)); + xfer += oprot->writeString((*_iter1601)); } xfer += oprot->writeListEnd(); } @@ -46496,21 +46542,7 @@ void swap(AlterTableRequest &a, AlterTableRequest &b) { swap(a.__isset, b.__isset); } -AlterTableRequest::AlterTableRequest(const AlterTableRequest& other1601) { - catName = other1601.catName; - dbName = other1601.dbName; - tableName = other1601.tableName; - table = other1601.table; - environmentContext = other1601.environmentContext; - writeId = other1601.writeId; - validWriteIdList = other1601.validWriteIdList; - processorCapabilities = other1601.processorCapabilities; - processorIdentifier = other1601.processorIdentifier; - expectedParameterKey = other1601.expectedParameterKey; - expectedParameterValue = other1601.expectedParameterValue; - __isset = other1601.__isset; -} -AlterTableRequest& AlterTableRequest::operator=(const AlterTableRequest& other1602) { +AlterTableRequest::AlterTableRequest(const AlterTableRequest& other1602) { catName = other1602.catName; dbName = other1602.dbName; tableName = other1602.tableName; @@ -46523,6 +46555,20 @@ AlterTableRequest& AlterTableRequest::operator=(const AlterTableRequest& other16 expectedParameterKey = other1602.expectedParameterKey; expectedParameterValue = other1602.expectedParameterValue; __isset = other1602.__isset; +} +AlterTableRequest& AlterTableRequest::operator=(const AlterTableRequest& other1603) { + catName = other1603.catName; + dbName = other1603.dbName; + tableName = other1603.tableName; + table = other1603.table; + environmentContext = other1603.environmentContext; + writeId = other1603.writeId; + validWriteIdList = other1603.validWriteIdList; + processorCapabilities = other1603.processorCapabilities; + processorIdentifier = other1603.processorIdentifier; + expectedParameterKey = other1603.expectedParameterKey; + expectedParameterValue = other1603.expectedParameterValue; + __isset = other1603.__isset; return *this; } void AlterTableRequest::printTo(std::ostream& out) const { @@ -46597,11 +46643,11 @@ void swap(AlterTableResponse &a, AlterTableResponse &b) { (void) b; } -AlterTableResponse::AlterTableResponse(const AlterTableResponse& other1603) noexcept { - (void) other1603; -} -AlterTableResponse& AlterTableResponse::operator=(const AlterTableResponse& other1604) noexcept { +AlterTableResponse::AlterTableResponse(const AlterTableResponse& other1604) noexcept { (void) other1604; +} +AlterTableResponse& AlterTableResponse::operator=(const AlterTableResponse& other1605) noexcept { + (void) other1605; return *this; } void AlterTableResponse::printTo(std::ostream& out) const { @@ -46654,9 +46700,9 @@ uint32_t GetPartitionsFilterSpec::read(::apache::thrift::protocol::TProtocol* ip { case 7: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1605; - xfer += iprot->readI32(ecast1605); - this->filterMode = static_cast(ecast1605); + int32_t ecast1606; + xfer += iprot->readI32(ecast1606); + this->filterMode = static_cast(ecast1606); this->__isset.filterMode = true; } else { xfer += iprot->skip(ftype); @@ -46666,14 +46712,14 @@ uint32_t GetPartitionsFilterSpec::read(::apache::thrift::protocol::TProtocol* ip if (ftype == ::apache::thrift::protocol::T_LIST) { { this->filters.clear(); - uint32_t _size1606; - ::apache::thrift::protocol::TType _etype1609; - xfer += iprot->readListBegin(_etype1609, _size1606); - this->filters.resize(_size1606); - uint32_t _i1610; - for (_i1610 = 0; _i1610 < _size1606; ++_i1610) + uint32_t _size1607; + ::apache::thrift::protocol::TType _etype1610; + xfer += iprot->readListBegin(_etype1610, _size1607); + this->filters.resize(_size1607); + uint32_t _i1611; + for (_i1611 = 0; _i1611 < _size1607; ++_i1611) { - xfer += iprot->readString(this->filters[_i1610]); + xfer += iprot->readString(this->filters[_i1611]); } xfer += iprot->readListEnd(); } @@ -46708,10 +46754,10 @@ uint32_t GetPartitionsFilterSpec::write(::apache::thrift::protocol::TProtocol* o xfer += oprot->writeFieldBegin("filters", ::apache::thrift::protocol::T_LIST, 8); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->filters.size())); - std::vector ::const_iterator _iter1611; - for (_iter1611 = this->filters.begin(); _iter1611 != this->filters.end(); ++_iter1611) + std::vector ::const_iterator _iter1612; + for (_iter1612 = this->filters.begin(); _iter1612 != this->filters.end(); ++_iter1612) { - xfer += oprot->writeString((*_iter1611)); + xfer += oprot->writeString((*_iter1612)); } xfer += oprot->writeListEnd(); } @@ -46729,15 +46775,15 @@ void swap(GetPartitionsFilterSpec &a, GetPartitionsFilterSpec &b) { swap(a.__isset, b.__isset); } -GetPartitionsFilterSpec::GetPartitionsFilterSpec(const GetPartitionsFilterSpec& other1612) { - filterMode = other1612.filterMode; - filters = other1612.filters; - __isset = other1612.__isset; -} -GetPartitionsFilterSpec& GetPartitionsFilterSpec::operator=(const GetPartitionsFilterSpec& other1613) { +GetPartitionsFilterSpec::GetPartitionsFilterSpec(const GetPartitionsFilterSpec& other1613) { filterMode = other1613.filterMode; filters = other1613.filters; __isset = other1613.__isset; +} +GetPartitionsFilterSpec& GetPartitionsFilterSpec::operator=(const GetPartitionsFilterSpec& other1614) { + filterMode = other1614.filterMode; + filters = other1614.filters; + __isset = other1614.__isset; return *this; } void GetPartitionsFilterSpec::printTo(std::ostream& out) const { @@ -46788,14 +46834,14 @@ uint32_t GetPartitionsResponse::read(::apache::thrift::protocol::TProtocol* ipro if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionSpec.clear(); - uint32_t _size1614; - ::apache::thrift::protocol::TType _etype1617; - xfer += iprot->readListBegin(_etype1617, _size1614); - this->partitionSpec.resize(_size1614); - uint32_t _i1618; - for (_i1618 = 0; _i1618 < _size1614; ++_i1618) + uint32_t _size1615; + ::apache::thrift::protocol::TType _etype1618; + xfer += iprot->readListBegin(_etype1618, _size1615); + this->partitionSpec.resize(_size1615); + uint32_t _i1619; + for (_i1619 = 0; _i1619 < _size1615; ++_i1619) { - xfer += this->partitionSpec[_i1618].read(iprot); + xfer += this->partitionSpec[_i1619].read(iprot); } xfer += iprot->readListEnd(); } @@ -46824,10 +46870,10 @@ uint32_t GetPartitionsResponse::write(::apache::thrift::protocol::TProtocol* opr xfer += oprot->writeFieldBegin("partitionSpec", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitionSpec.size())); - std::vector ::const_iterator _iter1619; - for (_iter1619 = this->partitionSpec.begin(); _iter1619 != this->partitionSpec.end(); ++_iter1619) + std::vector ::const_iterator _iter1620; + for (_iter1620 = this->partitionSpec.begin(); _iter1620 != this->partitionSpec.end(); ++_iter1620) { - xfer += (*_iter1619).write(oprot); + xfer += (*_iter1620).write(oprot); } xfer += oprot->writeListEnd(); } @@ -46844,13 +46890,13 @@ void swap(GetPartitionsResponse &a, GetPartitionsResponse &b) { swap(a.__isset, b.__isset); } -GetPartitionsResponse::GetPartitionsResponse(const GetPartitionsResponse& other1620) { - partitionSpec = other1620.partitionSpec; - __isset = other1620.__isset; -} -GetPartitionsResponse& GetPartitionsResponse::operator=(const GetPartitionsResponse& other1621) { +GetPartitionsResponse::GetPartitionsResponse(const GetPartitionsResponse& other1621) { partitionSpec = other1621.partitionSpec; __isset = other1621.__isset; +} +GetPartitionsResponse& GetPartitionsResponse::operator=(const GetPartitionsResponse& other1622) { + partitionSpec = other1622.partitionSpec; + __isset = other1622.__isset; return *this; } void GetPartitionsResponse::printTo(std::ostream& out) const { @@ -46987,14 +47033,14 @@ uint32_t GetPartitionsRequest::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->groupNames.clear(); - uint32_t _size1622; - ::apache::thrift::protocol::TType _etype1625; - xfer += iprot->readListBegin(_etype1625, _size1622); - this->groupNames.resize(_size1622); - uint32_t _i1626; - for (_i1626 = 0; _i1626 < _size1622; ++_i1626) + uint32_t _size1623; + ::apache::thrift::protocol::TType _etype1626; + xfer += iprot->readListBegin(_etype1626, _size1623); + this->groupNames.resize(_size1623); + uint32_t _i1627; + for (_i1627 = 0; _i1627 < _size1623; ++_i1627) { - xfer += iprot->readString(this->groupNames[_i1626]); + xfer += iprot->readString(this->groupNames[_i1627]); } xfer += iprot->readListEnd(); } @@ -47023,14 +47069,14 @@ uint32_t GetPartitionsRequest::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->processorCapabilities.clear(); - uint32_t _size1627; - ::apache::thrift::protocol::TType _etype1630; - xfer += iprot->readListBegin(_etype1630, _size1627); - this->processorCapabilities.resize(_size1627); - uint32_t _i1631; - for (_i1631 = 0; _i1631 < _size1627; ++_i1631) + uint32_t _size1628; + ::apache::thrift::protocol::TType _etype1631; + xfer += iprot->readListBegin(_etype1631, _size1628); + this->processorCapabilities.resize(_size1628); + uint32_t _i1632; + for (_i1632 = 0; _i1632 < _size1628; ++_i1632) { - xfer += iprot->readString(this->processorCapabilities[_i1631]); + xfer += iprot->readString(this->processorCapabilities[_i1632]); } xfer += iprot->readListEnd(); } @@ -47099,10 +47145,10 @@ uint32_t GetPartitionsRequest::write(::apache::thrift::protocol::TProtocol* opro xfer += oprot->writeFieldBegin("groupNames", ::apache::thrift::protocol::T_LIST, 6); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->groupNames.size())); - std::vector ::const_iterator _iter1632; - for (_iter1632 = this->groupNames.begin(); _iter1632 != this->groupNames.end(); ++_iter1632) + std::vector ::const_iterator _iter1633; + for (_iter1633 = this->groupNames.begin(); _iter1633 != this->groupNames.end(); ++_iter1633) { - xfer += oprot->writeString((*_iter1632)); + xfer += oprot->writeString((*_iter1633)); } xfer += oprot->writeListEnd(); } @@ -47120,10 +47166,10 @@ uint32_t GetPartitionsRequest::write(::apache::thrift::protocol::TProtocol* opro xfer += oprot->writeFieldBegin("processorCapabilities", ::apache::thrift::protocol::T_LIST, 9); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->processorCapabilities.size())); - std::vector ::const_iterator _iter1633; - for (_iter1633 = this->processorCapabilities.begin(); _iter1633 != this->processorCapabilities.end(); ++_iter1633) + std::vector ::const_iterator _iter1634; + for (_iter1634 = this->processorCapabilities.begin(); _iter1634 != this->processorCapabilities.end(); ++_iter1634) { - xfer += oprot->writeString((*_iter1633)); + xfer += oprot->writeString((*_iter1634)); } xfer += oprot->writeListEnd(); } @@ -47160,21 +47206,7 @@ void swap(GetPartitionsRequest &a, GetPartitionsRequest &b) { swap(a.__isset, b.__isset); } -GetPartitionsRequest::GetPartitionsRequest(const GetPartitionsRequest& other1634) { - catName = other1634.catName; - dbName = other1634.dbName; - tblName = other1634.tblName; - withAuth = other1634.withAuth; - user = other1634.user; - groupNames = other1634.groupNames; - projectionSpec = other1634.projectionSpec; - filterSpec = other1634.filterSpec; - processorCapabilities = other1634.processorCapabilities; - processorIdentifier = other1634.processorIdentifier; - validWriteIdList = other1634.validWriteIdList; - __isset = other1634.__isset; -} -GetPartitionsRequest& GetPartitionsRequest::operator=(const GetPartitionsRequest& other1635) { +GetPartitionsRequest::GetPartitionsRequest(const GetPartitionsRequest& other1635) { catName = other1635.catName; dbName = other1635.dbName; tblName = other1635.tblName; @@ -47187,6 +47219,20 @@ GetPartitionsRequest& GetPartitionsRequest::operator=(const GetPartitionsRequest processorIdentifier = other1635.processorIdentifier; validWriteIdList = other1635.validWriteIdList; __isset = other1635.__isset; +} +GetPartitionsRequest& GetPartitionsRequest::operator=(const GetPartitionsRequest& other1636) { + catName = other1636.catName; + dbName = other1636.dbName; + tblName = other1636.tblName; + withAuth = other1636.withAuth; + user = other1636.user; + groupNames = other1636.groupNames; + projectionSpec = other1636.projectionSpec; + filterSpec = other1636.filterSpec; + processorCapabilities = other1636.processorCapabilities; + processorIdentifier = other1636.processorIdentifier; + validWriteIdList = other1636.validWriteIdList; + __isset = other1636.__isset; return *this; } void GetPartitionsRequest::printTo(std::ostream& out) const { @@ -47381,16 +47427,7 @@ void swap(GetFieldsRequest &a, GetFieldsRequest &b) { swap(a.__isset, b.__isset); } -GetFieldsRequest::GetFieldsRequest(const GetFieldsRequest& other1636) { - catName = other1636.catName; - dbName = other1636.dbName; - tblName = other1636.tblName; - envContext = other1636.envContext; - validWriteIdList = other1636.validWriteIdList; - id = other1636.id; - __isset = other1636.__isset; -} -GetFieldsRequest& GetFieldsRequest::operator=(const GetFieldsRequest& other1637) { +GetFieldsRequest::GetFieldsRequest(const GetFieldsRequest& other1637) { catName = other1637.catName; dbName = other1637.dbName; tblName = other1637.tblName; @@ -47398,6 +47435,15 @@ GetFieldsRequest& GetFieldsRequest::operator=(const GetFieldsRequest& other1637) validWriteIdList = other1637.validWriteIdList; id = other1637.id; __isset = other1637.__isset; +} +GetFieldsRequest& GetFieldsRequest::operator=(const GetFieldsRequest& other1638) { + catName = other1638.catName; + dbName = other1638.dbName; + tblName = other1638.tblName; + envContext = other1638.envContext; + validWriteIdList = other1638.validWriteIdList; + id = other1638.id; + __isset = other1638.__isset; return *this; } void GetFieldsRequest::printTo(std::ostream& out) const { @@ -47453,14 +47499,14 @@ uint32_t GetFieldsResponse::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fields.clear(); - uint32_t _size1638; - ::apache::thrift::protocol::TType _etype1641; - xfer += iprot->readListBegin(_etype1641, _size1638); - this->fields.resize(_size1638); - uint32_t _i1642; - for (_i1642 = 0; _i1642 < _size1638; ++_i1642) + uint32_t _size1639; + ::apache::thrift::protocol::TType _etype1642; + xfer += iprot->readListBegin(_etype1642, _size1639); + this->fields.resize(_size1639); + uint32_t _i1643; + for (_i1643 = 0; _i1643 < _size1639; ++_i1643) { - xfer += this->fields[_i1642].read(iprot); + xfer += this->fields[_i1643].read(iprot); } xfer += iprot->readListEnd(); } @@ -47491,10 +47537,10 @@ uint32_t GetFieldsResponse::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("fields", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->fields.size())); - std::vector ::const_iterator _iter1643; - for (_iter1643 = this->fields.begin(); _iter1643 != this->fields.end(); ++_iter1643) + std::vector ::const_iterator _iter1644; + for (_iter1644 = this->fields.begin(); _iter1644 != this->fields.end(); ++_iter1644) { - xfer += (*_iter1643).write(oprot); + xfer += (*_iter1644).write(oprot); } xfer += oprot->writeListEnd(); } @@ -47510,11 +47556,11 @@ void swap(GetFieldsResponse &a, GetFieldsResponse &b) { swap(a.fields, b.fields); } -GetFieldsResponse::GetFieldsResponse(const GetFieldsResponse& other1644) { - fields = other1644.fields; -} -GetFieldsResponse& GetFieldsResponse::operator=(const GetFieldsResponse& other1645) { +GetFieldsResponse::GetFieldsResponse(const GetFieldsResponse& other1645) { fields = other1645.fields; +} +GetFieldsResponse& GetFieldsResponse::operator=(const GetFieldsResponse& other1646) { + fields = other1646.fields; return *this; } void GetFieldsResponse::printTo(std::ostream& out) const { @@ -47699,16 +47745,7 @@ void swap(GetSchemaRequest &a, GetSchemaRequest &b) { swap(a.__isset, b.__isset); } -GetSchemaRequest::GetSchemaRequest(const GetSchemaRequest& other1646) { - catName = other1646.catName; - dbName = other1646.dbName; - tblName = other1646.tblName; - envContext = other1646.envContext; - validWriteIdList = other1646.validWriteIdList; - id = other1646.id; - __isset = other1646.__isset; -} -GetSchemaRequest& GetSchemaRequest::operator=(const GetSchemaRequest& other1647) { +GetSchemaRequest::GetSchemaRequest(const GetSchemaRequest& other1647) { catName = other1647.catName; dbName = other1647.dbName; tblName = other1647.tblName; @@ -47716,6 +47753,15 @@ GetSchemaRequest& GetSchemaRequest::operator=(const GetSchemaRequest& other1647) validWriteIdList = other1647.validWriteIdList; id = other1647.id; __isset = other1647.__isset; +} +GetSchemaRequest& GetSchemaRequest::operator=(const GetSchemaRequest& other1648) { + catName = other1648.catName; + dbName = other1648.dbName; + tblName = other1648.tblName; + envContext = other1648.envContext; + validWriteIdList = other1648.validWriteIdList; + id = other1648.id; + __isset = other1648.__isset; return *this; } void GetSchemaRequest::printTo(std::ostream& out) const { @@ -47771,14 +47817,14 @@ uint32_t GetSchemaResponse::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fields.clear(); - uint32_t _size1648; - ::apache::thrift::protocol::TType _etype1651; - xfer += iprot->readListBegin(_etype1651, _size1648); - this->fields.resize(_size1648); - uint32_t _i1652; - for (_i1652 = 0; _i1652 < _size1648; ++_i1652) + uint32_t _size1649; + ::apache::thrift::protocol::TType _etype1652; + xfer += iprot->readListBegin(_etype1652, _size1649); + this->fields.resize(_size1649); + uint32_t _i1653; + for (_i1653 = 0; _i1653 < _size1649; ++_i1653) { - xfer += this->fields[_i1652].read(iprot); + xfer += this->fields[_i1653].read(iprot); } xfer += iprot->readListEnd(); } @@ -47809,10 +47855,10 @@ uint32_t GetSchemaResponse::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("fields", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->fields.size())); - std::vector ::const_iterator _iter1653; - for (_iter1653 = this->fields.begin(); _iter1653 != this->fields.end(); ++_iter1653) + std::vector ::const_iterator _iter1654; + for (_iter1654 = this->fields.begin(); _iter1654 != this->fields.end(); ++_iter1654) { - xfer += (*_iter1653).write(oprot); + xfer += (*_iter1654).write(oprot); } xfer += oprot->writeListEnd(); } @@ -47828,11 +47874,11 @@ void swap(GetSchemaResponse &a, GetSchemaResponse &b) { swap(a.fields, b.fields); } -GetSchemaResponse::GetSchemaResponse(const GetSchemaResponse& other1654) { - fields = other1654.fields; -} -GetSchemaResponse& GetSchemaResponse::operator=(const GetSchemaResponse& other1655) { +GetSchemaResponse::GetSchemaResponse(const GetSchemaResponse& other1655) { fields = other1655.fields; +} +GetSchemaResponse& GetSchemaResponse::operator=(const GetSchemaResponse& other1656) { + fields = other1656.fields; return *this; } void GetSchemaResponse::printTo(std::ostream& out) const { @@ -47932,14 +47978,14 @@ uint32_t GetPartitionRequest::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partVals.clear(); - uint32_t _size1656; - ::apache::thrift::protocol::TType _etype1659; - xfer += iprot->readListBegin(_etype1659, _size1656); - this->partVals.resize(_size1656); - uint32_t _i1660; - for (_i1660 = 0; _i1660 < _size1656; ++_i1660) + uint32_t _size1657; + ::apache::thrift::protocol::TType _etype1660; + xfer += iprot->readListBegin(_etype1660, _size1657); + this->partVals.resize(_size1657); + uint32_t _i1661; + for (_i1661 = 0; _i1661 < _size1657; ++_i1661) { - xfer += iprot->readString(this->partVals[_i1660]); + xfer += iprot->readString(this->partVals[_i1661]); } xfer += iprot->readListEnd(); } @@ -48003,10 +48049,10 @@ uint32_t GetPartitionRequest::write(::apache::thrift::protocol::TProtocol* oprot xfer += oprot->writeFieldBegin("partVals", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partVals.size())); - std::vector ::const_iterator _iter1661; - for (_iter1661 = this->partVals.begin(); _iter1661 != this->partVals.end(); ++_iter1661) + std::vector ::const_iterator _iter1662; + for (_iter1662 = this->partVals.begin(); _iter1662 != this->partVals.end(); ++_iter1662) { - xfer += oprot->writeString((*_iter1661)); + xfer += oprot->writeString((*_iter1662)); } xfer += oprot->writeListEnd(); } @@ -48038,16 +48084,7 @@ void swap(GetPartitionRequest &a, GetPartitionRequest &b) { swap(a.__isset, b.__isset); } -GetPartitionRequest::GetPartitionRequest(const GetPartitionRequest& other1662) { - catName = other1662.catName; - dbName = other1662.dbName; - tblName = other1662.tblName; - partVals = other1662.partVals; - validWriteIdList = other1662.validWriteIdList; - id = other1662.id; - __isset = other1662.__isset; -} -GetPartitionRequest& GetPartitionRequest::operator=(const GetPartitionRequest& other1663) { +GetPartitionRequest::GetPartitionRequest(const GetPartitionRequest& other1663) { catName = other1663.catName; dbName = other1663.dbName; tblName = other1663.tblName; @@ -48055,6 +48092,15 @@ GetPartitionRequest& GetPartitionRequest::operator=(const GetPartitionRequest& o validWriteIdList = other1663.validWriteIdList; id = other1663.id; __isset = other1663.__isset; +} +GetPartitionRequest& GetPartitionRequest::operator=(const GetPartitionRequest& other1664) { + catName = other1664.catName; + dbName = other1664.dbName; + tblName = other1664.tblName; + partVals = other1664.partVals; + validWriteIdList = other1664.validWriteIdList; + id = other1664.id; + __isset = other1664.__isset; return *this; } void GetPartitionRequest::printTo(std::ostream& out) const { @@ -48147,11 +48193,11 @@ void swap(GetPartitionResponse &a, GetPartitionResponse &b) { swap(a.partition, b.partition); } -GetPartitionResponse::GetPartitionResponse(const GetPartitionResponse& other1664) { - partition = other1664.partition; -} -GetPartitionResponse& GetPartitionResponse::operator=(const GetPartitionResponse& other1665) { +GetPartitionResponse::GetPartitionResponse(const GetPartitionResponse& other1665) { partition = other1665.partition; +} +GetPartitionResponse& GetPartitionResponse::operator=(const GetPartitionResponse& other1666) { + partition = other1666.partition; return *this; } void GetPartitionResponse::printTo(std::ostream& out) const { @@ -48336,16 +48382,7 @@ void swap(PartitionsRequest &a, PartitionsRequest &b) { swap(a.__isset, b.__isset); } -PartitionsRequest::PartitionsRequest(const PartitionsRequest& other1666) { - catName = other1666.catName; - dbName = other1666.dbName; - tblName = other1666.tblName; - maxParts = other1666.maxParts; - validWriteIdList = other1666.validWriteIdList; - id = other1666.id; - __isset = other1666.__isset; -} -PartitionsRequest& PartitionsRequest::operator=(const PartitionsRequest& other1667) { +PartitionsRequest::PartitionsRequest(const PartitionsRequest& other1667) { catName = other1667.catName; dbName = other1667.dbName; tblName = other1667.tblName; @@ -48353,6 +48390,15 @@ PartitionsRequest& PartitionsRequest::operator=(const PartitionsRequest& other16 validWriteIdList = other1667.validWriteIdList; id = other1667.id; __isset = other1667.__isset; +} +PartitionsRequest& PartitionsRequest::operator=(const PartitionsRequest& other1668) { + catName = other1668.catName; + dbName = other1668.dbName; + tblName = other1668.tblName; + maxParts = other1668.maxParts; + validWriteIdList = other1668.validWriteIdList; + id = other1668.id; + __isset = other1668.__isset; return *this; } void PartitionsRequest::printTo(std::ostream& out) const { @@ -48408,14 +48454,14 @@ uint32_t PartitionsResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size1668; - ::apache::thrift::protocol::TType _etype1671; - xfer += iprot->readListBegin(_etype1671, _size1668); - this->partitions.resize(_size1668); - uint32_t _i1672; - for (_i1672 = 0; _i1672 < _size1668; ++_i1672) + uint32_t _size1669; + ::apache::thrift::protocol::TType _etype1672; + xfer += iprot->readListBegin(_etype1672, _size1669); + this->partitions.resize(_size1669); + uint32_t _i1673; + for (_i1673 = 0; _i1673 < _size1669; ++_i1673) { - xfer += this->partitions[_i1672].read(iprot); + xfer += this->partitions[_i1673].read(iprot); } xfer += iprot->readListEnd(); } @@ -48446,10 +48492,10 @@ uint32_t PartitionsResponse::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitions.size())); - std::vector ::const_iterator _iter1673; - for (_iter1673 = this->partitions.begin(); _iter1673 != this->partitions.end(); ++_iter1673) + std::vector ::const_iterator _iter1674; + for (_iter1674 = this->partitions.begin(); _iter1674 != this->partitions.end(); ++_iter1674) { - xfer += (*_iter1673).write(oprot); + xfer += (*_iter1674).write(oprot); } xfer += oprot->writeListEnd(); } @@ -48465,11 +48511,11 @@ void swap(PartitionsResponse &a, PartitionsResponse &b) { swap(a.partitions, b.partitions); } -PartitionsResponse::PartitionsResponse(const PartitionsResponse& other1674) { - partitions = other1674.partitions; -} -PartitionsResponse& PartitionsResponse::operator=(const PartitionsResponse& other1675) { +PartitionsResponse::PartitionsResponse(const PartitionsResponse& other1675) { partitions = other1675.partitions; +} +PartitionsResponse& PartitionsResponse::operator=(const PartitionsResponse& other1676) { + partitions = other1676.partitions; return *this; } void PartitionsResponse::printTo(std::ostream& out) const { @@ -48574,14 +48620,14 @@ uint32_t GetPartitionNamesPsRequest::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partValues.clear(); - uint32_t _size1676; - ::apache::thrift::protocol::TType _etype1679; - xfer += iprot->readListBegin(_etype1679, _size1676); - this->partValues.resize(_size1676); - uint32_t _i1680; - for (_i1680 = 0; _i1680 < _size1676; ++_i1680) + uint32_t _size1677; + ::apache::thrift::protocol::TType _etype1680; + xfer += iprot->readListBegin(_etype1680, _size1677); + this->partValues.resize(_size1677); + uint32_t _i1681; + for (_i1681 = 0; _i1681 < _size1677; ++_i1681) { - xfer += iprot->readString(this->partValues[_i1680]); + xfer += iprot->readString(this->partValues[_i1681]); } xfer += iprot->readListEnd(); } @@ -48652,10 +48698,10 @@ uint32_t GetPartitionNamesPsRequest::write(::apache::thrift::protocol::TProtocol xfer += oprot->writeFieldBegin("partValues", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partValues.size())); - std::vector ::const_iterator _iter1681; - for (_iter1681 = this->partValues.begin(); _iter1681 != this->partValues.end(); ++_iter1681) + std::vector ::const_iterator _iter1682; + for (_iter1682 = this->partValues.begin(); _iter1682 != this->partValues.end(); ++_iter1682) { - xfer += oprot->writeString((*_iter1681)); + xfer += oprot->writeString((*_iter1682)); } xfer += oprot->writeListEnd(); } @@ -48693,17 +48739,7 @@ void swap(GetPartitionNamesPsRequest &a, GetPartitionNamesPsRequest &b) { swap(a.__isset, b.__isset); } -GetPartitionNamesPsRequest::GetPartitionNamesPsRequest(const GetPartitionNamesPsRequest& other1682) { - catName = other1682.catName; - dbName = other1682.dbName; - tblName = other1682.tblName; - partValues = other1682.partValues; - maxParts = other1682.maxParts; - validWriteIdList = other1682.validWriteIdList; - id = other1682.id; - __isset = other1682.__isset; -} -GetPartitionNamesPsRequest& GetPartitionNamesPsRequest::operator=(const GetPartitionNamesPsRequest& other1683) { +GetPartitionNamesPsRequest::GetPartitionNamesPsRequest(const GetPartitionNamesPsRequest& other1683) { catName = other1683.catName; dbName = other1683.dbName; tblName = other1683.tblName; @@ -48712,6 +48748,16 @@ GetPartitionNamesPsRequest& GetPartitionNamesPsRequest::operator=(const GetParti validWriteIdList = other1683.validWriteIdList; id = other1683.id; __isset = other1683.__isset; +} +GetPartitionNamesPsRequest& GetPartitionNamesPsRequest::operator=(const GetPartitionNamesPsRequest& other1684) { + catName = other1684.catName; + dbName = other1684.dbName; + tblName = other1684.tblName; + partValues = other1684.partValues; + maxParts = other1684.maxParts; + validWriteIdList = other1684.validWriteIdList; + id = other1684.id; + __isset = other1684.__isset; return *this; } void GetPartitionNamesPsRequest::printTo(std::ostream& out) const { @@ -48768,14 +48814,14 @@ uint32_t GetPartitionNamesPsResponse::read(::apache::thrift::protocol::TProtocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->names.clear(); - uint32_t _size1684; - ::apache::thrift::protocol::TType _etype1687; - xfer += iprot->readListBegin(_etype1687, _size1684); - this->names.resize(_size1684); - uint32_t _i1688; - for (_i1688 = 0; _i1688 < _size1684; ++_i1688) + uint32_t _size1685; + ::apache::thrift::protocol::TType _etype1688; + xfer += iprot->readListBegin(_etype1688, _size1685); + this->names.resize(_size1685); + uint32_t _i1689; + for (_i1689 = 0; _i1689 < _size1685; ++_i1689) { - xfer += iprot->readString(this->names[_i1688]); + xfer += iprot->readString(this->names[_i1689]); } xfer += iprot->readListEnd(); } @@ -48806,10 +48852,10 @@ uint32_t GetPartitionNamesPsResponse::write(::apache::thrift::protocol::TProtoco 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 _iter1689; - for (_iter1689 = this->names.begin(); _iter1689 != this->names.end(); ++_iter1689) + std::vector ::const_iterator _iter1690; + for (_iter1690 = this->names.begin(); _iter1690 != this->names.end(); ++_iter1690) { - xfer += oprot->writeString((*_iter1689)); + xfer += oprot->writeString((*_iter1690)); } xfer += oprot->writeListEnd(); } @@ -48825,11 +48871,11 @@ void swap(GetPartitionNamesPsResponse &a, GetPartitionNamesPsResponse &b) { swap(a.names, b.names); } -GetPartitionNamesPsResponse::GetPartitionNamesPsResponse(const GetPartitionNamesPsResponse& other1690) { - names = other1690.names; -} -GetPartitionNamesPsResponse& GetPartitionNamesPsResponse::operator=(const GetPartitionNamesPsResponse& other1691) { +GetPartitionNamesPsResponse::GetPartitionNamesPsResponse(const GetPartitionNamesPsResponse& other1691) { names = other1691.names; +} +GetPartitionNamesPsResponse& GetPartitionNamesPsResponse::operator=(const GetPartitionNamesPsResponse& other1692) { + names = other1692.names; return *this; } void GetPartitionNamesPsResponse::printTo(std::ostream& out) const { @@ -48944,14 +48990,14 @@ uint32_t GetPartitionsPsWithAuthRequest::read(::apache::thrift::protocol::TProto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partVals.clear(); - uint32_t _size1692; - ::apache::thrift::protocol::TType _etype1695; - xfer += iprot->readListBegin(_etype1695, _size1692); - this->partVals.resize(_size1692); - uint32_t _i1696; - for (_i1696 = 0; _i1696 < _size1692; ++_i1696) + uint32_t _size1693; + ::apache::thrift::protocol::TType _etype1696; + xfer += iprot->readListBegin(_etype1696, _size1693); + this->partVals.resize(_size1693); + uint32_t _i1697; + for (_i1697 = 0; _i1697 < _size1693; ++_i1697) { - xfer += iprot->readString(this->partVals[_i1696]); + xfer += iprot->readString(this->partVals[_i1697]); } xfer += iprot->readListEnd(); } @@ -48980,14 +49026,14 @@ uint32_t GetPartitionsPsWithAuthRequest::read(::apache::thrift::protocol::TProto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->groupNames.clear(); - uint32_t _size1697; - ::apache::thrift::protocol::TType _etype1700; - xfer += iprot->readListBegin(_etype1700, _size1697); - this->groupNames.resize(_size1697); - uint32_t _i1701; - for (_i1701 = 0; _i1701 < _size1697; ++_i1701) + uint32_t _size1698; + ::apache::thrift::protocol::TType _etype1701; + xfer += iprot->readListBegin(_etype1701, _size1698); + this->groupNames.resize(_size1698); + uint32_t _i1702; + for (_i1702 = 0; _i1702 < _size1698; ++_i1702) { - xfer += iprot->readString(this->groupNames[_i1701]); + xfer += iprot->readString(this->groupNames[_i1702]); } xfer += iprot->readListEnd(); } @@ -49050,10 +49096,10 @@ uint32_t GetPartitionsPsWithAuthRequest::write(::apache::thrift::protocol::TProt xfer += oprot->writeFieldBegin("partVals", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partVals.size())); - std::vector ::const_iterator _iter1702; - for (_iter1702 = this->partVals.begin(); _iter1702 != this->partVals.end(); ++_iter1702) + std::vector ::const_iterator _iter1703; + for (_iter1703 = this->partVals.begin(); _iter1703 != this->partVals.end(); ++_iter1703) { - xfer += oprot->writeString((*_iter1702)); + xfer += oprot->writeString((*_iter1703)); } xfer += oprot->writeListEnd(); } @@ -49073,10 +49119,10 @@ uint32_t GetPartitionsPsWithAuthRequest::write(::apache::thrift::protocol::TProt xfer += oprot->writeFieldBegin("groupNames", ::apache::thrift::protocol::T_LIST, 7); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->groupNames.size())); - std::vector ::const_iterator _iter1703; - for (_iter1703 = this->groupNames.begin(); _iter1703 != this->groupNames.end(); ++_iter1703) + std::vector ::const_iterator _iter1704; + for (_iter1704 = this->groupNames.begin(); _iter1704 != this->groupNames.end(); ++_iter1704) { - xfer += oprot->writeString((*_iter1703)); + xfer += oprot->writeString((*_iter1704)); } xfer += oprot->writeListEnd(); } @@ -49111,19 +49157,7 @@ void swap(GetPartitionsPsWithAuthRequest &a, GetPartitionsPsWithAuthRequest &b) swap(a.__isset, b.__isset); } -GetPartitionsPsWithAuthRequest::GetPartitionsPsWithAuthRequest(const GetPartitionsPsWithAuthRequest& other1704) { - catName = other1704.catName; - dbName = other1704.dbName; - tblName = other1704.tblName; - partVals = other1704.partVals; - maxParts = other1704.maxParts; - userName = other1704.userName; - groupNames = other1704.groupNames; - validWriteIdList = other1704.validWriteIdList; - id = other1704.id; - __isset = other1704.__isset; -} -GetPartitionsPsWithAuthRequest& GetPartitionsPsWithAuthRequest::operator=(const GetPartitionsPsWithAuthRequest& other1705) { +GetPartitionsPsWithAuthRequest::GetPartitionsPsWithAuthRequest(const GetPartitionsPsWithAuthRequest& other1705) { catName = other1705.catName; dbName = other1705.dbName; tblName = other1705.tblName; @@ -49134,6 +49168,18 @@ GetPartitionsPsWithAuthRequest& GetPartitionsPsWithAuthRequest::operator=(const validWriteIdList = other1705.validWriteIdList; id = other1705.id; __isset = other1705.__isset; +} +GetPartitionsPsWithAuthRequest& GetPartitionsPsWithAuthRequest::operator=(const GetPartitionsPsWithAuthRequest& other1706) { + catName = other1706.catName; + dbName = other1706.dbName; + tblName = other1706.tblName; + partVals = other1706.partVals; + maxParts = other1706.maxParts; + userName = other1706.userName; + groupNames = other1706.groupNames; + validWriteIdList = other1706.validWriteIdList; + id = other1706.id; + __isset = other1706.__isset; return *this; } void GetPartitionsPsWithAuthRequest::printTo(std::ostream& out) const { @@ -49192,14 +49238,14 @@ uint32_t GetPartitionsPsWithAuthResponse::read(::apache::thrift::protocol::TProt if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size1706; - ::apache::thrift::protocol::TType _etype1709; - xfer += iprot->readListBegin(_etype1709, _size1706); - this->partitions.resize(_size1706); - uint32_t _i1710; - for (_i1710 = 0; _i1710 < _size1706; ++_i1710) + uint32_t _size1707; + ::apache::thrift::protocol::TType _etype1710; + xfer += iprot->readListBegin(_etype1710, _size1707); + this->partitions.resize(_size1707); + uint32_t _i1711; + for (_i1711 = 0; _i1711 < _size1707; ++_i1711) { - xfer += this->partitions[_i1710].read(iprot); + xfer += this->partitions[_i1711].read(iprot); } xfer += iprot->readListEnd(); } @@ -49230,10 +49276,10 @@ uint32_t GetPartitionsPsWithAuthResponse::write(::apache::thrift::protocol::TPro 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 _iter1711; - for (_iter1711 = this->partitions.begin(); _iter1711 != this->partitions.end(); ++_iter1711) + std::vector ::const_iterator _iter1712; + for (_iter1712 = this->partitions.begin(); _iter1712 != this->partitions.end(); ++_iter1712) { - xfer += (*_iter1711).write(oprot); + xfer += (*_iter1712).write(oprot); } xfer += oprot->writeListEnd(); } @@ -49249,11 +49295,11 @@ void swap(GetPartitionsPsWithAuthResponse &a, GetPartitionsPsWithAuthResponse &b swap(a.partitions, b.partitions); } -GetPartitionsPsWithAuthResponse::GetPartitionsPsWithAuthResponse(const GetPartitionsPsWithAuthResponse& other1712) { - partitions = other1712.partitions; -} -GetPartitionsPsWithAuthResponse& GetPartitionsPsWithAuthResponse::operator=(const GetPartitionsPsWithAuthResponse& other1713) { +GetPartitionsPsWithAuthResponse::GetPartitionsPsWithAuthResponse(const GetPartitionsPsWithAuthResponse& other1713) { partitions = other1713.partitions; +} +GetPartitionsPsWithAuthResponse& GetPartitionsPsWithAuthResponse::operator=(const GetPartitionsPsWithAuthResponse& other1714) { + partitions = other1714.partitions; return *this; } void GetPartitionsPsWithAuthResponse::printTo(std::ostream& out) const { @@ -49439,16 +49485,7 @@ void swap(ReplicationMetrics &a, ReplicationMetrics &b) { swap(a.__isset, b.__isset); } -ReplicationMetrics::ReplicationMetrics(const ReplicationMetrics& other1714) { - scheduledExecutionId = other1714.scheduledExecutionId; - policy = other1714.policy; - dumpExecutionId = other1714.dumpExecutionId; - metadata = other1714.metadata; - progress = other1714.progress; - messageFormat = other1714.messageFormat; - __isset = other1714.__isset; -} -ReplicationMetrics& ReplicationMetrics::operator=(const ReplicationMetrics& other1715) { +ReplicationMetrics::ReplicationMetrics(const ReplicationMetrics& other1715) { scheduledExecutionId = other1715.scheduledExecutionId; policy = other1715.policy; dumpExecutionId = other1715.dumpExecutionId; @@ -49456,6 +49493,15 @@ ReplicationMetrics& ReplicationMetrics::operator=(const ReplicationMetrics& othe progress = other1715.progress; messageFormat = other1715.messageFormat; __isset = other1715.__isset; +} +ReplicationMetrics& ReplicationMetrics::operator=(const ReplicationMetrics& other1716) { + scheduledExecutionId = other1716.scheduledExecutionId; + policy = other1716.policy; + dumpExecutionId = other1716.dumpExecutionId; + metadata = other1716.metadata; + progress = other1716.progress; + messageFormat = other1716.messageFormat; + __isset = other1716.__isset; return *this; } void ReplicationMetrics::printTo(std::ostream& out) const { @@ -49511,14 +49557,14 @@ uint32_t ReplicationMetricList::read(::apache::thrift::protocol::TProtocol* ipro if (ftype == ::apache::thrift::protocol::T_LIST) { { this->replicationMetricList.clear(); - uint32_t _size1716; - ::apache::thrift::protocol::TType _etype1719; - xfer += iprot->readListBegin(_etype1719, _size1716); - this->replicationMetricList.resize(_size1716); - uint32_t _i1720; - for (_i1720 = 0; _i1720 < _size1716; ++_i1720) + uint32_t _size1717; + ::apache::thrift::protocol::TType _etype1720; + xfer += iprot->readListBegin(_etype1720, _size1717); + this->replicationMetricList.resize(_size1717); + uint32_t _i1721; + for (_i1721 = 0; _i1721 < _size1717; ++_i1721) { - xfer += this->replicationMetricList[_i1720].read(iprot); + xfer += this->replicationMetricList[_i1721].read(iprot); } xfer += iprot->readListEnd(); } @@ -49549,10 +49595,10 @@ uint32_t ReplicationMetricList::write(::apache::thrift::protocol::TProtocol* opr xfer += oprot->writeFieldBegin("replicationMetricList", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->replicationMetricList.size())); - std::vector ::const_iterator _iter1721; - for (_iter1721 = this->replicationMetricList.begin(); _iter1721 != this->replicationMetricList.end(); ++_iter1721) + std::vector ::const_iterator _iter1722; + for (_iter1722 = this->replicationMetricList.begin(); _iter1722 != this->replicationMetricList.end(); ++_iter1722) { - xfer += (*_iter1721).write(oprot); + xfer += (*_iter1722).write(oprot); } xfer += oprot->writeListEnd(); } @@ -49568,11 +49614,11 @@ void swap(ReplicationMetricList &a, ReplicationMetricList &b) { swap(a.replicationMetricList, b.replicationMetricList); } -ReplicationMetricList::ReplicationMetricList(const ReplicationMetricList& other1722) { - replicationMetricList = other1722.replicationMetricList; -} -ReplicationMetricList& ReplicationMetricList::operator=(const ReplicationMetricList& other1723) { +ReplicationMetricList::ReplicationMetricList(const ReplicationMetricList& other1723) { replicationMetricList = other1723.replicationMetricList; +} +ReplicationMetricList& ReplicationMetricList::operator=(const ReplicationMetricList& other1724) { + replicationMetricList = other1724.replicationMetricList; return *this; } void ReplicationMetricList::printTo(std::ostream& out) const { @@ -49698,17 +49744,17 @@ void swap(GetReplicationMetricsRequest &a, GetReplicationMetricsRequest &b) { swap(a.__isset, b.__isset); } -GetReplicationMetricsRequest::GetReplicationMetricsRequest(const GetReplicationMetricsRequest& other1724) { - scheduledExecutionId = other1724.scheduledExecutionId; - policy = other1724.policy; - dumpExecutionId = other1724.dumpExecutionId; - __isset = other1724.__isset; -} -GetReplicationMetricsRequest& GetReplicationMetricsRequest::operator=(const GetReplicationMetricsRequest& other1725) { +GetReplicationMetricsRequest::GetReplicationMetricsRequest(const GetReplicationMetricsRequest& other1725) { scheduledExecutionId = other1725.scheduledExecutionId; policy = other1725.policy; dumpExecutionId = other1725.dumpExecutionId; __isset = other1725.__isset; +} +GetReplicationMetricsRequest& GetReplicationMetricsRequest::operator=(const GetReplicationMetricsRequest& other1726) { + scheduledExecutionId = other1726.scheduledExecutionId; + policy = other1726.policy; + dumpExecutionId = other1726.dumpExecutionId; + __isset = other1726.__isset; return *this; } void GetReplicationMetricsRequest::printTo(std::ostream& out) const { @@ -49761,16 +49807,16 @@ uint32_t GetOpenTxnsRequest::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->excludeTxnTypes.clear(); - uint32_t _size1726; - ::apache::thrift::protocol::TType _etype1729; - xfer += iprot->readListBegin(_etype1729, _size1726); - this->excludeTxnTypes.resize(_size1726); - uint32_t _i1730; - for (_i1730 = 0; _i1730 < _size1726; ++_i1730) + uint32_t _size1727; + ::apache::thrift::protocol::TType _etype1730; + xfer += iprot->readListBegin(_etype1730, _size1727); + this->excludeTxnTypes.resize(_size1727); + uint32_t _i1731; + for (_i1731 = 0; _i1731 < _size1727; ++_i1731) { - int32_t ecast1731; - xfer += iprot->readI32(ecast1731); - this->excludeTxnTypes[_i1730] = static_cast(ecast1731); + int32_t ecast1732; + xfer += iprot->readI32(ecast1732); + this->excludeTxnTypes[_i1731] = static_cast(ecast1732); } xfer += iprot->readListEnd(); } @@ -49800,10 +49846,10 @@ uint32_t GetOpenTxnsRequest::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("excludeTxnTypes", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I32, static_cast(this->excludeTxnTypes.size())); - std::vector ::const_iterator _iter1732; - for (_iter1732 = this->excludeTxnTypes.begin(); _iter1732 != this->excludeTxnTypes.end(); ++_iter1732) + std::vector ::const_iterator _iter1733; + for (_iter1733 = this->excludeTxnTypes.begin(); _iter1733 != this->excludeTxnTypes.end(); ++_iter1733) { - xfer += oprot->writeI32(static_cast((*_iter1732))); + xfer += oprot->writeI32(static_cast((*_iter1733))); } xfer += oprot->writeListEnd(); } @@ -49820,13 +49866,13 @@ void swap(GetOpenTxnsRequest &a, GetOpenTxnsRequest &b) { swap(a.__isset, b.__isset); } -GetOpenTxnsRequest::GetOpenTxnsRequest(const GetOpenTxnsRequest& other1733) { - excludeTxnTypes = other1733.excludeTxnTypes; - __isset = other1733.__isset; -} -GetOpenTxnsRequest& GetOpenTxnsRequest::operator=(const GetOpenTxnsRequest& other1734) { +GetOpenTxnsRequest::GetOpenTxnsRequest(const GetOpenTxnsRequest& other1734) { excludeTxnTypes = other1734.excludeTxnTypes; __isset = other1734.__isset; +} +GetOpenTxnsRequest& GetOpenTxnsRequest::operator=(const GetOpenTxnsRequest& other1735) { + excludeTxnTypes = other1735.excludeTxnTypes; + __isset = other1735.__isset; return *this; } void GetOpenTxnsRequest::printTo(std::ostream& out) const { @@ -49954,15 +50000,15 @@ void swap(StoredProcedureRequest &a, StoredProcedureRequest &b) { swap(a.procName, b.procName); } -StoredProcedureRequest::StoredProcedureRequest(const StoredProcedureRequest& other1735) { - catName = other1735.catName; - dbName = other1735.dbName; - procName = other1735.procName; -} -StoredProcedureRequest& StoredProcedureRequest::operator=(const StoredProcedureRequest& other1736) { +StoredProcedureRequest::StoredProcedureRequest(const StoredProcedureRequest& other1736) { catName = other1736.catName; dbName = other1736.dbName; procName = other1736.procName; +} +StoredProcedureRequest& StoredProcedureRequest::operator=(const StoredProcedureRequest& other1737) { + catName = other1737.catName; + dbName = other1737.dbName; + procName = other1737.procName; return *this; } void StoredProcedureRequest::printTo(std::ostream& out) const { @@ -50072,15 +50118,15 @@ void swap(ListStoredProcedureRequest &a, ListStoredProcedureRequest &b) { swap(a.__isset, b.__isset); } -ListStoredProcedureRequest::ListStoredProcedureRequest(const ListStoredProcedureRequest& other1737) { - catName = other1737.catName; - dbName = other1737.dbName; - __isset = other1737.__isset; -} -ListStoredProcedureRequest& ListStoredProcedureRequest::operator=(const ListStoredProcedureRequest& other1738) { +ListStoredProcedureRequest::ListStoredProcedureRequest(const ListStoredProcedureRequest& other1738) { catName = other1738.catName; dbName = other1738.dbName; __isset = other1738.__isset; +} +ListStoredProcedureRequest& ListStoredProcedureRequest::operator=(const ListStoredProcedureRequest& other1739) { + catName = other1739.catName; + dbName = other1739.dbName; + __isset = other1739.__isset; return *this; } void ListStoredProcedureRequest::printTo(std::ostream& out) const { @@ -50235,21 +50281,21 @@ void swap(StoredProcedure &a, StoredProcedure &b) { swap(a.__isset, b.__isset); } -StoredProcedure::StoredProcedure(const StoredProcedure& other1739) { - name = other1739.name; - dbName = other1739.dbName; - catName = other1739.catName; - ownerName = other1739.ownerName; - source = other1739.source; - __isset = other1739.__isset; -} -StoredProcedure& StoredProcedure::operator=(const StoredProcedure& other1740) { +StoredProcedure::StoredProcedure(const StoredProcedure& other1740) { name = other1740.name; dbName = other1740.dbName; catName = other1740.catName; ownerName = other1740.ownerName; source = other1740.source; __isset = other1740.__isset; +} +StoredProcedure& StoredProcedure::operator=(const StoredProcedure& other1741) { + name = other1741.name; + dbName = other1741.dbName; + catName = other1741.catName; + ownerName = other1741.ownerName; + source = other1741.source; + __isset = other1741.__isset; return *this; } void StoredProcedure::printTo(std::ostream& out) const { @@ -50424,16 +50470,7 @@ void swap(AddPackageRequest &a, AddPackageRequest &b) { swap(a.__isset, b.__isset); } -AddPackageRequest::AddPackageRequest(const AddPackageRequest& other1741) { - catName = other1741.catName; - dbName = other1741.dbName; - packageName = other1741.packageName; - ownerName = other1741.ownerName; - header = other1741.header; - body = other1741.body; - __isset = other1741.__isset; -} -AddPackageRequest& AddPackageRequest::operator=(const AddPackageRequest& other1742) { +AddPackageRequest::AddPackageRequest(const AddPackageRequest& other1742) { catName = other1742.catName; dbName = other1742.dbName; packageName = other1742.packageName; @@ -50441,6 +50478,15 @@ AddPackageRequest& AddPackageRequest::operator=(const AddPackageRequest& other17 header = other1742.header; body = other1742.body; __isset = other1742.__isset; +} +AddPackageRequest& AddPackageRequest::operator=(const AddPackageRequest& other1743) { + catName = other1743.catName; + dbName = other1743.dbName; + packageName = other1743.packageName; + ownerName = other1743.ownerName; + header = other1743.header; + body = other1743.body; + __isset = other1743.__isset; return *this; } void AddPackageRequest::printTo(std::ostream& out) const { @@ -50573,15 +50619,15 @@ void swap(GetPackageRequest &a, GetPackageRequest &b) { swap(a.packageName, b.packageName); } -GetPackageRequest::GetPackageRequest(const GetPackageRequest& other1743) { - catName = other1743.catName; - dbName = other1743.dbName; - packageName = other1743.packageName; -} -GetPackageRequest& GetPackageRequest::operator=(const GetPackageRequest& other1744) { +GetPackageRequest::GetPackageRequest(const GetPackageRequest& other1744) { catName = other1744.catName; dbName = other1744.dbName; packageName = other1744.packageName; +} +GetPackageRequest& GetPackageRequest::operator=(const GetPackageRequest& other1745) { + catName = other1745.catName; + dbName = other1745.dbName; + packageName = other1745.packageName; return *this; } void GetPackageRequest::printTo(std::ostream& out) const { @@ -50711,15 +50757,15 @@ void swap(DropPackageRequest &a, DropPackageRequest &b) { swap(a.packageName, b.packageName); } -DropPackageRequest::DropPackageRequest(const DropPackageRequest& other1745) { - catName = other1745.catName; - dbName = other1745.dbName; - packageName = other1745.packageName; -} -DropPackageRequest& DropPackageRequest::operator=(const DropPackageRequest& other1746) { +DropPackageRequest::DropPackageRequest(const DropPackageRequest& other1746) { catName = other1746.catName; dbName = other1746.dbName; packageName = other1746.packageName; +} +DropPackageRequest& DropPackageRequest::operator=(const DropPackageRequest& other1747) { + catName = other1747.catName; + dbName = other1747.dbName; + packageName = other1747.packageName; return *this; } void DropPackageRequest::printTo(std::ostream& out) const { @@ -50829,15 +50875,15 @@ void swap(ListPackageRequest &a, ListPackageRequest &b) { swap(a.__isset, b.__isset); } -ListPackageRequest::ListPackageRequest(const ListPackageRequest& other1747) { - catName = other1747.catName; - dbName = other1747.dbName; - __isset = other1747.__isset; -} -ListPackageRequest& ListPackageRequest::operator=(const ListPackageRequest& other1748) { +ListPackageRequest::ListPackageRequest(const ListPackageRequest& other1748) { catName = other1748.catName; dbName = other1748.dbName; __isset = other1748.__isset; +} +ListPackageRequest& ListPackageRequest::operator=(const ListPackageRequest& other1749) { + catName = other1749.catName; + dbName = other1749.dbName; + __isset = other1749.__isset; return *this; } void ListPackageRequest::printTo(std::ostream& out) const { @@ -51009,16 +51055,7 @@ void swap(Package &a, Package &b) { swap(a.__isset, b.__isset); } -Package::Package(const Package& other1749) { - catName = other1749.catName; - dbName = other1749.dbName; - packageName = other1749.packageName; - ownerName = other1749.ownerName; - header = other1749.header; - body = other1749.body; - __isset = other1749.__isset; -} -Package& Package::operator=(const Package& other1750) { +Package::Package(const Package& other1750) { catName = other1750.catName; dbName = other1750.dbName; packageName = other1750.packageName; @@ -51026,6 +51063,15 @@ Package& Package::operator=(const Package& other1750) { header = other1750.header; body = other1750.body; __isset = other1750.__isset; +} +Package& Package::operator=(const Package& other1751) { + catName = other1751.catName; + dbName = other1751.dbName; + packageName = other1751.packageName; + ownerName = other1751.ownerName; + header = other1751.header; + body = other1751.body; + __isset = other1751.__isset; return *this; } void Package::printTo(std::ostream& out) const { @@ -51157,17 +51203,17 @@ void swap(GetAllWriteEventInfoRequest &a, GetAllWriteEventInfoRequest &b) { swap(a.__isset, b.__isset); } -GetAllWriteEventInfoRequest::GetAllWriteEventInfoRequest(const GetAllWriteEventInfoRequest& other1751) { - txnId = other1751.txnId; - dbName = other1751.dbName; - tableName = other1751.tableName; - __isset = other1751.__isset; -} -GetAllWriteEventInfoRequest& GetAllWriteEventInfoRequest::operator=(const GetAllWriteEventInfoRequest& other1752) { +GetAllWriteEventInfoRequest::GetAllWriteEventInfoRequest(const GetAllWriteEventInfoRequest& other1752) { txnId = other1752.txnId; dbName = other1752.dbName; tableName = other1752.tableName; __isset = other1752.__isset; +} +GetAllWriteEventInfoRequest& GetAllWriteEventInfoRequest::operator=(const GetAllWriteEventInfoRequest& other1753) { + txnId = other1753.txnId; + dbName = other1753.dbName; + tableName = other1753.tableName; + __isset = other1753.__isset; return *this; } void GetAllWriteEventInfoRequest::printTo(std::ostream& out) const { @@ -51255,13 +51301,13 @@ void swap(MetaException &a, MetaException &b) { swap(a.__isset, b.__isset); } -MetaException::MetaException(const MetaException& other1753) : TException() { - message = other1753.message; - __isset = other1753.__isset; -} -MetaException& MetaException::operator=(const MetaException& other1754) { +MetaException::MetaException(const MetaException& other1754) : TException() { message = other1754.message; __isset = other1754.__isset; +} +MetaException& MetaException::operator=(const MetaException& other1755) { + message = other1755.message; + __isset = other1755.__isset; return *this; } void MetaException::printTo(std::ostream& out) const { @@ -51358,13 +51404,13 @@ void swap(UnknownTableException &a, UnknownTableException &b) { swap(a.__isset, b.__isset); } -UnknownTableException::UnknownTableException(const UnknownTableException& other1755) : TException() { - message = other1755.message; - __isset = other1755.__isset; -} -UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other1756) { +UnknownTableException::UnknownTableException(const UnknownTableException& other1756) : TException() { message = other1756.message; __isset = other1756.__isset; +} +UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other1757) { + message = other1757.message; + __isset = other1757.__isset; return *this; } void UnknownTableException::printTo(std::ostream& out) const { @@ -51461,13 +51507,13 @@ void swap(UnknownDBException &a, UnknownDBException &b) { swap(a.__isset, b.__isset); } -UnknownDBException::UnknownDBException(const UnknownDBException& other1757) : TException() { - message = other1757.message; - __isset = other1757.__isset; -} -UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other1758) { +UnknownDBException::UnknownDBException(const UnknownDBException& other1758) : TException() { message = other1758.message; __isset = other1758.__isset; +} +UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other1759) { + message = other1759.message; + __isset = other1759.__isset; return *this; } void UnknownDBException::printTo(std::ostream& out) const { @@ -51564,13 +51610,13 @@ void swap(AlreadyExistsException &a, AlreadyExistsException &b) { swap(a.__isset, b.__isset); } -AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other1759) : TException() { - message = other1759.message; - __isset = other1759.__isset; -} -AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other1760) { +AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other1760) : TException() { message = other1760.message; __isset = other1760.__isset; +} +AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other1761) { + message = other1761.message; + __isset = other1761.__isset; return *this; } void AlreadyExistsException::printTo(std::ostream& out) const { @@ -51667,13 +51713,13 @@ void swap(InvalidPartitionException &a, InvalidPartitionException &b) { swap(a.__isset, b.__isset); } -InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other1761) : TException() { - message = other1761.message; - __isset = other1761.__isset; -} -InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other1762) { +InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other1762) : TException() { message = other1762.message; __isset = other1762.__isset; +} +InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other1763) { + message = other1763.message; + __isset = other1763.__isset; return *this; } void InvalidPartitionException::printTo(std::ostream& out) const { @@ -51770,13 +51816,13 @@ void swap(UnknownPartitionException &a, UnknownPartitionException &b) { swap(a.__isset, b.__isset); } -UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other1763) : TException() { - message = other1763.message; - __isset = other1763.__isset; -} -UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other1764) { +UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other1764) : TException() { message = other1764.message; __isset = other1764.__isset; +} +UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other1765) { + message = other1765.message; + __isset = other1765.__isset; return *this; } void UnknownPartitionException::printTo(std::ostream& out) const { @@ -51873,13 +51919,13 @@ void swap(InvalidObjectException &a, InvalidObjectException &b) { swap(a.__isset, b.__isset); } -InvalidObjectException::InvalidObjectException(const InvalidObjectException& other1765) : TException() { - message = other1765.message; - __isset = other1765.__isset; -} -InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other1766) { +InvalidObjectException::InvalidObjectException(const InvalidObjectException& other1766) : TException() { message = other1766.message; __isset = other1766.__isset; +} +InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other1767) { + message = other1767.message; + __isset = other1767.__isset; return *this; } void InvalidObjectException::printTo(std::ostream& out) const { @@ -51976,13 +52022,13 @@ void swap(NoSuchObjectException &a, NoSuchObjectException &b) { swap(a.__isset, b.__isset); } -NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other1767) : TException() { - message = other1767.message; - __isset = other1767.__isset; -} -NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other1768) { +NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other1768) : TException() { message = other1768.message; __isset = other1768.__isset; +} +NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other1769) { + message = other1769.message; + __isset = other1769.__isset; return *this; } void NoSuchObjectException::printTo(std::ostream& out) const { @@ -52079,13 +52125,13 @@ void swap(InvalidOperationException &a, InvalidOperationException &b) { swap(a.__isset, b.__isset); } -InvalidOperationException::InvalidOperationException(const InvalidOperationException& other1769) : TException() { - message = other1769.message; - __isset = other1769.__isset; -} -InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other1770) { +InvalidOperationException::InvalidOperationException(const InvalidOperationException& other1770) : TException() { message = other1770.message; __isset = other1770.__isset; +} +InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other1771) { + message = other1771.message; + __isset = other1771.__isset; return *this; } void InvalidOperationException::printTo(std::ostream& out) const { @@ -52182,13 +52228,13 @@ void swap(ConfigValSecurityException &a, ConfigValSecurityException &b) { swap(a.__isset, b.__isset); } -ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other1771) : TException() { - message = other1771.message; - __isset = other1771.__isset; -} -ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other1772) { +ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other1772) : TException() { message = other1772.message; __isset = other1772.__isset; +} +ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other1773) { + message = other1773.message; + __isset = other1773.__isset; return *this; } void ConfigValSecurityException::printTo(std::ostream& out) const { @@ -52285,13 +52331,13 @@ void swap(InvalidInputException &a, InvalidInputException &b) { swap(a.__isset, b.__isset); } -InvalidInputException::InvalidInputException(const InvalidInputException& other1773) : TException() { - message = other1773.message; - __isset = other1773.__isset; -} -InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other1774) { +InvalidInputException::InvalidInputException(const InvalidInputException& other1774) : TException() { message = other1774.message; __isset = other1774.__isset; +} +InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other1775) { + message = other1775.message; + __isset = other1775.__isset; return *this; } void InvalidInputException::printTo(std::ostream& out) const { @@ -52388,13 +52434,13 @@ void swap(NoSuchTxnException &a, NoSuchTxnException &b) { swap(a.__isset, b.__isset); } -NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other1775) : TException() { - message = other1775.message; - __isset = other1775.__isset; -} -NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other1776) { +NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other1776) : TException() { message = other1776.message; __isset = other1776.__isset; +} +NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other1777) { + message = other1777.message; + __isset = other1777.__isset; return *this; } void NoSuchTxnException::printTo(std::ostream& out) const { @@ -52491,13 +52537,13 @@ void swap(TxnAbortedException &a, TxnAbortedException &b) { swap(a.__isset, b.__isset); } -TxnAbortedException::TxnAbortedException(const TxnAbortedException& other1777) : TException() { - message = other1777.message; - __isset = other1777.__isset; -} -TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other1778) { +TxnAbortedException::TxnAbortedException(const TxnAbortedException& other1778) : TException() { message = other1778.message; __isset = other1778.__isset; +} +TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other1779) { + message = other1779.message; + __isset = other1779.__isset; return *this; } void TxnAbortedException::printTo(std::ostream& out) const { @@ -52594,13 +52640,13 @@ void swap(TxnOpenException &a, TxnOpenException &b) { swap(a.__isset, b.__isset); } -TxnOpenException::TxnOpenException(const TxnOpenException& other1779) : TException() { - message = other1779.message; - __isset = other1779.__isset; -} -TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other1780) { +TxnOpenException::TxnOpenException(const TxnOpenException& other1780) : TException() { message = other1780.message; __isset = other1780.__isset; +} +TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other1781) { + message = other1781.message; + __isset = other1781.__isset; return *this; } void TxnOpenException::printTo(std::ostream& out) const { @@ -52697,13 +52743,13 @@ void swap(NoSuchLockException &a, NoSuchLockException &b) { swap(a.__isset, b.__isset); } -NoSuchLockException::NoSuchLockException(const NoSuchLockException& other1781) : TException() { - message = other1781.message; - __isset = other1781.__isset; -} -NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other1782) { +NoSuchLockException::NoSuchLockException(const NoSuchLockException& other1782) : TException() { message = other1782.message; __isset = other1782.__isset; +} +NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other1783) { + message = other1783.message; + __isset = other1783.__isset; return *this; } void NoSuchLockException::printTo(std::ostream& out) const { @@ -52800,13 +52846,13 @@ void swap(CompactionAbortedException &a, CompactionAbortedException &b) { swap(a.__isset, b.__isset); } -CompactionAbortedException::CompactionAbortedException(const CompactionAbortedException& other1783) : TException() { - message = other1783.message; - __isset = other1783.__isset; -} -CompactionAbortedException& CompactionAbortedException::operator=(const CompactionAbortedException& other1784) { +CompactionAbortedException::CompactionAbortedException(const CompactionAbortedException& other1784) : TException() { message = other1784.message; __isset = other1784.__isset; +} +CompactionAbortedException& CompactionAbortedException::operator=(const CompactionAbortedException& other1785) { + message = other1785.message; + __isset = other1785.__isset; return *this; } void CompactionAbortedException::printTo(std::ostream& out) const { @@ -52903,13 +52949,13 @@ void swap(NoSuchCompactionException &a, NoSuchCompactionException &b) { swap(a.__isset, b.__isset); } -NoSuchCompactionException::NoSuchCompactionException(const NoSuchCompactionException& other1785) : TException() { - message = other1785.message; - __isset = other1785.__isset; -} -NoSuchCompactionException& NoSuchCompactionException::operator=(const NoSuchCompactionException& other1786) { +NoSuchCompactionException::NoSuchCompactionException(const NoSuchCompactionException& other1786) : TException() { message = other1786.message; __isset = other1786.__isset; +} +NoSuchCompactionException& NoSuchCompactionException::operator=(const NoSuchCompactionException& other1787) { + message = other1787.message; + __isset = other1787.__isset; return *this; } void NoSuchCompactionException::printTo(std::ostream& out) const { diff --git a/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/hive_metastore_types.h b/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/hive_metastore_types.h index bb5ac205a74d..3223c3340354 100644 --- a/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/hive_metastore_types.h +++ b/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/hive_metastore_types.h @@ -14300,9 +14300,11 @@ void swap(CmRecycleResponse &a, CmRecycleResponse &b); std::ostream& operator<<(std::ostream& out, const CmRecycleResponse& obj); typedef struct _TableMeta__isset { - _TableMeta__isset() : comments(false), catName(false) {} + _TableMeta__isset() : comments(false), catName(false), ownerName(false), ownerType(false) {} bool comments :1; bool catName :1; + bool ownerName :1; + bool ownerType :1; } _TableMeta__isset; class TableMeta : public virtual ::apache::thrift::TBase { @@ -14315,7 +14317,9 @@ class TableMeta : public virtual ::apache::thrift::TBase { tableName(), tableType(), comments(), - catName() { + catName(), + ownerName(), + ownerType(static_cast(0)) { } virtual ~TableMeta() noexcept; @@ -14324,6 +14328,12 @@ class TableMeta : public virtual ::apache::thrift::TBase { std::string tableType; std::string comments; std::string catName; + std::string ownerName; + /** + * + * @see PrincipalType + */ + PrincipalType::type ownerType; _TableMeta__isset __isset; @@ -14337,6 +14347,10 @@ class TableMeta : public virtual ::apache::thrift::TBase { void __set_catName(const std::string& val); + void __set_ownerName(const std::string& val); + + void __set_ownerType(const PrincipalType::type val); + bool operator == (const TableMeta & rhs) const { if (!(dbName == rhs.dbName)) @@ -14353,6 +14367,14 @@ class TableMeta : public virtual ::apache::thrift::TBase { return false; else if (__isset.catName && !(catName == rhs.catName)) 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 TableMeta &rhs) const { diff --git a/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/TableMeta.java b/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/TableMeta.java index 320683130f33..d85dff892139 100644 --- a/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/TableMeta.java +++ b/standalone-metastore/metastore-common/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/TableMeta.java @@ -16,6 +16,8 @@ private static final org.apache.thrift.protocol.TField TABLE_TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("tableType", org.apache.thrift.protocol.TType.STRING, (short)3); private static final org.apache.thrift.protocol.TField COMMENTS_FIELD_DESC = new org.apache.thrift.protocol.TField("comments", org.apache.thrift.protocol.TType.STRING, (short)4); private static final org.apache.thrift.protocol.TField CAT_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("catName", org.apache.thrift.protocol.TType.STRING, (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 org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new TableMetaStandardSchemeFactory(); private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new TableMetaTupleSchemeFactory(); @@ -25,6 +27,8 @@ private @org.apache.thrift.annotation.Nullable java.lang.String tableType; // required private @org.apache.thrift.annotation.Nullable java.lang.String comments; // optional private @org.apache.thrift.annotation.Nullable java.lang.String catName; // optional + private @org.apache.thrift.annotation.Nullable java.lang.String ownerName; // optional + private @org.apache.thrift.annotation.Nullable 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 { @@ -32,7 +36,13 @@ public enum _Fields implements org.apache.thrift.TFieldIdEnum { TABLE_NAME((short)2, "tableName"), TABLE_TYPE((short)3, "tableType"), COMMENTS((short)4, "comments"), - CAT_NAME((short)5, "catName"); + CAT_NAME((short)5, "catName"), + OWNER_NAME((short)6, "ownerName"), + /** + * + * @see PrincipalType + */ + OWNER_TYPE((short)7, "ownerType"); private static final java.util.Map byName = new java.util.HashMap(); @@ -58,6 +68,10 @@ public static _Fields findByThriftId(int fieldId) { return COMMENTS; case 5: // CAT_NAME return CAT_NAME; + case 6: // OWNER_NAME + return OWNER_NAME; + case 7: // OWNER_TYPE + return OWNER_TYPE; default: return null; } @@ -99,7 +113,7 @@ public java.lang.String getFieldName() { } // isset id assignments - private static final _Fields optionals[] = {_Fields.COMMENTS,_Fields.CAT_NAME}; + private static final _Fields optionals[] = {_Fields.COMMENTS,_Fields.CAT_NAME,_Fields.OWNER_NAME,_Fields.OWNER_TYPE}; public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; static { java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); @@ -113,6 +127,10 @@ public java.lang.String getFieldName() { new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); tmpMap.put(_Fields.CAT_NAME, new org.apache.thrift.meta_data.FieldMetaData("catName", org.apache.thrift.TFieldRequirementType.OPTIONAL, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + 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 = java.util.Collections.unmodifiableMap(tmpMap); org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TableMeta.class, metaDataMap); } @@ -150,6 +168,12 @@ public TableMeta(TableMeta other) { if (other.isSetCatName()) { this.catName = other.catName; } + if (other.isSetOwnerName()) { + this.ownerName = other.ownerName; + } + if (other.isSetOwnerType()) { + this.ownerType = other.ownerType; + } } public TableMeta deepCopy() { @@ -163,6 +187,8 @@ public void clear() { this.tableType = null; this.comments = null; this.catName = null; + this.ownerName = null; + this.ownerType = null; } @org.apache.thrift.annotation.Nullable @@ -285,6 +311,62 @@ public void setCatNameIsSet(boolean value) { } } + @org.apache.thrift.annotation.Nullable + public java.lang.String getOwnerName() { + return this.ownerName; + } + + public void setOwnerName(@org.apache.thrift.annotation.Nullable java.lang.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 + */ + @org.apache.thrift.annotation.Nullable + public PrincipalType getOwnerType() { + return this.ownerType; + } + + /** + * + * @see PrincipalType + */ + public void setOwnerType(@org.apache.thrift.annotation.Nullable 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, @org.apache.thrift.annotation.Nullable java.lang.Object value) { switch (field) { case DB_NAME: @@ -327,6 +409,22 @@ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable } break; + case OWNER_NAME: + if (value == null) { + unsetOwnerName(); + } else { + setOwnerName((java.lang.String)value); + } + break; + + case OWNER_TYPE: + if (value == null) { + unsetOwnerType(); + } else { + setOwnerType((PrincipalType)value); + } + break; + } } @@ -348,6 +446,12 @@ public java.lang.Object getFieldValue(_Fields field) { case CAT_NAME: return getCatName(); + case OWNER_NAME: + return getOwnerName(); + + case OWNER_TYPE: + return getOwnerType(); + } throw new java.lang.IllegalStateException(); } @@ -369,6 +473,10 @@ public boolean isSet(_Fields field) { return isSetComments(); case CAT_NAME: return isSetCatName(); + case OWNER_NAME: + return isSetOwnerName(); + case OWNER_TYPE: + return isSetOwnerType(); } throw new java.lang.IllegalStateException(); } @@ -431,6 +539,24 @@ public boolean equals(TableMeta that) { 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; } @@ -458,6 +584,14 @@ public int hashCode() { if (isSetCatName()) hashCode = hashCode * 8191 + catName.hashCode(); + hashCode = hashCode * 8191 + ((isSetOwnerName()) ? 131071 : 524287); + if (isSetOwnerName()) + hashCode = hashCode * 8191 + ownerName.hashCode(); + + hashCode = hashCode * 8191 + ((isSetOwnerType()) ? 131071 : 524287); + if (isSetOwnerType()) + hashCode = hashCode * 8191 + ownerType.getValue(); + return hashCode; } @@ -519,6 +653,26 @@ public int compareTo(TableMeta other) { return lastComparison; } } + lastComparison = java.lang.Boolean.compare(isSetOwnerName(), other.isSetOwnerName()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetOwnerName()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ownerName, other.ownerName); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = java.lang.Boolean.compare(isSetOwnerType(), other.isSetOwnerType()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetOwnerType()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ownerType, other.ownerType); + if (lastComparison != 0) { + return lastComparison; + } + } return 0; } @@ -583,6 +737,26 @@ public java.lang.String toString() { } 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(); } @@ -678,6 +852,22 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, TableMeta struct) t 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 = org.apache.hadoop.hive.metastore.api.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); } @@ -720,6 +910,20 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, TableMeta struct) 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(); } @@ -747,13 +951,25 @@ public void write(org.apache.thrift.protocol.TProtocol prot, TableMeta struct) t if (struct.isSetCatName()) { optionals.set(1); } - oprot.writeBitSet(optionals, 2); + if (struct.isSetOwnerName()) { + optionals.set(2); + } + if (struct.isSetOwnerType()) { + optionals.set(3); + } + oprot.writeBitSet(optionals, 4); if (struct.isSetComments()) { oprot.writeString(struct.comments); } if (struct.isSetCatName()) { oprot.writeString(struct.catName); } + if (struct.isSetOwnerName()) { + oprot.writeString(struct.ownerName); + } + if (struct.isSetOwnerType()) { + oprot.writeI32(struct.ownerType.getValue()); + } } @Override @@ -765,7 +981,7 @@ public void read(org.apache.thrift.protocol.TProtocol prot, TableMeta struct) th struct.setTableNameIsSet(true); struct.tableType = iprot.readString(); struct.setTableTypeIsSet(true); - java.util.BitSet incoming = iprot.readBitSet(2); + java.util.BitSet incoming = iprot.readBitSet(4); if (incoming.get(0)) { struct.comments = iprot.readString(); struct.setCommentsIsSet(true); @@ -774,6 +990,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, TableMeta struct) th struct.catName = iprot.readString(); struct.setCatNameIsSet(true); } + if (incoming.get(2)) { + struct.ownerName = iprot.readString(); + struct.setOwnerNameIsSet(true); + } + if (incoming.get(3)) { + struct.ownerType = org.apache.hadoop.hive.metastore.api.PrincipalType.findByValue(iprot.readI32()); + struct.setOwnerTypeIsSet(true); + } } } diff --git a/standalone-metastore/metastore-common/src/gen/thrift/gen-php/metastore/TableMeta.php b/standalone-metastore/metastore-common/src/gen/thrift/gen-php/metastore/TableMeta.php index 571649fcf4c8..9370945ba8b8 100644 --- a/standalone-metastore/metastore-common/src/gen/thrift/gen-php/metastore/TableMeta.php +++ b/standalone-metastore/metastore-common/src/gen/thrift/gen-php/metastore/TableMeta.php @@ -46,6 +46,17 @@ class TableMeta 'isRequired' => false, 'type' => TType::STRING, ), + 6 => array( + 'var' => 'ownerName', + 'isRequired' => false, + 'type' => TType::STRING, + ), + 7 => array( + 'var' => 'ownerType', + 'isRequired' => false, + 'type' => TType::I32, + 'class' => '\metastore\PrincipalType', + ), ); /** @@ -68,6 +79,14 @@ class TableMeta * @var string */ public $catName = null; + /** + * @var string + */ + public $ownerName = null; + /** + * @var int + */ + public $ownerType = null; public function __construct($vals = null) { @@ -87,6 +106,12 @@ public function __construct($vals = null) if (isset($vals['catName'])) { $this->catName = $vals['catName']; } + if (isset($vals['ownerName'])) { + $this->ownerName = $vals['ownerName']; + } + if (isset($vals['ownerType'])) { + $this->ownerType = $vals['ownerType']; + } } } @@ -144,6 +169,20 @@ public function read($input) $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; @@ -183,6 +222,16 @@ public function write($output) $xfer += $output->writeString($this->catName); $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; diff --git a/standalone-metastore/metastore-common/src/gen/thrift/gen-py/hive_metastore/ttypes.py b/standalone-metastore/metastore-common/src/gen/thrift/gen-py/hive_metastore/ttypes.py index 6547ba0953d8..50a6c5fe8088 100644 --- a/standalone-metastore/metastore-common/src/gen/thrift/gen-py/hive_metastore/ttypes.py +++ b/standalone-metastore/metastore-common/src/gen/thrift/gen-py/hive_metastore/ttypes.py @@ -20863,16 +20863,20 @@ class TableMeta(object): - tableType - comments - catName + - ownerName + - ownerType """ - def __init__(self, dbName=None, tableName=None, tableType=None, comments=None, catName=None,): + def __init__(self, dbName=None, tableName=None, tableType=None, comments=None, catName=None, ownerName=None, ownerType=None,): self.dbName = dbName self.tableName = tableName self.tableType = tableType self.comments = comments self.catName = catName + self.ownerName = ownerName + self.ownerType = ownerType def read(self, iprot): if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: @@ -20908,6 +20912,16 @@ def read(self, iprot): self.catName = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString() else: iprot.skip(ftype) + elif fid == 6: + if ftype == TType.STRING: + self.ownerName = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else 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() @@ -20938,6 +20952,14 @@ def write(self, oprot): oprot.writeFieldBegin('catName', TType.STRING, 5) oprot.writeString(self.catName.encode('utf-8') if sys.version_info[0] == 2 else self.catName) oprot.writeFieldEnd() + if self.ownerName is not None: + oprot.writeFieldBegin('ownerName', TType.STRING, 6) + oprot.writeString(self.ownerName.encode('utf-8') if sys.version_info[0] == 2 else 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() @@ -32163,6 +32185,8 @@ def __ne__(self, other): (3, TType.STRING, 'tableType', 'UTF8', None, ), # 3 (4, TType.STRING, 'comments', 'UTF8', None, ), # 4 (5, TType.STRING, 'catName', 'UTF8', None, ), # 5 + (6, TType.STRING, 'ownerName', 'UTF8', None, ), # 6 + (7, TType.I32, 'ownerType', None, None, ), # 7 ) all_structs.append(Materialization) Materialization.thrift_spec = ( diff --git a/standalone-metastore/metastore-common/src/gen/thrift/gen-rb/hive_metastore_types.rb b/standalone-metastore/metastore-common/src/gen/thrift/gen-rb/hive_metastore_types.rb index 26b53a00630f..9d864db0d059 100644 --- a/standalone-metastore/metastore-common/src/gen/thrift/gen-rb/hive_metastore_types.rb +++ b/standalone-metastore/metastore-common/src/gen/thrift/gen-rb/hive_metastore_types.rb @@ -5844,13 +5844,17 @@ class TableMeta TABLETYPE = 3 COMMENTS = 4 CATNAME = 5 + OWNERNAME = 6 + OWNERTYPE = 7 FIELDS = { DBNAME => {:type => ::Thrift::Types::STRING, :name => 'dbName'}, TABLENAME => {:type => ::Thrift::Types::STRING, :name => 'tableName'}, TABLETYPE => {:type => ::Thrift::Types::STRING, :name => 'tableType'}, COMMENTS => {:type => ::Thrift::Types::STRING, :name => 'comments', :optional => true}, - CATNAME => {:type => ::Thrift::Types::STRING, :name => 'catName', :optional => true} + CATNAME => {:type => ::Thrift::Types::STRING, :name => 'catName', :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 @@ -5859,6 +5863,9 @@ def validate raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Required field dbName is unset!') unless @dbName raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Required field tableName is unset!') unless @tableName raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Required field tableType is unset!') unless @tableType + 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 diff --git a/standalone-metastore/metastore-common/src/main/java/org/apache/hadoop/hive/metastore/DefaultMetaStoreFilterHookImpl.java b/standalone-metastore/metastore-common/src/main/java/org/apache/hadoop/hive/metastore/DefaultMetaStoreFilterHookImpl.java index 3af78502040e..bc881165579c 100644 --- a/standalone-metastore/metastore-common/src/main/java/org/apache/hadoop/hive/metastore/DefaultMetaStoreFilterHookImpl.java +++ b/standalone-metastore/metastore-common/src/main/java/org/apache/hadoop/hive/metastore/DefaultMetaStoreFilterHookImpl.java @@ -54,7 +54,14 @@ public List filterTableNames(String catName, String dbName, List } @Override - public List filterTableMetas(String catName, String dbName,List tableMetas) throws MetaException { + @Deprecated + public List filterTableMetas(String catName, String dbName, List tableMetas) + throws MetaException { + return filterTableMetas(tableMetas); + } + + @Override + public List filterTableMetas(List tableMetas) throws MetaException { return tableMetas; } diff --git a/standalone-metastore/metastore-common/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java b/standalone-metastore/metastore-common/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java index 7a13c595de42..12cb7242479f 100644 --- a/standalone-metastore/metastore-common/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java +++ b/standalone-metastore/metastore-common/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java @@ -2934,9 +2934,9 @@ public List getTableMeta(String dbPatterns, String tablePatterns, Lis @Override public List getTableMeta(String catName, String dbPatterns, String tablePatterns, List tableTypes) throws TException { - List tableMetas = client.get_table_meta(prependCatalogToDbName( - catName, dbPatterns, conf), tablePatterns, tableTypes); - return FilterUtils.filterTableMetasIfEnabled(isClientFilterEnabled, filterHook, catName, dbPatterns, tableMetas); + List tableMetas = client.get_table_meta(prependCatalogToDbName(catName, dbPatterns, conf), + tablePatterns, tableTypes); + return FilterUtils.filterTableMetasIfEnabled(isClientFilterEnabled, filterHook, tableMetas); } @Override diff --git a/standalone-metastore/metastore-common/src/main/java/org/apache/hadoop/hive/metastore/MetaStoreFilterHook.java b/standalone-metastore/metastore-common/src/main/java/org/apache/hadoop/hive/metastore/MetaStoreFilterHook.java index e2da15e54f21..43b4db5a145d 100644 --- a/standalone-metastore/metastore-common/src/main/java/org/apache/hadoop/hive/metastore/MetaStoreFilterHook.java +++ b/standalone-metastore/metastore-common/src/main/java/org/apache/hadoop/hive/metastore/MetaStoreFilterHook.java @@ -85,15 +85,24 @@ default List filterCatalogs(List catalogs) throws MetaException List filterTableNames(String catName, String dbName, List tableList) throws MetaException; - // Previously this was handled by filterTableNames. But it can't be anymore because we can no - // longer depend on a 1-1 mapping between table name and entry in the list. + /** + * Filter given list of TableMeta objects + * @param catName catalog name + * @param dbName database name + * @param tableMetas list of table returned by the metastore + * @deprecated Replaced by {@link #filterTableMetas(List)} + * @return List of filtered table names + */ + @Deprecated + List filterTableMetas(String catName, String dbName, List tableMetas) throws MetaException; + /** * Filter a list of TableMeta objects. * @param tableMetas list of TableMetas to filter * @return filtered table metas * @throws MetaException something went wrong */ - List filterTableMetas(String catName,String dbName,List tableMetas) throws MetaException; + List filterTableMetas(List tableMetas) throws MetaException; /** * filter to given table object if applicable diff --git a/standalone-metastore/metastore-common/src/main/java/org/apache/hadoop/hive/metastore/utils/FilterUtils.java b/standalone-metastore/metastore-common/src/main/java/org/apache/hadoop/hive/metastore/utils/FilterUtils.java index d1ebe0aeaaa3..e1d8866864b0 100644 --- a/standalone-metastore/metastore-common/src/main/java/org/apache/hadoop/hive/metastore/utils/FilterUtils.java +++ b/standalone-metastore/metastore-common/src/main/java/org/apache/hadoop/hive/metastore/utils/FilterUtils.java @@ -186,25 +186,20 @@ public static Table filterTableIfEnabled( * Filter list of meta data of tables if filtering is enabled. Otherwise, return original list * @param isFilterEnabled true: filtering is enabled; false: filtring is disabled. * @param filterHook: the object that does filtering - * @param catName: the catalog name - * @param dbName: the database name * @param tableMetas: the list of meta data of tables * @return the list of table meta data that current user has access if filtering is enabled; * otherwise, the original list * @throws MetaException * @throws NoSuchObjectException */ - public static List filterTableMetasIfEnabled( - boolean isFilterEnabled, MetaStoreFilterHook filterHook, - String catName, String dbName, List tableMetas) - throws MetaException, NoSuchObjectException { + public static List filterTableMetasIfEnabled(boolean isFilterEnabled, MetaStoreFilterHook filterHook, + List tableMetas) throws MetaException, NoSuchObjectException { if (tableMetas == null || tableMetas.isEmpty()) { return tableMetas; } if (isFilterEnabled) { - return filterHook.filterTableMetas( - catName, dbName, tableMetas); + return filterHook.filterTableMetas(tableMetas); } return tableMetas; diff --git a/standalone-metastore/metastore-common/src/main/thrift/hive_metastore.thrift b/standalone-metastore/metastore-common/src/main/thrift/hive_metastore.thrift index 6c1fd7a9f0c1..647d5c6cf170 100644 --- a/standalone-metastore/metastore-common/src/main/thrift/hive_metastore.thrift +++ b/standalone-metastore/metastore-common/src/main/thrift/hive_metastore.thrift @@ -1755,6 +1755,8 @@ struct TableMeta { 3: required string tableType; 4: optional string comments; 5: optional string catName; + 6: optional string ownerName; + 7: optional PrincipalType ownerType; } struct Materialization { diff --git a/standalone-metastore/metastore-server/src/main/java/org/apache/hadoop/hive/metastore/HMSHandler.java b/standalone-metastore/metastore-server/src/main/java/org/apache/hadoop/hive/metastore/HMSHandler.java index 15bb8d822455..85c78cc6a2e7 100644 --- a/standalone-metastore/metastore-server/src/main/java/org/apache/hadoop/hive/metastore/HMSHandler.java +++ b/standalone-metastore/metastore-server/src/main/java/org/apache/hadoop/hive/metastore/HMSHandler.java @@ -3588,8 +3588,7 @@ public List get_table_meta(String dbnames, String tblNames, List getTableMeta(String catName, String dbNames, String table // tables in all databases, essentially a full dump) pm.getFetchPlan().addGroup(FetchGroups.FETCH_DATABASE_ON_MTABLE); query = pm.newQuery(MTable.class, filterBuilder.toString()) ; - query.setResult("database.name, tableName, tableType, parameters.get(\"comment\")"); + query.setResult("database.name, tableName, tableType, parameters.get(\"comment\"), owner, ownerType"); List tables = (List) query.executeWithArray(parameterVals.toArray(new String[0])); for (Object[] table : tables) { TableMeta metaData = new TableMeta(table[0].toString(), table[1].toString(), table[2].toString()); @@ -1981,6 +1981,12 @@ public List getTableMeta(String catName, String dbNames, String table if (table[3] != null) { metaData.setComments(table[3].toString()); } + if (table[4] != null) { + metaData.setOwnerName(table[4].toString()); + } + if (table[5] != null) { + metaData.setOwnerType(getPrincipalTypeFromStr(table[5].toString())); + } metas.add(metaData); } commited = commitTransaction(); diff --git a/standalone-metastore/metastore-server/src/test/java/org/apache/hadoop/hive/metastore/NonCatCallsWithCatalog.java b/standalone-metastore/metastore-server/src/test/java/org/apache/hadoop/hive/metastore/NonCatCallsWithCatalog.java index 82e3fefdeaef..3b3898667702 100644 --- a/standalone-metastore/metastore-server/src/test/java/org/apache/hadoop/hive/metastore/NonCatCallsWithCatalog.java +++ b/standalone-metastore/metastore-server/src/test/java/org/apache/hadoop/hive/metastore/NonCatCallsWithCatalog.java @@ -507,6 +507,9 @@ public void getTableMeta() throws TException { table.unsetCatName(); client.createTable(table); TableMeta tableMeta = new TableMeta(dbName, tableNames[i], TableType.MANAGED_TABLE.name()); + tableMeta.setOwnerName(table.getOwner()); + tableMeta.setOwnerType(table.getOwnerType()); + tableMeta.setCatName(expectedCatalog()); expected.add(tableMeta); } diff --git a/standalone-metastore/metastore-server/src/test/java/org/apache/hadoop/hive/metastore/TestFilterHooks.java b/standalone-metastore/metastore-server/src/test/java/org/apache/hadoop/hive/metastore/TestFilterHooks.java index 5d555a5f1a51..46f3617b9697 100644 --- a/standalone-metastore/metastore-server/src/test/java/org/apache/hadoop/hive/metastore/TestFilterHooks.java +++ b/standalone-metastore/metastore-server/src/test/java/org/apache/hadoop/hive/metastore/TestFilterHooks.java @@ -105,7 +105,14 @@ public List
filterTables(List
tableList) throws MetaException { } @Override - public List filterTableMetas(String catName, String dbName,List tableMetas) throws MetaException { + @Deprecated + public List filterTableMetas(String catName, String dbName,List tableMetas) + throws MetaException { + return filterTableMetas(tableMetas); + } + + @Override + public List filterTableMetas(List tableMetas) throws MetaException { return tableMetas; } diff --git a/standalone-metastore/metastore-server/src/test/java/org/apache/hadoop/hive/metastore/client/TestGetTableMeta.java b/standalone-metastore/metastore-server/src/test/java/org/apache/hadoop/hive/metastore/client/TestGetTableMeta.java index 7e4b317ff346..9b8147161fdf 100644 --- a/standalone-metastore/metastore-server/src/test/java/org/apache/hadoop/hive/metastore/client/TestGetTableMeta.java +++ b/standalone-metastore/metastore-server/src/test/java/org/apache/hadoop/hive/metastore/client/TestGetTableMeta.java @@ -26,14 +26,14 @@ import com.google.common.collect.ImmutableSet; import org.apache.hadoop.conf.Configuration; -import org.apache.hadoop.hive.metastore.IMetaStoreClient; +import org.apache.hadoop.hive.metastore.HiveMetaStoreClient; import org.apache.hadoop.hive.metastore.MetaStoreTestUtils; import org.apache.hadoop.hive.metastore.TableType; import org.apache.hadoop.hive.metastore.annotation.MetastoreCheckinTest; -import org.apache.hadoop.hive.metastore.annotation.MetastoreUnitTest; import org.apache.hadoop.hive.metastore.api.CreationMetadata; import org.apache.hadoop.hive.metastore.api.Catalog; import org.apache.hadoop.hive.metastore.api.Database; +import org.apache.hadoop.hive.metastore.api.PrincipalType; import org.apache.hadoop.hive.metastore.api.Table; import org.apache.hadoop.hive.metastore.api.TableMeta; import org.apache.hadoop.hive.metastore.client.builder.CatalogBuilder; @@ -43,6 +43,7 @@ import org.apache.hadoop.hive.metastore.conf.MetastoreConf.ConfVars; import org.apache.hadoop.hive.metastore.minihms.AbstractMetaStoreService; import org.apache.hadoop.hive.metastore.utils.MetaStoreUtils; + import org.apache.thrift.TException; import com.google.common.collect.Lists; @@ -66,11 +67,11 @@ public class TestGetTableMeta extends MetaStoreClientTest { private AbstractMetaStoreService metaStore; private Configuration conf; - private IMetaStoreClient client; - + private HiveMetaStoreClient client; private static final String DB_NAME = "testpartdb"; private static final String TABLE_NAME = "testparttable"; - + private static final String TABLE_OWNER = "testuser"; + private static final PrincipalType TABLE_OWNER_TYPE = PrincipalType.USER; private List expectedMetas = null; public TestGetTableMeta(String name, AbstractMetaStoreService metaStore) { @@ -80,12 +81,15 @@ public TestGetTableMeta(String name, AbstractMetaStoreService metaStore) { @Before public void setUp() throws Exception { conf = MetastoreConf.newMetastoreConf(); - org.apache.hadoop.hive.metastore.conf.MetastoreConf - .setBoolVar(this.conf, ConfVars.HIVE_IN_TEST, true); + // Directly set client capability since HiveConf is unaccessable through standalone-metastore + MetastoreConf.setBoolVar(conf, ConfVars.HIVE_IN_TEST, true); MetaStoreTestUtils.setConfForStandloneMode(conf); // Get new client client = metaStore.getClient(); + String[] clientCaps = new String[]{"HIVEMANAGEDINSERTWRITE","HIVEMANAGESTATS","HIVECACHEINVALIDATE", + "CONNECTORWRITE"}; + client.setProcessorCapabilities(clientCaps); // Clean up client.dropDatabase(DB_NAME + "_one", true, true, true); @@ -122,28 +126,25 @@ public void tearDown() throws Exception { } } - private void createDB(String dbName) throws TException { new DatabaseBuilder(). setName(dbName). create(client, metaStore.getConf()); } - - private Table createTable(String dbName, String tableName, TableType type) + private Table createTable(String dbName, String tableName, TableType type, String owner, PrincipalType ownerType) throws Exception { TableBuilder builder = new TableBuilder() .setCatName("hive") - .setDbName(dbName) - .setTableName(tableName) + .setDbName(dbName) .setTableName(tableName) + .setOwner(owner) + .setOwnerType(ownerType) .addCol("id", "int") .addCol("name", "string") .setType(type.name()); - Table table = builder.build(metaStore.getConf()); - if (type == TableType.MATERIALIZED_VIEW) { CreationMetadata cm = new CreationMetadata( MetaStoreUtils.getDefaultCatalog(metaStore.getConf()), dbName, tableName, ImmutableSet.of()); @@ -153,31 +154,45 @@ private Table createTable(String dbName, String tableName, TableType type) if (type == TableType.EXTERNAL_TABLE) { table.getParameters().put("EXTERNAL", "true"); + } else if (type == TableType.MANAGED_TABLE) { + // we do not want MANAGED tables to be converted to EXTERNAL + table.getParameters().put("transactional", "true"); + table.getParameters().put("transactional_properties", "insert_only"); } - return table; } - private TableMeta createTestTable(String dbName, String tableName, TableType type, String comment) - throws Exception { - Table table = createTable(dbName, tableName, type); - table.getParameters().put("comment", comment); + private class OwnerInfo { + String owner; + PrincipalType ownerType; + } + + private TableMeta createTestTable(String dbName, String tableName, TableType type, String comment, + OwnerInfo ownerInfo) throws Exception { + String owner = ownerInfo == null ? TABLE_OWNER : ownerInfo.owner; + PrincipalType ownerType = ownerInfo == null ? TABLE_OWNER_TYPE : ownerInfo.ownerType; + Table table = createTable(dbName, tableName, type, owner, ownerType); + TableMeta expectedTableMeta = new TableMeta(dbName, tableName, type.toString()); + if (comment != null) { + table.getParameters().put("comment", comment); + expectedTableMeta.setComments(comment); + } + expectedTableMeta.setOwnerName(owner); + expectedTableMeta.setOwnerType(ownerType); + expectedTableMeta.setCatName("hive"); client.createTable(table); - table = client.getTable(dbName, tableName); - TableMeta tableMeta = new TableMeta(dbName, tableName, table.getTableType()); - tableMeta.setComments(comment); - tableMeta.setCatName("hive"); - return tableMeta; + return expectedTableMeta; + + } + + private TableMeta createTestTable(String dbName, String tableName, TableType type, String comment) + throws Exception { + return createTestTable(dbName, tableName, type, comment, null); } private TableMeta createTestTable(String dbName, String tableName, TableType type) - throws Exception { - Table table = createTable(dbName, tableName, type); - client.createTable(table); - table = client.getTable(dbName, tableName); - TableMeta tableMeta = new TableMeta(dbName, tableName, table.getTableType()); - tableMeta.setCatName("hive"); - return tableMeta; + throws Exception { + return createTestTable(dbName, tableName, type, null, null); } private void assertTableMetas(int[] expected, List actualTableMetas) { @@ -194,7 +209,7 @@ private void assertTableMetas(List fullExpected, List actu Set metas = new HashSet<>(actual); for (int i : expected){ - assertTrue("Missing " + fullExpected.get(i), metas.remove(fullExpected.get(i))); + assertTrue("Missing " + fullExpected.get(i) + "" + actual, metas.remove(fullExpected.get(i))); } assertTrue("Unexpected tableMeta(s): " + metas, metas.isEmpty()); @@ -233,11 +248,11 @@ public void testGetTableMeta() throws Exception { tableMetas = client.getTableMeta("testpartdb*", "*", Lists.newArrayList( TableType.EXTERNAL_TABLE.name())); - assertTableMetas(new int[]{0, 1, 3}, tableMetas); + assertTableMetas(new int[]{0}, tableMetas); tableMetas = client.getTableMeta("testpartdb*", "*", Lists.newArrayList( TableType.EXTERNAL_TABLE.name(), TableType.MATERIALIZED_VIEW.name())); - assertTableMetas(new int[]{0, 1, 3, 4}, tableMetas); + assertTableMetas(new int[]{0, 4}, tableMetas); tableMetas = client.getTableMeta("*one", "*", Lists.newArrayList("*TABLE")); assertTableMetas(new int[]{}, tableMetas); @@ -315,12 +330,16 @@ public void tablesInDifferentCatalog() throws TException { client.createTable(new TableBuilder() .inDb(db) .setTableName(tableNames[i]) + .setOwner(TABLE_OWNER) + .setOwnerType(TABLE_OWNER_TYPE) .addCol("id", "int") .addCol("name", "string") .build(metaStore.getConf())); Table table = client.getTable(catName, dbName, tableNames[i]); TableMeta tableMeta = new TableMeta(dbName, tableNames[i], table.getTableType()); tableMeta.setCatName(catName); + tableMeta.setOwnerName(TABLE_OWNER); + tableMeta.setOwnerType(TABLE_OWNER_TYPE); expected.add(tableMeta); } diff --git a/standalone-metastore/metastore-server/src/test/java/org/apache/hadoop/hive/metastore/minihms/AbstractMetaStoreService.java b/standalone-metastore/metastore-server/src/test/java/org/apache/hadoop/hive/metastore/minihms/AbstractMetaStoreService.java index dc6203f26623..9a66c4930290 100644 --- a/standalone-metastore/metastore-server/src/test/java/org/apache/hadoop/hive/metastore/minihms/AbstractMetaStoreService.java +++ b/standalone-metastore/metastore-server/src/test/java/org/apache/hadoop/hive/metastore/minihms/AbstractMetaStoreService.java @@ -99,7 +99,7 @@ public void start(Map metastoreOverlay, * @return The client connected to this service * @throws MetaException if any Exception occurs during client configuration */ - public IMetaStoreClient getClient() throws MetaException { + public HiveMetaStoreClient getClient() throws MetaException { return new HiveMetaStoreClient(configuration); }